diff --git a/TypeScript b/TypeScript
index 66f6f9b..93de502 160000
--- a/TypeScript
+++ b/TypeScript
@@ -1 +1 @@
-Subproject commit 66f6f9ba05e1a3ebdeb0a66e0603f40ab3e9b8a3
+Subproject commit 93de502656a7a0cdf30737513d29bcb396c79662
diff --git a/bin/lib.d.ts b/bin/lib.d.ts
index 775e2f3..a65770c 100644
--- a/bin/lib.d.ts
+++ b/bin/lib.d.ts
@@ -4258,6 +4258,7 @@ interface KeyAlgorithm {
 }
 
 interface KeyboardEventInit extends EventModifierInit {
+    code?: string;
     key?: string;
     location?: number;
     repeat?: boolean;
@@ -6420,7 +6421,7 @@ declare var DeviceRotationRate: {
     new(): DeviceRotationRate;
 }
 
-interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent {
+interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent, ParentNode {
     /**
       * Sets or gets the URL for the current document. 
       */
@@ -7483,7 +7484,7 @@ declare var Document: {
     new(): Document;
 }
 
-interface DocumentFragment extends Node, NodeSelector {
+interface DocumentFragment extends Node, NodeSelector, ParentNode {
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -7552,7 +7553,7 @@ declare var EXT_texture_filter_anisotropic: {
     readonly TEXTURE_MAX_ANISOTROPY_EXT: number;
 }
 
-interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode {
+interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode, ParentNode {
     readonly classList: DOMTokenList;
     className: string;
     readonly clientHeight: number;
@@ -7807,6 +7808,16 @@ interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelec
     getElementsByClassName(classNames: string): NodeListOf<Element>;
     matches(selector: string): boolean;
     closest(selector: string): Element | null;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    insertAdjacentElement(position: string, insertedElement: Element): Element | null;
+    insertAdjacentHTML(where: string, html: string): void;
+    insertAdjacentText(where: string, text: string): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -8578,7 +8589,7 @@ interface HTMLCanvasElement extends HTMLElement {
       * @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;
-    toBlob(callback: (result: Blob | null) => void, ... arguments: any[]): void;
+    toBlob(callback: (result: Blob | null) => void, type?: string, ...arguments: any[]): void;
 }
 
 declare var HTMLCanvasElement: {
@@ -8753,11 +8764,7 @@ interface HTMLElement extends Element {
     click(): void;
     dragDrop(): boolean;
     focus(): void;
-    insertAdjacentElement(position: string, insertedElement: Element): Element;
-    insertAdjacentHTML(where: string, html: string): void;
-    insertAdjacentText(where: string, text: string): void;
     msGetInputContext(): MSInputMethodContext;
-    scrollIntoView(top?: boolean): void;
     setActive(): void;
     addEventListener(type: "MSContentZoom", listener: (this: this, ev: UIEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -10022,6 +10029,7 @@ interface HTMLLinkElement extends HTMLElement, LinkStyle {
       */
     type: string;
     import?: Document;
+    integrity: string;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -10310,7 +10318,7 @@ interface HTMLMediaElement extends HTMLElement {
       */
     canPlayType(type: string): string;
     /**
-      * Fires immediately after the client loads the object.
+      * Resets the audio or video object and loads a new media resource.
       */
     load(): void;
     /**
@@ -10883,6 +10891,7 @@ interface HTMLScriptElement extends HTMLElement {
       * Sets or retrieves the MIME type for the associated scripting engine.
       */
     type: string;
+    integrity: string;
 }
 
 declare var HTMLScriptElement: {
@@ -11888,6 +11897,7 @@ interface KeyboardEvent extends UIEvent {
     readonly repeat: boolean;
     readonly shiftKey: boolean;
     readonly which: number;
+    readonly code: string;
     getModifierState(keyArg: string): boolean;
     initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void;
     readonly DOM_KEY_LOCATION_JOYSTICK: number;
@@ -13260,6 +13270,7 @@ interface PerformanceTiming {
     readonly responseStart: number;
     readonly unloadEventEnd: number;
     readonly unloadEventStart: number;
+    readonly secureConnectionStart: number;
     toJSON(): any;
 }
 
@@ -15537,8 +15548,8 @@ declare var StereoPannerNode: {
 interface Storage {
     readonly length: number;
     clear(): void;
-    getItem(key: string): string;
-    key(index: number): string;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
     removeItem(key: string): void;
     setItem(key: string, data: string): void;
     [key: string]: any;
@@ -17079,7 +17090,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     onunload: (this: this, ev: Event) => any;
     onvolumechange: (this: this, ev: Event) => any;
     onwaiting: (this: this, ev: Event) => any;
-    readonly opener: Window;
+    opener: any;
     orientation: string | number;
     readonly outerHeight: number;
     readonly outerWidth: number;
@@ -17134,6 +17145,9 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+    scroll(options?: ScrollToOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollBy(options?: ScrollToOptions): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -18161,6 +18175,20 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+interface ScrollOptions {
+    behavior?: ScrollBehavior;
+}
+
+interface ScrollToOptions extends ScrollOptions {
+    left?: number;
+    top?: number;
+}
+
+interface ScrollIntoViewOptions extends ScrollOptions {
+    block?: ScrollLogicalPosition;
+    inline?: ScrollLogicalPosition;
+}
+
 interface ClipboardEventInit extends EventInit {
     data?: string;
     dataType?: string;
@@ -18204,7 +18232,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {
@@ -18340,6 +18368,13 @@ interface JsonWebKey {
     k?: string;
 }
 
+interface ParentNode {
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    readonly childElementCount: number;
+}
+
 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
 interface ErrorEventHandler {
@@ -18410,7 +18445,7 @@ declare var location: Location;
 declare var locationbar: BarProp;
 declare var menubar: BarProp;
 declare var msCredentials: MSCredentials;
-declare var name: string;
+declare const name: never;
 declare var navigator: Navigator;
 declare var offscreenBuffering: string | boolean;
 declare var onabort: (this: Window, ev: UIEvent) => any;
@@ -18504,7 +18539,7 @@ declare var ontouchstart: (ev: TouchEvent) => any;
 declare var onunload: (this: Window, ev: Event) => any;
 declare var onvolumechange: (this: Window, ev: Event) => any;
 declare var onwaiting: (this: Window, ev: Event) => any;
-declare var opener: Window;
+declare var opener: any;
 declare var orientation: string | number;
 declare var outerHeight: number;
 declare var outerWidth: number;
@@ -18557,6 +18592,9 @@ declare function webkitCancelAnimationFrame(handle: number): void;
 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+declare function scroll(options?: ScrollToOptions): void;
+declare function scrollTo(options?: ScrollToOptions): void;
+declare function scrollBy(options?: ScrollToOptions): void;
 declare function toString(): string;
 declare function addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 declare function dispatchEvent(evt: Event): boolean;
@@ -18712,6 +18750,8 @@ type MSOutboundPayload = MSVideoSendPayload | MSAudioSendPayload;
 type RTCIceGatherCandidate = RTCIceCandidate | RTCIceCandidateComplete;
 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
 type payloadtype = number;
+type ScrollBehavior = "auto" | "instant" | "smooth";
+type ScrollLogicalPosition = "start" | "center" | "end" | "nearest";
 type IDBValidKey = number | string | Date | IDBArrayKey;
 type BufferSource = ArrayBuffer | ArrayBufferView;
 type MouseWheelEvent = WheelEvent;
diff --git a/bin/lib.dom.d.ts b/bin/lib.dom.d.ts
index ec23413..4e45a38 100644
--- a/bin/lib.dom.d.ts
+++ b/bin/lib.dom.d.ts
@@ -142,6 +142,7 @@ interface KeyAlgorithm {
 }
 
 interface KeyboardEventInit extends EventModifierInit {
+    code?: string;
     key?: string;
     location?: number;
     repeat?: boolean;
@@ -2304,7 +2305,7 @@ declare var DeviceRotationRate: {
     new(): DeviceRotationRate;
 }
 
-interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent {
+interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent, ParentNode {
     /**
       * Sets or gets the URL for the current document. 
       */
@@ -3367,7 +3368,7 @@ declare var Document: {
     new(): Document;
 }
 
-interface DocumentFragment extends Node, NodeSelector {
+interface DocumentFragment extends Node, NodeSelector, ParentNode {
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -3436,7 +3437,7 @@ declare var EXT_texture_filter_anisotropic: {
     readonly TEXTURE_MAX_ANISOTROPY_EXT: number;
 }
 
-interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode {
+interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode, ParentNode {
     readonly classList: DOMTokenList;
     className: string;
     readonly clientHeight: number;
@@ -3691,6 +3692,16 @@ interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelec
     getElementsByClassName(classNames: string): NodeListOf<Element>;
     matches(selector: string): boolean;
     closest(selector: string): Element | null;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    insertAdjacentElement(position: string, insertedElement: Element): Element | null;
+    insertAdjacentHTML(where: string, html: string): void;
+    insertAdjacentText(where: string, text: string): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -4462,7 +4473,7 @@ interface HTMLCanvasElement extends HTMLElement {
       * @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;
-    toBlob(callback: (result: Blob | null) => void, ... arguments: any[]): void;
+    toBlob(callback: (result: Blob | null) => void, type?: string, ...arguments: any[]): void;
 }
 
 declare var HTMLCanvasElement: {
@@ -4637,11 +4648,7 @@ interface HTMLElement extends Element {
     click(): void;
     dragDrop(): boolean;
     focus(): void;
-    insertAdjacentElement(position: string, insertedElement: Element): Element;
-    insertAdjacentHTML(where: string, html: string): void;
-    insertAdjacentText(where: string, text: string): void;
     msGetInputContext(): MSInputMethodContext;
-    scrollIntoView(top?: boolean): void;
     setActive(): void;
     addEventListener(type: "MSContentZoom", listener: (this: this, ev: UIEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -5906,6 +5913,7 @@ interface HTMLLinkElement extends HTMLElement, LinkStyle {
       */
     type: string;
     import?: Document;
+    integrity: string;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -6194,7 +6202,7 @@ interface HTMLMediaElement extends HTMLElement {
       */
     canPlayType(type: string): string;
     /**
-      * Fires immediately after the client loads the object.
+      * Resets the audio or video object and loads a new media resource.
       */
     load(): void;
     /**
@@ -6767,6 +6775,7 @@ interface HTMLScriptElement extends HTMLElement {
       * Sets or retrieves the MIME type for the associated scripting engine.
       */
     type: string;
+    integrity: string;
 }
 
 declare var HTMLScriptElement: {
@@ -7772,6 +7781,7 @@ interface KeyboardEvent extends UIEvent {
     readonly repeat: boolean;
     readonly shiftKey: boolean;
     readonly which: number;
+    readonly code: string;
     getModifierState(keyArg: string): boolean;
     initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void;
     readonly DOM_KEY_LOCATION_JOYSTICK: number;
@@ -9144,6 +9154,7 @@ interface PerformanceTiming {
     readonly responseStart: number;
     readonly unloadEventEnd: number;
     readonly unloadEventStart: number;
+    readonly secureConnectionStart: number;
     toJSON(): any;
 }
 
@@ -11421,8 +11432,8 @@ declare var StereoPannerNode: {
 interface Storage {
     readonly length: number;
     clear(): void;
-    getItem(key: string): string;
-    key(index: number): string;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
     removeItem(key: string): void;
     setItem(key: string, data: string): void;
     [key: string]: any;
@@ -12963,7 +12974,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     onunload: (this: this, ev: Event) => any;
     onvolumechange: (this: this, ev: Event) => any;
     onwaiting: (this: this, ev: Event) => any;
-    readonly opener: Window;
+    opener: any;
     orientation: string | number;
     readonly outerHeight: number;
     readonly outerWidth: number;
@@ -13018,6 +13029,9 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+    scroll(options?: ScrollToOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollBy(options?: ScrollToOptions): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -14045,6 +14059,20 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+interface ScrollOptions {
+    behavior?: ScrollBehavior;
+}
+
+interface ScrollToOptions extends ScrollOptions {
+    left?: number;
+    top?: number;
+}
+
+interface ScrollIntoViewOptions extends ScrollOptions {
+    block?: ScrollLogicalPosition;
+    inline?: ScrollLogicalPosition;
+}
+
 interface ClipboardEventInit extends EventInit {
     data?: string;
     dataType?: string;
@@ -14088,7 +14116,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {
@@ -14224,6 +14252,13 @@ interface JsonWebKey {
     k?: string;
 }
 
+interface ParentNode {
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    readonly childElementCount: number;
+}
+
 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
 interface ErrorEventHandler {
@@ -14294,7 +14329,7 @@ declare var location: Location;
 declare var locationbar: BarProp;
 declare var menubar: BarProp;
 declare var msCredentials: MSCredentials;
-declare var name: string;
+declare const name: never;
 declare var navigator: Navigator;
 declare var offscreenBuffering: string | boolean;
 declare var onabort: (this: Window, ev: UIEvent) => any;
@@ -14388,7 +14423,7 @@ declare var ontouchstart: (ev: TouchEvent) => any;
 declare var onunload: (this: Window, ev: Event) => any;
 declare var onvolumechange: (this: Window, ev: Event) => any;
 declare var onwaiting: (this: Window, ev: Event) => any;
-declare var opener: Window;
+declare var opener: any;
 declare var orientation: string | number;
 declare var outerHeight: number;
 declare var outerWidth: number;
@@ -14441,6 +14476,9 @@ declare function webkitCancelAnimationFrame(handle: number): void;
 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+declare function scroll(options?: ScrollToOptions): void;
+declare function scrollTo(options?: ScrollToOptions): void;
+declare function scrollBy(options?: ScrollToOptions): void;
 declare function toString(): string;
 declare function addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 declare function dispatchEvent(evt: Event): boolean;
@@ -14596,6 +14634,8 @@ type MSOutboundPayload = MSVideoSendPayload | MSAudioSendPayload;
 type RTCIceGatherCandidate = RTCIceCandidate | RTCIceCandidateComplete;
 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
 type payloadtype = number;
+type ScrollBehavior = "auto" | "instant" | "smooth";
+type ScrollLogicalPosition = "start" | "center" | "end" | "nearest";
 type IDBValidKey = number | string | Date | IDBArrayKey;
 type BufferSource = ArrayBuffer | ArrayBufferView;
 type MouseWheelEvent = WheelEvent;
\ No newline at end of file
diff --git a/bin/lib.es6.d.ts b/bin/lib.es6.d.ts
index c2c0494..084ed4e 100644
--- a/bin/lib.es6.d.ts
+++ b/bin/lib.es6.d.ts
@@ -5866,6 +5866,7 @@ interface KeyAlgorithm {
 }
 
 interface KeyboardEventInit extends EventModifierInit {
+    code?: string;
     key?: string;
     location?: number;
     repeat?: boolean;
@@ -8028,7 +8029,7 @@ declare var DeviceRotationRate: {
     new(): DeviceRotationRate;
 }
 
-interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent {
+interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent, ParentNode {
     /**
       * Sets or gets the URL for the current document. 
       */
@@ -9091,7 +9092,7 @@ declare var Document: {
     new(): Document;
 }
 
-interface DocumentFragment extends Node, NodeSelector {
+interface DocumentFragment extends Node, NodeSelector, ParentNode {
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -9160,7 +9161,7 @@ declare var EXT_texture_filter_anisotropic: {
     readonly TEXTURE_MAX_ANISOTROPY_EXT: number;
 }
 
-interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode {
+interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode, ParentNode {
     readonly classList: DOMTokenList;
     className: string;
     readonly clientHeight: number;
@@ -9415,6 +9416,16 @@ interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelec
     getElementsByClassName(classNames: string): NodeListOf<Element>;
     matches(selector: string): boolean;
     closest(selector: string): Element | null;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    insertAdjacentElement(position: string, insertedElement: Element): Element | null;
+    insertAdjacentHTML(where: string, html: string): void;
+    insertAdjacentText(where: string, text: string): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -10186,7 +10197,7 @@ interface HTMLCanvasElement extends HTMLElement {
       * @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;
-    toBlob(callback: (result: Blob | null) => void, ... arguments: any[]): void;
+    toBlob(callback: (result: Blob | null) => void, type?: string, ...arguments: any[]): void;
 }
 
 declare var HTMLCanvasElement: {
@@ -10361,11 +10372,7 @@ interface HTMLElement extends Element {
     click(): void;
     dragDrop(): boolean;
     focus(): void;
-    insertAdjacentElement(position: string, insertedElement: Element): Element;
-    insertAdjacentHTML(where: string, html: string): void;
-    insertAdjacentText(where: string, text: string): void;
     msGetInputContext(): MSInputMethodContext;
-    scrollIntoView(top?: boolean): void;
     setActive(): void;
     addEventListener(type: "MSContentZoom", listener: (this: this, ev: UIEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -11630,6 +11637,7 @@ interface HTMLLinkElement extends HTMLElement, LinkStyle {
       */
     type: string;
     import?: Document;
+    integrity: string;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -11918,7 +11926,7 @@ interface HTMLMediaElement extends HTMLElement {
       */
     canPlayType(type: string): string;
     /**
-      * Fires immediately after the client loads the object.
+      * Resets the audio or video object and loads a new media resource.
       */
     load(): void;
     /**
@@ -12491,6 +12499,7 @@ interface HTMLScriptElement extends HTMLElement {
       * Sets or retrieves the MIME type for the associated scripting engine.
       */
     type: string;
+    integrity: string;
 }
 
 declare var HTMLScriptElement: {
@@ -13496,6 +13505,7 @@ interface KeyboardEvent extends UIEvent {
     readonly repeat: boolean;
     readonly shiftKey: boolean;
     readonly which: number;
+    readonly code: string;
     getModifierState(keyArg: string): boolean;
     initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void;
     readonly DOM_KEY_LOCATION_JOYSTICK: number;
@@ -14868,6 +14878,7 @@ interface PerformanceTiming {
     readonly responseStart: number;
     readonly unloadEventEnd: number;
     readonly unloadEventStart: number;
+    readonly secureConnectionStart: number;
     toJSON(): any;
 }
 
@@ -17145,8 +17156,8 @@ declare var StereoPannerNode: {
 interface Storage {
     readonly length: number;
     clear(): void;
-    getItem(key: string): string;
-    key(index: number): string;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
     removeItem(key: string): void;
     setItem(key: string, data: string): void;
     [key: string]: any;
@@ -18687,7 +18698,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     onunload: (this: this, ev: Event) => any;
     onvolumechange: (this: this, ev: Event) => any;
     onwaiting: (this: this, ev: Event) => any;
-    readonly opener: Window;
+    opener: any;
     orientation: string | number;
     readonly outerHeight: number;
     readonly outerWidth: number;
@@ -18742,6 +18753,9 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+    scroll(options?: ScrollToOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollBy(options?: ScrollToOptions): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -19769,6 +19783,20 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+interface ScrollOptions {
+    behavior?: ScrollBehavior;
+}
+
+interface ScrollToOptions extends ScrollOptions {
+    left?: number;
+    top?: number;
+}
+
+interface ScrollIntoViewOptions extends ScrollOptions {
+    block?: ScrollLogicalPosition;
+    inline?: ScrollLogicalPosition;
+}
+
 interface ClipboardEventInit extends EventInit {
     data?: string;
     dataType?: string;
@@ -19812,7 +19840,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {
@@ -19948,6 +19976,13 @@ interface JsonWebKey {
     k?: string;
 }
 
+interface ParentNode {
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    readonly childElementCount: number;
+}
+
 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
 interface ErrorEventHandler {
@@ -20018,7 +20053,7 @@ declare var location: Location;
 declare var locationbar: BarProp;
 declare var menubar: BarProp;
 declare var msCredentials: MSCredentials;
-declare var name: string;
+declare const name: never;
 declare var navigator: Navigator;
 declare var offscreenBuffering: string | boolean;
 declare var onabort: (this: Window, ev: UIEvent) => any;
@@ -20112,7 +20147,7 @@ declare var ontouchstart: (ev: TouchEvent) => any;
 declare var onunload: (this: Window, ev: Event) => any;
 declare var onvolumechange: (this: Window, ev: Event) => any;
 declare var onwaiting: (this: Window, ev: Event) => any;
-declare var opener: Window;
+declare var opener: any;
 declare var orientation: string | number;
 declare var outerHeight: number;
 declare var outerWidth: number;
@@ -20165,6 +20200,9 @@ declare function webkitCancelAnimationFrame(handle: number): void;
 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+declare function scroll(options?: ScrollToOptions): void;
+declare function scrollTo(options?: ScrollToOptions): void;
+declare function scrollBy(options?: ScrollToOptions): void;
 declare function toString(): string;
 declare function addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 declare function dispatchEvent(evt: Event): boolean;
@@ -20320,6 +20358,8 @@ type MSOutboundPayload = MSVideoSendPayload | MSAudioSendPayload;
 type RTCIceGatherCandidate = RTCIceCandidate | RTCIceCandidateComplete;
 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
 type payloadtype = number;
+type ScrollBehavior = "auto" | "instant" | "smooth";
+type ScrollLogicalPosition = "start" | "center" | "end" | "nearest";
 type IDBValidKey = number | string | Date | IDBArrayKey;
 type BufferSource = ArrayBuffer | ArrayBufferView;
 type MouseWheelEvent = WheelEvent;
diff --git a/bin/lib.webworker.d.ts b/bin/lib.webworker.d.ts
index be707d2..5b35d82 100644
--- a/bin/lib.webworker.d.ts
+++ b/bin/lib.webworker.d.ts
@@ -1016,7 +1016,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {
diff --git a/bin/ntypescript.d.ts b/bin/ntypescript.d.ts
index afa4a18..824f2d5 100644
--- a/bin/ntypescript.d.ts
+++ b/bin/ntypescript.d.ts
@@ -304,8 +304,11 @@ declare namespace ts {
         JSDocPropertyTag = 280,
         JSDocTypeLiteral = 281,
         JSDocLiteralType = 282,
-        SyntaxList = 283,
-        Count = 284,
+        JSDocNullKeyword = 283,
+        JSDocUndefinedKeyword = 284,
+        JSDocNeverKeyword = 285,
+        SyntaxList = 286,
+        Count = 287,
         FirstAssignment = 56,
         LastAssignment = 68,
         FirstReservedWord = 70,
@@ -332,7 +335,7 @@ declare namespace ts {
         FirstJSDocNode = 257,
         LastJSDocNode = 282,
         FirstJSDocTagNode = 273,
-        LastJSDocTagNode = 282,
+        LastJSDocTagNode = 285,
     }
     enum NodeFlags {
         None = 0,
@@ -1693,10 +1696,6 @@ declare namespace ts {
     interface GenericType extends InterfaceType, TypeReference {
         instantiations: Map<TypeReference>;
     }
-    interface TupleType extends ObjectType {
-        elementTypes: Type[];
-        thisType?: Type;
-    }
     interface UnionOrIntersectionType extends Type {
         types: Type[];
         resolvedProperties: SymbolTable;
@@ -2605,6 +2604,7 @@ declare namespace ts {
     function nodeIsPresent(node: Node): boolean;
     function getTokenPosOfNode(node: Node, sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
     function isJSDocNode(node: Node): boolean;
+    function isJSDocTag(node: Node): boolean;
     function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFile): number;
     function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node, includeTrivia?: boolean): string;
     function getTextOfNodeFromSourceText(sourceText: string, node: Node): string;
@@ -7827,6 +7827,10 @@ declare namespace ts {
     function stripQuotes(name: string): string;
     function scriptKindIs(fileName: string, host: LanguageServiceHost, ...scriptKinds: ScriptKind[]): boolean;
     function getScriptKind(fileName: string, host?: LanguageServiceHost): ScriptKind;
+    function parseAndReEmitConfigJSONFile(content: string): {
+        configJsonObject: any;
+        diagnostics: Diagnostic[];
+    };
 }
 declare namespace ts.JsTyping {
     interface TypingResolutionHost {
diff --git a/bin/ntypescript.js b/bin/ntypescript.js
index 53c9f71..400750c 100644
--- a/bin/ntypescript.js
+++ b/bin/ntypescript.js
@@ -320,10 +320,13 @@ var ts;
         SyntaxKind[SyntaxKind["JSDocPropertyTag"] = 280] = "JSDocPropertyTag";
         SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 281] = "JSDocTypeLiteral";
         SyntaxKind[SyntaxKind["JSDocLiteralType"] = 282] = "JSDocLiteralType";
+        SyntaxKind[SyntaxKind["JSDocNullKeyword"] = 283] = "JSDocNullKeyword";
+        SyntaxKind[SyntaxKind["JSDocUndefinedKeyword"] = 284] = "JSDocUndefinedKeyword";
+        SyntaxKind[SyntaxKind["JSDocNeverKeyword"] = 285] = "JSDocNeverKeyword";
         // Synthesized list
-        SyntaxKind[SyntaxKind["SyntaxList"] = 283] = "SyntaxList";
+        SyntaxKind[SyntaxKind["SyntaxList"] = 286] = "SyntaxList";
         // Enum value count
-        SyntaxKind[SyntaxKind["Count"] = 284] = "Count";
+        SyntaxKind[SyntaxKind["Count"] = 287] = "Count";
         // Markers
         SyntaxKind[SyntaxKind["FirstAssignment"] = 56] = "FirstAssignment";
         SyntaxKind[SyntaxKind["LastAssignment"] = 68] = "LastAssignment";
@@ -351,7 +354,7 @@ var ts;
         SyntaxKind[SyntaxKind["FirstJSDocNode"] = 257] = "FirstJSDocNode";
         SyntaxKind[SyntaxKind["LastJSDocNode"] = 282] = "LastJSDocNode";
         SyntaxKind[SyntaxKind["FirstJSDocTagNode"] = 273] = "FirstJSDocTagNode";
-        SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 282] = "LastJSDocTagNode";
+        SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 285] = "LastJSDocTagNode";
     })(ts.SyntaxKind || (ts.SyntaxKind = {}));
     var SyntaxKind = ts.SyntaxKind;
     (function (NodeFlags) {
@@ -3128,7 +3131,7 @@ var ts;
         // the syntax list itself considers them as normal trivia. Therefore if we simply skip
         // trivia for the list, we may have skipped the JSDocComment as well. So we should process its
         // first child to determine the actual position of its first token.
-        if (node.kind === 283 /* SyntaxList */ && node._children.length > 0) {
+        if (node.kind === 286 /* SyntaxList */ && node._children.length > 0) {
             return getTokenPosOfNode(node._children[0], sourceFile, includeJsDocComment);
         }
         return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);
@@ -3138,6 +3141,10 @@ var ts;
         return node.kind >= 257 /* FirstJSDocNode */ && node.kind <= 282 /* LastJSDocNode */;
     }
     ts.isJSDocNode = isJSDocNode;
+    function isJSDocTag(node) {
+        return node.kind >= 273 /* FirstJSDocTagNode */ && node.kind <= 285 /* LastJSDocTagNode */;
+    }
+    ts.isJSDocTag = isJSDocTag;
     function getNonDecoratorTokenPosOfNode(node, sourceFile) {
         if (nodeIsMissing(node) || !node.decorators) {
             return getTokenPosOfNode(node, sourceFile);
@@ -9023,7 +9030,7 @@ var ts;
             // Note: it is not actually necessary to save/restore the context flags here.  That's
             // because the saving/restoring of these flags happens naturally through the recursive
             // descent nature of our parser.  However, we still store this here just so we can
-            // assert that that invariant holds.
+            // assert that invariant holds.
             var saveContextFlags = contextFlags;
             // If we're only looking ahead, then tell the scanner to only lookahead as well.
             // Otherwise, if we're actually speculatively parsing, then tell the scanner to do the
@@ -10629,7 +10636,7 @@ var ts;
             //
             // Note: for ease of implementation we treat productions '2' and '3' as the same thing.
             // (i.e. they're both BinaryExpressions with an assignment operator in it).
-            // First, do the simple check if we have a YieldExpression (production '5').
+            // First, do the simple check if we have a YieldExpression (production '6').
             if (isYieldExpression()) {
                 return parseYieldExpression();
             }
@@ -11158,22 +11165,39 @@ var ts;
             return finishNode(node);
         }
         /**
-         * Parse ES7 unary expression and await expression
+         * Parse ES7 exponential expression and await expression
+         *
+         * ES7 ExponentiationExpression:
+         *      1) UnaryExpression[?Yield]
+         *      2) UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]
          *
-         * ES7 UnaryExpression:
-         *      1) SimpleUnaryExpression[?yield]
-         *      2) IncrementExpression[?yield] ** UnaryExpression[?yield]
          */
         function parseUnaryExpressionOrHigher() {
-            if (isAwaitExpression()) {
-                return parseAwaitExpression();
-            }
-            if (isIncrementExpression()) {
+            /**
+             * ES7 UpdateExpression:
+             *      1) LeftHandSideExpression[?Yield]
+             *      2) LeftHandSideExpression[?Yield][no LineTerminator here]++
+             *      3) LeftHandSideExpression[?Yield][no LineTerminator here]--
+             *      4) ++UnaryExpression[?Yield]
+             *      5) --UnaryExpression[?Yield]
+             */
+            if (isUpdateExpression()) {
                 var incrementExpression = parseIncrementExpression();
                 return token() === 38 /* AsteriskAsteriskToken */ ?
                     parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
                     incrementExpression;
             }
+            /**
+             * ES7 UnaryExpression:
+             *      1) UpdateExpression[?yield]
+             *      2) delete UpdateExpression[?yield]
+             *      3) void UpdateExpression[?yield]
+             *      4) typeof UpdateExpression[?yield]
+             *      5) + UpdateExpression[?yield]
+             *      6) - UpdateExpression[?yield]
+             *      7) ~ UpdateExpression[?yield]
+             *      8) ! UpdateExpression[?yield]
+             */
             var unaryOperator = token();
             var simpleUnaryExpression = parseSimpleUnaryExpression();
             if (token() === 38 /* AsteriskAsteriskToken */) {
@@ -11190,8 +11214,8 @@ var ts;
         /**
          * Parse ES7 simple-unary expression or higher:
          *
-         * ES7 SimpleUnaryExpression:
-         *      1) IncrementExpression[?yield]
+         * ES7 UnaryExpression:
+         *      1) UpdateExpression[?yield]
          *      2) delete UnaryExpression[?yield]
          *      3) void UnaryExpression[?yield]
          *      4) typeof UnaryExpression[?yield]
@@ -11214,13 +11238,15 @@ var ts;
                     return parseTypeOfExpression();
                 case 103 /* VoidKeyword */:
                     return parseVoidExpression();
-                case 119 /* AwaitKeyword */:
-                    return parseAwaitExpression();
                 case 25 /* LessThanToken */:
                     // This is modified UnaryExpression grammar in TypeScript
                     //  UnaryExpression (modified):
                     //      < type > UnaryExpression
                     return parseTypeAssertion();
+                case 119 /* AwaitKeyword */:
+                    if (isAwaitExpression()) {
+                        return parseAwaitExpression();
+                    }
                 default:
                     return parseIncrementExpression();
             }
@@ -11228,14 +11254,14 @@ var ts;
         /**
          * Check if the current token can possibly be an ES7 increment expression.
          *
-         * ES7 IncrementExpression:
+         * ES7 UpdateExpression:
          *      LeftHandSideExpression[?Yield]
          *      LeftHandSideExpression[?Yield][no LineTerminator here]++
          *      LeftHandSideExpression[?Yield][no LineTerminator here]--
          *      ++LeftHandSideExpression[?Yield]
          *      --LeftHandSideExpression[?Yield]
          */
-        function isIncrementExpression() {
+        function isUpdateExpression() {
             // This function is called inside parseUnaryExpression to decide
             // whether to call parseSimpleUnaryExpression or call parseIncrementExpression directly
             switch (token()) {
@@ -11246,6 +11272,7 @@ var ts;
                 case 78 /* DeleteKeyword */:
                 case 101 /* TypeOfKeyword */:
                 case 103 /* VoidKeyword */:
+                case 119 /* AwaitKeyword */:
                     return false;
                 case 25 /* LessThanToken */:
                     // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
@@ -13391,6 +13418,9 @@ var ts;
                     case 120 /* BooleanKeyword */:
                     case 133 /* SymbolKeyword */:
                     case 103 /* VoidKeyword */:
+                    case 93 /* NullKeyword */:
+                    case 135 /* UndefinedKeyword */:
+                    case 127 /* NeverKeyword */:
                         return parseTokenNode();
                     case 9 /* StringLiteral */:
                     case 8 /* NumericLiteral */:
@@ -16544,7 +16574,7 @@ var ts;
             getJsxIntrinsicTagNames: getJsxIntrinsicTagNames,
             isOptionalParameter: isOptionalParameter
         };
-        var tupleTypes = ts.createMap();
+        var tupleTypes = [];
         var unionTypes = ts.createMap();
         var intersectionTypes = ts.createMap();
         var stringLiteralTypes = ts.createMap();
@@ -17482,13 +17512,13 @@ var ts;
                     else {
                         symbolFromVariable = getPropertyOfVariable(targetSymbol, name_10.text);
                     }
-                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
-                    if (!symbolFromVariable && allowSyntheticDefaultImports && name_10.text === "default") {
-                        symbolFromVariable = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
-                    }
                     // if symbolFromVariable is export - get its final target
                     symbolFromVariable = resolveSymbol(symbolFromVariable);
                     var symbolFromModule = getExportOfModule(targetSymbol, name_10.text);
+                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
+                    if (!symbolFromModule && allowSyntheticDefaultImports && name_10.text === "default") {
+                        symbolFromModule = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
+                    }
                     var symbol = symbolFromModule && symbolFromVariable ?
                         combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
                         symbolFromModule || symbolFromVariable;
@@ -18378,9 +18408,6 @@ var ts;
                         // The specified symbol flags need to be reinterpreted as type flags
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 793064 /* Type */, 0 /* None */, nextFlags);
                     }
-                    else if (type.flags & 262144 /* Tuple */) {
-                        writeTupleType(type);
-                    }
                     else if (!(flags & 512 /* InTypeAlias */) && type.flags & (2097152 /* Anonymous */ | 1572864 /* UnionOrIntersection */) && type.aliasSymbol) {
                         var typeArguments = type.aliasTypeArguments;
                         writeSymbolTypeReference(type.aliasSymbol, typeArguments, 0, typeArguments ? typeArguments.length : 0, nextFlags);
@@ -18444,6 +18471,11 @@ var ts;
                         writePunctuation(writer, 19 /* OpenBracketToken */);
                         writePunctuation(writer, 20 /* CloseBracketToken */);
                     }
+                    else if (type.target.flags & 262144 /* Tuple */) {
+                        writePunctuation(writer, 19 /* OpenBracketToken */);
+                        writeTypeList(type.typeArguments.slice(0, getTypeReferenceArity(type)), 24 /* CommaToken */);
+                        writePunctuation(writer, 20 /* CloseBracketToken */);
+                    }
                     else {
                         // Write the type reference in the format f<A>.g<B>.C<X, Y> where A and B are type arguments
                         // for outer type parameters, and f and g are the respective declaring containers of those
@@ -18471,11 +18503,6 @@ var ts;
                         writeSymbolTypeReference(type.symbol, typeArguments, i, typeParameterCount, flags);
                     }
                 }
-                function writeTupleType(type) {
-                    writePunctuation(writer, 19 /* OpenBracketToken */);
-                    writeTypeList(type.elementTypes, 24 /* CommaToken */);
-                    writePunctuation(writer, 20 /* CloseBracketToken */);
-                }
                 function writeUnionOrIntersectionType(type, flags) {
                     if (flags & 64 /* InElementType */) {
                         writePunctuation(writer, 17 /* OpenParenToken */);
@@ -19131,7 +19158,7 @@ var ts;
                         : elementType;
                     if (!type) {
                         if (isTupleType(parentType)) {
-                            error(declaration, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), parentType.elementTypes.length, pattern.elements.length);
+                            error(declaration, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), getTypeReferenceArity(parentType), pattern.elements.length);
                         }
                         else {
                             error(declaration, ts.Diagnostics.Type_0_has_no_property_1, typeToString(parentType), propName);
@@ -19231,9 +19258,14 @@ var ts;
                     }
                 }
                 // Use contextual parameter type if one is available
-                var type = declaration.symbol.name === "this"
-                    ? getContextuallyTypedThisType(func)
-                    : getContextuallyTypedParameterType(declaration);
+                var type = void 0;
+                if (declaration.symbol.name === "this") {
+                    var thisParameter = getContextualThisParameter(func);
+                    type = thisParameter ? getTypeOfSymbol(thisParameter) : undefined;
+                }
+                else {
+                    type = getContextuallyTypedParameterType(declaration);
+                }
                 if (type) {
                     return addOptionality(type, /*optional*/ declaration.questionToken && includeOptionality);
                 }
@@ -19303,12 +19335,12 @@ var ts;
             }
             // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
             var elementTypes = ts.map(elements, function (e) { return e.kind === 193 /* OmittedExpression */ ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors); });
+            var result = createTupleType(elementTypes);
             if (includePatternInType) {
-                var result = createNewTupleType(elementTypes);
+                result = cloneTypeReference(result);
                 result.pattern = pattern;
-                return result;
             }
-            return createTupleType(elementTypes);
+            return result;
         }
         // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself
         // and without regard to its context (i.e. without regard any type annotation or initializer associated with the
@@ -19679,17 +19711,20 @@ var ts;
             return type.resolvedBaseConstructorType;
         }
         function getBaseTypes(type) {
-            var isClass = type.symbol.flags & 32 /* Class */;
-            var isInterface = type.symbol.flags & 64 /* Interface */;
             if (!type.resolvedBaseTypes) {
-                if (!isClass && !isInterface) {
-                    ts.Debug.fail("type must be class or interface");
+                if (type.flags & 262144 /* Tuple */) {
+                    type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters))];
                 }
-                if (isClass) {
-                    resolveBaseTypesOfClass(type);
+                else if (type.symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
+                    if (type.symbol.flags & 32 /* Class */) {
+                        resolveBaseTypesOfClass(type);
+                    }
+                    if (type.symbol.flags & 64 /* Interface */) {
+                        resolveBaseTypesOfInterface(type);
+                    }
                 }
-                if (isInterface) {
-                    resolveBaseTypesOfInterface(type);
+                else {
+                    ts.Debug.fail("type must be class or interface");
                 }
             }
             return type.resolvedBaseTypes;
@@ -20102,19 +20137,24 @@ var ts;
             if (type.flags & 131072 /* Reference */) {
                 return createTypeReference(type.target, ts.concatenate(type.typeArguments, [thisArgument || type.target.thisType]));
             }
-            if (type.flags & 262144 /* Tuple */) {
-                return createTupleType(type.elementTypes, thisArgument);
-            }
             return type;
         }
         function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
-            var mapper = identityMapper;
-            var members = source.symbol.members;
-            var callSignatures = source.declaredCallSignatures;
-            var constructSignatures = source.declaredConstructSignatures;
-            var stringIndexInfo = source.declaredStringIndexInfo;
-            var numberIndexInfo = source.declaredNumberIndexInfo;
-            if (!ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+            var mapper;
+            var members;
+            var callSignatures;
+            var constructSignatures;
+            var stringIndexInfo;
+            var numberIndexInfo;
+            if (ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+                mapper = identityMapper;
+                members = source.symbol ? source.symbol.members : createSymbolTable(source.declaredProperties);
+                callSignatures = source.declaredCallSignatures;
+                constructSignatures = source.declaredConstructSignatures;
+                stringIndexInfo = source.declaredStringIndexInfo;
+                numberIndexInfo = source.declaredNumberIndexInfo;
+            }
+            else {
                 mapper = createTypeMapper(typeParameters, typeArguments);
                 members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1);
                 callSignatures = instantiateList(source.declaredCallSignatures, mapper, instantiateSignature);
@@ -20124,7 +20164,7 @@ var ts;
             }
             var baseTypes = getBaseTypes(source);
             if (baseTypes.length) {
-                if (members === source.symbol.members) {
+                if (source.symbol && members === source.symbol.members) {
                     members = createSymbolTable(source.declaredProperties);
                 }
                 var thisArgument = ts.lastOrUndefined(typeArguments);
@@ -20188,24 +20228,6 @@ var ts;
             }
             return result;
         }
-        function createTupleTypeMemberSymbols(memberTypes) {
-            var members = ts.createMap();
-            for (var i = 0; i < memberTypes.length; i++) {
-                var symbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "" + i);
-                symbol.type = memberTypes[i];
-                members[i] = symbol;
-            }
-            return members;
-        }
-        function resolveTupleTypeMembers(type) {
-            var arrayElementType = getUnionType(type.elementTypes);
-            // Make the tuple type itself the 'this' type by including an extra type argument
-            // (Unless it's provided in the case that the tuple is a type parameter constraint)
-            var arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type.thisType || type]));
-            var members = createTupleTypeMemberSymbols(type.elementTypes);
-            addInheritedMembers(members, arrayType.properties);
-            setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
-        }
         function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) {
             for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
                 var s = signatureList_1[_i];
@@ -20378,9 +20400,6 @@ var ts;
                 else if (type.flags & 2097152 /* Anonymous */) {
                     resolveAnonymousTypeMembers(type);
                 }
-                else if (type.flags & 262144 /* Tuple */) {
-                    resolveTupleTypeMembers(type);
-                }
                 else if (type.flags & 524288 /* Union */) {
                     resolveUnionTypeMembers(type);
                 }
@@ -20749,6 +20768,9 @@ var ts;
                 if (isJSConstructSignature) {
                     minArgumentCount--;
                 }
+                if (!thisParameter && ts.isObjectLiteralMethod(declaration)) {
+                    thisParameter = getContextualThisParameter(declaration);
+                }
                 var classType = declaration.kind === 148 /* Constructor */ ?
                     getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol))
                     : undefined;
@@ -21021,6 +21043,15 @@ var ts;
             }
             return type;
         }
+        function cloneTypeReference(source) {
+            var type = createObjectType(source.flags, source.symbol);
+            type.target = source.target;
+            type.typeArguments = source.typeArguments;
+            return type;
+        }
+        function getTypeReferenceArity(type) {
+            return type.target.typeParameters ? type.target.typeParameters.length : 0;
+        }
         // Get type from reference to class or interface
         function getTypeFromClassOrInterfaceReference(node, symbol) {
             var type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
@@ -21232,17 +21263,46 @@ var ts;
             }
             return links.resolvedType;
         }
-        function createTupleType(elementTypes, thisType) {
-            var id = getTypeListId(elementTypes) + "," + (thisType ? thisType.id : 0);
-            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
-        }
-        function createNewTupleType(elementTypes, thisType) {
-            var propagatedFlags = getPropagatingFlagsOfTypes(elementTypes, /*excludeKinds*/ 0);
-            var type = createObjectType(262144 /* Tuple */ | propagatedFlags);
-            type.elementTypes = elementTypes;
-            type.thisType = thisType;
+        // We represent tuple types as type references to synthesized generic interface types created by
+        // this function. The types are of the form:
+        //
+        //   interface Tuple<T0, T1, T2, ...> extends Array<T0 | T1 | T2 | ...> { 0: T0, 1: T1, 2: T2, ... }
+        //
+        // Note that the generic type created by this function has no symbol associated with it. The same
+        // is true for each of the synthesized type parameters.
+        function createTupleTypeOfArity(arity) {
+            var typeParameters = [];
+            var properties = [];
+            for (var i = 0; i < arity; i++) {
+                var typeParameter = createType(16384 /* TypeParameter */);
+                typeParameters.push(typeParameter);
+                var property = createSymbol(4 /* Property */ | 67108864 /* Transient */, "" + i);
+                property.type = typeParameter;
+                properties.push(property);
+            }
+            var type = createObjectType(262144 /* Tuple */ | 131072 /* Reference */);
+            type.typeParameters = typeParameters;
+            type.outerTypeParameters = undefined;
+            type.localTypeParameters = typeParameters;
+            type.instantiations = ts.createMap();
+            type.instantiations[getTypeListId(type.typeParameters)] = type;
+            type.target = type;
+            type.typeArguments = type.typeParameters;
+            type.thisType = createType(16384 /* TypeParameter */ | 268435456 /* ThisType */);
+            type.thisType.constraint = type;
+            type.declaredProperties = properties;
+            type.declaredCallSignatures = emptyArray;
+            type.declaredConstructSignatures = emptyArray;
+            type.declaredStringIndexInfo = undefined;
+            type.declaredNumberIndexInfo = undefined;
             return type;
         }
+        function getTupleTypeOfArity(arity) {
+            return tupleTypes[arity] || (tupleTypes[arity] = createTupleTypeOfArity(arity));
+        }
+        function createTupleType(elementTypes) {
+            return createTypeReference(getTupleTypeOfArity(elementTypes.length), elementTypes);
+        }
         function getTypeFromTupleTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
@@ -21524,6 +21584,12 @@ var ts;
                     return nullType;
                 case 127 /* NeverKeyword */:
                     return neverType;
+                case 283 /* JSDocNullKeyword */:
+                    return nullType;
+                case 284 /* JSDocUndefinedKeyword */:
+                    return undefinedType;
+                case 285 /* JSDocNeverKeyword */:
+                    return neverType;
                 case 165 /* ThisType */:
                 case 97 /* ThisKeyword */:
                     return getTypeFromThisTypeNode(node);
@@ -21796,9 +21862,6 @@ var ts;
                 if (type.flags & 131072 /* Reference */) {
                     return createTypeReference(type.target, instantiateList(type.typeArguments, mapper, instantiateType));
                 }
-                if (type.flags & 262144 /* Tuple */) {
-                    return createTupleType(instantiateList(type.elementTypes, mapper, instantiateType));
-                }
                 if (type.flags & 524288 /* Union */ && !(type.flags & 8190 /* Primitive */)) {
                     return getUnionType(instantiateList(type.types, mapper, instantiateType), /*subtypeReduction*/ false, type.aliasSymbol, mapper.targetTypes);
                 }
@@ -22999,7 +23062,7 @@ var ts;
          * Prefer using isTupleLikeType() unless the use of `elementTypes` is required.
          */
         function isTupleType(type) {
-            return !!(type.flags & 262144 /* Tuple */);
+            return !!(type.flags & 131072 /* Reference */ && type.target.flags & 262144 /* Tuple */);
         }
         function getFalsyFlagsOfTypes(types) {
             var result = 0;
@@ -23120,11 +23183,8 @@ var ts;
                 if (type.flags & 524288 /* Union */) {
                     return getUnionType(ts.map(type.types, getWidenedConstituentType));
                 }
-                if (isArrayType(type)) {
-                    return createArrayType(getWidenedType(type.typeArguments[0]));
-                }
-                if (isTupleType(type)) {
-                    return createTupleType(ts.map(type.elementTypes, getWidenedType));
+                if (isArrayType(type) || isTupleType(type)) {
+                    return createTypeReference(type.target, ts.map(type.typeArguments, getWidenedType));
                 }
             }
             return type;
@@ -23150,11 +23210,8 @@ var ts;
                     }
                 }
             }
-            if (isArrayType(type)) {
-                return reportWideningErrorsInType(type.typeArguments[0]);
-            }
-            if (isTupleType(type)) {
-                for (var _b = 0, _c = type.elementTypes; _b < _c.length; _b++) {
+            if (isArrayType(type) || isTupleType(type)) {
+                for (var _b = 0, _c = type.typeArguments; _b < _c.length; _b++) {
                     var t = _c[_b];
                     if (reportWideningErrorsInType(t)) {
                         errorReported = true;
@@ -23259,7 +23316,6 @@ var ts;
         function couldContainTypeParameters(type) {
             return !!(type.flags & 16384 /* TypeParameter */ ||
                 type.flags & 131072 /* Reference */ && ts.forEach(type.typeArguments, couldContainTypeParameters) ||
-                type.flags & 262144 /* Tuple */ && ts.forEach(type.elementTypes, couldContainTypeParameters) ||
                 type.flags & 2097152 /* Anonymous */ && type.symbol && type.symbol.flags & (8192 /* Method */ | 2048 /* TypeLiteral */ | 32 /* Class */) ||
                 type.flags & 1572864 /* UnionOrIntersection */ && couldUnionOrIntersectionContainTypeParameters(type));
         }
@@ -23360,14 +23416,6 @@ var ts;
                         inferFromTypes(sourceTypes[i], targetTypes[i]);
                     }
                 }
-                else if (source.flags & 262144 /* Tuple */ && target.flags & 262144 /* Tuple */ && source.elementTypes.length === target.elementTypes.length) {
-                    // If source and target are tuples of the same size, infer from element types
-                    var sourceTypes = source.elementTypes;
-                    var targetTypes = target.elementTypes;
-                    for (var i = 0; i < sourceTypes.length; i++) {
-                        inferFromTypes(sourceTypes[i], targetTypes[i]);
-                    }
-                }
                 else if (target.flags & 1572864 /* UnionOrIntersection */) {
                     var targetTypes = target.types;
                     var typeParameterCount = 0;
@@ -24796,10 +24844,6 @@ var ts;
                         return getInferredClassType(classSymbol);
                     }
                 }
-                var type = getContextuallyTypedThisType(container);
-                if (type) {
-                    return type;
-                }
                 var thisType = getThisTypeOfDeclaration(container);
                 if (thisType) {
                     return thisType;
@@ -25017,11 +25061,11 @@ var ts;
                 return false;
             }
         }
-        function getContextuallyTypedThisType(func) {
+        function getContextualThisParameter(func) {
             if (isContextSensitiveFunctionOrObjectLiteralMethod(func) && func.kind !== 180 /* ArrowFunction */) {
                 var contextualSignature = getContextualSignature(func);
                 if (contextualSignature) {
-                    return getThisTypeOfSignature(contextualSignature);
+                    return contextualSignature.thisParameter;
                 }
             }
             return undefined;
@@ -25539,7 +25583,7 @@ var ts;
                 // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
                 // that we get the same behavior for "var [x, y] = []" and "[x, y] = []".
                 if (inDestructuringPattern && elementTypes.length) {
-                    var type = createNewTupleType(elementTypes);
+                    var type = cloneTypeReference(createTupleType(elementTypes));
                     type.pattern = node;
                     return type;
                 }
@@ -25553,7 +25597,7 @@ var ts;
                         for (var i = elementTypes.length; i < patternElements.length; i++) {
                             var patternElement = patternElements[i];
                             if (hasDefaultValue(patternElement)) {
-                                elementTypes.push(contextualType.elementTypes[i]);
+                                elementTypes.push(contextualType.typeArguments[i]);
                             }
                             else {
                                 if (patternElement.kind !== 193 /* OmittedExpression */) {
@@ -27653,6 +27697,12 @@ var ts;
         }
         function assignContextualParameterTypes(signature, context, mapper) {
             var len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
+            if (context.thisParameter) {
+                if (!signature.thisParameter) {
+                    signature.thisParameter = createTransientSymbol(context.thisParameter, undefined);
+                }
+                assignTypeToParameterAndFixTypeParameters(signature.thisParameter, getTypeOfSymbol(context.thisParameter), mapper);
+            }
             for (var i = 0; i < len; i++) {
                 var parameter = signature.parameters[i];
                 var contextualParameterType = getTypeAtPosition(context, i);
@@ -28336,7 +28386,7 @@ var ts;
                         // such as NodeCheckFlags.LexicalThis on "this"expression.
                         checkExpression(element);
                         if (isTupleType(sourceType)) {
-                            error(element, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), sourceType.elementTypes.length, elements.length);
+                            error(element, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), getTypeReferenceArity(sourceType), elements.length);
                         }
                         else {
                             error(element, ts.Diagnostics.Type_0_has_no_property_1, typeToString(sourceType), propName);
@@ -33233,7 +33283,7 @@ var ts;
             else if (isTypeOfKind(type, 34 /* StringLike */)) {
                 return ts.TypeReferenceSerializationKind.StringLikeType;
             }
-            else if (isTypeOfKind(type, 262144 /* Tuple */)) {
+            else if (isTupleType(type)) {
                 return ts.TypeReferenceSerializationKind.ArrayLikeType;
             }
             else if (isTypeOfKind(type, 512 /* ESSymbol */)) {
@@ -39167,6 +39217,10 @@ var ts;
                 else if (node.parent.kind === 188 /* ConditionalExpression */ && node.parent.condition === node) {
                     return true;
                 }
+                else if (node.parent.kind === 185 /* PrefixUnaryExpression */ || node.parent.kind === 181 /* DeleteExpression */ ||
+                    node.parent.kind === 182 /* TypeOfExpression */ || node.parent.kind === 183 /* VoidExpression */) {
+                    return true;
+                }
                 return false;
             }
             function needsParenthesisForPropertyAccessOrInvocation(node) {
@@ -45684,8 +45738,9 @@ var ts;
             var typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
             if (typesFile) {
                 var onlyRecordFailures_1 = !directoryProbablyExists(ts.getDirectoryPath(typesFile), state.host);
-                // The package.json "typings" property must specify the file with extension, so just try that exact filename.
-                var result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures_1, state);
+                // A package.json "typings" may specify an exact filename, or may choose to omit an extension.
+                var result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures_1, state) ||
+                    tryAddingExtensions(typesFile, extensions, failedLookupLocation, onlyRecordFailures_1, state);
                 if (result) {
                     return result;
                 }
@@ -49938,7 +49993,7 @@ var ts;
         // for the position of the relevant node (or comma).
         var syntaxList = ts.forEach(node.parent.getChildren(), function (c) {
             // find syntax list that covers the span of the node
-            if (c.kind === 283 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) {
+            if (c.kind === 286 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) {
                 return c;
             }
         });
@@ -50624,6 +50679,27 @@ var ts;
         return ts.ensureScriptKind(fileName, scriptKind);
     }
     ts.getScriptKind = getScriptKind;
+    function parseAndReEmitConfigJSONFile(content) {
+        var options = {
+            fileName: "config.js",
+            compilerOptions: {
+                target: 2 /* ES6 */
+            },
+            reportDiagnostics: true
+        };
+        var _a = ts.transpileModule("(" + content + ")", options), outputText = _a.outputText, diagnostics = _a.diagnostics;
+        // Becasue the content was wrapped in "()", the start position of diagnostics needs to be subtract by 1
+        // also, the emitted result will have "(" in the beginning and ");" in the end. We need to strip these
+        // as well
+        var trimmedOutput = outputText.trim();
+        var configJsonObject = JSON.parse(trimmedOutput.substring(1, trimmedOutput.length - 2));
+        for (var _i = 0, diagnostics_4 = diagnostics; _i < diagnostics_4.length; _i++) {
+            var diagnostic = diagnostics_4[_i];
+            diagnostic.start = diagnostic.start - 1;
+        }
+        return { configJsonObject: configJsonObject, diagnostics: diagnostics };
+    }
+    ts.parseAndReEmitConfigJSONFile = parseAndReEmitConfigJSONFile;
 })(ts || (ts = {}));
 // Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0.
 // See LICENSE.txt in the project root for complete license information.
@@ -53738,7 +53814,7 @@ var ts;
             return pos;
         };
         NodeObject.prototype.createSyntaxList = function (nodes) {
-            var list = createNode(283 /* SyntaxList */, nodes.pos, nodes.end, this);
+            var list = createNode(286 /* SyntaxList */, nodes.pos, nodes.end, this);
             list._children = [];
             var pos = nodes.pos;
             for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) {
@@ -53761,7 +53837,7 @@ var ts;
                 scanner.setText((sourceFile || this.getSourceFile()).text);
                 children = [];
                 var pos_3 = this.pos;
-                var useJSDocScanner_1 = this.kind >= 273 /* FirstJSDocTagNode */ && this.kind <= 282 /* LastJSDocTagNode */;
+                var useJSDocScanner_1 = this.kind >= 273 /* FirstJSDocTagNode */ && this.kind <= 285 /* LastJSDocTagNode */;
                 var processNode = function (node) {
                     if (pos_3 < node.pos) {
                         pos_3 = _this.addSyntheticNodes(children, pos_3, node.pos, useJSDocScanner_1);
@@ -53783,6 +53859,10 @@ var ts;
                         processNode(jsDocComment);
                     }
                 }
+                // For syntactic classifications, all trivia are classcified together, including jsdoc comments.
+                // For that to work, the jsdoc comments should still be the leading trivia of the first child. 
+                // Restoring the scanner position ensures that. 
+                pos_3 = this.pos;
                 ts.forEachChild(this, processNode, processNodes);
                 if (pos_3 < this.end) {
                     this.addSyntheticNodes(children, pos_3, this.end);
@@ -59608,6 +59688,9 @@ var ts;
              * False will mean that node is not classified and traverse routine should recurse into node contents.
              */
             function tryClassifyNode(node) {
+                if (ts.isJSDocTag(node)) {
+                    return true;
+                }
                 if (ts.nodeIsMissing(node)) {
                     return true;
                 }
diff --git a/bin/typescript.d.ts b/bin/typescript.d.ts
index c1c1edf..c4db57d 100644
--- a/bin/typescript.d.ts
+++ b/bin/typescript.d.ts
@@ -304,8 +304,11 @@ declare namespace ts {
         JSDocPropertyTag = 280,
         JSDocTypeLiteral = 281,
         JSDocLiteralType = 282,
-        SyntaxList = 283,
-        Count = 284,
+        JSDocNullKeyword = 283,
+        JSDocUndefinedKeyword = 284,
+        JSDocNeverKeyword = 285,
+        SyntaxList = 286,
+        Count = 287,
         FirstAssignment = 56,
         LastAssignment = 68,
         FirstReservedWord = 70,
@@ -332,7 +335,7 @@ declare namespace ts {
         FirstJSDocNode = 257,
         LastJSDocNode = 282,
         FirstJSDocTagNode = 273,
-        LastJSDocTagNode = 282,
+        LastJSDocTagNode = 285,
     }
     const enum NodeFlags {
         None = 0,
@@ -1693,10 +1696,6 @@ declare namespace ts {
     interface GenericType extends InterfaceType, TypeReference {
         instantiations: Map<TypeReference>;
     }
-    interface TupleType extends ObjectType {
-        elementTypes: Type[];
-        thisType?: Type;
-    }
     interface UnionOrIntersectionType extends Type {
         types: Type[];
         resolvedProperties: SymbolTable;
@@ -2605,6 +2604,7 @@ declare namespace ts {
     function nodeIsPresent(node: Node): boolean;
     function getTokenPosOfNode(node: Node, sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
     function isJSDocNode(node: Node): boolean;
+    function isJSDocTag(node: Node): boolean;
     function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFile): number;
     function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node, includeTrivia?: boolean): string;
     function getTextOfNodeFromSourceText(sourceText: string, node: Node): string;
@@ -7827,6 +7827,10 @@ declare namespace ts {
     function stripQuotes(name: string): string;
     function scriptKindIs(fileName: string, host: LanguageServiceHost, ...scriptKinds: ScriptKind[]): boolean;
     function getScriptKind(fileName: string, host?: LanguageServiceHost): ScriptKind;
+    function parseAndReEmitConfigJSONFile(content: string): {
+        configJsonObject: any;
+        diagnostics: Diagnostic[];
+    };
 }
 declare namespace ts.JsTyping {
     interface TypingResolutionHost {
diff --git a/bin/typescript.js b/bin/typescript.js
index 8cec495..8d2388b 100644
--- a/bin/typescript.js
+++ b/bin/typescript.js
@@ -320,10 +320,13 @@ var ts;
         SyntaxKind[SyntaxKind["JSDocPropertyTag"] = 280] = "JSDocPropertyTag";
         SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 281] = "JSDocTypeLiteral";
         SyntaxKind[SyntaxKind["JSDocLiteralType"] = 282] = "JSDocLiteralType";
+        SyntaxKind[SyntaxKind["JSDocNullKeyword"] = 283] = "JSDocNullKeyword";
+        SyntaxKind[SyntaxKind["JSDocUndefinedKeyword"] = 284] = "JSDocUndefinedKeyword";
+        SyntaxKind[SyntaxKind["JSDocNeverKeyword"] = 285] = "JSDocNeverKeyword";
         // Synthesized list
-        SyntaxKind[SyntaxKind["SyntaxList"] = 283] = "SyntaxList";
+        SyntaxKind[SyntaxKind["SyntaxList"] = 286] = "SyntaxList";
         // Enum value count
-        SyntaxKind[SyntaxKind["Count"] = 284] = "Count";
+        SyntaxKind[SyntaxKind["Count"] = 287] = "Count";
         // Markers
         SyntaxKind[SyntaxKind["FirstAssignment"] = 56] = "FirstAssignment";
         SyntaxKind[SyntaxKind["LastAssignment"] = 68] = "LastAssignment";
@@ -351,7 +354,7 @@ var ts;
         SyntaxKind[SyntaxKind["FirstJSDocNode"] = 257] = "FirstJSDocNode";
         SyntaxKind[SyntaxKind["LastJSDocNode"] = 282] = "LastJSDocNode";
         SyntaxKind[SyntaxKind["FirstJSDocTagNode"] = 273] = "FirstJSDocTagNode";
-        SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 282] = "LastJSDocTagNode";
+        SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 285] = "LastJSDocTagNode";
     })(ts.SyntaxKind || (ts.SyntaxKind = {}));
     var SyntaxKind = ts.SyntaxKind;
     (function (NodeFlags) {
@@ -3128,7 +3131,7 @@ var ts;
         // the syntax list itself considers them as normal trivia. Therefore if we simply skip
         // trivia for the list, we may have skipped the JSDocComment as well. So we should process its
         // first child to determine the actual position of its first token.
-        if (node.kind === 283 /* SyntaxList */ && node._children.length > 0) {
+        if (node.kind === 286 /* SyntaxList */ && node._children.length > 0) {
             return getTokenPosOfNode(node._children[0], sourceFile, includeJsDocComment);
         }
         return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);
@@ -3138,6 +3141,10 @@ var ts;
         return node.kind >= 257 /* FirstJSDocNode */ && node.kind <= 282 /* LastJSDocNode */;
     }
     ts.isJSDocNode = isJSDocNode;
+    function isJSDocTag(node) {
+        return node.kind >= 273 /* FirstJSDocTagNode */ && node.kind <= 285 /* LastJSDocTagNode */;
+    }
+    ts.isJSDocTag = isJSDocTag;
     function getNonDecoratorTokenPosOfNode(node, sourceFile) {
         if (nodeIsMissing(node) || !node.decorators) {
             return getTokenPosOfNode(node, sourceFile);
@@ -9023,7 +9030,7 @@ var ts;
             // Note: it is not actually necessary to save/restore the context flags here.  That's
             // because the saving/restoring of these flags happens naturally through the recursive
             // descent nature of our parser.  However, we still store this here just so we can
-            // assert that that invariant holds.
+            // assert that invariant holds.
             var saveContextFlags = contextFlags;
             // If we're only looking ahead, then tell the scanner to only lookahead as well.
             // Otherwise, if we're actually speculatively parsing, then tell the scanner to do the
@@ -10629,7 +10636,7 @@ var ts;
             //
             // Note: for ease of implementation we treat productions '2' and '3' as the same thing.
             // (i.e. they're both BinaryExpressions with an assignment operator in it).
-            // First, do the simple check if we have a YieldExpression (production '5').
+            // First, do the simple check if we have a YieldExpression (production '6').
             if (isYieldExpression()) {
                 return parseYieldExpression();
             }
@@ -11158,22 +11165,39 @@ var ts;
             return finishNode(node);
         }
         /**
-         * Parse ES7 unary expression and await expression
+         * Parse ES7 exponential expression and await expression
+         *
+         * ES7 ExponentiationExpression:
+         *      1) UnaryExpression[?Yield]
+         *      2) UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]
          *
-         * ES7 UnaryExpression:
-         *      1) SimpleUnaryExpression[?yield]
-         *      2) IncrementExpression[?yield] ** UnaryExpression[?yield]
          */
         function parseUnaryExpressionOrHigher() {
-            if (isAwaitExpression()) {
-                return parseAwaitExpression();
-            }
-            if (isIncrementExpression()) {
+            /**
+             * ES7 UpdateExpression:
+             *      1) LeftHandSideExpression[?Yield]
+             *      2) LeftHandSideExpression[?Yield][no LineTerminator here]++
+             *      3) LeftHandSideExpression[?Yield][no LineTerminator here]--
+             *      4) ++UnaryExpression[?Yield]
+             *      5) --UnaryExpression[?Yield]
+             */
+            if (isUpdateExpression()) {
                 var incrementExpression = parseIncrementExpression();
                 return token() === 38 /* AsteriskAsteriskToken */ ?
                     parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
                     incrementExpression;
             }
+            /**
+             * ES7 UnaryExpression:
+             *      1) UpdateExpression[?yield]
+             *      2) delete UpdateExpression[?yield]
+             *      3) void UpdateExpression[?yield]
+             *      4) typeof UpdateExpression[?yield]
+             *      5) + UpdateExpression[?yield]
+             *      6) - UpdateExpression[?yield]
+             *      7) ~ UpdateExpression[?yield]
+             *      8) ! UpdateExpression[?yield]
+             */
             var unaryOperator = token();
             var simpleUnaryExpression = parseSimpleUnaryExpression();
             if (token() === 38 /* AsteriskAsteriskToken */) {
@@ -11190,8 +11214,8 @@ var ts;
         /**
          * Parse ES7 simple-unary expression or higher:
          *
-         * ES7 SimpleUnaryExpression:
-         *      1) IncrementExpression[?yield]
+         * ES7 UnaryExpression:
+         *      1) UpdateExpression[?yield]
          *      2) delete UnaryExpression[?yield]
          *      3) void UnaryExpression[?yield]
          *      4) typeof UnaryExpression[?yield]
@@ -11214,13 +11238,15 @@ var ts;
                     return parseTypeOfExpression();
                 case 103 /* VoidKeyword */:
                     return parseVoidExpression();
-                case 119 /* AwaitKeyword */:
-                    return parseAwaitExpression();
                 case 25 /* LessThanToken */:
                     // This is modified UnaryExpression grammar in TypeScript
                     //  UnaryExpression (modified):
                     //      < type > UnaryExpression
                     return parseTypeAssertion();
+                case 119 /* AwaitKeyword */:
+                    if (isAwaitExpression()) {
+                        return parseAwaitExpression();
+                    }
                 default:
                     return parseIncrementExpression();
             }
@@ -11228,14 +11254,14 @@ var ts;
         /**
          * Check if the current token can possibly be an ES7 increment expression.
          *
-         * ES7 IncrementExpression:
+         * ES7 UpdateExpression:
          *      LeftHandSideExpression[?Yield]
          *      LeftHandSideExpression[?Yield][no LineTerminator here]++
          *      LeftHandSideExpression[?Yield][no LineTerminator here]--
          *      ++LeftHandSideExpression[?Yield]
          *      --LeftHandSideExpression[?Yield]
          */
-        function isIncrementExpression() {
+        function isUpdateExpression() {
             // This function is called inside parseUnaryExpression to decide
             // whether to call parseSimpleUnaryExpression or call parseIncrementExpression directly
             switch (token()) {
@@ -11246,6 +11272,7 @@ var ts;
                 case 78 /* DeleteKeyword */:
                 case 101 /* TypeOfKeyword */:
                 case 103 /* VoidKeyword */:
+                case 119 /* AwaitKeyword */:
                     return false;
                 case 25 /* LessThanToken */:
                     // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
@@ -13391,6 +13418,9 @@ var ts;
                     case 120 /* BooleanKeyword */:
                     case 133 /* SymbolKeyword */:
                     case 103 /* VoidKeyword */:
+                    case 93 /* NullKeyword */:
+                    case 135 /* UndefinedKeyword */:
+                    case 127 /* NeverKeyword */:
                         return parseTokenNode();
                     case 9 /* StringLiteral */:
                     case 8 /* NumericLiteral */:
@@ -16544,7 +16574,7 @@ var ts;
             getJsxIntrinsicTagNames: getJsxIntrinsicTagNames,
             isOptionalParameter: isOptionalParameter
         };
-        var tupleTypes = ts.createMap();
+        var tupleTypes = [];
         var unionTypes = ts.createMap();
         var intersectionTypes = ts.createMap();
         var stringLiteralTypes = ts.createMap();
@@ -17482,13 +17512,13 @@ var ts;
                     else {
                         symbolFromVariable = getPropertyOfVariable(targetSymbol, name_10.text);
                     }
-                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
-                    if (!symbolFromVariable && allowSyntheticDefaultImports && name_10.text === "default") {
-                        symbolFromVariable = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
-                    }
                     // if symbolFromVariable is export - get its final target
                     symbolFromVariable = resolveSymbol(symbolFromVariable);
                     var symbolFromModule = getExportOfModule(targetSymbol, name_10.text);
+                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
+                    if (!symbolFromModule && allowSyntheticDefaultImports && name_10.text === "default") {
+                        symbolFromModule = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
+                    }
                     var symbol = symbolFromModule && symbolFromVariable ?
                         combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
                         symbolFromModule || symbolFromVariable;
@@ -18378,9 +18408,6 @@ var ts;
                         // The specified symbol flags need to be reinterpreted as type flags
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 793064 /* Type */, 0 /* None */, nextFlags);
                     }
-                    else if (type.flags & 262144 /* Tuple */) {
-                        writeTupleType(type);
-                    }
                     else if (!(flags & 512 /* InTypeAlias */) && type.flags & (2097152 /* Anonymous */ | 1572864 /* UnionOrIntersection */) && type.aliasSymbol) {
                         var typeArguments = type.aliasTypeArguments;
                         writeSymbolTypeReference(type.aliasSymbol, typeArguments, 0, typeArguments ? typeArguments.length : 0, nextFlags);
@@ -18444,6 +18471,11 @@ var ts;
                         writePunctuation(writer, 19 /* OpenBracketToken */);
                         writePunctuation(writer, 20 /* CloseBracketToken */);
                     }
+                    else if (type.target.flags & 262144 /* Tuple */) {
+                        writePunctuation(writer, 19 /* OpenBracketToken */);
+                        writeTypeList(type.typeArguments.slice(0, getTypeReferenceArity(type)), 24 /* CommaToken */);
+                        writePunctuation(writer, 20 /* CloseBracketToken */);
+                    }
                     else {
                         // Write the type reference in the format f<A>.g<B>.C<X, Y> where A and B are type arguments
                         // for outer type parameters, and f and g are the respective declaring containers of those
@@ -18471,11 +18503,6 @@ var ts;
                         writeSymbolTypeReference(type.symbol, typeArguments, i, typeParameterCount, flags);
                     }
                 }
-                function writeTupleType(type) {
-                    writePunctuation(writer, 19 /* OpenBracketToken */);
-                    writeTypeList(type.elementTypes, 24 /* CommaToken */);
-                    writePunctuation(writer, 20 /* CloseBracketToken */);
-                }
                 function writeUnionOrIntersectionType(type, flags) {
                     if (flags & 64 /* InElementType */) {
                         writePunctuation(writer, 17 /* OpenParenToken */);
@@ -19131,7 +19158,7 @@ var ts;
                         : elementType;
                     if (!type) {
                         if (isTupleType(parentType)) {
-                            error(declaration, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), parentType.elementTypes.length, pattern.elements.length);
+                            error(declaration, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), getTypeReferenceArity(parentType), pattern.elements.length);
                         }
                         else {
                             error(declaration, ts.Diagnostics.Type_0_has_no_property_1, typeToString(parentType), propName);
@@ -19231,9 +19258,14 @@ var ts;
                     }
                 }
                 // Use contextual parameter type if one is available
-                var type = declaration.symbol.name === "this"
-                    ? getContextuallyTypedThisType(func)
-                    : getContextuallyTypedParameterType(declaration);
+                var type = void 0;
+                if (declaration.symbol.name === "this") {
+                    var thisParameter = getContextualThisParameter(func);
+                    type = thisParameter ? getTypeOfSymbol(thisParameter) : undefined;
+                }
+                else {
+                    type = getContextuallyTypedParameterType(declaration);
+                }
                 if (type) {
                     return addOptionality(type, /*optional*/ declaration.questionToken && includeOptionality);
                 }
@@ -19303,12 +19335,12 @@ var ts;
             }
             // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
             var elementTypes = ts.map(elements, function (e) { return e.kind === 193 /* OmittedExpression */ ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors); });
+            var result = createTupleType(elementTypes);
             if (includePatternInType) {
-                var result = createNewTupleType(elementTypes);
+                result = cloneTypeReference(result);
                 result.pattern = pattern;
-                return result;
             }
-            return createTupleType(elementTypes);
+            return result;
         }
         // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself
         // and without regard to its context (i.e. without regard any type annotation or initializer associated with the
@@ -19679,17 +19711,20 @@ var ts;
             return type.resolvedBaseConstructorType;
         }
         function getBaseTypes(type) {
-            var isClass = type.symbol.flags & 32 /* Class */;
-            var isInterface = type.symbol.flags & 64 /* Interface */;
             if (!type.resolvedBaseTypes) {
-                if (!isClass && !isInterface) {
-                    ts.Debug.fail("type must be class or interface");
+                if (type.flags & 262144 /* Tuple */) {
+                    type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters))];
                 }
-                if (isClass) {
-                    resolveBaseTypesOfClass(type);
+                else if (type.symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
+                    if (type.symbol.flags & 32 /* Class */) {
+                        resolveBaseTypesOfClass(type);
+                    }
+                    if (type.symbol.flags & 64 /* Interface */) {
+                        resolveBaseTypesOfInterface(type);
+                    }
                 }
-                if (isInterface) {
-                    resolveBaseTypesOfInterface(type);
+                else {
+                    ts.Debug.fail("type must be class or interface");
                 }
             }
             return type.resolvedBaseTypes;
@@ -20102,19 +20137,24 @@ var ts;
             if (type.flags & 131072 /* Reference */) {
                 return createTypeReference(type.target, ts.concatenate(type.typeArguments, [thisArgument || type.target.thisType]));
             }
-            if (type.flags & 262144 /* Tuple */) {
-                return createTupleType(type.elementTypes, thisArgument);
-            }
             return type;
         }
         function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
-            var mapper = identityMapper;
-            var members = source.symbol.members;
-            var callSignatures = source.declaredCallSignatures;
-            var constructSignatures = source.declaredConstructSignatures;
-            var stringIndexInfo = source.declaredStringIndexInfo;
-            var numberIndexInfo = source.declaredNumberIndexInfo;
-            if (!ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+            var mapper;
+            var members;
+            var callSignatures;
+            var constructSignatures;
+            var stringIndexInfo;
+            var numberIndexInfo;
+            if (ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+                mapper = identityMapper;
+                members = source.symbol ? source.symbol.members : createSymbolTable(source.declaredProperties);
+                callSignatures = source.declaredCallSignatures;
+                constructSignatures = source.declaredConstructSignatures;
+                stringIndexInfo = source.declaredStringIndexInfo;
+                numberIndexInfo = source.declaredNumberIndexInfo;
+            }
+            else {
                 mapper = createTypeMapper(typeParameters, typeArguments);
                 members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1);
                 callSignatures = instantiateList(source.declaredCallSignatures, mapper, instantiateSignature);
@@ -20124,7 +20164,7 @@ var ts;
             }
             var baseTypes = getBaseTypes(source);
             if (baseTypes.length) {
-                if (members === source.symbol.members) {
+                if (source.symbol && members === source.symbol.members) {
                     members = createSymbolTable(source.declaredProperties);
                 }
                 var thisArgument = ts.lastOrUndefined(typeArguments);
@@ -20188,24 +20228,6 @@ var ts;
             }
             return result;
         }
-        function createTupleTypeMemberSymbols(memberTypes) {
-            var members = ts.createMap();
-            for (var i = 0; i < memberTypes.length; i++) {
-                var symbol = createSymbol(4 /* Property */ | 67108864 /* Transient */, "" + i);
-                symbol.type = memberTypes[i];
-                members[i] = symbol;
-            }
-            return members;
-        }
-        function resolveTupleTypeMembers(type) {
-            var arrayElementType = getUnionType(type.elementTypes);
-            // Make the tuple type itself the 'this' type by including an extra type argument
-            // (Unless it's provided in the case that the tuple is a type parameter constraint)
-            var arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type.thisType || type]));
-            var members = createTupleTypeMemberSymbols(type.elementTypes);
-            addInheritedMembers(members, arrayType.properties);
-            setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
-        }
         function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) {
             for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
                 var s = signatureList_1[_i];
@@ -20378,9 +20400,6 @@ var ts;
                 else if (type.flags & 2097152 /* Anonymous */) {
                     resolveAnonymousTypeMembers(type);
                 }
-                else if (type.flags & 262144 /* Tuple */) {
-                    resolveTupleTypeMembers(type);
-                }
                 else if (type.flags & 524288 /* Union */) {
                     resolveUnionTypeMembers(type);
                 }
@@ -20749,6 +20768,9 @@ var ts;
                 if (isJSConstructSignature) {
                     minArgumentCount--;
                 }
+                if (!thisParameter && ts.isObjectLiteralMethod(declaration)) {
+                    thisParameter = getContextualThisParameter(declaration);
+                }
                 var classType = declaration.kind === 148 /* Constructor */ ?
                     getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol))
                     : undefined;
@@ -21021,6 +21043,15 @@ var ts;
             }
             return type;
         }
+        function cloneTypeReference(source) {
+            var type = createObjectType(source.flags, source.symbol);
+            type.target = source.target;
+            type.typeArguments = source.typeArguments;
+            return type;
+        }
+        function getTypeReferenceArity(type) {
+            return type.target.typeParameters ? type.target.typeParameters.length : 0;
+        }
         // Get type from reference to class or interface
         function getTypeFromClassOrInterfaceReference(node, symbol) {
             var type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
@@ -21232,17 +21263,46 @@ var ts;
             }
             return links.resolvedType;
         }
-        function createTupleType(elementTypes, thisType) {
-            var id = getTypeListId(elementTypes) + "," + (thisType ? thisType.id : 0);
-            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
-        }
-        function createNewTupleType(elementTypes, thisType) {
-            var propagatedFlags = getPropagatingFlagsOfTypes(elementTypes, /*excludeKinds*/ 0);
-            var type = createObjectType(262144 /* Tuple */ | propagatedFlags);
-            type.elementTypes = elementTypes;
-            type.thisType = thisType;
+        // We represent tuple types as type references to synthesized generic interface types created by
+        // this function. The types are of the form:
+        //
+        //   interface Tuple<T0, T1, T2, ...> extends Array<T0 | T1 | T2 | ...> { 0: T0, 1: T1, 2: T2, ... }
+        //
+        // Note that the generic type created by this function has no symbol associated with it. The same
+        // is true for each of the synthesized type parameters.
+        function createTupleTypeOfArity(arity) {
+            var typeParameters = [];
+            var properties = [];
+            for (var i = 0; i < arity; i++) {
+                var typeParameter = createType(16384 /* TypeParameter */);
+                typeParameters.push(typeParameter);
+                var property = createSymbol(4 /* Property */ | 67108864 /* Transient */, "" + i);
+                property.type = typeParameter;
+                properties.push(property);
+            }
+            var type = createObjectType(262144 /* Tuple */ | 131072 /* Reference */);
+            type.typeParameters = typeParameters;
+            type.outerTypeParameters = undefined;
+            type.localTypeParameters = typeParameters;
+            type.instantiations = ts.createMap();
+            type.instantiations[getTypeListId(type.typeParameters)] = type;
+            type.target = type;
+            type.typeArguments = type.typeParameters;
+            type.thisType = createType(16384 /* TypeParameter */ | 268435456 /* ThisType */);
+            type.thisType.constraint = type;
+            type.declaredProperties = properties;
+            type.declaredCallSignatures = emptyArray;
+            type.declaredConstructSignatures = emptyArray;
+            type.declaredStringIndexInfo = undefined;
+            type.declaredNumberIndexInfo = undefined;
             return type;
         }
+        function getTupleTypeOfArity(arity) {
+            return tupleTypes[arity] || (tupleTypes[arity] = createTupleTypeOfArity(arity));
+        }
+        function createTupleType(elementTypes) {
+            return createTypeReference(getTupleTypeOfArity(elementTypes.length), elementTypes);
+        }
         function getTypeFromTupleTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
@@ -21524,6 +21584,12 @@ var ts;
                     return nullType;
                 case 127 /* NeverKeyword */:
                     return neverType;
+                case 283 /* JSDocNullKeyword */:
+                    return nullType;
+                case 284 /* JSDocUndefinedKeyword */:
+                    return undefinedType;
+                case 285 /* JSDocNeverKeyword */:
+                    return neverType;
                 case 165 /* ThisType */:
                 case 97 /* ThisKeyword */:
                     return getTypeFromThisTypeNode(node);
@@ -21796,9 +21862,6 @@ var ts;
                 if (type.flags & 131072 /* Reference */) {
                     return createTypeReference(type.target, instantiateList(type.typeArguments, mapper, instantiateType));
                 }
-                if (type.flags & 262144 /* Tuple */) {
-                    return createTupleType(instantiateList(type.elementTypes, mapper, instantiateType));
-                }
                 if (type.flags & 524288 /* Union */ && !(type.flags & 8190 /* Primitive */)) {
                     return getUnionType(instantiateList(type.types, mapper, instantiateType), /*subtypeReduction*/ false, type.aliasSymbol, mapper.targetTypes);
                 }
@@ -22999,7 +23062,7 @@ var ts;
          * Prefer using isTupleLikeType() unless the use of `elementTypes` is required.
          */
         function isTupleType(type) {
-            return !!(type.flags & 262144 /* Tuple */);
+            return !!(type.flags & 131072 /* Reference */ && type.target.flags & 262144 /* Tuple */);
         }
         function getFalsyFlagsOfTypes(types) {
             var result = 0;
@@ -23120,11 +23183,8 @@ var ts;
                 if (type.flags & 524288 /* Union */) {
                     return getUnionType(ts.map(type.types, getWidenedConstituentType));
                 }
-                if (isArrayType(type)) {
-                    return createArrayType(getWidenedType(type.typeArguments[0]));
-                }
-                if (isTupleType(type)) {
-                    return createTupleType(ts.map(type.elementTypes, getWidenedType));
+                if (isArrayType(type) || isTupleType(type)) {
+                    return createTypeReference(type.target, ts.map(type.typeArguments, getWidenedType));
                 }
             }
             return type;
@@ -23150,11 +23210,8 @@ var ts;
                     }
                 }
             }
-            if (isArrayType(type)) {
-                return reportWideningErrorsInType(type.typeArguments[0]);
-            }
-            if (isTupleType(type)) {
-                for (var _b = 0, _c = type.elementTypes; _b < _c.length; _b++) {
+            if (isArrayType(type) || isTupleType(type)) {
+                for (var _b = 0, _c = type.typeArguments; _b < _c.length; _b++) {
                     var t = _c[_b];
                     if (reportWideningErrorsInType(t)) {
                         errorReported = true;
@@ -23259,7 +23316,6 @@ var ts;
         function couldContainTypeParameters(type) {
             return !!(type.flags & 16384 /* TypeParameter */ ||
                 type.flags & 131072 /* Reference */ && ts.forEach(type.typeArguments, couldContainTypeParameters) ||
-                type.flags & 262144 /* Tuple */ && ts.forEach(type.elementTypes, couldContainTypeParameters) ||
                 type.flags & 2097152 /* Anonymous */ && type.symbol && type.symbol.flags & (8192 /* Method */ | 2048 /* TypeLiteral */ | 32 /* Class */) ||
                 type.flags & 1572864 /* UnionOrIntersection */ && couldUnionOrIntersectionContainTypeParameters(type));
         }
@@ -23360,14 +23416,6 @@ var ts;
                         inferFromTypes(sourceTypes[i], targetTypes[i]);
                     }
                 }
-                else if (source.flags & 262144 /* Tuple */ && target.flags & 262144 /* Tuple */ && source.elementTypes.length === target.elementTypes.length) {
-                    // If source and target are tuples of the same size, infer from element types
-                    var sourceTypes = source.elementTypes;
-                    var targetTypes = target.elementTypes;
-                    for (var i = 0; i < sourceTypes.length; i++) {
-                        inferFromTypes(sourceTypes[i], targetTypes[i]);
-                    }
-                }
                 else if (target.flags & 1572864 /* UnionOrIntersection */) {
                     var targetTypes = target.types;
                     var typeParameterCount = 0;
@@ -24796,10 +24844,6 @@ var ts;
                         return getInferredClassType(classSymbol);
                     }
                 }
-                var type = getContextuallyTypedThisType(container);
-                if (type) {
-                    return type;
-                }
                 var thisType = getThisTypeOfDeclaration(container);
                 if (thisType) {
                     return thisType;
@@ -25017,11 +25061,11 @@ var ts;
                 return false;
             }
         }
-        function getContextuallyTypedThisType(func) {
+        function getContextualThisParameter(func) {
             if (isContextSensitiveFunctionOrObjectLiteralMethod(func) && func.kind !== 180 /* ArrowFunction */) {
                 var contextualSignature = getContextualSignature(func);
                 if (contextualSignature) {
-                    return getThisTypeOfSignature(contextualSignature);
+                    return contextualSignature.thisParameter;
                 }
             }
             return undefined;
@@ -25539,7 +25583,7 @@ var ts;
                 // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
                 // that we get the same behavior for "var [x, y] = []" and "[x, y] = []".
                 if (inDestructuringPattern && elementTypes.length) {
-                    var type = createNewTupleType(elementTypes);
+                    var type = cloneTypeReference(createTupleType(elementTypes));
                     type.pattern = node;
                     return type;
                 }
@@ -25553,7 +25597,7 @@ var ts;
                         for (var i = elementTypes.length; i < patternElements.length; i++) {
                             var patternElement = patternElements[i];
                             if (hasDefaultValue(patternElement)) {
-                                elementTypes.push(contextualType.elementTypes[i]);
+                                elementTypes.push(contextualType.typeArguments[i]);
                             }
                             else {
                                 if (patternElement.kind !== 193 /* OmittedExpression */) {
@@ -27653,6 +27697,12 @@ var ts;
         }
         function assignContextualParameterTypes(signature, context, mapper) {
             var len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
+            if (context.thisParameter) {
+                if (!signature.thisParameter) {
+                    signature.thisParameter = createTransientSymbol(context.thisParameter, undefined);
+                }
+                assignTypeToParameterAndFixTypeParameters(signature.thisParameter, getTypeOfSymbol(context.thisParameter), mapper);
+            }
             for (var i = 0; i < len; i++) {
                 var parameter = signature.parameters[i];
                 var contextualParameterType = getTypeAtPosition(context, i);
@@ -28336,7 +28386,7 @@ var ts;
                         // such as NodeCheckFlags.LexicalThis on "this"expression.
                         checkExpression(element);
                         if (isTupleType(sourceType)) {
-                            error(element, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), sourceType.elementTypes.length, elements.length);
+                            error(element, ts.Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), getTypeReferenceArity(sourceType), elements.length);
                         }
                         else {
                             error(element, ts.Diagnostics.Type_0_has_no_property_1, typeToString(sourceType), propName);
@@ -33233,7 +33283,7 @@ var ts;
             else if (isTypeOfKind(type, 34 /* StringLike */)) {
                 return ts.TypeReferenceSerializationKind.StringLikeType;
             }
-            else if (isTypeOfKind(type, 262144 /* Tuple */)) {
+            else if (isTupleType(type)) {
                 return ts.TypeReferenceSerializationKind.ArrayLikeType;
             }
             else if (isTypeOfKind(type, 512 /* ESSymbol */)) {
@@ -39167,6 +39217,10 @@ var ts;
                 else if (node.parent.kind === 188 /* ConditionalExpression */ && node.parent.condition === node) {
                     return true;
                 }
+                else if (node.parent.kind === 185 /* PrefixUnaryExpression */ || node.parent.kind === 181 /* DeleteExpression */ ||
+                    node.parent.kind === 182 /* TypeOfExpression */ || node.parent.kind === 183 /* VoidExpression */) {
+                    return true;
+                }
                 return false;
             }
             function needsParenthesisForPropertyAccessOrInvocation(node) {
@@ -45684,8 +45738,9 @@ var ts;
             var typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
             if (typesFile) {
                 var onlyRecordFailures_1 = !directoryProbablyExists(ts.getDirectoryPath(typesFile), state.host);
-                // The package.json "typings" property must specify the file with extension, so just try that exact filename.
-                var result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures_1, state);
+                // A package.json "typings" may specify an exact filename, or may choose to omit an extension.
+                var result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures_1, state) ||
+                    tryAddingExtensions(typesFile, extensions, failedLookupLocation, onlyRecordFailures_1, state);
                 if (result) {
                     return result;
                 }
@@ -49938,7 +49993,7 @@ var ts;
         // for the position of the relevant node (or comma).
         var syntaxList = ts.forEach(node.parent.getChildren(), function (c) {
             // find syntax list that covers the span of the node
-            if (c.kind === 283 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) {
+            if (c.kind === 286 /* SyntaxList */ && c.pos <= node.pos && c.end >= node.end) {
                 return c;
             }
         });
@@ -50624,6 +50679,27 @@ var ts;
         return ts.ensureScriptKind(fileName, scriptKind);
     }
     ts.getScriptKind = getScriptKind;
+    function parseAndReEmitConfigJSONFile(content) {
+        var options = {
+            fileName: "config.js",
+            compilerOptions: {
+                target: 2 /* ES6 */
+            },
+            reportDiagnostics: true
+        };
+        var _a = ts.transpileModule("(" + content + ")", options), outputText = _a.outputText, diagnostics = _a.diagnostics;
+        // Becasue the content was wrapped in "()", the start position of diagnostics needs to be subtract by 1
+        // also, the emitted result will have "(" in the beginning and ");" in the end. We need to strip these
+        // as well
+        var trimmedOutput = outputText.trim();
+        var configJsonObject = JSON.parse(trimmedOutput.substring(1, trimmedOutput.length - 2));
+        for (var _i = 0, diagnostics_4 = diagnostics; _i < diagnostics_4.length; _i++) {
+            var diagnostic = diagnostics_4[_i];
+            diagnostic.start = diagnostic.start - 1;
+        }
+        return { configJsonObject: configJsonObject, diagnostics: diagnostics };
+    }
+    ts.parseAndReEmitConfigJSONFile = parseAndReEmitConfigJSONFile;
 })(ts || (ts = {}));
 // Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0.
 // See LICENSE.txt in the project root for complete license information.
@@ -53738,7 +53814,7 @@ var ts;
             return pos;
         };
         NodeObject.prototype.createSyntaxList = function (nodes) {
-            var list = createNode(283 /* SyntaxList */, nodes.pos, nodes.end, this);
+            var list = createNode(286 /* SyntaxList */, nodes.pos, nodes.end, this);
             list._children = [];
             var pos = nodes.pos;
             for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) {
@@ -53761,7 +53837,7 @@ var ts;
                 scanner.setText((sourceFile || this.getSourceFile()).text);
                 children = [];
                 var pos_3 = this.pos;
-                var useJSDocScanner_1 = this.kind >= 273 /* FirstJSDocTagNode */ && this.kind <= 282 /* LastJSDocTagNode */;
+                var useJSDocScanner_1 = this.kind >= 273 /* FirstJSDocTagNode */ && this.kind <= 285 /* LastJSDocTagNode */;
                 var processNode = function (node) {
                     if (pos_3 < node.pos) {
                         pos_3 = _this.addSyntheticNodes(children, pos_3, node.pos, useJSDocScanner_1);
@@ -53783,6 +53859,10 @@ var ts;
                         processNode(jsDocComment);
                     }
                 }
+                // For syntactic classifications, all trivia are classcified together, including jsdoc comments.
+                // For that to work, the jsdoc comments should still be the leading trivia of the first child. 
+                // Restoring the scanner position ensures that. 
+                pos_3 = this.pos;
                 ts.forEachChild(this, processNode, processNodes);
                 if (pos_3 < this.end) {
                     this.addSyntheticNodes(children, pos_3, this.end);
@@ -59608,6 +59688,9 @@ var ts;
              * False will mean that node is not classified and traverse routine should recurse into node contents.
              */
             function tryClassifyNode(node) {
+                if (ts.isJSDocTag(node)) {
+                    return true;
+                }
                 if (ts.nodeIsMissing(node)) {
                     return true;
                 }
diff --git a/kicktravis b/kicktravis
index 4637460..95770d5 100644
--- a/kicktravis
+++ b/kicktravis
@@ -1 +1 @@
-2016-08-22 [ci skip] Version: 1.201608220006.1+66f6f9ba05e1a3ebdeb0a66e0603f40ab3e9b8a3
+2016-08-23 [ci skip] Version: 1.201608230008.1+93de502656a7a0cdf30737513d29bcb396c79662
diff --git a/package.json b/package.json
index 8430ff1..cb588d5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ntypescript",
-  "version": "1.201608220006.1+66f6f9ba05e1a3ebdeb0a66e0603f40ab3e9b8a3",
+  "version": "1.201608230008.1+93de502656a7a0cdf30737513d29bcb396c79662",
   "description": "A nicer version of microsoft/typescript packaged and released for API developers",
   "main": "./bin/ntypescript.js",
   "bin": {
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 8568cd5..3708024 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -106,7 +106,7 @@ namespace ts {
             isOptionalParameter
         };
 
-        const tupleTypes = createMap<TupleType>();
+        const tupleTypes: GenericType[] = [];
         const unionTypes = createMap<UnionType>();
         const intersectionTypes = createMap<IntersectionType>();
         const stringLiteralTypes = createMap<LiteralType>();
@@ -1126,13 +1126,13 @@ namespace ts {
                     else {
                         symbolFromVariable = getPropertyOfVariable(targetSymbol, name.text);
                     }
-                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
-                    if (!symbolFromVariable && allowSyntheticDefaultImports && name.text === "default") {
-                        symbolFromVariable = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
-                    }
                     // if symbolFromVariable is export - get its final target
                     symbolFromVariable = resolveSymbol(symbolFromVariable);
-                    const symbolFromModule = getExportOfModule(targetSymbol, name.text);
+                    let symbolFromModule = getExportOfModule(targetSymbol, name.text);
+                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
+                    if (!symbolFromModule && allowSyntheticDefaultImports && name.text === "default") {
+                        symbolFromModule = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
+                    }
                     const symbol = symbolFromModule && symbolFromVariable ?
                         combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
                         symbolFromModule || symbolFromVariable;
@@ -2145,9 +2145,6 @@ namespace ts {
                         // The specified symbol flags need to be reinterpreted as type flags
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, nextFlags);
                     }
-                    else if (type.flags & TypeFlags.Tuple) {
-                        writeTupleType(<TupleType>type);
-                    }
                     else if (!(flags & TypeFormatFlags.InTypeAlias) && type.flags & (TypeFlags.Anonymous | TypeFlags.UnionOrIntersection) && type.aliasSymbol) {
                         const typeArguments = type.aliasTypeArguments;
                         writeSymbolTypeReference(type.aliasSymbol, typeArguments, 0, typeArguments ? typeArguments.length : 0, nextFlags);
@@ -2214,6 +2211,11 @@ namespace ts {
                         writePunctuation(writer, SyntaxKind.OpenBracketToken);
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                     }
+                    else if (type.target.flags & TypeFlags.Tuple) {
+                        writePunctuation(writer, SyntaxKind.OpenBracketToken);
+                        writeTypeList(type.typeArguments.slice(0, getTypeReferenceArity(type)), SyntaxKind.CommaToken);
+                        writePunctuation(writer, SyntaxKind.CloseBracketToken);
+                    }
                     else {
                         // Write the type reference in the format f<A>.g<B>.C<X, Y> where A and B are type arguments
                         // for outer type parameters, and f and g are the respective declaring containers of those
@@ -2242,12 +2244,6 @@ namespace ts {
                     }
                 }
 
-                function writeTupleType(type: TupleType) {
-                    writePunctuation(writer, SyntaxKind.OpenBracketToken);
-                    writeTypeList(type.elementTypes, SyntaxKind.CommaToken);
-                    writePunctuation(writer, SyntaxKind.CloseBracketToken);
-                }
-
                 function writeUnionOrIntersectionType(type: UnionOrIntersectionType, flags: TypeFormatFlags) {
                     if (flags & TypeFormatFlags.InElementType) {
                         writePunctuation(writer, SyntaxKind.OpenParenToken);
@@ -2958,7 +2954,7 @@ namespace ts {
                         : elementType;
                     if (!type) {
                         if (isTupleType(parentType)) {
-                            error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), (<TupleType>parentType).elementTypes.length, pattern.elements.length);
+                            error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), getTypeReferenceArity(<TypeReference>parentType), pattern.elements.length);
                         }
                         else {
                             error(declaration, Diagnostics.Type_0_has_no_property_1, typeToString(parentType), propName);
@@ -3070,9 +3066,14 @@ namespace ts {
                     }
                 }
                 // Use contextual parameter type if one is available
-                const type = declaration.symbol.name === "this"
-                    ? getContextuallyTypedThisType(func)
-                    : getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                let type: Type;
+                if (declaration.symbol.name === "this") {
+                    const thisParameter = getContextualThisParameter(func);
+                    type = thisParameter ? getTypeOfSymbol(thisParameter) : undefined;
+                }
+                else {
+                    type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                }
                 if (type) {
                     return addOptionality(type, /*optional*/ declaration.questionToken && includeOptionality);
                 }
@@ -3150,12 +3151,12 @@ namespace ts {
             }
             // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
             const elementTypes = map(elements, e => e.kind === SyntaxKind.OmittedExpression ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors));
+            let result = createTupleType(elementTypes);
             if (includePatternInType) {
-                const result = createNewTupleType(elementTypes);
+                result = cloneTypeReference(result);
                 result.pattern = pattern;
-                return result;
             }
-            return createTupleType(elementTypes);
+            return result;
         }
 
         // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself
@@ -3564,17 +3565,20 @@ namespace ts {
         }
 
         function getBaseTypes(type: InterfaceType): ObjectType[] {
-            const isClass = type.symbol.flags & SymbolFlags.Class;
-            const isInterface = type.symbol.flags & SymbolFlags.Interface;
             if (!type.resolvedBaseTypes) {
-                if (!isClass && !isInterface) {
-                    Debug.fail("type must be class or interface");
+                if (type.flags & TypeFlags.Tuple) {
+                    type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters))];
                 }
-                if (isClass) {
-                    resolveBaseTypesOfClass(type);
+                else if (type.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+                    if (type.symbol.flags & SymbolFlags.Class) {
+                        resolveBaseTypesOfClass(type);
+                    }
+                    if (type.symbol.flags & SymbolFlags.Interface) {
+                        resolveBaseTypesOfInterface(type);
+                    }
                 }
-                if (isInterface) {
-                    resolveBaseTypesOfInterface(type);
+                else {
+                    Debug.fail("type must be class or interface");
                 }
             }
             return type.resolvedBaseTypes;
@@ -4001,20 +4005,25 @@ namespace ts {
                 return createTypeReference((<TypeReference>type).target,
                     concatenate((<TypeReference>type).typeArguments, [thisArgument || (<TypeReference>type).target.thisType]));
             }
-            if (type.flags & TypeFlags.Tuple) {
-                return createTupleType((type as TupleType).elementTypes, thisArgument);
-            }
             return type;
         }
 
         function resolveObjectTypeMembers(type: ObjectType, source: InterfaceTypeWithDeclaredMembers, typeParameters: TypeParameter[], typeArguments: Type[]) {
-            let mapper = identityMapper;
-            let members = source.symbol.members;
-            let callSignatures = source.declaredCallSignatures;
-            let constructSignatures = source.declaredConstructSignatures;
-            let stringIndexInfo = source.declaredStringIndexInfo;
-            let numberIndexInfo = source.declaredNumberIndexInfo;
-            if (!rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+            let mapper: TypeMapper;
+            let members: SymbolTable;
+            let callSignatures: Signature[];
+            let constructSignatures: Signature[];
+            let stringIndexInfo: IndexInfo;
+            let numberIndexInfo: IndexInfo;
+            if (rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+                mapper = identityMapper;
+                members = source.symbol ? source.symbol.members : createSymbolTable(source.declaredProperties);
+                callSignatures = source.declaredCallSignatures;
+                constructSignatures = source.declaredConstructSignatures;
+                stringIndexInfo = source.declaredStringIndexInfo;
+                numberIndexInfo = source.declaredNumberIndexInfo;
+            }
+            else {
                 mapper = createTypeMapper(typeParameters, typeArguments);
                 members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1);
                 callSignatures = instantiateList(source.declaredCallSignatures, mapper, instantiateSignature);
@@ -4024,7 +4033,7 @@ namespace ts {
             }
             const baseTypes = getBaseTypes(source);
             if (baseTypes.length) {
-                if (members === source.symbol.members) {
+                if (source.symbol && members === source.symbol.members) {
                     members = createSymbolTable(source.declaredProperties);
                 }
                 const thisArgument = lastOrUndefined(typeArguments);
@@ -4094,26 +4103,6 @@ namespace ts {
             return result;
         }
 
-        function createTupleTypeMemberSymbols(memberTypes: Type[]): SymbolTable {
-            const members = createMap<Symbol>();
-            for (let i = 0; i < memberTypes.length; i++) {
-                const symbol = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
-                symbol.type = memberTypes[i];
-                members[i] = symbol;
-            }
-            return members;
-        }
-
-        function resolveTupleTypeMembers(type: TupleType) {
-            const arrayElementType = getUnionType(type.elementTypes);
-            // Make the tuple type itself the 'this' type by including an extra type argument
-            // (Unless it's provided in the case that the tuple is a type parameter constraint)
-            const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type.thisType || type]));
-            const members = createTupleTypeMemberSymbols(type.elementTypes);
-            addInheritedMembers(members, arrayType.properties);
-            setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
-        }
-
         function findMatchingSignature(signatureList: Signature[], signature: Signature, partialMatch: boolean, ignoreThisTypes: boolean, ignoreReturnTypes: boolean): Signature {
             for (const s of signatureList) {
                 if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypesIdentical)) {
@@ -4292,9 +4281,6 @@ namespace ts {
                 else if (type.flags & TypeFlags.Anonymous) {
                     resolveAnonymousTypeMembers(<AnonymousType>type);
                 }
-                else if (type.flags & TypeFlags.Tuple) {
-                    resolveTupleTypeMembers(<TupleType>type);
-                }
                 else if (type.flags & TypeFlags.Union) {
                     resolveUnionTypeMembers(<UnionType>type);
                 }
@@ -4694,6 +4680,9 @@ namespace ts {
                 if (isJSConstructSignature) {
                     minArgumentCount--;
                 }
+                if (!thisParameter && isObjectLiteralMethod(declaration)) {
+                    thisParameter = getContextualThisParameter(declaration);
+                }
 
                 const classType = declaration.kind === SyntaxKind.Constructor ?
                     getDeclaredTypeOfClassOrInterface(getMergedSymbol((<ClassDeclaration>declaration.parent).symbol))
@@ -4992,6 +4981,17 @@ namespace ts {
             return type;
         }
 
+        function cloneTypeReference(source: TypeReference): TypeReference {
+            const type = <TypeReference>createObjectType(source.flags, source.symbol);
+            type.target = source.target;
+            type.typeArguments = source.typeArguments;
+            return type;
+        }
+
+        function getTypeReferenceArity(type: TypeReference): number {
+            return type.target.typeParameters ? type.target.typeParameters.length : 0;
+        }
+
         // Get type from reference to class or interface
         function getTypeFromClassOrInterfaceReference(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference, symbol: Symbol): Type {
             const type = <InterfaceType>getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
@@ -5234,17 +5234,47 @@ namespace ts {
             return links.resolvedType;
         }
 
-        function createTupleType(elementTypes: Type[], thisType?: Type) {
-            const id = getTypeListId(elementTypes) + "," + (thisType ? thisType.id : 0);
-            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
+        // We represent tuple types as type references to synthesized generic interface types created by
+        // this function. The types are of the form:
+        //
+        //   interface Tuple<T0, T1, T2, ...> extends Array<T0 | T1 | T2 | ...> { 0: T0, 1: T1, 2: T2, ... }
+        //
+        // Note that the generic type created by this function has no symbol associated with it. The same
+        // is true for each of the synthesized type parameters.
+        function createTupleTypeOfArity(arity: number): GenericType {
+            const typeParameters: TypeParameter[] = [];
+            const properties: Symbol[] = [];
+            for (let i = 0; i < arity; i++) {
+                const typeParameter = <TypeParameter>createType(TypeFlags.TypeParameter);
+                typeParameters.push(typeParameter);
+                const property = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
+                property.type = typeParameter;
+                properties.push(property);
+            }
+            const type = <GenericType & InterfaceTypeWithDeclaredMembers>createObjectType(TypeFlags.Tuple | TypeFlags.Reference);
+            type.typeParameters = typeParameters;
+            type.outerTypeParameters = undefined;
+            type.localTypeParameters = typeParameters;
+            type.instantiations = createMap<TypeReference>();
+            type.instantiations[getTypeListId(type.typeParameters)] = <GenericType>type;
+            type.target = <GenericType>type;
+            type.typeArguments = type.typeParameters;
+            type.thisType = <TypeParameter>createType(TypeFlags.TypeParameter | TypeFlags.ThisType);
+            type.thisType.constraint = type;
+            type.declaredProperties = properties;
+            type.declaredCallSignatures = emptyArray;
+            type.declaredConstructSignatures = emptyArray;
+            type.declaredStringIndexInfo = undefined;
+            type.declaredNumberIndexInfo = undefined;
+            return type;
+        }
+
+        function getTupleTypeOfArity(arity: number): GenericType {
+            return tupleTypes[arity] || (tupleTypes[arity] = createTupleTypeOfArity(arity));
         }
 
-        function createNewTupleType(elementTypes: Type[], thisType?: Type) {
-            const propagatedFlags = getPropagatingFlagsOfTypes(elementTypes, /*excludeKinds*/ 0);
-            const type = <TupleType>createObjectType(TypeFlags.Tuple | propagatedFlags);
-            type.elementTypes = elementTypes;
-            type.thisType = thisType;
-            return type;
+        function createTupleType(elementTypes: Type[]) {
+            return createTypeReference(getTupleTypeOfArity(elementTypes.length), elementTypes);
         }
 
         function getTypeFromTupleTypeNode(node: TupleTypeNode): Type {
@@ -5552,6 +5582,12 @@ namespace ts {
                     return nullType;
                 case SyntaxKind.NeverKeyword:
                     return neverType;
+                case SyntaxKind.JSDocNullKeyword:
+                    return nullType;
+                case SyntaxKind.JSDocUndefinedKeyword:
+                    return undefinedType;
+                case SyntaxKind.JSDocNeverKeyword:
+                    return neverType;
                 case SyntaxKind.ThisType:
                 case SyntaxKind.ThisKeyword:
                     return getTypeFromThisTypeNode(node);
@@ -5845,9 +5881,6 @@ namespace ts {
                 if (type.flags & TypeFlags.Reference) {
                     return createTypeReference((<TypeReference>type).target, instantiateList((<TypeReference>type).typeArguments, mapper, instantiateType));
                 }
-                if (type.flags & TypeFlags.Tuple) {
-                    return createTupleType(instantiateList((<TupleType>type).elementTypes, mapper, instantiateType));
-                }
                 if (type.flags & TypeFlags.Union && !(type.flags & TypeFlags.Primitive)) {
                     return getUnionType(instantiateList((<UnionType>type).types, mapper, instantiateType), /*subtypeReduction*/ false, type.aliasSymbol, mapper.targetTypes);
                 }
@@ -7168,8 +7201,8 @@ namespace ts {
          * Check if a Type was written as a tuple type literal.
          * Prefer using isTupleLikeType() unless the use of `elementTypes` is required.
          */
-        function isTupleType(type: Type): type is TupleType {
-            return !!(type.flags & TypeFlags.Tuple);
+        function isTupleType(type: Type): boolean {
+            return !!(type.flags & TypeFlags.Reference && (<TypeReference>type).target.flags & TypeFlags.Tuple);
         }
 
         function getFalsyFlagsOfTypes(types: Type[]): TypeFlags {
@@ -7301,11 +7334,8 @@ namespace ts {
                 if (type.flags & TypeFlags.Union) {
                     return getUnionType(map((<UnionType>type).types, getWidenedConstituentType));
                 }
-                if (isArrayType(type)) {
-                    return createArrayType(getWidenedType((<TypeReference>type).typeArguments[0]));
-                }
-                if (isTupleType(type)) {
-                    return createTupleType(map(type.elementTypes, getWidenedType));
+                if (isArrayType(type) || isTupleType(type)) {
+                    return createTypeReference((<TypeReference>type).target, map((<TypeReference>type).typeArguments, getWidenedType));
                 }
             }
             return type;
@@ -7331,11 +7361,8 @@ namespace ts {
                     }
                 }
             }
-            if (isArrayType(type)) {
-                return reportWideningErrorsInType((<TypeReference>type).typeArguments[0]);
-            }
-            if (isTupleType(type)) {
-                for (const t of type.elementTypes) {
+            if (isArrayType(type) || isTupleType(type)) {
+                for (const t of (<TypeReference>type).typeArguments) {
                     if (reportWideningErrorsInType(t)) {
                         errorReported = true;
                     }
@@ -7445,7 +7472,6 @@ namespace ts {
         function couldContainTypeParameters(type: Type): boolean {
             return !!(type.flags & TypeFlags.TypeParameter ||
                 type.flags & TypeFlags.Reference && forEach((<TypeReference>type).typeArguments, couldContainTypeParameters) ||
-                type.flags & TypeFlags.Tuple && forEach((<TupleType>type).elementTypes, couldContainTypeParameters) ||
                 type.flags & TypeFlags.Anonymous && type.symbol && type.symbol.flags & (SymbolFlags.Method | SymbolFlags.TypeLiteral | SymbolFlags.Class) ||
                 type.flags & TypeFlags.UnionOrIntersection && couldUnionOrIntersectionContainTypeParameters(<UnionOrIntersectionType>type));
         }
@@ -7548,14 +7574,6 @@ namespace ts {
                         inferFromTypes(sourceTypes[i], targetTypes[i]);
                     }
                 }
-                else if (source.flags & TypeFlags.Tuple && target.flags & TypeFlags.Tuple && (<TupleType>source).elementTypes.length === (<TupleType>target).elementTypes.length) {
-                    // If source and target are tuples of the same size, infer from element types
-                    const sourceTypes = (<TupleType>source).elementTypes;
-                    const targetTypes = (<TupleType>target).elementTypes;
-                    for (let i = 0; i < sourceTypes.length; i++) {
-                        inferFromTypes(sourceTypes[i], targetTypes[i]);
-                    }
-                }
                 else if (target.flags & TypeFlags.UnionOrIntersection) {
                     const targetTypes = (<UnionOrIntersectionType>target).types;
                     let typeParameterCount = 0;
@@ -9100,10 +9118,6 @@ namespace ts {
                         return getInferredClassType(classSymbol);
                     }
                 }
-                const type = getContextuallyTypedThisType(container);
-                if (type) {
-                    return type;
-                }
 
                 const thisType = getThisTypeOfDeclaration(container);
                 if (thisType) {
@@ -9344,11 +9358,11 @@ namespace ts {
             }
         }
 
-        function getContextuallyTypedThisType(func: FunctionLikeDeclaration): Type {
+        function getContextualThisParameter(func: FunctionLikeDeclaration): Symbol {
             if (isContextSensitiveFunctionOrObjectLiteralMethod(func) && func.kind !== SyntaxKind.ArrowFunction) {
                 const contextualSignature = getContextualSignature(func);
                 if (contextualSignature) {
-                    return getThisTypeOfSignature(contextualSignature);
+                    return contextualSignature.thisParameter;
                 }
             }
 
@@ -9913,7 +9927,7 @@ namespace ts {
                 // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
                 // that we get the same behavior for "var [x, y] = []" and "[x, y] = []".
                 if (inDestructuringPattern && elementTypes.length) {
-                    const type = createNewTupleType(elementTypes);
+                    const type = cloneTypeReference(createTupleType(elementTypes));
                     type.pattern = node;
                     return type;
                 }
@@ -9927,7 +9941,7 @@ namespace ts {
                         for (let i = elementTypes.length; i < patternElements.length; i++) {
                             const patternElement = patternElements[i];
                             if (hasDefaultValue(patternElement)) {
-                                elementTypes.push((<TupleType>contextualType).elementTypes[i]);
+                                elementTypes.push((<TypeReference>contextualType).typeArguments[i]);
                             }
                             else {
                                 if (patternElement.kind !== SyntaxKind.OmittedExpression) {
@@ -12291,6 +12305,12 @@ namespace ts {
 
         function assignContextualParameterTypes(signature: Signature, context: Signature, mapper: TypeMapper) {
             const len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
+            if (context.thisParameter) {
+                if (!signature.thisParameter) {
+                    signature.thisParameter = createTransientSymbol(context.thisParameter, undefined);
+                }
+                assignTypeToParameterAndFixTypeParameters(signature.thisParameter, getTypeOfSymbol(context.thisParameter), mapper);
+            }
             for (let i = 0; i < len; i++) {
                 const parameter = signature.parameters[i];
                 const contextualParameterType = getTypeAtPosition(context, i);
@@ -13038,7 +13058,7 @@ namespace ts {
                         // such as NodeCheckFlags.LexicalThis on "this"expression.
                         checkExpression(element);
                         if (isTupleType(sourceType)) {
-                            error(element, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), (<TupleType>sourceType).elementTypes.length, elements.length);
+                            error(element, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), getTypeReferenceArity(<TypeReference>sourceType), elements.length);
                         }
                         else {
                             error(element, Diagnostics.Type_0_has_no_property_1, typeToString(sourceType), propName);
@@ -18515,7 +18535,7 @@ namespace ts {
             else if (isTypeOfKind(type, TypeFlags.StringLike)) {
                 return TypeReferenceSerializationKind.StringLikeType;
             }
-            else if (isTypeOfKind(type, TypeFlags.Tuple)) {
+            else if (isTupleType(type)) {
                 return TypeReferenceSerializationKind.ArrayLikeType;
             }
             else if (isTypeOfKind(type, TypeFlags.ESSymbol)) {
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 357a155..d0f7918 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1817,6 +1817,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 else if (node.parent.kind === SyntaxKind.ConditionalExpression && (<ConditionalExpression>node.parent).condition === node) {
                     return true;
                 }
+                else if (node.parent.kind === SyntaxKind.PrefixUnaryExpression || node.parent.kind === SyntaxKind.DeleteExpression ||
+                    node.parent.kind === SyntaxKind.TypeOfExpression || node.parent.kind === SyntaxKind.VoidExpression) {
+                    return true;
+                }
 
                 return false;
             }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 035b742..b5ba898 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -912,7 +912,7 @@ namespace ts {
             // Note: it is not actually necessary to save/restore the context flags here.  That's
             // because the saving/restoring of these flags happens naturally through the recursive
             // descent nature of our parser.  However, we still store this here just so we can
-            // assert that that invariant holds.
+            // assert that invariant holds.
             const saveContextFlags = contextFlags;
 
             // If we're only looking ahead, then tell the scanner to only lookahead as well.
@@ -2765,7 +2765,7 @@ namespace ts {
             // Note: for ease of implementation we treat productions '2' and '3' as the same thing.
             // (i.e. they're both BinaryExpressions with an assignment operator in it).
 
-            // First, do the simple check if we have a YieldExpression (production '5').
+            // First, do the simple check if we have a YieldExpression (production '6').
             if (isYieldExpression()) {
                 return parseYieldExpression();
             }
@@ -3373,24 +3373,40 @@ namespace ts {
         }
 
         /**
-         * Parse ES7 unary expression and await expression
+         * Parse ES7 exponential expression and await expression
+         *
+         * ES7 ExponentiationExpression:
+         *      1) UnaryExpression[?Yield]
+         *      2) UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]
          *
-         * ES7 UnaryExpression:
-         *      1) SimpleUnaryExpression[?yield]
-         *      2) IncrementExpression[?yield] ** UnaryExpression[?yield]
          */
         function parseUnaryExpressionOrHigher(): UnaryExpression | BinaryExpression {
-            if (isAwaitExpression()) {
-                return parseAwaitExpression();
-            }
-
-            if (isIncrementExpression()) {
+            /**
+             * ES7 UpdateExpression:
+             *      1) LeftHandSideExpression[?Yield]
+             *      2) LeftHandSideExpression[?Yield][no LineTerminator here]++
+             *      3) LeftHandSideExpression[?Yield][no LineTerminator here]--
+             *      4) ++UnaryExpression[?Yield]
+             *      5) --UnaryExpression[?Yield]
+             */
+            if (isUpdateExpression()) {
                 const incrementExpression = parseIncrementExpression();
                 return token() === SyntaxKind.AsteriskAsteriskToken ?
                     <BinaryExpression>parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
                     incrementExpression;
             }
 
+            /**
+             * ES7 UnaryExpression:
+             *      1) UpdateExpression[?yield]
+             *      2) delete UpdateExpression[?yield]
+             *      3) void UpdateExpression[?yield]
+             *      4) typeof UpdateExpression[?yield]
+             *      5) + UpdateExpression[?yield]
+             *      6) - UpdateExpression[?yield]
+             *      7) ~ UpdateExpression[?yield]
+             *      8) ! UpdateExpression[?yield]
+             */
             const unaryOperator = token();
             const simpleUnaryExpression = parseSimpleUnaryExpression();
             if (token() === SyntaxKind.AsteriskAsteriskToken) {
@@ -3408,8 +3424,8 @@ namespace ts {
         /**
          * Parse ES7 simple-unary expression or higher:
          *
-         * ES7 SimpleUnaryExpression:
-         *      1) IncrementExpression[?yield]
+         * ES7 UnaryExpression:
+         *      1) UpdateExpression[?yield]
          *      2) delete UnaryExpression[?yield]
          *      3) void UnaryExpression[?yield]
          *      4) typeof UnaryExpression[?yield]
@@ -3432,13 +3448,15 @@ namespace ts {
                     return parseTypeOfExpression();
                 case SyntaxKind.VoidKeyword:
                     return parseVoidExpression();
-                case SyntaxKind.AwaitKeyword:
-                    return parseAwaitExpression();
                 case SyntaxKind.LessThanToken:
                     // This is modified UnaryExpression grammar in TypeScript
                     //  UnaryExpression (modified):
                     //      < type > UnaryExpression
                     return parseTypeAssertion();
+                case SyntaxKind.AwaitKeyword:
+                    if (isAwaitExpression()) {
+                        return parseAwaitExpression();
+                    }
                 default:
                     return parseIncrementExpression();
             }
@@ -3447,14 +3465,14 @@ namespace ts {
         /**
          * Check if the current token can possibly be an ES7 increment expression.
          *
-         * ES7 IncrementExpression:
+         * ES7 UpdateExpression:
          *      LeftHandSideExpression[?Yield]
          *      LeftHandSideExpression[?Yield][no LineTerminator here]++
          *      LeftHandSideExpression[?Yield][no LineTerminator here]--
          *      ++LeftHandSideExpression[?Yield]
          *      --LeftHandSideExpression[?Yield]
          */
-        function isIncrementExpression(): boolean {
+        function isUpdateExpression(): boolean {
             // This function is called inside parseUnaryExpression to decide
             // whether to call parseSimpleUnaryExpression or call parseIncrementExpression directly
             switch (token()) {
@@ -3465,6 +3483,7 @@ namespace ts {
                 case SyntaxKind.DeleteKeyword:
                 case SyntaxKind.TypeOfKeyword:
                 case SyntaxKind.VoidKeyword:
+                case SyntaxKind.AwaitKeyword:
                     return false;
                 case SyntaxKind.LessThanToken:
                     // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
@@ -5893,6 +5912,9 @@ namespace ts {
                     case SyntaxKind.BooleanKeyword:
                     case SyntaxKind.SymbolKeyword:
                     case SyntaxKind.VoidKeyword:
+                    case SyntaxKind.NullKeyword:
+                    case SyntaxKind.UndefinedKeyword:
+                    case SyntaxKind.NeverKeyword:
                         return parseTokenNode<JSDocType>();
                     case SyntaxKind.StringLiteral:
                     case SyntaxKind.NumericLiteral:
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index afd2dda..f099d85 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -720,8 +720,9 @@ namespace ts {
             const typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
             if (typesFile) {
                 const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(typesFile), state.host);
-                // The package.json "typings" property must specify the file with extension, so just try that exact filename.
-                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state);
+                // A package.json "typings" may specify an exact filename, or may choose to omit an extension.
+                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state) ||
+                    tryAddingExtensions(typesFile, extensions, failedLookupLocation, onlyRecordFailures, state);
                 if (result) {
                     return result;
                 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 7594d2c..50beef5 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -351,6 +351,9 @@ namespace ts {
         JSDocPropertyTag,
         JSDocTypeLiteral,
         JSDocLiteralType,
+        JSDocNullKeyword,
+        JSDocUndefinedKeyword,
+        JSDocNeverKeyword,
 
         // Synthesized list
         SyntaxList,
@@ -383,7 +386,7 @@ namespace ts {
         FirstJSDocNode = JSDocTypeExpression,
         LastJSDocNode = JSDocLiteralType,
         FirstJSDocTagNode = JSDocComment,
-        LastJSDocTagNode = JSDocLiteralType
+        LastJSDocTagNode = JSDocNeverKeyword
     }
 
     export const enum NodeFlags {
@@ -2263,7 +2266,7 @@ namespace ts {
         Class                   = 1 << 15,  // Class
         Interface               = 1 << 16,  // Interface
         Reference               = 1 << 17,  // Generic type reference
-        Tuple                   = 1 << 18,  // Tuple
+        Tuple                   = 1 << 18,  // Synthesized generic tuple type
         Union                   = 1 << 19,  // Union (T | U)
         Intersection            = 1 << 20,  // Intersection (T & U)
         Anonymous               = 1 << 21,  // Anonymous
@@ -2385,11 +2388,6 @@ namespace ts {
         instantiations: Map<TypeReference>;   // Generic instantiation cache
     }
 
-    export interface TupleType extends ObjectType {
-        elementTypes: Type[];  // Element types
-        thisType?: Type;       // This-type of tuple (only needed for tuples that are constraints of type parameters)
-    }
-
     export interface UnionOrIntersectionType extends Type {
         types: Type[];                    // Constituent types
         /* @internal */
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 870df4a..0c026fc 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -301,6 +301,10 @@ namespace ts {
         return node.kind >= SyntaxKind.FirstJSDocNode && node.kind <= SyntaxKind.LastJSDocNode;
     }
 
+    export function isJSDocTag(node: Node) {
+        return node.kind >= SyntaxKind.FirstJSDocTagNode && node.kind <= SyntaxKind.LastJSDocTagNode;
+    }
+
     export function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFile): number {
         if (nodeIsMissing(node) || !node.decorators) {
             return getTokenPosOfNode(node, sourceFile);
diff --git a/src/services/services.ts b/src/services/services.ts
index d200e08..babb5cf 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -299,6 +299,10 @@ namespace ts {
                         processNode(jsDocComment);
                     }
                 }
+                // For syntactic classifications, all trivia are classcified together, including jsdoc comments.
+                // For that to work, the jsdoc comments should still be the leading trivia of the first child. 
+                // Restoring the scanner position ensures that. 
+                pos = this.pos;
                 forEachChild(this, processNode, processNodes);
                 if (pos < this.end) {
                     this.addSyntheticNodes(children, pos, this.end);
@@ -7596,6 +7600,10 @@ namespace ts {
              * False will mean that node is not classified and traverse routine should recurse into node contents.
              */
             function tryClassifyNode(node: Node): boolean {
+                if (isJSDocTag(node)) {
+                    return true;
+                }
+
                 if (nodeIsMissing(node)) {
                     return true;
                 }
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 7f41cdb..858f889 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -925,4 +925,24 @@ namespace ts {
         }
         return ensureScriptKind(fileName, scriptKind);
     }
+
+    export function parseAndReEmitConfigJSONFile(content: string) {
+        const options: TranspileOptions = {
+            fileName: "config.js",
+            compilerOptions: {
+                target: ScriptTarget.ES6
+            },
+            reportDiagnostics: true
+        };
+        const { outputText, diagnostics } = ts.transpileModule("(" + content + ")", options);
+        // Becasue the content was wrapped in "()", the start position of diagnostics needs to be subtract by 1
+        // also, the emitted result will have "(" in the beginning and ");" in the end. We need to strip these
+        // as well
+        const trimmedOutput = outputText.trim();
+        const configJsonObject = JSON.parse(trimmedOutput.substring(1, trimmedOutput.length - 2));
+        for (const diagnostic of diagnostics) {
+            diagnostic.start = diagnostic.start - 1;
+        }
+        return { configJsonObject, diagnostics };
+    }
 }
\ No newline at end of file