typescript-src 0.8.3 → 0.9.0

data/lib/support/lib.d.ts

@@ -47,13 +47,13 @@ declare function parseFloat(string: string): number;
   * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a number). 
   * @param number A numeric value.
   */
-declare function isNaN(number: number): bool;
+declare function isNaN(number: number): boolean;
 
 /** 
   * Determines whether a supplied number is finite.
   * @param number Any numeric value.
   */
-declare function isFinite(number: number): bool;
+declare function isFinite(number: number): boolean;
 
 /**
   * Gets the unencoded version of an encoded Uniform Resource Identifier (URI).
@@ -80,10 +80,10 @@ declare function encodeURI(uri: string): string;
 declare function encodeURIComponent(uriComponent: string): string;
 
 interface PropertyDescriptor {
-    configurable?: bool;
-    enumerable?: bool;
+    configurable?: boolean;
+    enumerable?: boolean;
     value?: any;
-    writable?: bool;
+    writable?: boolean;
     get?(): any;
     set?(v: any): void;
 }
@@ -106,19 +106,19 @@ interface Object {
       * Determines whether an object has a property with the specified name. 
       * @param v A property name.
       */
-    hasOwnProperty(v: string): bool;
+    hasOwnProperty(v: string): boolean;
 
     /**
       * Determines whether an object exists in another object's prototype chain. 
       * @param v Another object whose prototype chain is to be checked.
       */
-    isPrototypeOf(v: Object): bool;
+    isPrototypeOf(v: Object): boolean;
 
     /** 
       * Determines whether a specified property is enumerable.
       * @param v A property name.
       */
-    propertyIsEnumerable(v: string): bool;
+    propertyIsEnumerable(v: string): boolean;
 
     [s: string]: any;
 }
@@ -199,19 +199,19 @@ declare var Object: {
       * Returns true if existing property attributes cannot be modified in an object and new properties cannot be added to the object.
       * @param o Object to test. 
       */
-    isSealed(o: any): bool;
+    isSealed(o: any): boolean;
 
     /**
       * Returns true if existing property attributes and values cannot be modified in an object, and new properties cannot be added to the object.
       * @param o Object to test.  
       */
-    isFrozen(o: any): bool;
+    isFrozen(o: any): boolean;
 
     /**
       * Returns a value that indicates whether new properties can be added to an object.
       * @param o Object to test. 
       */
-    isExtensible(o: any): bool;
+    isExtensible(o: any): boolean;
 
     /**
       * Returns the names of the enumerable properties and methods of an object.
@@ -429,7 +429,7 @@ interface Boolean {
 }
 declare var Boolean: {
     new (value?: any): Boolean;
-    (value?: any): bool;
+    (value?: any): boolean;
     prototype: Boolean;
 }
 
@@ -767,7 +767,7 @@ interface RegExpExecArray {
     toString(): string;
     toLocaleString(): string;
     concat(...items: string[][]): string[];
-    join(seperator?: string): string;
+    join(separator?: string): string;
     pop(): string;
     push(...items: string[]): number;
     reverse(): string[];
@@ -780,11 +780,11 @@ interface RegExpExecArray {
 
     indexOf(searchElement: string, fromIndex?: number): number;
     lastIndexOf(searchElement: string, fromIndex?: number): number;
-    every(callbackfn: (value: string, index: number, array: string[]) => bool, thisArg?: any): bool;
-    some(callbackfn: (value: string, index: number, array: string[]) => bool, thisArg?: any): bool;
+    every(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean;
+    some(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean;
     forEach(callbackfn: (value: string, index: number, array: string[]) => void , thisArg?: any): void;
     map(callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): any[];
-    filter(callbackfn: (value: string, index: number, array: string[]) => bool, thisArg?: any): string[];
+    filter(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): string[];
     reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any;
     reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any;
 }
@@ -800,15 +800,15 @@ interface RegExp {
       * Returns a Boolean value that indicates whether or not a pattern exists in a searched string.
       * @param string String on which to perform the search.
       */
-    test(string: string): bool;
+    test(string: string): boolean;
     /** Returns a copy of the text of the regular expression pattern. Read-only. The rgExp argument is a Regular expression object. It can be a variable name or a literal. */
     source: string;
     /** Returns a Boolean value indicating the state of the global flag (g) used with a regular expression. Default is false. Read-only. */
-    global: bool;
+    global: boolean;
     /** Returns a Boolean value indicating the state of the ignoreCase flag (i) used with a regular expression. Default is false. Read-only. */
-    ignoreCase: bool;
+    ignoreCase: boolean;
     /** Returns a Boolean value indicating the state of the multiline flag (m) used with a regular expression. Default is false. Read-only. */
-    multiline: bool;
+    multiline: boolean;
 
     lastIndex: number;
 
@@ -939,41 +939,47 @@ declare var JSON: JSON;
 /// ECMAScript Array API (specially handled by compiler)
 ////////////////
 
-interface Array {
+interface Array<T> {
     toString(): string;
     toLocaleString(): string;
-    concat(...items: _element[][]): _element[];
-    concat(...items: _element[]): _element[];
-    join(seperator?: string): string;
-    pop(): _element;
-    push(...items: _element[]): number;
-    reverse(): _element[];
-    shift(): _element;
-    slice(start: number, end?: number): _element[];
-    sort(compareFn?: (a: _element, b: _element) => number): _element[];
-    splice(start: number): _element[];
-    splice(start: number, deleteCount: number, ...items: _element[]): _element[];
-    unshift(...items: _element[]): number;
-
-    indexOf(searchElement: _element, fromIndex?: number): number;
-    lastIndexOf(searchElement: _element, fromIndex?: number): number;
-    every(callbackfn: (value: _element, index: number, array: _element[]) => bool, thisArg?: any): bool;
-    some(callbackfn: (value: _element, index: number, array: _element[]) => bool, thisArg?: any): bool;
-    forEach(callbackfn: (value: _element, index: number, array: _element[]) => void , thisArg?: any): void;
-    map(callbackfn: (value: _element, index: number, array: _element[]) => any, thisArg?: any): any[];
-    filter(callbackfn: (value: _element, index: number, array: _element[]) => bool, thisArg?: any): _element[];
-    reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: _element[]) => any, initialValue?: any): any;
-    reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: _element[]) => any, initialValue?: any): any;
+    concat<U extends T[]>(...items: U[]): T[];
+    concat(...items: T[]): T[];
+    join(separator?: string): string;
+    pop(): T;
+    push(...items: T[]): number;
+    reverse(): T[];
+    shift(): T;
+    slice(start: number, end?: number): T[];
+    sort(compareFn?: (a: T, b: T) => number): T[];
+    splice(start: number): T[];
+    splice(start: number, deleteCount: number, ...items: T[]): T[];
+    unshift(...items: T[]): number;
+
+    indexOf(searchElement: T, fromIndex?: number): number;
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
+    some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
+    forEach(callbackfn: (value: T, index: number, array: T[]) => void , thisArg?: any): void;
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
+    filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
 
     length: number;
+
 }
 declare var Array: {
-    new (...items: any[]): any[];
-    (...items: any[]): any[];
-    isArray(arg: any): bool;
-    prototype: Array;
+    new <T>(arrayLength: number): T[];
+    new <T>(...items: T[]): T[];
+    <T>(arrayLength: number): T[];
+    <T>(...items: T[]): T[];
+    isArray(arg: any): boolean;
+    prototype: Array<any>;
 }
 
+
 ////////////////
 /// IE10 ECMAScript Extensions
 ////////////////
@@ -1147,21 +1153,21 @@ declare var Float64Array: {
 interface DataView extends ArrayBufferView {
     getInt8(byteOffset: number): number;
     getUint8(byteOffset: number): number;
-    getInt16(byteOffset: number, littleEndian?: bool): number;
-    getUint16(byteOffset: number, littleEndian?: bool): number;
-    getInt32(byteOffset: number, littleEndian?: bool): number;
-    getUint32(byteOffset: number, littleEndian?: bool): number;
-    getFloat32(byteOffset: number, littleEndian?: bool): number;
-    getFloat64(byteOffset: number, littleEndian?: bool): number;
+    getInt16(byteOffset: number, littleEndian?: boolean): number;
+    getUint16(byteOffset: number, littleEndian?: boolean): number;
+    getInt32(byteOffset: number, littleEndian?: boolean): number;
+    getUint32(byteOffset: number, littleEndian?: boolean): number;
+    getFloat32(byteOffset: number, littleEndian?: boolean): number;
+    getFloat64(byteOffset: number, littleEndian?: boolean): number;
 
     setInt8(byteOffset: number, value: number): void;
     setUint8(byteOffset: number, value: number): void;
-    setInt16(byteOffset: number, value: number, littleEndian?: bool): void;
-    setUint16(byteOffset: number, value: number, littleEndian?: bool): void;
-    setInt32(byteOffset: number, value: number, littleEndian?: bool): void;
-    setUint32(byteOffset: number, value: number, littleEndian?: bool): void;
-    setFloat32(byteOffset: number, value: number, littleEndian?: bool): void;
-    setFloat64(byteOffset: number, value: number, littleEndian?: bool): void;
+    setInt16(byteOffset: number, value: number, littleEndian?: boolean): void;
+    setUint16(byteOffset: number, value: number, littleEndian?: boolean): void;
+    setInt32(byteOffset: number, value: number, littleEndian?: boolean): void;
+    setUint32(byteOffset: number, value: number, littleEndian?: boolean): void;
+    setFloat32(byteOffset: number, value: number, littleEndian?: boolean): void;
+    setFloat64(byteOffset: number, value: number, littleEndian?: boolean): void;
 }
 declare var DataView: {
     prototype: DataView;
@@ -1211,7 +1217,7 @@ interface TreeWalker {
     filter: NodeFilterCallback;
     root: Node;
     currentNode: Node;
-    expandEntityReferences: bool;
+    expandEntityReferences: boolean;
     previousSibling(): Node;
     lastChild(): Node;
     nextSibling(): Node;
@@ -1256,11 +1262,18 @@ declare var Performance: {
 
 interface SVGSVGElementEventHandlers {
     onresize: (ev: UIEvent) => any;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => void, useCapture?: boolean): void;
     onunload: (ev: Event) => any;
+    addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
     onscroll: (ev: UIEvent) => any;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onerror: (ev: Event) => any;
+    addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void;
     onzoom: (ev: any) => any;
+    addEventListener(type: "zoom", listener: (ev: any) => any, useCapture?: boolean): void;
     onabort: (ev: UIEvent) => any;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface MSDataBindingTableExtensions {
@@ -1279,7 +1292,7 @@ interface DOML2DeprecatedAlignmentStyle_HTMLParagraphElement {
 interface CompositionEvent extends UIEvent {
     data: string;
     locale: string;
-    initCompositionEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, dataArg: string, locale: string): void;
+    initCompositionEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, dataArg: string, locale: string): void;
 }
 declare var CompositionEvent: {
     prototype: CompositionEvent;
@@ -1350,18 +1363,18 @@ interface MSStyleCSSProperties extends MSCSSProperties {
     posLeft: number;
     pixelTop: number;
     pixelBottom: number;
-    textDecorationNone: bool;
+    textDecorationNone: boolean;
     pixelLeft: number;
     posTop: number;
     posBottom: number;
-    textDecorationOverline: bool;
+    textDecorationOverline: boolean;
     posWidth: number;
-    textDecorationLineThrough: bool;
+    textDecorationLineThrough: boolean;
     pixelHeight: number;
-    textDecorationBlink: bool;
+    textDecorationBlink: boolean;
     posRight: number;
     pixelRight: number;
-    textDecorationUnderline: bool;
+    textDecorationUnderline: boolean;
 }
 declare var MSStyleCSSProperties: {
     prototype: MSStyleCSSProperties;
@@ -1371,10 +1384,10 @@ declare var MSStyleCSSProperties: {
 interface MSCSSStyleSheetExtensions {
     owningElement: Element;
     imports: StyleSheetList;
-    isAlternate: bool;
+    isAlternate: boolean;
     rules: MSCSSRuleList;
-    isPrefAlternate: bool;
-    readOnly: bool;
+    isPrefAlternate: boolean;
+    readOnly: boolean;
     cssText: string;
     href: string;
     id: string;
@@ -1464,7 +1477,7 @@ interface PositionErrorCallback {
 interface DOMImplementation extends DOMHTMLImplementation {
     createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType;
     createDocument(namespaceURI: string, qualifiedName: string, doctype: DocumentType): Document;
-    hasFeature(feature: string, version?: string): bool;
+    hasFeature(feature: string, version?: string): boolean;
 }
 declare var DOMImplementation: {
     prototype: DOMImplementation;
@@ -1494,46 +1507,74 @@ interface DocumentRange {
 
 interface MSHTMLDocumentExtensions {
     onrowexit: (ev: MSEventObj) => any;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     compatible: MSCompatibleInfoCollection;
     oncontrolselect: (ev: MSEventObj) => any;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onrowsinserted: (ev: MSEventObj) => any;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onpropertychange: (ev: MSEventObj) => any;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     media: string;
     onafterupdate: (ev: MSEventObj) => any;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onhelp: (ev: Event) => any;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
     uniqueID: string;
     onbeforeactivate: (ev: UIEvent) => any;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onstoragecommit: (ev: StorageEvent) => any;
+    addEventListener(type: "storagecommit", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
     onselectionchange: (ev: Event) => any;
+    addEventListener(type: "selectionchange", listener: (ev: Event) => any, useCapture?: boolean): void;
     documentMode: number;
     onfocusout: (ev: FocusEvent) => any;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     ondataavailable: (ev: MSEventObj) => any;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onbeforeupdate: (ev: MSEventObj) => any;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onfocusin: (ev: FocusEvent) => any;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     security: string;
     namespaces: MSNamespaceInfoCollection;
     ondatasetcomplete: (ev: MSEventObj) => any;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onbeforedeactivate: (ev: UIEvent) => any;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onstop: (ev: Event) => any;
+    addEventListener(type: "stop", listener: (ev: Event) => any, useCapture?: boolean): void;
     onactivate: (ev: UIEvent) => any;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onmssitemodejumplistitemremoved: (ev: MSSiteModeEvent) => any;
+    addEventListener(type: "mssitemodejumplistitemremoved", listener: (ev: MSSiteModeEvent) => any, useCapture?: boolean): void;
     frames: Window;
     onselectstart: (ev: Event) => any;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
     onerrorupdate: (ev: MSEventObj) => any;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     parentWindow: Window;
     ondeactivate: (ev: UIEvent) => any;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     ondatasetchanged: (ev: MSEventObj) => any;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onrowsdelete: (ev: MSEventObj) => any;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onmsthumbnailclick: (ev: MSSiteModeEvent) => any;
+    addEventListener(type: "msthumbnailclick", listener: (ev: MSSiteModeEvent) => any, useCapture?: boolean): void;
     onrowenter: (ev: MSEventObj) => any;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onbeforeeditfocus: (ev: MSEventObj) => any;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     Script: MSScriptHost;
     oncellchange: (ev: MSEventObj) => any;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     URLUnencoded: string;
     updateSettings(): void;
-    execCommandShowHelp(commandId: string): bool;
+    execCommandShowHelp(commandId: string): boolean;
     releaseCapture(): void;
     focus(): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface CSS2Properties {
@@ -1666,16 +1707,119 @@ interface Element extends Node, NodeSelector, ElementTraversal, MSElementExtensi
     scrollHeight: number;
     getAttribute(name?: string): string;
     getElementsByTagNameNS(namespaceURI: string, localName: string): NodeList;
-    hasAttributeNS(namespaceURI: string, localName: string): bool;
+    hasAttributeNS(namespaceURI: string, localName: string): boolean;
     getBoundingClientRect(): ClientRect;
     getAttributeNS(namespaceURI: string, localName: string): string;
     getAttributeNodeNS(namespaceURI: string, localName: string): Attr;
     setAttributeNodeNS(newAttr: Attr): Attr;
-    hasAttribute(name: string): bool;
+    hasAttribute(name: string): boolean;
     removeAttribute(name?: string): void;
     setAttributeNS(namespaceURI: string, qualifiedName: string, value: string): void;
     getAttributeNode(name: string): Attr;
     getElementsByTagName(name: string): NodeList;
+    getElementsByTagName(name: "a"): NodeListOf<HTMLAnchorElement>;
+    getElementsByTagName(name: "abbr"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "address"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "area"): NodeListOf<HTMLAreaElement>;
+    getElementsByTagName(name: "article"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "aside"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "audio"): NodeListOf<HTMLAudioElement>;
+    getElementsByTagName(name: "b"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "base"): NodeListOf<HTMLBaseElement>;
+    getElementsByTagName(name: "bdi"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "bdo"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "blockquote"): NodeListOf<HTMLQuoteElement>;
+    getElementsByTagName(name: "body"): NodeListOf<HTMLBodyElement>;
+    getElementsByTagName(name: "br"): NodeListOf<HTMLBRElement>;
+    getElementsByTagName(name: "button"): NodeListOf<HTMLButtonElement>;
+    getElementsByTagName(name: "canvas"): NodeListOf<HTMLCanvasElement>;
+    getElementsByTagName(name: "caption"): NodeListOf<HTMLTableCaptionElement>;
+    getElementsByTagName(name: "cite"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "code"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "col"): NodeListOf<HTMLTableColElement>;
+    getElementsByTagName(name: "colgroup"): NodeListOf<HTMLTableColElement>;
+    getElementsByTagName(name: "datalist"): NodeListOf<HTMLDataListElement>;
+    getElementsByTagName(name: "dd"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "del"): NodeListOf<HTMLModElement>;
+    getElementsByTagName(name: "dfn"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "div"): NodeListOf<HTMLDivElement>;
+    getElementsByTagName(name: "dl"): NodeListOf<HTMLDListElement>;
+    getElementsByTagName(name: "dt"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "em"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "embed"): NodeListOf<HTMLEmbedElement>;
+    getElementsByTagName(name: "fieldset"): NodeListOf<HTMLFieldSetElement>;
+    getElementsByTagName(name: "figcaption"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "figure"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "footer"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "form"): NodeListOf<HTMLFormElement>;
+    getElementsByTagName(name: "h1"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h2"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h3"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h4"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h5"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h6"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "head"): NodeListOf<HTMLHeadElement>;
+    getElementsByTagName(name: "header"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "hgroup"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "hr"): NodeListOf<HTMLHRElement>;
+    getElementsByTagName(name: "html"): NodeListOf<HTMLHtmlElement>;
+    getElementsByTagName(name: "i"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "iframe"): NodeListOf<HTMLIFrameElement>;
+    getElementsByTagName(name: "img"): NodeListOf<HTMLImageElement>;
+    getElementsByTagName(name: "input"): NodeListOf<HTMLInputElement>;
+    getElementsByTagName(name: "ins"): NodeListOf<HTMLModElement>;
+    getElementsByTagName(name: "kbd"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "label"): NodeListOf<HTMLLabelElement>;
+    getElementsByTagName(name: "legend"): NodeListOf<HTMLLegendElement>;
+    getElementsByTagName(name: "li"): NodeListOf<HTMLLIElement>;
+    getElementsByTagName(name: "link"): NodeListOf<HTMLLinkElement>;
+    getElementsByTagName(name: "main"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "map"): NodeListOf<HTMLMapElement>;
+    getElementsByTagName(name: "mark"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "menu"): NodeListOf<HTMLMenuElement>;
+    getElementsByTagName(name: "meta"): NodeListOf<HTMLMetaElement>;
+    getElementsByTagName(name: "nav"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "noscript"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "object"): NodeListOf<HTMLObjectElement>;
+    getElementsByTagName(name: "ol"): NodeListOf<HTMLOListElement>;
+    getElementsByTagName(name: "optgroup"): NodeListOf<HTMLOptGroupElement>;
+    getElementsByTagName(name: "option"): NodeListOf<HTMLOptionElement>;
+    getElementsByTagName(name: "p"): NodeListOf<HTMLParagraphElement>;
+    getElementsByTagName(name: "param"): NodeListOf<HTMLParamElement>;
+    getElementsByTagName(name: "pre"): NodeListOf<HTMLPreElement>;
+    getElementsByTagName(name: "progress"): NodeListOf<HTMLProgressElement>;
+    getElementsByTagName(name: "q"): NodeListOf<HTMLQuoteElement>;
+    getElementsByTagName(name: "rp"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "rt"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "ruby"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "s"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "samp"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "script"): NodeListOf<HTMLScriptElement>;
+    getElementsByTagName(name: "section"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "select"): NodeListOf<HTMLSelectElement>;
+    getElementsByTagName(name: "small"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "source"): NodeListOf<HTMLSourceElement>;
+    getElementsByTagName(name: "span"): NodeListOf<HTMLSpanElement>;
+    getElementsByTagName(name: "strong"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "style"): NodeListOf<HTMLStyleElement>;
+    getElementsByTagName(name: "sub"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "summary"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "sup"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "table"): NodeListOf<HTMLTableElement>;
+    getElementsByTagName(name: "tbody"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "td"): NodeListOf<HTMLTableDataCellElement>;
+    getElementsByTagName(name: "textarea"): NodeListOf<HTMLTextAreaElement>;
+    getElementsByTagName(name: "tfoot"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "th"): NodeListOf<HTMLTableHeaderCellElement>;
+    getElementsByTagName(name: "thead"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "title"): NodeListOf<HTMLTitleElement>;
+    getElementsByTagName(name: "tr"): NodeListOf<HTMLTableRowElement>;
+    getElementsByTagName(name: "track"): NodeListOf<HTMLTrackElement>;
+    getElementsByTagName(name: "u"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "ul"): NodeListOf<HTMLUListElement>;
+    getElementsByTagName(name: "var"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "video"): NodeListOf<HTMLVideoElement>;
+    getElementsByTagName(name: "wbr"): NodeListOf<HTMLElement>;
     setAttributeNode(newAttr: Attr): Attr;
     getClientRects(): ClientRectList;
     removeAttributeNode(oldAttr: Attr): Attr;
@@ -1769,17 +1913,17 @@ interface Node extends EventTarget {
     prefix: string;
     removeChild(oldChild: Node): Node;
     appendChild(newChild: Node): Node;
-    isSupported(feature: string, version: string): bool;
-    isEqualNode(arg: Node): bool;
+    isSupported(feature: string, version: string): boolean;
+    isEqualNode(arg: Node): boolean;
     lookupPrefix(namespaceURI: string): string;
-    isDefaultNamespace(namespaceURI: string): bool;
+    isDefaultNamespace(namespaceURI: string): boolean;
     compareDocumentPosition(other: Node): number;
     normalize(): void;
-    isSameNode(other: Node): bool;
-    hasAttributes(): bool;
+    isSameNode(other: Node): boolean;
+    hasAttributes(): boolean;
     lookupNamespaceURI(prefix: string): string;
-    cloneNode(deep?: bool): Node;
-    hasChildNodes(): bool;
+    cloneNode(deep?: boolean): Node;
+    hasChildNodes(): boolean;
     replaceChild(newChild: Node, oldChild: Node): Node;
     insertBefore(newChild: Node, refChild?: Node): Node;
     ENTITY_REFERENCE_NODE: number;
@@ -1830,7 +1974,7 @@ interface MSHTMLLegendElementExtensions {
 interface MSCSSStyleDeclarationExtensions {
     getAttribute(attributeName: string, flags?: number): any;
     setAttribute(attributeName: string, AttributeValue: any, flags?: number): void;
-    removeAttribute(attributeName: string, flags?: number): bool;
+    removeAttribute(attributeName: string, flags?: number): boolean;
 }
 
 interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {
@@ -1862,7 +2006,7 @@ interface MSHTMLObjectElementExtensions {
 }
 
 interface DOML2DeprecatedListSpaceReduction {
-    compact: bool;
+    compact: boolean;
 }
 
 interface CSS3Properties {
@@ -1912,21 +2056,21 @@ interface MouseEvent extends UIEvent, MSMouseEventExtensions {
     offsetY: number;
     x: number;
     y: number;
-    altKey: bool;
-    metaKey: bool;
-    ctrlKey: bool;
+    altKey: boolean;
+    metaKey: boolean;
+    ctrlKey: boolean;
     offsetX: number;
     screenX: number;
     clientY: number;
-    shiftKey: bool;
+    shiftKey: boolean;
     screenY: number;
     relatedTarget: EventTarget;
     button: number;
     pageY: number;
     buttons: number;
     clientX: number;
-    initMouseEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: bool, altKeyArg: bool, shiftKeyArg: bool, metaKeyArg: bool, buttonArg: number, relatedTargetArg: EventTarget): void;
-    getModifierState(keyArg: string): bool;
+    initMouseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget): void;
+    getModifierState(keyArg: string): boolean;
 }
 declare var MouseEvent: {
     prototype: MouseEvent;
@@ -2000,7 +2144,7 @@ declare var TextMetrics: {
 }
 
 interface DOML2DeprecatedWordWrapSuppression_HTMLBodyElement {
-    noWrap: bool;
+    noWrap: boolean;
 }
 
 interface HTMLOListElement extends HTMLElement, DOML2DeprecatedListNumberingAndBulletStyle, DOML2DeprecatedListSpaceReduction, MSHTMLOListElementExtensions {
@@ -2041,7 +2185,7 @@ declare var CDATASection: {
 
 interface StyleMedia {
     type: string;
-    matchMedium(mediaquery: string): bool;
+    matchMedium(mediaquery: string): boolean;
 }
 declare var StyleMedia: {
     prototype: StyleMedia;
@@ -2061,31 +2205,31 @@ interface TextRange {
     queryCommandValue(cmdID: string): any;
     getBookmark(): string;
     move(Unit: string, Count?: number): number;
-    queryCommandIndeterm(cmdID: string): bool;
-    scrollIntoView(fStart?: bool): void;
-    findText(string: string, count?: number, flags?: number): bool;
-    execCommand(cmdID: string, showUI?: bool, value?: any): bool;
+    queryCommandIndeterm(cmdID: string): boolean;
+    scrollIntoView(fStart?: boolean): void;
+    findText(string: string, count?: number, flags?: number): boolean;
+    execCommand(cmdID: string, showUI?: boolean, value?: any): boolean;
     getBoundingClientRect(): ClientRect;
-    moveToBookmark(Bookmark: string): bool;
-    isEqual(range: TextRange): bool;
+    moveToBookmark(Bookmark: string): boolean;
+    isEqual(range: TextRange): boolean;
     duplicate(): TextRange;
-    collapse(Start?: bool): void;
+    collapse(Start?: boolean): void;
     queryCommandText(cmdID: string): string;
     select(): void;
     pasteHTML(html: string): void;
-    inRange(range: TextRange): bool;
+    inRange(range: TextRange): boolean;
     moveEnd(Unit: string, Count?: number): number;
     getClientRects(): ClientRectList;
     moveStart(Unit: string, Count?: number): number;
     parentElement(): Element;
-    queryCommandState(cmdID: string): bool;
+    queryCommandState(cmdID: string): boolean;
     compareEndPoints(how: string, sourceRange: TextRange): number;
-    execCommandShowHelp(cmdID: string): bool;
+    execCommandShowHelp(cmdID: string): boolean;
     moveToElementText(element: Element): void;
-    expand(Unit: string): bool;
-    queryCommandSupported(cmdID: string): bool;
+    expand(Unit: string): boolean;
+    queryCommandSupported(cmdID: string): boolean;
     setEndPoint(how: string, SourceRange: TextRange): void;
-    queryCommandEnabled(cmdID: string): bool;
+    queryCommandEnabled(cmdID: string): boolean;
 }
 declare var TextRange: {
     prototype: TextRange;
@@ -2100,7 +2244,7 @@ interface HTMLSelectElement extends HTMLElement, MSHTMLCollectionExtensions, MSD
     size: number;
     length: number;
     selectedIndex: number;
-    multiple: bool;
+    multiple: boolean;
     type: string;
     remove(index?: number): void;
     add(element: HTMLElement, before?: any): void;
@@ -2138,7 +2282,7 @@ interface SVGTests {
     requiredFeatures: SVGStringList;
     requiredExtensions: SVGStringList;
     systemLanguage: SVGStringList;
-    hasExtension(extension: string): bool;
+    hasExtension(extension: string): boolean;
 }
 
 interface MSSelection {
@@ -2169,7 +2313,7 @@ declare var HTMLMetaElement: {
 }
 
 interface Selection {
-    isCollapsed: bool;
+    isCollapsed: boolean;
     anchorNode: Node;
     focusNode: Node;
     anchorOffset: number;
@@ -2233,7 +2377,7 @@ interface NodeIterator {
     whatToShow: number;
     filter: NodeFilterCallback;
     root: Node;
-    expandEntityReferences: bool;
+    expandEntityReferences: boolean;
     nextNode(): Node;
     detach(): void;
     previousNode(): Node;
@@ -2289,7 +2433,7 @@ interface MSHTMLAppletElementExtensions extends DOML2DeprecatedBorderStyle_HTMLO
     data: string;
     contentDocument: Document;
     altHtml: string;
-    declare: bool;
+    declare: boolean;
     type: string;
     BaseHref: string;
 }
@@ -2330,15 +2474,15 @@ interface ControlRangeCollection {
     queryCommandValue(cmdID: string): any;
     remove(index: number): void;
     add(item: Element): void;
-    queryCommandIndeterm(cmdID: string): bool;
+    queryCommandIndeterm(cmdID: string): boolean;
     scrollIntoView(varargStart?: any): void;
     item(index: number): Element;
     [index: number]: Element;
-    execCommand(cmdID: string, showUI?: bool, value?: any): bool;
+    execCommand(cmdID: string, showUI?: boolean, value?: any): boolean;
     addElement(item: Element): void;
-    queryCommandState(cmdID: string): bool;
-    queryCommandSupported(cmdID: string): bool;
-    queryCommandEnabled(cmdID: string): bool;
+    queryCommandState(cmdID: string): boolean;
+    queryCommandSupported(cmdID: string): boolean;
+    queryCommandEnabled(cmdID: string): boolean;
     queryCommandText(cmdID: string): string;
     select(): void;
 }
@@ -2355,18 +2499,22 @@ interface MSHTMLFrameElementExtensions {
     width: any;
     contentWindow: Window;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     frameBorder: string;
     height: any;
     border: string;
     frameSpacing: any;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface MSNamespaceInfo extends MSEventAttachmentTarget {
     urn: string;
     onreadystatechange: (ev: Event) => any;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     name: string;
     readyState: string;
     doImport(implementationUrl: string): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var MSNamespaceInfo: {
     prototype: MSNamespaceInfo;
@@ -2395,12 +2543,12 @@ declare var HTMLTableCaptionElement: {
 
 interface HTMLOptionElement extends HTMLElement, MSDataBindingExtensions {
     index: number;
-    defaultSelected: bool;
+    defaultSelected: boolean;
     value: string;
     text: string;
     form: HTMLFormElement;
     label: string;
-    selected: bool;
+    selected: boolean;
 }
 declare var HTMLOptionElement: {
     prototype: HTMLOptionElement;
@@ -2426,7 +2574,7 @@ declare var HTMLMenuElement: {
 
 interface MouseWheelEvent extends MouseEvent {
     wheelDelta: number;
-    initMouseWheelEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, wheelDeltaArg: number): void;
+    initMouseWheelEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, wheelDeltaArg: number): void;
 }
 declare var MouseWheelEvent: {
     prototype: MouseWheelEvent;
@@ -2480,90 +2628,151 @@ interface MSHTMLTableDataCellElementExtensions {
 
 interface Window extends ViewCSS, MSEventAttachmentTarget, MSWindowExtensions, WindowPerformance, ScreenView, EventTarget, WindowLocalStorage, WindowSessionStorage, WindowTimers {
     ondragend: (ev: DragEvent) => any;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onkeydown: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     ondragover: (ev: DragEvent) => any;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onkeyup: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     onreset: (ev: Event) => any;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
     onmouseup: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     ondragstart: (ev: DragEvent) => any;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     ondrag: (ev: DragEvent) => any;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onmouseover: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     ondragleave: (ev: DragEvent) => any;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     history: History;
     name: string;
     onafterprint: (ev: Event) => any;
+    addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void;
     onpause: (ev: Event) => any;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
     onbeforeprint: (ev: Event) => any;
+    addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void;
     top: Window;
     onmousedown: (ev: MouseEvent) => any;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onseeked: (ev: Event) => any;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
     opener: Window;
     onclick: (ev: MouseEvent) => any;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onwaiting: (ev: Event) => any;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
     ononline: (ev: Event) => any;
+    addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void;
     ondurationchange: (ev: Event) => any;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
     frames: Window;
     onblur: (ev: FocusEvent) => any;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onemptied: (ev: Event) => any;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
     onseeking: (ev: Event) => any;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
     oncanplay: (ev: Event) => any;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
     onstalled: (ev: Event) => any;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
     onmousemove: (ev: MouseEvent) => any;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onoffline: (ev: Event) => any;
+    addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void;
     length: number;
     onbeforeunload: (ev: BeforeUnloadEvent) => any;
+    addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void;
     onratechange: (ev: Event) => any;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onstorage: (ev: StorageEvent) => any;
+    addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
     onloadstart: (ev: Event) => any;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
     ondragenter: (ev: DragEvent) => any;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onsubmit: (ev: Event) => any;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
     self: Window;
     onprogress: (ev: any) => any;
+    addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void;
     ondblclick: (ev: MouseEvent) => any;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     oncontextmenu: (ev: MouseEvent) => any;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onchange: (ev: Event) => any;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
     onloadedmetadata: (ev: Event) => any;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
     onplay: (ev: Event) => any;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
     onerror: ErrorFunction;
     onplaying: (ev: Event) => any;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
     parent: Window;
     location: Location;
     oncanplaythrough: (ev: Event) => any;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
     onabort: (ev: UIEvent) => any;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onreadystatechange: (ev: Event) => any;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onkeypress: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     frameElement: Element;
     onloadeddata: (ev: Event) => any;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
     onsuspend: (ev: Event) => any;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
     window: Window;
     onfocus: (ev: FocusEvent) => any;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onmessage: (ev: MessageEvent) => any;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
     ontimeupdate: (ev: Event) => any;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
     onresize: (ev: UIEvent) => any;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     navigator: Navigator;
     onselect: (ev: UIEvent) => any;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     ondrop: (ev: DragEvent) => any;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onmouseout: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onended: (ev: Event) => any;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
     onhashchange: (ev: Event) => any;
+    addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onunload: (ev: Event) => any;
+    addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
     onscroll: (ev: UIEvent) => any;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onmousewheel: (ev: MouseWheelEvent) => any;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     onvolumechange: (ev: Event) => any;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     oninput: (ev: Event) => any;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
     alert(message?: string): void;
     focus(): void;
     print(): void;
     prompt(message?: string, defaul?: string): string;
     toString(): string;
-    open(url?: string, target?: string, features?: string, replace?: bool): Window;
+    open(url?: string, target?: string, features?: string, replace?: boolean): Window;
     close(): void;
-    confirm(message?: string): bool;
+    confirm(message?: string): boolean;
     postMessage(message: any, targetOrigin: string, ports?: any): void;
     showModalDialog(url?: string, argument?: any, options?: any): any;
     blur(): void;
     getSelection(): Selection;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var Window: {
     prototype: Window;
@@ -2589,7 +2798,7 @@ declare var MSSiteModeEvent: {
 }
 
 interface MSCSSStyleRuleExtensions {
-    readOnly: bool;
+    readOnly: boolean;
 }
 
 interface StyleSheetPageList {
@@ -2608,7 +2817,6 @@ interface HTMLCollection extends MSHTMLCollectionExtensions {
     (nameOrIndex: any, optionalIndex: any): Element;
     namedItem(name: string): Element;
     [index: number]: Element;
-    [name: string]: Element;
     (name: string): Element;
 }
 declare var HTMLCollection: {
@@ -2663,8 +2871,8 @@ interface HTMLImageElement extends HTMLElement, DOML2DeprecatedMarginStyle, DOML
     name: string;
     height: number;
     longDesc: string;
-    isMap: bool;
-    complete: bool;
+    isMap: boolean;
+    complete: boolean;
 }
 declare var HTMLImageElement: {
     prototype: HTMLImageElement;
@@ -2683,7 +2891,7 @@ interface HTMLAreaElement extends HTMLElement, MSHTMLAreaElementExtensions {
     hash: string;
     target: string;
     href: string;
-    noHref: bool;
+    noHref: boolean;
     shape: string;
     toString(): string;
 }
@@ -2693,9 +2901,9 @@ declare var HTMLAreaElement: {
 }
 
 interface EventTarget {
-    removeEventListener(type: string, listener: EventListener, useCapture?: bool): void;
-    addEventListener(type: string, listener: EventListener, useCapture?: bool): void;
-    dispatchEvent(evt: Event): bool;
+    removeEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+    dispatchEvent(evt: Event): boolean;
 }
 
 interface SVGAngle {
@@ -2755,16 +2963,16 @@ declare var CanvasGradient: {
 
 interface KeyboardEvent extends UIEvent, KeyboardEventExtensions {
     location: number;
-    shiftKey: bool;
+    shiftKey: boolean;
     locale: string;
     key: string;
-    altKey: bool;
-    metaKey: bool;
+    altKey: boolean;
+    metaKey: boolean;
     char: string;
-    ctrlKey: bool;
-    repeat: bool;
-    getModifierState(keyArg: string): bool;
-    initKeyboardEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, keyArg: string, locationArg: number, modifiersListArg: string, repeat: bool, locale: string): void;
+    ctrlKey: boolean;
+    repeat: boolean;
+    getModifierState(keyArg: string): boolean;
+    initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void;
     DOM_KEY_LOCATION_RIGHT: number;
     DOM_KEY_LOCATION_STANDARD: number;
     DOM_KEY_LOCATION_LEFT: number;
@@ -2788,20 +2996,226 @@ interface Document extends Node, DocumentStyle, DocumentRange, HTMLDocument, Nod
     xmlVersion: string;
     implementation: DOMImplementation;
     xmlEncoding: string;
-    xmlStandalone: bool;
+    xmlStandalone: boolean;
     documentElement: HTMLElement;
     inputEncoding: string;
     createElement(tagName: string): HTMLElement;
+    createElement(tagName: "a"): HTMLAnchorElement;
+    createElement(tagName: "abbr"): HTMLElement;
+    createElement(tagName: "address"): HTMLElement;
+    createElement(tagName: "area"): HTMLAreaElement;
+    createElement(tagName: "article"): HTMLElement;
+    createElement(tagName: "aside"): HTMLElement;
+    createElement(tagName: "audio"): HTMLAudioElement;
+    createElement(tagName: "b"): HTMLElement;
+    createElement(tagName: "base"): HTMLBaseElement;
+    createElement(tagName: "bdi"): HTMLElement;
+    createElement(tagName: "bdo"): HTMLElement;
+    createElement(tagName: "blockquote"): HTMLQuoteElement;
+    createElement(tagName: "body"): HTMLBodyElement;
+    createElement(tagName: "br"): HTMLBRElement;
+    createElement(tagName: "button"): HTMLButtonElement;
+    createElement(tagName: "canvas"): HTMLCanvasElement;
+    createElement(tagName: "caption"): HTMLTableCaptionElement;
+    createElement(tagName: "cite"): HTMLElement;
+    createElement(tagName: "code"): HTMLElement;
+    createElement(tagName: "col"): HTMLTableColElement;
+    createElement(tagName: "colgroup"): HTMLTableColElement;
+    createElement(tagName: "datalist"): HTMLDataListElement;
+    createElement(tagName: "dd"): HTMLElement;
+    createElement(tagName: "del"): HTMLModElement;
+    createElement(tagName: "dfn"): HTMLElement;
+    createElement(tagName: "div"): HTMLDivElement;
+    createElement(tagName: "dl"): HTMLDListElement;
+    createElement(tagName: "dt"): HTMLElement;
+    createElement(tagName: "em"): HTMLElement;
+    createElement(tagName: "embed"): HTMLEmbedElement;
+    createElement(tagName: "fieldset"): HTMLFieldSetElement;
+    createElement(tagName: "figcaption"): HTMLElement;
+    createElement(tagName: "figure"): HTMLElement;
+    createElement(tagName: "footer"): HTMLElement;
+    createElement(tagName: "form"): HTMLFormElement;
+    createElement(tagName: "h1"): HTMLHeadingElement;
+    createElement(tagName: "h2"): HTMLHeadingElement;
+    createElement(tagName: "h3"): HTMLHeadingElement;
+    createElement(tagName: "h4"): HTMLHeadingElement;
+    createElement(tagName: "h5"): HTMLHeadingElement;
+    createElement(tagName: "h6"): HTMLHeadingElement;
+    createElement(tagName: "head"): HTMLHeadElement;
+    createElement(tagName: "header"): HTMLElement;
+    createElement(tagName: "hgroup"): HTMLElement;
+    createElement(tagName: "hr"): HTMLHRElement;
+    createElement(tagName: "html"): HTMLHtmlElement;
+    createElement(tagName: "i"): HTMLElement;
+    createElement(tagName: "iframe"): HTMLIFrameElement;
+    createElement(tagName: "img"): HTMLImageElement;
+    createElement(tagName: "input"): HTMLInputElement;
+    createElement(tagName: "ins"): HTMLModElement;
+    createElement(tagName: "kbd"): HTMLElement;
+    createElement(tagName: "label"): HTMLLabelElement;
+    createElement(tagName: "legend"): HTMLLegendElement;
+    createElement(tagName: "li"): HTMLLIElement;
+    createElement(tagName: "link"): HTMLLinkElement;
+    createElement(tagName: "main"): HTMLElement;
+    createElement(tagName: "map"): HTMLMapElement;
+    createElement(tagName: "mark"): HTMLElement;
+    createElement(tagName: "menu"): HTMLMenuElement;
+    createElement(tagName: "meta"): HTMLMetaElement;
+    createElement(tagName: "nav"): HTMLElement;
+    createElement(tagName: "noscript"): HTMLElement;
+    createElement(tagName: "object"): HTMLObjectElement;
+    createElement(tagName: "ol"): HTMLOListElement;
+    createElement(tagName: "optgroup"): HTMLOptGroupElement;
+    createElement(tagName: "option"): HTMLOptionElement;
+    createElement(tagName: "p"): HTMLParagraphElement;
+    createElement(tagName: "param"): HTMLParamElement;
+    createElement(tagName: "pre"): HTMLPreElement;
+    createElement(tagName: "progress"): HTMLProgressElement;
+    createElement(tagName: "q"): HTMLQuoteElement;
+    createElement(tagName: "rp"): HTMLElement;
+    createElement(tagName: "rt"): HTMLElement;
+    createElement(tagName: "ruby"): HTMLElement;
+    createElement(tagName: "s"): HTMLElement;
+    createElement(tagName: "samp"): HTMLElement;
+    createElement(tagName: "script"): HTMLScriptElement;
+    createElement(tagName: "section"): HTMLElement;
+    createElement(tagName: "select"): HTMLSelectElement;
+    createElement(tagName: "small"): HTMLElement;
+    createElement(tagName: "source"): HTMLSourceElement;
+    createElement(tagName: "span"): HTMLSpanElement;
+    createElement(tagName: "strong"): HTMLElement;
+    createElement(tagName: "style"): HTMLStyleElement;
+    createElement(tagName: "sub"): HTMLElement;
+    createElement(tagName: "summary"): HTMLElement;
+    createElement(tagName: "sup"): HTMLElement;
+    createElement(tagName: "table"): HTMLTableElement;
+    createElement(tagName: "tbody"): HTMLTableSectionElement;
+    createElement(tagName: "td"): HTMLTableDataCellElement;
+    createElement(tagName: "textarea"): HTMLTextAreaElement;
+    createElement(tagName: "tfoot"): HTMLTableSectionElement;
+    createElement(tagName: "th"): HTMLTableHeaderCellElement;
+    createElement(tagName: "thead"): HTMLTableSectionElement;
+    createElement(tagName: "title"): HTMLTitleElement;
+    createElement(tagName: "tr"): HTMLTableRowElement;
+    createElement(tagName: "track"): HTMLTrackElement;
+    createElement(tagName: "u"): HTMLElement;
+    createElement(tagName: "ul"): HTMLUListElement;
+    createElement(tagName: "var"): HTMLElement;
+    createElement(tagName: "video"): HTMLVideoElement;
+    createElement(tagName: "wbr"): HTMLElement;
     adoptNode(source: Node): Node;
     createComment(data: string): Comment;
     createDocumentFragment(): DocumentFragment;
     getElementsByTagName(tagname: string): NodeList;
+    getElementsByTagName(name: "a"): NodeListOf<HTMLAnchorElement>;
+    getElementsByTagName(name: "abbr"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "address"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "area"): NodeListOf<HTMLAreaElement>;
+    getElementsByTagName(name: "article"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "aside"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "audio"): NodeListOf<HTMLAudioElement>;
+    getElementsByTagName(name: "b"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "base"): NodeListOf<HTMLBaseElement>;
+    getElementsByTagName(name: "bdi"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "bdo"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "blockquote"): NodeListOf<HTMLQuoteElement>;
+    getElementsByTagName(name: "body"): NodeListOf<HTMLBodyElement>;
+    getElementsByTagName(name: "br"): NodeListOf<HTMLBRElement>;
+    getElementsByTagName(name: "button"): NodeListOf<HTMLButtonElement>;
+    getElementsByTagName(name: "canvas"): NodeListOf<HTMLCanvasElement>;
+    getElementsByTagName(name: "caption"): NodeListOf<HTMLTableCaptionElement>;
+    getElementsByTagName(name: "cite"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "code"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "col"): NodeListOf<HTMLTableColElement>;
+    getElementsByTagName(name: "colgroup"): NodeListOf<HTMLTableColElement>;
+    getElementsByTagName(name: "datalist"): NodeListOf<HTMLDataListElement>;
+    getElementsByTagName(name: "dd"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "del"): NodeListOf<HTMLModElement>;
+    getElementsByTagName(name: "dfn"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "div"): NodeListOf<HTMLDivElement>;
+    getElementsByTagName(name: "dl"): NodeListOf<HTMLDListElement>;
+    getElementsByTagName(name: "dt"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "em"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "embed"): NodeListOf<HTMLEmbedElement>;
+    getElementsByTagName(name: "fieldset"): NodeListOf<HTMLFieldSetElement>;
+    getElementsByTagName(name: "figcaption"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "figure"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "footer"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "form"): NodeListOf<HTMLFormElement>;
+    getElementsByTagName(name: "h1"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h2"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h3"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h4"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h5"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "h6"): NodeListOf<HTMLHeadingElement>;
+    getElementsByTagName(name: "head"): NodeListOf<HTMLHeadElement>;
+    getElementsByTagName(name: "header"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "hgroup"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "hr"): NodeListOf<HTMLHRElement>;
+    getElementsByTagName(name: "html"): NodeListOf<HTMLHtmlElement>;
+    getElementsByTagName(name: "i"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "iframe"): NodeListOf<HTMLIFrameElement>;
+    getElementsByTagName(name: "img"): NodeListOf<HTMLImageElement>;
+    getElementsByTagName(name: "input"): NodeListOf<HTMLInputElement>;
+    getElementsByTagName(name: "ins"): NodeListOf<HTMLModElement>;
+    getElementsByTagName(name: "kbd"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "label"): NodeListOf<HTMLLabelElement>;
+    getElementsByTagName(name: "legend"): NodeListOf<HTMLLegendElement>;
+    getElementsByTagName(name: "li"): NodeListOf<HTMLLIElement>;
+    getElementsByTagName(name: "link"): NodeListOf<HTMLLinkElement>;
+    getElementsByTagName(name: "main"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "map"): NodeListOf<HTMLMapElement>;
+    getElementsByTagName(name: "mark"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "menu"): NodeListOf<HTMLMenuElement>;
+    getElementsByTagName(name: "meta"): NodeListOf<HTMLMetaElement>;
+    getElementsByTagName(name: "nav"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "noscript"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "object"): NodeListOf<HTMLObjectElement>;
+    getElementsByTagName(name: "ol"): NodeListOf<HTMLOListElement>;
+    getElementsByTagName(name: "optgroup"): NodeListOf<HTMLOptGroupElement>;
+    getElementsByTagName(name: "option"): NodeListOf<HTMLOptionElement>;
+    getElementsByTagName(name: "p"): NodeListOf<HTMLParagraphElement>;
+    getElementsByTagName(name: "param"): NodeListOf<HTMLParamElement>;
+    getElementsByTagName(name: "pre"): NodeListOf<HTMLPreElement>;
+    getElementsByTagName(name: "progress"): NodeListOf<HTMLProgressElement>;
+    getElementsByTagName(name: "q"): NodeListOf<HTMLQuoteElement>;
+    getElementsByTagName(name: "rp"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "rt"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "ruby"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "s"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "samp"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "script"): NodeListOf<HTMLScriptElement>;
+    getElementsByTagName(name: "section"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "select"): NodeListOf<HTMLSelectElement>;
+    getElementsByTagName(name: "small"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "source"): NodeListOf<HTMLSourceElement>;
+    getElementsByTagName(name: "span"): NodeListOf<HTMLSpanElement>;
+    getElementsByTagName(name: "strong"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "style"): NodeListOf<HTMLStyleElement>;
+    getElementsByTagName(name: "sub"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "summary"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "sup"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "table"): NodeListOf<HTMLTableElement>;
+    getElementsByTagName(name: "tbody"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "td"): NodeListOf<HTMLTableDataCellElement>;
+    getElementsByTagName(name: "textarea"): NodeListOf<HTMLTextAreaElement>;
+    getElementsByTagName(name: "tfoot"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "th"): NodeListOf<HTMLTableHeaderCellElement>;
+    getElementsByTagName(name: "thead"): NodeListOf<HTMLTableSectionElement>;
+    getElementsByTagName(name: "title"): NodeListOf<HTMLTitleElement>;
+    getElementsByTagName(name: "tr"): NodeListOf<HTMLTableRowElement>;
+    getElementsByTagName(name: "track"): NodeListOf<HTMLTrackElement>;
+    getElementsByTagName(name: "u"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "ul"): NodeListOf<HTMLUListElement>;
+    getElementsByTagName(name: "var"): NodeListOf<HTMLElement>;
+    getElementsByTagName(name: "video"): NodeListOf<HTMLVideoElement>;
+    getElementsByTagName(name: "wbr"): NodeListOf<HTMLElement>;
     getElementsByTagNameNS(namespaceURI: string, localName: string): NodeList;
     createProcessingInstruction(target: string, data: string): ProcessingInstruction;
     createElementNS(namespaceURI: string, qualifiedName: string): Element;
     createAttribute(name: string): Attr;
     createTextNode(data: string): Text;
-    importNode(importedNode: Node, deep: bool): Node;
+    importNode(importedNode: Node, deep: boolean): Node;
     createCDATASection(data: string): CDATASection;
     createAttributeNS(namespaceURI: string, qualifiedName: string): Attr;
     getElementById(elementId: string): HTMLElement;
@@ -2815,7 +3229,7 @@ interface MessageEvent extends Event {
     source: Window;
     origin: string;
     data: any;
-    initMessageEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, dataArg: any, originArg: string, lastEventIdArg: string, sourceArg: Window): void;
+    initMessageEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, dataArg: any, originArg: string, lastEventIdArg: string, sourceArg: Window): void;
 }
 declare var MessageEvent: {
     prototype: MessageEvent;
@@ -2834,7 +3248,7 @@ declare var SVGElement: {
 }
 
 interface HTMLScriptElement extends HTMLElement {
-    defer: bool;
+    defer: boolean;
     text: string;
     src: string;
     htmlFor: string;
@@ -2908,9 +3322,9 @@ interface CanvasRenderingContext2D {
     restore(): void;
     setTransform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void;
     save(): void;
-    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: bool): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
     measureText(text: string): TextMetrics;
-    isPointInPath(x: number, y: number): bool;
+    isPointInPath(x: number, y: number): boolean;
     quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
     putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void;
     rotate(angle: number): void;
@@ -2966,12 +3380,12 @@ interface MSHTMLElementRangeExtensions {
 
 interface SVGPathSegArcAbs extends SVGPathSeg {
     y: number;
-    sweepFlag: bool;
+    sweepFlag: boolean;
     r2: number;
     x: number;
     angle: number;
     r1: number;
-    largeArcFlag: bool;
+    largeArcFlag: boolean;
 }
 declare var SVGPathSegArcAbs: {
     prototype: SVGPathSegArcAbs;
@@ -2980,7 +3394,7 @@ declare var SVGPathSegArcAbs: {
 
 interface MSScreenExtensions {
     deviceXDPI: number;
-    fontSmoothingEnabled: bool;
+    fontSmoothingEnabled: boolean;
     bufferDepth: number;
     logicalXDPI: number;
     systemXDPI: number;
@@ -3038,7 +3452,7 @@ interface HTMLFrameElement extends HTMLElement, GetSVGDocument, MSHTMLFrameEleme
     marginWidth: string;
     contentDocument: Document;
     longDesc: string;
-    noResize: bool;
+    noResize: boolean;
 }
 declare var HTMLFrameElement: {
     prototype: HTMLFrameElement;
@@ -3097,13 +3511,15 @@ interface MSHTMLButtonElementExtensions {
 
 interface XMLHttpRequest extends EventTarget, MSXMLHttpRequestExtensions {
     onreadystatechange: (ev: Event) => any;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     status: number;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     readyState: number;
     responseText: string;
     responseXML: Document;
     statusText: string;
-    open(method: string, url: string, async?: bool, user?: string, password?: string): void;
+    open(method: string, url: string, async?: boolean, user?: string, password?: string): void;
     send(data?: any): void;
     abort(): void;
     getAllResponseHeaders(): string;
@@ -3114,6 +3530,7 @@ interface XMLHttpRequest extends EventTarget, MSXMLHttpRequestExtensions {
     UNSENT: number;
     OPENED: number;
     HEADERS_RECEIVED: number;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var XMLHttpRequest: {
     prototype: XMLHttpRequest;
@@ -3187,21 +3604,36 @@ interface MSHTMLTableCellElementExtensions {
 
 interface HTMLFrameSetElement extends HTMLElement, MSHTMLFrameSetElementExtensions, MSBorderColorStyle_HTMLFrameSetElement {
     onresize: (ev: UIEvent) => any;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     ononline: (ev: Event) => any;
+    addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void;
     onafterprint: (ev: Event) => any;
+    addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void;
     onbeforeprint: (ev: Event) => any;
+    addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void;
     onoffline: (ev: Event) => any;
+    addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void;
     rows: string;
     cols: string;
     onblur: (ev: FocusEvent) => any;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onunload: (ev: Event) => any;
+    addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
     onhashchange: (ev: Event) => any;
+    addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onfocus: (ev: FocusEvent) => any;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onmessage: (ev: MessageEvent) => any;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     onerror: (ev: Event) => any;
+    addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void;
     onbeforeunload: (ev: BeforeUnloadEvent) => any;
+    addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void;
     onstorage: (ev: StorageEvent) => any;
+    addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var HTMLFrameSetElement: {
     prototype: HTMLFrameSetElement;
@@ -3259,8 +3691,8 @@ interface SVGLangSpace {
 interface DataTransfer {
     effectAllowed: string;
     dropEffect: string;
-    clearData(format?: string): bool;
-    setData(format: string, data: string): bool;
+    clearData(format?: string): boolean;
+    setData(format: string, data: string): boolean;
     getData(format: string): string;
 }
 declare var DataTransfer: {
@@ -3270,7 +3702,7 @@ declare var DataTransfer: {
 
 interface FocusEvent extends UIEvent {
     relatedTarget: EventTarget;
-    initFocusEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, relatedTargetArg: EventTarget): void;
+    initFocusEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number, relatedTargetArg: EventTarget): void;
 }
 declare var FocusEvent: {
     prototype: FocusEvent;
@@ -3279,7 +3711,7 @@ declare var FocusEvent: {
 
 interface Range {
     startOffset: number;
-    collapsed: bool;
+    collapsed: boolean;
     endOffset: number;
     startContainer: Node;
     endContainer: Node;
@@ -3293,7 +3725,7 @@ interface Range {
     toString(): string;
     compareBoundaryPoints(how: number, sourceRange: Range): number;
     insertNode(newNode: Node): void;
-    collapse(toStart: bool): void;
+    collapse(toStart: boolean): void;
     selectNodeContents(refNode: Node): void;
     cloneContents(): DocumentFragment;
     setEnd(refNode: Node, offset: number): void;
@@ -3334,7 +3766,7 @@ declare var SVGPoint: {
 
 interface MSPluginsCollection {
     length: number;
-    refresh(reload?: bool): void;
+    refresh(reload?: boolean): void;
 }
 declare var MSPluginsCollection: {
     prototype: MSPluginsCollection;
@@ -3372,7 +3804,7 @@ interface SVGSVGElement extends SVGElement, SVGZoomAndPan, SVGLangSpace, SVGLoca
     getIntersectionList(rect: SVGRect, referenceElement: SVGElement): NodeList;
     unpauseAnimations(): void;
     createSVGRect(): SVGRect;
-    checkIntersection(element: SVGElement, rect: SVGRect): bool;
+    checkIntersection(element: SVGElement, rect: SVGRect): boolean;
     unsuspendRedrawAll(): void;
     pauseAnimations(): void;
     suspendRedraw(maxWaitMilliseconds: number): number;
@@ -3383,7 +3815,7 @@ interface SVGSVGElement extends SVGElement, SVGZoomAndPan, SVGLangSpace, SVGLoca
     unsuspendRedraw(suspendHandleID: number): void;
     forceRedraw(): void;
     getCurrentTime(): number;
-    checkEnclosure(element: SVGElement, rect: SVGRect): bool;
+    checkEnclosure(element: SVGElement, rect: SVGRect): boolean;
     createSVGMatrix(): SVGMatrix;
     createSVGPoint(): SVGPoint;
     createSVGNumber(): SVGNumber;
@@ -3488,7 +3920,7 @@ interface ViewCSS {
 }
 
 interface MSAttrExtensions {
-    expando: bool;
+    expando: boolean;
 }
 
 interface MSStorageExtensions {
@@ -3528,12 +3960,12 @@ interface MSHTMLCollectionExtensions {
 }
 
 interface DOML2DeprecatedWordWrapSuppression_HTMLDivElement {
-    noWrap: bool;
+    noWrap: boolean;
 }
 
 interface DocumentTraversal {
-    createNodeIterator(root: Node, whatToShow: number, filter: NodeFilterCallback, entityReferenceExpansion: bool): NodeIterator;
-    createTreeWalker(root: Node, whatToShow: number, filter: NodeFilterCallback, entityReferenceExpansion: bool): TreeWalker;
+    createNodeIterator(root: Node, whatToShow: number, filter: NodeFilterCallback, entityReferenceExpansion: boolean): NodeIterator;
+    createTreeWalker(root: Node, whatToShow: number, filter: NodeFilterCallback, entityReferenceExpansion: boolean): TreeWalker;
 }
 
 interface Storage extends MSStorageExtensions {
@@ -3576,7 +4008,7 @@ declare var HTMLIFrameElement: {
 interface MSNavigatorAbilities {
     userLanguage: string;
     plugins: MSPluginsCollection;
-    cookieEnabled: bool;
+    cookieEnabled: boolean;
     appCodeName: string;
     cpuClass: string;
     appMinorVersion: string;
@@ -3585,8 +4017,8 @@ interface MSNavigatorAbilities {
     mimeTypes: MSMimeTypesCollection;
     product: string;
     systemLanguage: string;
-    javaEnabled(): bool;
-    taintEnabled(): bool;
+    javaEnabled(): boolean;
+    taintEnabled(): boolean;
 }
 
 interface TextRangeCollection {
@@ -3601,19 +4033,34 @@ declare var TextRangeCollection: {
 
 interface HTMLBodyElement extends HTMLElement, HTMLBodyElementDOML2Deprecated, MSHTMLBodyElementExtensions, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle {
     onresize: (ev: UIEvent) => any;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     ononline: (ev: Event) => any;
+    addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void;
     onafterprint: (ev: Event) => any;
+    addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void;
     onbeforeprint: (ev: Event) => any;
+    addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void;
     onoffline: (ev: Event) => any;
+    addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void;
     onblur: (ev: FocusEvent) => any;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onhashchange: (ev: Event) => any;
+    addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onunload: (ev: Event) => any;
+    addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
     onfocus: (ev: FocusEvent) => any;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onmessage: (ev: MessageEvent) => any;
+    addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     onerror: (ev: Event) => any;
+    addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void;
     onbeforeunload: (ev: BeforeUnloadEvent) => any;
+    addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void;
     onstorage: (ev: StorageEvent) => any;
+    addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var HTMLBodyElement: {
     prototype: HTMLBodyElement;
@@ -3634,8 +4081,8 @@ declare var DocumentType: {
 }
 
 interface MSHTMLInputElementExtensions extends DOML2DeprecatedMarginStyle_HTMLInputElement, DOML2DeprecatedBorderStyle_HTMLInputElement {
-    status: bool;
-    complete: bool;
+    status: boolean;
+    complete: boolean;
     createTextRange(): TextRange;
 }
 
@@ -3661,7 +4108,7 @@ interface MutationEvent extends Event {
     attrName: string;
     prevValue: string;
     relatedNode: Node;
-    initMutationEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void;
+    initMutationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void;
     MODIFICATION: number;
     REMOVAL: number;
     ADDITION: number;
@@ -3676,7 +4123,7 @@ declare var MutationEvent: {
 
 interface DragEvent extends MouseEvent {
     dataTransfer: DataTransfer;
-    initDragEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: bool, altKeyArg: bool, shiftKeyArg: bool, metaKeyArg: bool, buttonArg: number, relatedTargetArg: EventTarget, dataTransferArg: DataTransfer): void;
+    initDragEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, dataTransferArg: DataTransfer): void;
 }
 declare var DragEvent: {
     prototype: DragEvent;
@@ -3703,7 +4150,7 @@ interface DOML2DeprecatedListNumberingAndBulletStyle {
 
 interface HTMLInputElement extends HTMLElement, DOML2DeprecatedAlignmentStyle_HTMLInputElement, MSImageResourceExtensions_HTMLInputElement, MSHTMLInputElementExtensions, MSDataBindingExtensions {
     width: string;
-    defaultChecked: bool;
+    defaultChecked: boolean;
     alt: string;
     accept: string;
     value: string;
@@ -3713,10 +4160,10 @@ interface HTMLInputElement extends HTMLElement, DOML2DeprecatedAlignmentStyle_HT
     form: HTMLFormElement;
     selectionStart: number;
     height: string;
-    indeterminate: bool;
-    readOnly: bool;
+    indeterminate: boolean;
+    readOnly: boolean;
     size: number;
-    checked: bool;
+    checked: boolean;
     maxLength: number;
     selectionEnd: number;
     type: string;
@@ -3767,8 +4214,8 @@ declare var SVGImageElement: {
 }
 
 interface MSElementExtensions {
-    msMatchesSelector(selectors: string): bool;
-    fireEvent(eventName: string, eventObj?: any): bool;
+    msMatchesSelector(selectors: string): boolean;
+    fireEvent(eventName: string, eventObj?: any): boolean;
 }
 
 interface HTMLParamElement extends HTMLElement {
@@ -3859,20 +4306,31 @@ interface DOMHTMLImplementation {
 }
 
 interface NavigatorOnLine {
-    onLine: bool;
+    onLine: boolean;
 }
 
 interface SVGElementEventHandlers {
     onmouseover: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onmousemove: (ev: MouseEvent) => any;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onmouseout: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     ondblclick: (ev: MouseEvent) => any;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onfocusout: (ev: FocusEvent) => any;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onfocusin: (ev: FocusEvent) => any;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onmousedown: (ev: MouseEvent) => any;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onmouseup: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     onclick: (ev: MouseEvent) => any;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface WindowLocalStorage {
@@ -3888,12 +4346,12 @@ declare var SVGMetadataElement: {
 
 interface SVGPathSegArcRel extends SVGPathSeg {
     y: number;
-    sweepFlag: bool;
+    sweepFlag: boolean;
     r2: number;
     x: number;
     angle: number;
     r1: number;
-    largeArcFlag: bool;
+    largeArcFlag: boolean;
 }
 declare var SVGPathSegArcRel: {
     prototype: SVGPathSegArcRel;
@@ -3927,14 +4385,19 @@ declare var SVGStringList: {
 interface XDomainRequest {
     timeout: number;
     onerror: (ev: Event) => any;
+    addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     onprogress: (ev: any) => any;
+    addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void;
     ontimeout: (ev: Event) => any;
+    addEventListener(type: "timeout", listener: (ev: Event) => any, useCapture?: boolean): void;
     responseText: string;
     contentType: string;
     open(method: string, url: string): void;
     abort(): void;
     send(data?: any): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var XDomainRequest: {
     prototype: XDomainRequest;
@@ -4020,7 +4483,7 @@ declare var SVGPathSegCurvetoCubicRel: {
     new(): SVGPathSegCurvetoCubicRel;
 }
 
-interface MSEventObj {
+interface MSEventObj extends Event {
     nextPage: string;
     keyCode: number;
     toElement: Element;
@@ -4040,12 +4503,12 @@ interface MSEventObj {
     data: string;
     srcFilter: Object;
     boundElements: HTMLCollection;
-    cancelBubble: bool;
-    altLeft: bool;
+    cancelBubble: boolean;
+    altLeft: boolean;
     behaviorCookie: number;
     bookmarks: BookmarkCollection;
     type: string;
-    repeat: bool;
+    repeat: boolean;
     srcElement: Element;
     source: Window;
     fromElement: Element;
@@ -4053,21 +4516,21 @@ interface MSEventObj {
     x: number;
     behaviorPart: number;
     qualifier: string;
-    altKey: bool;
-    ctrlKey: bool;
+    altKey: boolean;
+    ctrlKey: boolean;
     clientY: number;
-    shiftKey: bool;
-    shiftLeft: bool;
-    contentOverflow: bool;
+    shiftKey: boolean;
+    shiftLeft: boolean;
+    contentOverflow: boolean;
     screenY: number;
-    ctrlLeft: bool;
+    ctrlLeft: boolean;
     button: number;
     srcUrn: string;
     clientX: number;
     actionURL: string;
     getAttribute(strAttributeName: string, lFlags?: number): any;
     setAttribute(strAttributeName: string, AttributeValue: any, lFlags?: number): void;
-    removeAttribute(strAttributeName: string, lFlags?: number): bool;
+    removeAttribute(strAttributeName: string, lFlags?: number): boolean;
 }
 declare var MSEventObj: {
     prototype: MSEventObj;
@@ -4110,7 +4573,8 @@ interface HTMLCanvasElement extends HTMLElement {
     height: number;
     toDataURL(): string;
     toDataURL(type: string, ...args: any[]): string;
-    getContext(contextId: string): CanvasRenderingContext2D;
+    getContext(contextId: string): any;
+    getContext(contextId: "2d"): CanvasRenderingContext2D;
 }
 declare var HTMLCanvasElement: {
     prototype: HTMLCanvasElement;
@@ -4134,7 +4598,7 @@ interface Location {
     port: string;
     pathname: string;
     host: string;
-    reload(flag?: bool): void;
+    reload(flag?: boolean): void;
     replace(url: string): void;
     assign(url: string): void;
     toString(): string;
@@ -4155,11 +4619,11 @@ declare var HTMLStyleElement: {
 
 interface MSHTMLOptGroupElementExtensions {
     index: number;
-    defaultSelected: bool;
+    defaultSelected: boolean;
     text: string;
     value: string;
     form: HTMLFormElement;
-    selected: bool;
+    selected: boolean;
 }
 
 interface MSBorderColorHighlightStyle {
@@ -4203,7 +4667,7 @@ declare var SVGTransform: {
 
 interface MSCSSFilter {
     Percent: number;
-    Enabled: bool;
+    Enabled: boolean;
     Duration: number;
     Play(Duration: number): void;
     Apply(): void;
@@ -4217,7 +4681,7 @@ declare var MSCSSFilter: {
 interface UIEvent extends Event {
     detail: number;
     view: AbstractView;
-    initUIEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number): void;
+    initUIEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number): void;
 }
 declare var UIEvent: {
     prototype: UIEvent;
@@ -4284,7 +4748,7 @@ interface WheelEvent extends MouseEvent {
     deltaX: number;
     deltaMode: number;
     deltaY: number;
-    initWheelEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, deltaXArg: number, deltaYArg: number, deltaZArg: number, deltaMode: number): void;
+    initWheelEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, deltaXArg: number, deltaYArg: number, deltaZArg: number, deltaMode: number): void;
     DOM_DELTA_PIXEL: number;
     DOM_DELTA_LINE: number;
     DOM_DELTA_PAGE: number;
@@ -4302,7 +4766,7 @@ interface DOML2DeprecatedAlignmentStyle_HTMLDivElement {
 }
 
 interface MSEventAttachmentTarget {
-    attachEvent(event: string, listener: EventListener): bool;
+    attachEvent(event: string, listener: EventListener): boolean;
     detachEvent(event: string, listener: EventListener): void;
 }
 
@@ -4329,14 +4793,14 @@ interface SVGPathElement extends SVGElement, SVGStylable, SVGAnimatedPathData, S
     createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs;
     createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs;
     createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel;
-    createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: bool, sweepFlag: bool): SVGPathSegArcRel;
+    createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcRel;
     createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs;
     createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel;
     getTotalLength(): number;
     createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel;
     createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs;
     createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs;
-    createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: bool, sweepFlag: bool): SVGPathSegArcAbs;
+    createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcAbs;
 }
 declare var SVGPathElement: {
     prototype: SVGPathElement;
@@ -4354,7 +4818,7 @@ declare var MSCompatibleInfo: {
 
 interface MSHTMLDocumentEventExtensions {
     createEventObject(eventObj?: any): MSEventObj;
-    fireEvent(eventName: string, eventObj?: any): bool;
+    fireEvent(eventName: string, eventObj?: any): boolean;
 }
 
 interface Text extends CharacterData, MSNodeExtensions {
@@ -4511,7 +4975,7 @@ declare var HTMLBaseFontElement: {
 
 interface CustomEvent extends Event {
     detail: Object;
-    initCustomEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, detailArg: Object): void;
+    initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: Object): void;
 }
 declare var CustomEvent: {
     prototype: CustomEvent;
@@ -4545,7 +5009,7 @@ interface HTMLTextAreaElement extends HTMLElement, MSDataBindingExtensions, MSHT
     selectionStart: number;
     rows: number;
     cols: number;
-    readOnly: bool;
+    readOnly: boolean;
     wrap: string;
     selectionEnd: number;
     type: string;
@@ -4588,7 +5052,8 @@ interface MSWindowModeless {
 interface HTMLMarqueeElement extends HTMLElement, DOML2DeprecatedMarginStyle_HTMLMarqueeElement, MSDataBindingExtensions, MSHTMLMarqueeElementExtensions, DOML2DeprecatedBackgroundColorStyle {
     width: string;
     onbounce: (ev: Event) => any;
-    trueSpeed: bool;
+    addEventListener(type: "bounce", listener: (ev: Event) => any, useCapture?: boolean): void;
+    trueSpeed: boolean;
     scrollAmount: number;
     scrollDelay: number;
     behavior: string;
@@ -4596,9 +5061,12 @@ interface HTMLMarqueeElement extends HTMLElement, DOML2DeprecatedMarginStyle_HTM
     loop: number;
     direction: string;
     onstart: (ev: Event) => any;
+    addEventListener(type: "start", listener: (ev: Event) => any, useCapture?: boolean): void;
     onfinish: (ev: Event) => any;
+    addEventListener(type: "finish", listener: (ev: Event) => any, useCapture?: boolean): void;
     stop(): void;
     start(): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var HTMLMarqueeElement: {
     prototype: HTMLMarqueeElement;
@@ -4618,7 +5086,7 @@ declare var SVGRect: {
 
 interface MSNodeExtensions {
     swapNode(otherNode: Node): Node;
-    removeNode(deep?: bool): Node;
+    removeNode(deep?: boolean): Node;
     replaceNode(replacement: Node): Node;
 }
 
@@ -4734,7 +5202,7 @@ declare var HTMLModElement: {
 }
 
 interface DOML2DeprecatedWordWrapSuppression {
-    noWrap: bool;
+    noWrap: boolean;
 }
 
 interface BeforeUnloadEvent extends Event {
@@ -4747,7 +5215,7 @@ declare var BeforeUnloadEvent: {
 
 interface MSPopupWindow {
     document: HTMLDocument;
-    isOpen: bool;
+    isOpen: boolean;
     show(x: number, y: number, w: number, h: number, element?: any): void;
     hide(): void;
 }
@@ -4795,15 +5263,15 @@ declare var SVGUseElement: {
 
 interface Event extends MSEventExtensions {
     timeStamp: number;
-    defaultPrevented: bool;
-    isTrusted: bool;
+    defaultPrevented: boolean;
+    isTrusted: boolean;
     currentTarget: EventTarget;
     target: EventTarget;
     eventPhase: number;
     type: string;
-    cancelable: bool;
-    bubbles: bool;
-    initEvent(eventTypeArg: string, canBubbleArg: bool, cancelableArg: bool): void;
+    cancelable: boolean;
+    bubbles: boolean;
+    initEvent(eventTypeArg: string, canBubbleArg: boolean, cancelableArg: boolean): void;
     stopPropagation(): void;
     stopImmediatePropagation(): void;
     preventDefault(): void;
@@ -4831,76 +5299,115 @@ declare var ImageData: {
 
 interface MSHTMLElementExtensions {
     onlosecapture: (ev: MSEventObj) => any;
+    addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onrowexit: (ev: MSEventObj) => any;
+    addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     oncontrolselect: (ev: MSEventObj) => any;
+    addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onrowsinserted: (ev: MSEventObj) => any;
+    addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onmouseleave: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     document: HTMLDocument;
     behaviorUrns: MSBehaviorUrnsCollection;
     onpropertychange: (ev: MSEventObj) => any;
+    addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     children: HTMLCollection;
     filters: Object;
     onbeforecut: (ev: DragEvent) => any;
+    addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     scopeName: string;
     onbeforepaste: (ev: DragEvent) => any;
+    addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onmove: (ev: MSEventObj) => any;
+    addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onafterupdate: (ev: MSEventObj) => any;
+    addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onbeforecopy: (ev: DragEvent) => any;
+    addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onlayoutcomplete: (ev: MSEventObj) => any;
+    addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onresizeend: (ev: MSEventObj) => any;
+    addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     uniqueID: string;
     onhelp: (ev: Event) => any;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
     onbeforeactivate: (ev: UIEvent) => any;
-    isMultiLine: bool;
+    addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    isMultiLine: boolean;
     uniqueNumber: number;
     tagUrn: string;
     onfocusout: (ev: FocusEvent) => any;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     ondataavailable: (ev: MSEventObj) => any;
-    hideFocus: bool;
+    addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    hideFocus: boolean;
     onbeforeupdate: (ev: MSEventObj) => any;
+    addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onfilterchange: (ev: MSEventObj) => any;
+    addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onfocusin: (ev: FocusEvent) => any;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     recordNumber: any;
     parentTextEdit: Element;
     ondatasetcomplete: (ev: MSEventObj) => any;
+    addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onbeforedeactivate: (ev: UIEvent) => any;
+    addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     outerText: string;
     onresizestart: (ev: MSEventObj) => any;
+    addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onactivate: (ev: UIEvent) => any;
-    isTextEdit: bool;
-    isDisabled: bool;
+    addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
+    isTextEdit: boolean;
+    isDisabled: boolean;
     readyState: string;
     all: HTMLCollection;
     onmouseenter: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onmovestart: (ev: MSEventObj) => any;
+    addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onselectstart: (ev: Event) => any;
+    addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void;
     onpaste: (ev: DragEvent) => any;
-    canHaveHTML: bool;
+    addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
+    canHaveHTML: boolean;
     innerText: string;
     onerrorupdate: (ev: MSEventObj) => any;
+    addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     ondeactivate: (ev: UIEvent) => any;
+    addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     oncut: (ev: DragEvent) => any;
+    addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onmoveend: (ev: MSEventObj) => any;
+    addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onresize: (ev: UIEvent) => any;
+    addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     language: string;
     ondatasetchanged: (ev: MSEventObj) => any;
+    addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     oncopy: (ev: DragEvent) => any;
+    addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onrowsdelete: (ev: MSEventObj) => any;
+    addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     parentElement: HTMLElement;
     onrowenter: (ev: MSEventObj) => any;
+    addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
     onbeforeeditfocus: (ev: MSEventObj) => any;
-    canHaveChildren: bool;
+    addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    canHaveChildren: boolean;
     sourceIndex: number;
     oncellchange: (ev: MSEventObj) => any;
-    dragDrop(): bool;
+    addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void;
+    dragDrop(): boolean;
     releaseCapture(): void;
     addFilter(filter: Object): void;
-    setCapture(containerCapture?: bool): void;
-    removeBehavior(cookie: number): bool;
-    contains(child: HTMLElement): bool;
+    setCapture(containerCapture?: boolean): void;
+    removeBehavior(cookie: number): boolean;
+    contains(child: HTMLElement): boolean;
     applyElement(apply: Element, where?: string): Element;
     replaceAdjacentText(where: string, newText: string): string;
-    mergeAttributes(source: HTMLElement, preserveIdentity?: bool): void;
+    mergeAttributes(source: HTMLElement, preserveIdentity?: boolean): void;
     insertAdjacentElement(position: string, insertedElement: Element): Element;
     insertAdjacentText(where: string, text: string): void;
     getAdjacentText(where: string): string;
@@ -4908,6 +5415,7 @@ interface MSHTMLElementExtensions {
     setActive(): void;
     addBehavior(bstrUrl: string, factory?: any): number;
     clearAttributes(): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface HTMLTableColElement extends HTMLElement, MSHTMLTableColElementExtensions, HTMLTableAlignment, DOML2DeprecatedAlignmentStyle_HTMLTableColElement {
@@ -4921,102 +5429,155 @@ declare var HTMLTableColElement: {
 
 interface HTMLDocument extends MSEventAttachmentTarget, MSHTMLDocumentSelection, MSHTMLDocumentExtensions, MSNodeExtensions, MSResourceMetadata, MSHTMLDocumentEventExtensions, MSHTMLDocumentViewExtensions {
     ondragend: (ev: DragEvent) => any;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     ondragover: (ev: DragEvent) => any;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onkeydown: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     bgColor: string;
     onkeyup: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     onreset: (ev: Event) => any;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
     onmouseup: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     ondragstart: (ev: DragEvent) => any;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     scripts: HTMLCollection;
     ondrag: (ev: DragEvent) => any;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     linkColor: string;
     ondragleave: (ev: DragEvent) => any;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onmouseover: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onpause: (ev: Event) => any;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
     charset: string;
     vlinkColor: string;
     onmousedown: (ev: MouseEvent) => any;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onseeked: (ev: Event) => any;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
     title: string;
     onclick: (ev: MouseEvent) => any;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onwaiting: (ev: Event) => any;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
     defaultCharset: string;
     embeds: HTMLCollection;
     ondurationchange: (ev: Event) => any;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
     all: HTMLCollection;
     applets: HTMLCollection;
     forms: HTMLCollection;
     onblur: (ev: FocusEvent) => any;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     dir: string;
     body: HTMLElement;
     designMode: string;
     onemptied: (ev: Event) => any;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
     domain: string;
     onseeking: (ev: Event) => any;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
     oncanplay: (ev: Event) => any;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
     onstalled: (ev: Event) => any;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
     onmousemove: (ev: MouseEvent) => any;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onratechange: (ev: Event) => any;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onloadstart: (ev: Event) => any;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
     ondragenter: (ev: DragEvent) => any;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onsubmit: (ev: Event) => any;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
     onprogress: (ev: any) => any;
+    addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void;
     ondblclick: (ev: MouseEvent) => any;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     oncontextmenu: (ev: MouseEvent) => any;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     activeElement: Element;
     onchange: (ev: Event) => any;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
     onloadedmetadata: (ev: Event) => any;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
     onerror: (ev: Event) => any;
+    addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void;
     onplay: (ev: Event) => any;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
     links: HTMLCollection;
     onplaying: (ev: Event) => any;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
     URL: string;
     images: HTMLCollection;
     head: HTMLHeadElement;
     location: Location;
     cookie: string;
     oncanplaythrough: (ev: Event) => any;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
     onabort: (ev: UIEvent) => any;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     characterSet: string;
     anchors: HTMLCollection;
     lastModified: string;
     onreadystatechange: (ev: Event) => any;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onkeypress: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     onloadeddata: (ev: Event) => any;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
     plugins: HTMLCollection;
     onsuspend: (ev: Event) => any;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
     referrer: string;
     readyState: string;
     alinkColor: string;
     onfocus: (ev: FocusEvent) => any;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     fgColor: string;
     ontimeupdate: (ev: Event) => any;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
     onselect: (ev: UIEvent) => any;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     ondrop: (ev: DragEvent) => any;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onmouseout: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onended: (ev: Event) => any;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
     compatMode: string;
     onscroll: (ev: UIEvent) => any;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onmousewheel: (ev: MouseWheelEvent) => any;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     onvolumechange: (ev: Event) => any;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     oninput: (ev: Event) => any;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
     queryCommandValue(commandId: string): string;
-    queryCommandIndeterm(commandId: string): bool;
-    execCommand(commandId: string, showUI?: bool, value?: any): bool;
+    queryCommandIndeterm(commandId: string): boolean;
+    execCommand(commandId: string, showUI?: boolean, value?: any): boolean;
     getElementsByName(elementName: string): NodeList;
     writeln(...content: string[]): void;
-    open(url?: string, name?: string, features?: string, replace?: bool): any;
-    queryCommandState(commandId: string): bool;
+    open(url?: string, name?: string, features?: string, replace?: boolean): any;
+    queryCommandState(commandId: string): boolean;
     close(): void;
-    hasFocus(): bool;
+    hasFocus(): boolean;
     getElementsByClassName(classNames: string): NodeList;
-    queryCommandSupported(commandId: string): bool;
+    queryCommandSupported(commandId: string): boolean;
     getSelection(): Selection;
-    queryCommandEnabled(commandId: string): bool;
+    queryCommandEnabled(commandId: string): boolean;
     write(...content: string[]): void;
     queryCommandText(commandId: string): string;
+    addEventListener(type: "DOMContentLoaded", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface SVGException {
@@ -5153,7 +5714,6 @@ interface NamedNodeMap {
     [index: number]: Node;
     removeNamedItem(name: string): Node;
     getNamedItem(name: string): Node;
-    [name: string]: Node;
     setNamedItem(arg: Node): Node;
     getNamedItemNS(namespaceURI: string, localName: string): Node;
     setNamedItemNS(arg: Node): Node;
@@ -5215,20 +5775,25 @@ declare var SVGPathSegCurvetoCubicSmoothRel: {
 interface MSWindowExtensions {
     status: string;
     onmouseleave: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     screenLeft: number;
     offscreenBuffering: any;
     maxConnectionsPerServer: number;
     onmouseenter: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     clipboardData: DataTransfer;
     defaultStatus: string;
     clientInformation: Navigator;
-    closed: bool;
+    closed: boolean;
     onhelp: (ev: Event) => any;
+    addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
     external: BrowserPublic;
     event: MSEventObj;
     onfocusout: (ev: FocusEvent) => any;
+    addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     screenTop: number;
     onfocusin: (ev: FocusEvent) => any;
+    addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     showModelessDialog(url?: string, argument?: any, options?: any): Window;
     navigate(url: string): void;
     resizeBy(x?: number, y?: number): void;
@@ -5241,6 +5806,7 @@ interface MSWindowExtensions {
     moveTo(x?: number, y?: number): void;
     moveBy(x?: number, y?: number): void;
     showHelp(url: string, helpArg?: any, features?: string): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface ProcessingInstruction extends Node {
@@ -5277,7 +5843,7 @@ interface TextEvent extends UIEvent {
     inputMethod: number;
     data: string;
     locale: string;
-    initTextEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, dataArg: string, inputMethod: number, locale: string): void;
+    initTextEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, dataArg: string, inputMethod: number, locale: string): void;
     DOM_INPUT_METHOD_KEYBOARD: number;
     DOM_INPUT_METHOD_DROP: number;
     DOM_INPUT_METHOD_IME: number;
@@ -5343,7 +5909,7 @@ interface SVGAnimatedPathData {
 }
 
 interface Position {
-    timestamp: Date;
+    timestamp: number;
     coords: Coordinates;
 }
 declare var Position: {
@@ -5396,7 +5962,7 @@ declare var HTMLSpanElement: {
 }
 
 interface HTMLHRElementDOML2Deprecated {
-    noShade: bool;
+    noShade: boolean;
 }
 
 interface HTMLHeadElement extends HTMLElement {
@@ -5455,7 +6021,7 @@ declare var SVGZoomAndPan: {
 }
 
 interface MSEventExtensions {
-    cancelBubble: bool;
+    cancelBubble: boolean;
     srcElement: Element;
 }
 
@@ -5464,22 +6030,22 @@ interface HTMLMediaElement extends HTMLElement {
     played: TimeRanges;
     currentSrc: string;
     readyState: string;
-    autobuffer: bool;
-    loop: bool;
-    ended: bool;
+    autobuffer: boolean;
+    loop: boolean;
+    ended: boolean;
     buffered: TimeRanges;
     error: MediaError;
     seekable: TimeRanges;
-    autoplay: bool;
-    controls: bool;
+    autoplay: boolean;
+    controls: boolean;
     volume: number;
     src: string;
     playbackRate: number;
     duration: number;
-    muted: bool;
+    muted: boolean;
     defaultPlaybackRate: number;
-    paused: bool;
-    seeking: bool;
+    paused: boolean;
+    seeking: boolean;
     currentTime: number;
     preload: string;
     networkState: number;
@@ -5533,7 +6099,7 @@ declare var MSMimeTypesCollection: {
 }
 
 interface StyleSheet {
-    disabled: bool;
+    disabled: boolean;
     ownerNode: Node;
     parentStyleSheet: StyleSheet;
     href: string;
@@ -5586,6 +6152,12 @@ declare var NodeList: {
     new(): NodeList;
 }
 
+interface NodeListOf<TNode extends Node> {
+    length: number;
+    item(index: number): TNode;
+    [index: number]: TNode;
+}
+
 interface HTMLDTElement extends HTMLElement, DOML2DeprecatedWordWrapSuppression_HTMLDTElement {
 }
 declare var HTMLDTElement: {
@@ -5607,7 +6179,7 @@ interface StyleSheetPage {
 }
 
 interface DOML2DeprecatedWordWrapSuppression_HTMLDDElement {
-    noWrap: bool;
+    noWrap: boolean;
 }
 
 interface MSHTMLTableRowElementExtensions {
@@ -5687,7 +6259,7 @@ interface MSHTMLOListElementExtensions {
 }
 
 interface DOML2DeprecatedWordWrapSuppression_HTMLDTElement {
-    noWrap: bool;
+    noWrap: boolean;
 }
 
 interface ScreenView extends AbstractView {
@@ -5771,80 +6343,132 @@ declare var HTMLBGSoundElement: {
 
 interface HTMLElement extends Element, MSHTMLElementRangeExtensions, ElementCSSInlineStyle, MSEventAttachmentTarget, MSHTMLElementExtensions, MSNodeExtensions {
     ondragend: (ev: DragEvent) => any;
+    addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onkeydown: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     ondragover: (ev: DragEvent) => any;
+    addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     onkeyup: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     offsetTop: number;
     onreset: (ev: Event) => any;
+    addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
     onmouseup: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     ondragstart: (ev: DragEvent) => any;
+    addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     ondrag: (ev: DragEvent) => any;
+    addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     innerHTML: string;
     onmouseover: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     ondragleave: (ev: DragEvent) => any;
+    addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     lang: string;
     onpause: (ev: Event) => any;
+    addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
     className: string;
     onseeked: (ev: Event) => any;
+    addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
     onmousedown: (ev: MouseEvent) => any;
+    addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     title: string;
     onclick: (ev: MouseEvent) => any;
+    addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onwaiting: (ev: Event) => any;
+    addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
     outerHTML: string;
     offsetLeft: number;
     ondurationchange: (ev: Event) => any;
+    addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
     offsetHeight: number;
     dir: string;
     onblur: (ev: FocusEvent) => any;
+    addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     onemptied: (ev: Event) => any;
+    addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
     onseeking: (ev: Event) => any;
+    addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
     oncanplay: (ev: Event) => any;
+    addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
     onstalled: (ev: Event) => any;
+    addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
     onmousemove: (ev: MouseEvent) => any;
+    addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     style: MSStyleCSSProperties;
-    isContentEditable: bool;
+    isContentEditable: boolean;
     onratechange: (ev: Event) => any;
+    addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onloadstart: (ev: Event) => any;
+    addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
     ondragenter: (ev: DragEvent) => any;
+    addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     contentEditable: string;
     onsubmit: (ev: Event) => any;
+    addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
     tabIndex: number;
     onprogress: (ev: any) => any;
+    addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void;
     ondblclick: (ev: MouseEvent) => any;
+    addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     oncontextmenu: (ev: MouseEvent) => any;
+    addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onchange: (ev: Event) => any;
+    addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
     onloadedmetadata: (ev: Event) => any;
+    addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
     onerror: (ev: Event) => any;
+    addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void;
     onplay: (ev: Event) => any;
+    addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
     id: string;
     onplaying: (ev: Event) => any;
+    addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
     oncanplaythrough: (ev: Event) => any;
+    addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
     onabort: (ev: UIEvent) => any;
+    addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onreadystatechange: (ev: Event) => any;
+    addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onkeypress: (ev: KeyboardEvent) => any;
+    addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
     offsetParent: Element;
     onloadeddata: (ev: Event) => any;
-    disabled: bool;
+    addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
+    disabled: boolean;
     onsuspend: (ev: Event) => any;
+    addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
     accessKey: string;
     onfocus: (ev: FocusEvent) => any;
+    addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
     ontimeupdate: (ev: Event) => any;
+    addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
     onselect: (ev: UIEvent) => any;
+    addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     ondrop: (ev: DragEvent) => any;
+    addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
     offsetWidth: number;
     onmouseout: (ev: MouseEvent) => any;
+    addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
     onended: (ev: Event) => any;
+    addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
     onscroll: (ev: UIEvent) => any;
+    addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
     onmousewheel: (ev: MouseWheelEvent) => any;
+    addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
     onvolumechange: (ev: Event) => any;
+    addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     oninput: (ev: Event) => any;
+    addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
     click(): void;
     getElementsByClassName(classNames: string): NodeList;
-    scrollIntoView(top?: bool): void;
+    scrollIntoView(top?: boolean): void;
     focus(): void;
     blur(): void;
     insertAdjacentHTML(where: string, html: string): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var HTMLElement: {
     prototype: HTMLElement;
@@ -5884,7 +6508,7 @@ interface DOML2DeprecatedTextFlowControl_HTMLBlockElement {
 }
 
 interface PositionOptions {
-    enableHighAccuracy?: bool;
+    enableHighAccuracy?: boolean;
     timeout?: number;
     maximumAge?: number;
 }
@@ -5901,7 +6525,7 @@ interface HTMLObjectElement extends HTMLElement, MSHTMLObjectElementExtensions,
     height: string;
     contentDocument: Document;
     codeBase: string;
-    declare: bool;
+    declare: boolean;
     type: string;
     code: string;
 }
@@ -5924,7 +6548,7 @@ interface StorageEvent extends Event {
     url: string;
     storageArea: Storage;
     key: string;
-    initStorageEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, keyArg: string, oldValueArg: any, newValueArg: any, urlArg: string, storageAreaArg: Storage): void;
+    initStorageEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, keyArg: string, oldValueArg: any, newValueArg: any, urlArg: string, storageAreaArg: Storage): void;
 }
 declare var StorageEvent: {
     prototype: StorageEvent;
@@ -6062,8 +6686,8 @@ interface MSHTMLIsIndexElementExtensions {
 }
 
 interface SVGAnimatedBoolean {
-    animVal: bool;
-    baseVal: bool;
+    animVal: boolean;
+    baseVal: boolean;
 }
 declare var SVGAnimatedBoolean: {
     prototype: SVGAnimatedBoolean;
@@ -6079,8 +6703,10 @@ declare var SVGSwitchElement: {
 
 interface MSHTMLIFrameElementExtensions extends DOML2DeprecatedMarginStyle_MSHTMLIFrameElementExtensions, DOML2DeprecatedBorderStyle_MSHTMLIFrameElementExtensions {
     onload: (ev: Event) => any;
+    addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
     frameSpacing: any;
-    noResize: bool;
+    noResize: boolean;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface SVGPreserveAspectRatio {
@@ -6121,7 +6747,7 @@ declare var SVGPreserveAspectRatio: {
 }
 
 interface Attr extends Node, MSAttrExtensions {
-    specified: bool;
+    specified: boolean;
     ownerElement: Element;
     value: string;
     name: string;
@@ -6263,113 +6889,178 @@ declare var SVGMaskElement: {
 }
 
 declare var Audio: { new (src?: string): HTMLAudioElement; };
-declare var Option: { new (text?: string, value?: string, defaultSelected?: bool, selected?: bool): HTMLOptionElement; };
+declare var Option: { new (text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement; };
 declare var Image: { new (width?: number, height?: number): HTMLImageElement; };
 
 declare var ondragend: (ev: DragEvent) => any;
+declare function addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
 declare var onkeydown: (ev: KeyboardEvent) => any;
+declare function addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
 declare var ondragover: (ev: DragEvent) => any;
+declare function addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
 declare var onkeyup: (ev: KeyboardEvent) => any;
+declare function addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
 declare var onreset: (ev: Event) => any;
+declare function addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onmouseup: (ev: MouseEvent) => any;
+declare function addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var ondragstart: (ev: DragEvent) => any;
+declare function addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
 declare var ondrag: (ev: DragEvent) => any;
+declare function addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
 declare var onmouseover: (ev: MouseEvent) => any;
+declare function addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var ondragleave: (ev: DragEvent) => any;
+declare function addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
 declare var history: History;
 declare var name: string;
 declare var onafterprint: (ev: Event) => any;
+declare function addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onpause: (ev: Event) => any;
+declare function addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onbeforeprint: (ev: Event) => any;
+declare function addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var top: Window;
 declare var onmousedown: (ev: MouseEvent) => any;
+declare function addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var onseeked: (ev: Event) => any;
+declare function addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var opener: Window;
 declare var onclick: (ev: MouseEvent) => any;
+declare function addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var onwaiting: (ev: Event) => any;
+declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var ononline: (ev: Event) => any;
+declare function addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var ondurationchange: (ev: Event) => any;
+declare function addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var frames: Window;
 declare var onblur: (ev: FocusEvent) => any;
+declare function addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
 declare var onemptied: (ev: Event) => any;
+declare function addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onseeking: (ev: Event) => any;
+declare function addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var oncanplay: (ev: Event) => any;
+declare function addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onstalled: (ev: Event) => any;
+declare function addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onmousemove: (ev: MouseEvent) => any;
+declare function addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var onoffline: (ev: Event) => any;
+declare function addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var length: number;
 declare var onbeforeunload: (ev: BeforeUnloadEvent) => any;
+declare function addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void;
 declare var onratechange: (ev: Event) => any;
+declare function addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onstorage: (ev: StorageEvent) => any;
+declare function addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void;
 declare var onloadstart: (ev: Event) => any;
+declare function addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var ondragenter: (ev: DragEvent) => any;
+declare function addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
 declare var onsubmit: (ev: Event) => any;
+declare function addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var self: Window;
 declare var onprogress: (ev: any) => any;
+declare function addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void;
 declare var ondblclick: (ev: MouseEvent) => any;
+declare function addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var oncontextmenu: (ev: MouseEvent) => any;
+declare function addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var onchange: (ev: Event) => any;
+declare function addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onloadedmetadata: (ev: Event) => any;
+declare function addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onplay: (ev: Event) => any;
+declare function addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onerror: ErrorFunction;
 declare var onplaying: (ev: Event) => any;
+declare function addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var parent: Window;
 declare var location: Location;
 declare var oncanplaythrough: (ev: Event) => any;
+declare function addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onabort: (ev: UIEvent) => any;
+declare function addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
 declare var onreadystatechange: (ev: Event) => any;
+declare function addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onkeypress: (ev: KeyboardEvent) => any;
+declare function addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void;
 declare var frameElement: Element;
 declare var onloadeddata: (ev: Event) => any;
+declare function addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onsuspend: (ev: Event) => any;
+declare function addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var window: Window;
 declare var onfocus: (ev: FocusEvent) => any;
+declare function addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
 declare var onmessage: (ev: MessageEvent) => any;
+declare function addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void;
 declare var ontimeupdate: (ev: Event) => any;
+declare function addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onresize: (ev: UIEvent) => any;
+declare function addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
 declare var navigator: Navigator;
 declare var onselect: (ev: UIEvent) => any;
+declare function addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
 declare var ondrop: (ev: DragEvent) => any;
+declare function addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void;
 declare var onmouseout: (ev: MouseEvent) => any;
+declare function addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var onended: (ev: Event) => any;
+declare function addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onhashchange: (ev: Event) => any;
+declare function addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onunload: (ev: Event) => any;
+declare function addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onscroll: (ev: UIEvent) => any;
+declare function addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void;
 declare var onmousewheel: (ev: MouseWheelEvent) => any;
+declare function addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void;
 declare var onload: (ev: Event) => any;
+declare function addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var onvolumechange: (ev: Event) => any;
+declare function addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var oninput: (ev: Event) => any;
+declare function addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare function alert(message?: string): void;
 declare function focus(): void;
 declare function print(): void;
 declare function prompt(message?: string, defaul?: string): string;
 declare function toString(): string;
-declare function open(url?: string, target?: string, features?: string, replace?: bool): Window;
+declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window;
 declare function close(): void;
-declare function confirm(message?: string): bool;
+declare function confirm(message?: string): boolean;
 declare function postMessage(message: any, targetOrigin: string, ports?: any): void;
 declare function showModalDialog(url?: string, argument?: any, options?: any): any;
 declare function blur(): void;
 declare function getSelection(): Selection;
 declare function getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
-declare function attachEvent(event: string, listener: EventListener): bool;
+declare function attachEvent(event: string, listener: EventListener): boolean;
 declare function detachEvent(event: string, listener: EventListener): void;
 declare var status: string;
 declare var onmouseleave: (ev: MouseEvent) => any;
+declare function addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var screenLeft: number;
 declare var offscreenBuffering: any;
 declare var maxConnectionsPerServer: number;
 declare var onmouseenter: (ev: MouseEvent) => any;
+declare function addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void;
 declare var clipboardData: DataTransfer;
 declare var defaultStatus: string;
 declare var clientInformation: Navigator;
-declare var closed: bool;
+declare var closed: boolean;
 declare var onhelp: (ev: Event) => any;
+declare function addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void;
 declare var external: BrowserPublic;
 declare var event: MSEventObj;
 declare var onfocusout: (ev: FocusEvent) => any;
+declare function addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
 declare var screenTop: number;
 declare var onfocusin: (ev: FocusEvent) => any;
+declare function addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void;
 declare function showModelessDialog(url?: string, argument?: any, options?: any): Window;
 declare function navigate(url: string): void;
 declare function resizeBy(x?: number, y?: number): void;
@@ -6397,9 +7088,9 @@ declare function scrollBy(x?: number, y?: number): void;
 declare function scrollTo(x?: number, y?: number): void;
 declare var styleMedia: StyleMedia;
 declare var document: Document;
-declare function removeEventListener(type: string, listener: EventListener, useCapture?: bool): void;
-declare function addEventListener(type: string, listener: EventListener, useCapture?: bool): void;
-declare function dispatchEvent(evt: Event): bool;
+declare function removeEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+declare function addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
+declare function dispatchEvent(evt: Event): boolean;
 declare var localStorage: Storage;
 declare var sessionStorage: Storage;
 declare function clearTimeout(handle: number): void;
@@ -6414,6 +7105,7 @@ declare function setInterval(expression: any, msec?: number, language?: any): nu
 
 interface HTMLBodyElement {
     onpopstate: (ev: PopStateEvent) => any;
+    addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void;
 }
 
 interface MSGestureEvent extends UIEvent {
@@ -6434,7 +7126,7 @@ interface MSGestureEvent extends UIEvent {
     scale: number;
     gestureObject: any;
     clientX: number;
-    initGestureEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, offsetXArg: number, offsetYArg: number, translationXArg: number, translationYArg: number, scaleArg: number, expansionArg: number, rotationArg: number, velocityXArg: number, velocityYArg: number, velocityExpansionArg: number, velocityAngularArg: number, hwTimestampArg: number): void;
+    initGestureEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, offsetXArg: number, offsetYArg: number, translationXArg: number, translationYArg: number, scaleArg: number, expansionArg: number, rotationArg: number, velocityXArg: number, velocityYArg: number, velocityExpansionArg: number, velocityAngularArg: number, hwTimestampArg: number): void;
     MSGESTURE_FLAG_BEGIN: number;
     MSGESTURE_FLAG_END: number;
     MSGESTURE_FLAG_CANCEL: number;
@@ -6460,10 +7152,10 @@ interface HTMLInputElement {
     files: FileList;
     max: string;
     formTarget: string;
-    willValidate: bool;
+    willValidate: boolean;
     step: string;
-    autofocus: bool;
-    required: bool;
+    autofocus: boolean;
+    required: boolean;
     formEnctype: string;
     valueAsNumber: number;
     placeholder: string;
@@ -6475,8 +7167,8 @@ interface HTMLInputElement {
     pattern: string;
     validity: ValidityState;
     formNoValidate: string;
-    multiple: bool;
-    checkValidity(): bool;
+    multiple: boolean;
+    checkValidity(): boolean;
     stepDown(n?: number): void;
     stepUp(n?: number): void;
     setCustomValidity(error: string): void;
@@ -6487,7 +7179,7 @@ interface ErrorEvent extends Event {
     filename: string;
     lineno: number;
     message: string;
-    initErrorEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, messageArg: string, filenameArg: string, linenoArg: number): void;
+    initErrorEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, messageArg: string, filenameArg: string, linenoArg: number): void;
 }
 declare var ErrorEvent: {
     prototype: ErrorEvent;
@@ -6536,25 +7228,42 @@ declare var SVGFEFloodElement: {
 interface MSElementExtensions {
     msRegionOverflow: string;
     onmspointerdown: (ev: any) => any;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgotpointercapture: (ev: any) => any;
+    addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturedoubletap: (ev: any) => any;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerhover: (ev: any) => any;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturehold: (ev: any) => any;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointermove: (ev: any) => any;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturechange: (ev: any) => any;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturestart: (ev: any) => any;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointercancel: (ev: any) => any;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgestureend: (ev: any) => any;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturetap: (ev: any) => any;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerout: (ev: any) => any;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsinertiastart: (ev: any) => any;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
     onmslostpointercapture: (ev: any) => any;
+    addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerover: (ev: any) => any;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
     msContentZoomFactor: number;
     onmspointerup: (ev: any) => any;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
     msGetRegionContent(): MSRangeCollection;
     msReleasePointerCapture(pointerId: number): void;
     msSetPointerCapture(pointerId: number): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var MSElementExtensions: {
     prototype: MSElementExtensions;
@@ -6577,14 +7286,17 @@ declare var MSGesture: {
 
 interface TextTrackCue extends EventTarget {
     onenter: (ev: Event) => any;
+    addEventListener(type: "enter", listener: (ev: Event) => any, useCapture?: boolean): void;
     track: TextTrack;
     endTime: number;
     text: string;
-    pauseOnExit: bool;
+    pauseOnExit: boolean;
     id: string;
     startTime: number;
     onexit: (ev: Event) => any;
+    addEventListener(type: "exit", listener: (ev: Event) => any, useCapture?: boolean): void;
     getCueAsHTML(): DocumentFragment;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var TextTrackCue: {
     prototype: TextTrackCue;
@@ -6592,7 +7304,7 @@ declare var TextTrackCue: {
 }
 
 interface MSHTMLDocumentViewExtensions {
-    msCSSOMElementFloatMetrics: bool;
+    msCSSOMElementFloatMetrics: boolean;
     msElementsFromPoint(x: number, y: number): NodeList;
     msElementsFromRect(left: number, top: number, width: number, height: number): NodeList;
 }
@@ -6630,9 +7342,9 @@ interface CSSFlexibleBoxProperties {
 
 interface DOMTokenList {
     length: number;
-    contains(token: string): bool;
+    contains(token: string): boolean;
     remove(token: string): void;
-    toggle(token: string): bool;
+    toggle(token: string): boolean;
     add(token: string): void;
     item(index: number): string;
     [index: number]: string;
@@ -6720,7 +7432,7 @@ interface Navigator extends MSFileSaver {
 interface TransitionEvent extends Event {
     propertyName: string;
     elapsedTime: number;
-    initTransitionEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, propertyNameArg: string, elapsedTimeArg: number): void;
+    initTransitionEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, propertyNameArg: string, elapsedTimeArg: number): void;
 }
 declare var TransitionEvent: {
     prototype: TransitionEvent;
@@ -6728,7 +7440,7 @@ declare var TransitionEvent: {
 }
 
 interface MediaQueryList {
-    matches: bool;
+    matches: boolean;
     media: string;
     addListener(listener: MediaQueryListListener): void;
     removeListener(listener: MediaQueryListListener): void;
@@ -6763,10 +7475,10 @@ interface CSSFontsProperties {
 }
 
 interface CloseEvent extends Event {
-    wasClean: bool;
+    wasClean: boolean;
     reason: string;
     code: number;
-    initCloseEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, wasCleanArg: bool, codeArg: number, reasonArg: string): void;
+    initCloseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, wasCleanArg: boolean, codeArg: number, reasonArg: string): void;
 }
 declare var CloseEvent: {
     prototype: CloseEvent;
@@ -6778,10 +7490,14 @@ interface WebSocket extends EventTarget {
     readyState: number;
     bufferedAmount: number;
     onopen: (ev: Event) => any;
+    addEventListener(type: "open", listener: (ev: Event) => any, useCapture?: boolean): void;
     extensions: string;
     onmessage: (ev: any) => any;
+    addEventListener(type: "message", listener: (ev: any) => any, useCapture?: boolean): void;
     onclose: (ev: CloseEvent) => any;
+    addEventListener(type: "close", listener: (ev: CloseEvent) => any, useCapture?: boolean): void;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     binaryType: string;
     url: string;
     close(code?: number, reason?: string): void;
@@ -6790,6 +7506,7 @@ interface WebSocket extends EventTarget {
     CLOSING: number;
     CONNECTING: number;
     CLOSED: number;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var WebSocket: {
     prototype: WebSocket;
@@ -6804,9 +7521,9 @@ declare var WebSocket: {
 
 interface ProgressEvent extends Event {
     loaded: number;
-    lengthComputable: bool;
+    lengthComputable: boolean;
     total: number;
-    initProgressEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, lengthComputableArg: bool, loadedArg: number, totalArg: number): void;
+    initProgressEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, lengthComputableArg: boolean, loadedArg: number, totalArg: number): void;
 }
 declare var ProgressEvent: {
     prototype: ProgressEvent;
@@ -6831,7 +7548,7 @@ interface IDBObjectStore {
     deleteIndex(indexName: string): void;
     index(name: string): IDBIndex;
     get(key: any): IDBRequest;
-    delet(key: any): IDBRequest;
+    delete(key: any): IDBRequest;
 }
 declare var IDBObjectStore: {
     prototype: IDBObjectStore;
@@ -6839,7 +7556,7 @@ declare var IDBObjectStore: {
 }
 
 interface ObjectURLOptions {
-    oneTimeOnly?: bool;
+    oneTimeOnly?: boolean;
 }
 
 interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
@@ -6855,21 +7572,37 @@ declare var SVGFEGaussianBlurElement: {
 
 interface MSHTMLDocumentExtensions {
     onmspointerdown: (ev: any) => any;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointercancel: (ev: any) => any;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturedoubletap: (ev: any) => any;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturetap: (ev: any) => any;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgestureend: (ev: any) => any;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerout: (ev: any) => any;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsmanipulationstatechanged: (ev: any) => any;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsinertiastart: (ev: any) => any;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerhover: (ev: any) => any;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
     onmscontentzoom: (ev: any) => any;
+    addEventListener(type: "mscontentzoom", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturehold: (ev: any) => any;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointermove: (ev: any) => any;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerover: (ev: any) => any;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturechange: (ev: any) => any;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturestart: (ev: any) => any;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerup: (ev: any) => any;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
 }
 declare var MSHTMLDocumentExtensions: {
     prototype: MSHTMLDocumentExtensions;
@@ -6898,7 +7631,7 @@ declare var IDBVersionChangeEvent: {
 }
 
 interface IDBIndex {
-    unique: bool;
+    unique: boolean;
     name: string;
     keyPath: string;
     objectStore: IDBObjectStore;
@@ -6929,8 +7662,8 @@ interface IDBCursor {
     key: any;
     primaryKey: any;
     advance(count: number): void;
-    delet(): IDBRequest;
-    continu(key?: any): void;
+    delete(): IDBRequest;
+    continue(key?: any): void;
     update(value: any): IDBRequest;
 }
 declare var IDBCursor: {
@@ -7001,24 +7734,32 @@ declare var IDBCursorWithValue: {
 
 interface HTMLTextAreaElement {
     validationMessage: string;
-    autofocus: bool;
+    autofocus: boolean;
     validity: ValidityState;
-    required: bool;
+    required: boolean;
     maxLength: number;
-    willValidate: bool;
+    willValidate: boolean;
     placeholder: string;
-    checkValidity(): bool;
+    checkValidity(): boolean;
     setCustomValidity(error: string): void;
 }
 
 interface XMLHttpRequestEventTarget extends EventTarget {
     onprogress: (ev: ProgressEvent) => any;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     onload: (ev: any) => any;
+    addEventListener(type: "load", listener: (ev: any) => any, useCapture?: boolean): void;
     ontimeout: (ev: any) => any;
+    addEventListener(type: "timeout", listener: (ev: any) => any, useCapture?: boolean): void;
     onabort: (ev: any) => any;
+    addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void;
     onloadstart: (ev: any) => any;
+    addEventListener(type: "loadstart", listener: (ev: any) => any, useCapture?: boolean): void;
     onloadend: (ev: ProgressEvent) => any;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var XMLHttpRequestEventTarget: {
     prototype: XMLHttpRequestEventTarget;
@@ -7033,10 +7774,13 @@ interface IDBEnvironment {
 interface AudioTrackList extends EventTarget {
     length: number;
     onchange: (ev: any) => any;
+    addEventListener(type: "change", listener: (ev: any) => any, useCapture?: boolean): void;
     onaddtrack: (ev: TrackEvent) => any;
+    addEventListener(type: "addtrack", listener: (ev: TrackEvent) => any, useCapture?: boolean): void;
     getTrackById(id: string): AudioTrack;
     item(index: number): AudioTrack;
     [index: number]: AudioTrack;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var AudioTrackList: {
     prototype: AudioTrackList;
@@ -7045,17 +7789,24 @@ declare var AudioTrackList: {
 
 interface MSBaseReader extends EventTarget {
     onprogress: (ev: ProgressEvent) => any;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
     readyState: number;
     onabort: (ev: any) => any;
+    addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void;
     onloadend: (ev: ProgressEvent) => any;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     onload: (ev: any) => any;
+    addEventListener(type: "load", listener: (ev: any) => any, useCapture?: boolean): void;
     onloadstart: (ev: any) => any;
+    addEventListener(type: "loadstart", listener: (ev: any) => any, useCapture?: boolean): void;
     result: any;
     abort(): void;
     LOADING: number;
     EMPTY: number;
     DONE: number;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface History {
@@ -7091,11 +7842,11 @@ declare var SVGFEMorphologyElement: {
 
 interface HTMLSelectElement {
     validationMessage: string;
-    autofocus: bool;
+    autofocus: boolean;
     validity: ValidityState;
-    required: bool;
-    willValidate: bool;
-    checkValidity(): bool;
+    required: boolean;
+    willValidate: boolean;
+    checkValidity(): boolean;
     setCustomValidity(error: string): void;
 }
 
@@ -7173,7 +7924,7 @@ interface MSCSSContentZoomProperties {
 interface AnimationEvent extends Event {
     animationName: string;
     elapsedTime: number;
-    initAnimationEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, animationNameArg: string, elapsedTimeArg: number): void;
+    initAnimationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, animationNameArg: string, elapsedTimeArg: number): void;
 }
 declare var AnimationEvent: {
     prototype: AnimationEvent;
@@ -7218,7 +7969,9 @@ declare var MSRangeCollection: {
 
 interface MSHTMLElementExtensions {
     onmscontentzoom: (ev: any) => any;
+    addEventListener(type: "mscontentzoom", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsmanipulationstatechanged: (ev: any) => any;
+    addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void;
 }
 declare var MSHTMLElementExtensions: {
     prototype: MSHTMLElementExtensions;
@@ -7258,17 +8011,17 @@ declare var SVGFEFuncBElement: {
 
 interface IDBKeyRange {
     upper: any;
-    upperOpen: bool;
+    upperOpen: boolean;
     lower: any;
-    lowerOpen: bool;
-    bound(lower: any, upper: any, lowerOpen?: bool, upperOpen?: bool): IDBKeyRange;
+    lowerOpen: boolean;
+    bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
     only(value: any): IDBKeyRange;
-    lowerBound(bound: any, open?: bool): IDBKeyRange;
-    upperBound(bound: any, open?: bool): IDBKeyRange;
+    lowerBound(bound: any, open?: boolean): IDBKeyRange;
+    upperBound(bound: any, open?: boolean): IDBKeyRange;
 }
 declare var IDBKeyRange: {
     prototype: IDBKeyRange;
-    new(): IDBKeyRange;
+    new (): IDBKeyRange;
 }
 
 interface WindowConsole {
@@ -7290,13 +8043,17 @@ declare var SVG1_1Properties: {
 
 interface IDBTransaction extends EventTarget {
     oncomplete: (ev: Event) => any;
+    addEventListener(type: "complete", listener: (ev: Event) => any, useCapture?: boolean): void;
     db: IDBDatabase;
     mode: string;
     error: DOMError;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     onabort: (ev: any) => any;
+    addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void;
     abort(): void;
     objectStore(name: string): IDBObjectStore;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var IDBTransaction: {
     prototype: IDBTransaction;
@@ -7305,20 +8062,34 @@ declare var IDBTransaction: {
 
 interface MSWindowExtensions {
     onmspointerdown: (ev: any) => any;
+    addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointercancel: (ev: any) => any;
+    addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturedoubletap: (ev: any) => any;
+    addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgestureend: (ev: any) => any;
+    addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturetap: (ev: any) => any;
+    addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerout: (ev: any) => any;
+    addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerhover: (ev: any) => any;
+    addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsinertiastart: (ev: any) => any;
+    addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointermove: (ev: any) => any;
+    addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturehold: (ev: any) => any;
+    addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerover: (ev: any) => any;
+    addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturechange: (ev: any) => any;
+    addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void;
     onmsgesturestart: (ev: any) => any;
+    addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void;
     onmspointerup: (ev: any) => any;
-    msIsStaticHTML(html: string): bool;
+    addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void;
+    msIsStaticHTML(html: string): boolean;
 }
 declare var MSWindowExtensions: {
     prototype: MSWindowExtensions;
@@ -7330,7 +8101,7 @@ interface AudioTrack {
     language: string;
     id: string;
     label: string;
-    enabled: bool;
+    enabled: boolean;
 }
 declare var AudioTrack: {
     prototype: AudioTrack;
@@ -7407,6 +8178,7 @@ interface MSCSSTouchManipulationProperties {
 
 interface Window extends WindowAnimationTiming, WindowBase64, IDBEnvironment, WindowConsole {
     onpopstate: (ev: PopStateEvent) => any;
+    addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void;
     applicationCache: ApplicationCache;
     matchMedia(mediaQuery: string): MediaQueryList;
     msMatchMedia(mediaQuery: string): MediaQueryList;
@@ -7486,21 +8258,21 @@ declare var SVGFEColorMatrixElement: {
 interface Console {
     info(): void;
     info(message: any, ...optionalParams: any[]): void;
-    profile(reportName?: string): bool;
+    profile(reportName?: string): boolean;
     assert(): void;
-    assert(test: bool): void;
-    assert(test: bool, message: any, ...optionalParams: any[]): void;
-    msIsIndependentlyComposed(element: Element): bool;
-    clear(): bool;
-    dir(): bool;
-    dir(value: any, ...optionalParams: any[]): bool;
+    assert(test: boolean): void;
+    assert(test: boolean, message: any, ...optionalParams: any[]): void;
+    msIsIndependentlyComposed(element: Element): boolean;
+    clear(): boolean;
+    dir(): boolean;
+    dir(value: any, ...optionalParams: any[]): boolean;
     warn(): void;
     warn(message: any, ...optionalParams: any[]): void;
     error(): void;
     error(message: any, ...optionalParams: any[]): void;
     log(): void;
     log(message: any, ...optionalParams: any[]): void;
-    profileEnd(): bool;
+    profileEnd(): boolean;
 }
 declare var Console: {
     prototype: Console;
@@ -7523,10 +8295,10 @@ declare var SVGFESpotLightElement: {
 }
 
 interface DocumentVisibility {
-    msHidden: bool;
+    msHidden: boolean;
     msVisibilityState: string;
     visibilityState: string;
-    hidden: bool;
+    hidden: boolean;
 }
 
 interface WindowBase64 {
@@ -7539,11 +8311,14 @@ interface IDBDatabase extends EventTarget {
     name: string;
     objectStoreNames: DOMStringList;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     onabort: (ev: any) => any;
+    addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void;
     createObjectStore(name: string, optionalParameters?: any): IDBObjectStore;
     close(): void;
     transaction(storeNames: any, mode?: string): IDBTransaction;
     deleteObjectStore(name: string): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var IDBDatabase: {
     prototype: IDBDatabase;
@@ -7559,7 +8334,7 @@ declare var MSProtocolsCollection: {
 
 interface DOMStringList {
     length: number;
-    contains(str: string): bool;
+    contains(str: string): boolean;
     item(index: number): string;
     [index: number]: string;
 }
@@ -7586,7 +8361,10 @@ interface CSSMultiColumnProperties {
 
 interface IDBOpenDBRequest extends IDBRequest {
     onupgradeneeded: (ev: IDBVersionChangeEvent) => any;
+    addEventListener(type: "upgradeneeded", listener: (ev: IDBVersionChangeEvent) => any, useCapture?: boolean): void;
     onblocked: (ev: Event) => any;
+    addEventListener(type: "blocked", listener: (ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var IDBOpenDBRequest: {
     prototype: IDBOpenDBRequest;
@@ -7596,14 +8374,14 @@ declare var IDBOpenDBRequest: {
 interface HTMLButtonElement {
     validationMessage: string;
     formTarget: string;
-    willValidate: bool;
+    willValidate: boolean;
     formAction: string;
-    autofocus: bool;
+    autofocus: boolean;
     validity: ValidityState;
     formNoValidate: string;
     formEnctype: string;
     formMethod: string;
-    checkValidity(): bool;
+    checkValidity(): boolean;
     setCustomValidity(error: string): void;
 }
 
@@ -7630,8 +8408,8 @@ declare var SVGFEOffsetElement: {
 
 interface HTMLFormElement {
     autocomplete: string;
-    noValidate: bool;
-    checkValidity(): bool;
+    noValidate: boolean;
+    checkValidity(): boolean;
 }
 
 interface MSUnsafeFunctionCallback {
@@ -7646,7 +8424,7 @@ interface MessageEvent extends Event {
 }
 
 interface HTMLScriptElement {
-    async: bool;
+    async: boolean;
 }
 
 interface HTMLMediaElement extends MSHTMLMediaElementExtensions {
@@ -7661,9 +8439,12 @@ interface TextTrack extends EventTarget {
     activeCues: TextTrackCueList;
     cues: TextTrackCueList;
     oncuechange: (ev: Event) => any;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
     kind: string;
     onload: (ev: any) => any;
+    addEventListener(type: "load", listener: (ev: any) => any, useCapture?: boolean): void;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     label: string;
     ERROR: number;
     SHOWING: number;
@@ -7672,6 +8453,7 @@ interface TextTrack extends EventTarget {
     NONE: number;
     HIDDEN: number;
     DISABLED: number;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var TextTrack: {
     prototype: TextTrack;
@@ -7692,11 +8474,14 @@ interface MediaQueryListListener {
 interface IDBRequest extends EventTarget {
     source: any;
     onsuccess: (ev: Event) => any;
+    addEventListener(type: "success", listener: (ev: Event) => any, useCapture?: boolean): void;
     error: DOMError;
     transaction: IDBTransaction;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     readyState: string;
     result: any;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var IDBRequest: {
     prototype: IDBRequest;
@@ -7705,9 +8490,11 @@ declare var IDBRequest: {
 
 interface MessagePort extends EventTarget {
     onmessage: (ev: any) => any;
+    addEventListener(type: "message", listener: (ev: any) => any, useCapture?: boolean): void;
     close(): void;
     postMessage(message: any, ports?: any): void;
     start(): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var MessagePort: {
     prototype: MessagePort;
@@ -7747,13 +8534,21 @@ declare var Blob: {
 interface ApplicationCache extends EventTarget {
     status: number;
     ondownloading: (ev: Event) => any;
+    addEventListener(type: "downloading", listener: (ev: Event) => any, useCapture?: boolean): void;
     onprogress: (ev: ProgressEvent) => any;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
     onupdateready: (ev: Event) => any;
+    addEventListener(type: "updateready", listener: (ev: Event) => any, useCapture?: boolean): void;
     oncached: (ev: Event) => any;
+    addEventListener(type: "cached", listener: (ev: Event) => any, useCapture?: boolean): void;
     onobsolete: (ev: Event) => any;
+    addEventListener(type: "obsolete", listener: (ev: Event) => any, useCapture?: boolean): void;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     onchecking: (ev: Event) => any;
+    addEventListener(type: "checking", listener: (ev: Event) => any, useCapture?: boolean): void;
     onnoupdate: (ev: Event) => any;
+    addEventListener(type: "noupdate", listener: (ev: Event) => any, useCapture?: boolean): void;
     swapCache(): void;
     abort(): void;
     update(): void;
@@ -7763,6 +8558,7 @@ interface ApplicationCache extends EventTarget {
     DOWNLOADING: number;
     IDLE: number;
     OBSOLETE: number;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var ApplicationCache: {
     prototype: ApplicationCache;
@@ -7776,18 +8572,22 @@ declare var ApplicationCache: {
 }
 
 interface MSHTMLVideoElementExtensions {
-    msIsStereo3D: bool;
+    msIsStereo3D: boolean;
     msStereo3DPackingMode: string;
     onMSVideoOptimalLayoutChanged: (ev: any) => any;
+    addEventListener(type: "MSVideoOptimalLayoutChanged", listener: (ev: any) => any, useCapture?: boolean): void;
     onMSVideoFrameStepCompleted: (ev: any) => any;
+    addEventListener(type: "MSVideoFrameStepCompleted", listener: (ev: any) => any, useCapture?: boolean): void;
     msStereo3DRenderMode: string;
-    msIsLayoutOptimalForPlayback: bool;
-    msHorizontalMirror: bool;
+    msIsLayoutOptimalForPlayback: boolean;
+    msHorizontalMirror: boolean;
     onMSVideoFormatChanged: (ev: any) => any;
-    msZoom: bool;
-    msInsertVideoEffect(activatableClassId: string, effectRequired: bool, config?: any): void;
+    addEventListener(type: "MSVideoFormatChanged", listener: (ev: any) => any, useCapture?: boolean): void;
+    msZoom: boolean;
+    msInsertVideoEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
     msSetVideoRectangle(left: number, top: number, right: number, bottom: number): void;
-    msFrameStep(forward: bool): void;
+    msFrameStep(forward: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface FrameRequestCallback {
@@ -7806,12 +8606,12 @@ interface CSS3DTransformsProperties {
 }
 
 interface XMLHttpRequest {
-    withCredentials: bool;
+    withCredentials: boolean;
 }
 
 interface PopStateEvent extends Event {
     state: any;
-    initPopStateEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, stateArg: any): void;
+    initPopStateEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, stateArg: any): void;
 }
 declare var PopStateEvent: {
     prototype: PopStateEvent;
@@ -7839,8 +8639,8 @@ interface CSSGridProperties {
 }
 
 interface MSFileSaver {
-    msSaveBlob(blob: any, defaultName?: string): bool;
-    msSaveOrOpenBlob(blob: any, defaultName?: string): bool;
+    msSaveBlob(blob: any, defaultName?: string): boolean;
+    msSaveOrOpenBlob(blob: any, defaultName?: string): boolean;
 }
 
 interface MSStream {
@@ -7859,8 +8659,8 @@ interface MediaError extends MSMediaErrorExtensions {
 interface HTMLFieldSetElement {
     validationMessage: string;
     validity: ValidityState;
-    willValidate: bool;
-    checkValidity(): bool;
+    willValidate: boolean;
+    checkValidity(): boolean;
     setCustomValidity(error: string): void;
 }
 
@@ -7879,9 +8679,10 @@ interface MSRangeExtensions {
 
 interface HTMLElement {
     oncuechange: (ev: Event) => any;
-    spellcheck: bool;
+    addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void;
+    spellcheck: boolean;
     classList: DOMTokenList;
-    draggable: bool;
+    draggable: boolean;
 }
 
 interface DataTransfer {
@@ -7913,8 +8714,8 @@ interface Range extends MSRangeExtensions {
 interface HTMLObjectElement {
     validationMessage: string;
     validity: ValidityState;
-    willValidate: bool;
-    checkValidity(): bool;
+    willValidate: boolean;
+    checkValidity(): boolean;
     setCustomValidity(error: string): void;
 }
 
@@ -7923,7 +8724,7 @@ interface MSPointerEvent extends MouseEvent {
     rotation: number;
     pressure: number;
     pointerType: number;
-    isPrimary: bool;
+    isPrimary: boolean;
     tiltY: number;
     height: number;
     intermediatePoints: any;
@@ -7931,7 +8732,7 @@ interface MSPointerEvent extends MouseEvent {
     tiltX: number;
     hwTimestamp: number;
     pointerId: number;
-    initPointerEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: bool, altKeyArg: bool, shiftKeyArg: bool, metaKeyArg: bool, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: number, hwTimestampArg: number, isPrimary: bool): void;
+    initPointerEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: number, hwTimestampArg: number, isPrimary: boolean): void;
     getCurrentPoint(element: Element): void;
     getIntermediatePoints(element: Element): void;
     MSPOINTER_TYPE_PEN: number;
@@ -7978,7 +8779,7 @@ interface MSCSSHighContrastProperties {
 interface MSManipulationEvent extends UIEvent {
     lastState: number;
     currentState: number;
-    initMSManipulationEvent(typeArg: string, canBubbleArg: bool, cancelableArg: bool, viewArg: AbstractView, detailArg: number, lastState: number, currentState: number): void;
+    initMSManipulationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: AbstractView, detailArg: number, lastState: number, currentState: number): void;
     MS_MANIPULATION_STATE_STOPPED: number;
     MS_MANIPULATION_STATE_ACTIVE: number;
     MS_MANIPULATION_STATE_INERTIA: number;
@@ -7996,13 +8797,12 @@ interface FormData {
 }
 declare var FormData: {
     prototype: FormData;
-    new (): FormData;
-    new (form: HTMLFormElement): FormData;
+    new (form?: HTMLFormElement): FormData;
 }
 
 interface MSHTMLImageElementExtensions {
-    msPlayToPrimary: bool;
-    msPlayToDisabled: bool;
+    msPlayToPrimary: boolean;
+    msPlayToDisabled: boolean;
     msPlayToSource: any;
 }
 declare var MSHTMLImageElementExtensions: {
@@ -8012,14 +8812,14 @@ declare var MSHTMLImageElementExtensions: {
 
 interface MSHTMLMediaElementExtensions {
     msAudioCategory: string;
-    msRealTime: bool;
-    msPlayToPrimary: bool;
-    msPlayToDisabled: bool;
+    msRealTime: boolean;
+    msPlayToPrimary: boolean;
+    msPlayToDisabled: boolean;
     msPlayToSource: any;
     msAudioDeviceType: string;
     msClearEffects(): void;
     msSetMediaProtectionManager(mediaProtectionManager?: any): void;
-    msInsertAudioEffect(activatableClassId: string, effectRequired: bool, config?: any): void;
+    msInsertAudioEffect(activatableClassId: string, effectRequired: boolean, config?: any): void;
 }
 
 interface SVGFEImageElement extends SVGElement, SVGLangSpace, SVGFilterPrimitiveStandardAttributes, SVGURIReference {
@@ -8040,6 +8840,8 @@ declare var HTMLDataListElement: {
 
 interface AbstractWorker extends EventTarget {
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 
 interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes {
@@ -8071,15 +8873,15 @@ declare var SVGFECompositeElement: {
 }
 
 interface ValidityState {
-    customError: bool;
-    valueMissing: bool;
-    stepMismatch: bool;
-    rangeUnderflow: bool;
-    rangeOverflow: bool;
-    typeMismatch: bool;
-    patternMismatch: bool;
-    tooLong: bool;
-    valid: bool;
+    customError: boolean;
+    valueMissing: boolean;
+    stepMismatch: boolean;
+    rangeUnderflow: boolean;
+    rangeOverflow: boolean;
+    typeMismatch: boolean;
+    patternMismatch: boolean;
+    tooLong: boolean;
+    valid: boolean;
 }
 declare var ValidityState: {
     prototype: ValidityState;
@@ -8095,7 +8897,7 @@ interface HTMLTrackElement extends HTMLElement {
     srclang: string;
     track: TextTrack;
     label: string;
-    defaul: bool;
+    defaul: boolean;
 }
 declare var HTMLTrackElement: {
     prototype: HTMLTrackElement;
@@ -8118,12 +8920,18 @@ declare var MSApp: MSApp;
 interface MSXMLHttpRequestExtensions {
     response: any;
     onprogress: (ev: ProgressEvent) => any;
+    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
     onabort: (ev: any) => any;
+    addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void;
     responseType: string;
     onloadend: (ev: ProgressEvent) => any;
+    addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
     upload: XMLHttpRequestEventTarget;
     onerror: (ev: ErrorEvent) => any;
+    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
     onloadstart: (ev: any) => any;
+    addEventListener(type: "loadstart", listener: (ev: any) => any, useCapture?: boolean): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var MSXMLHttpRequestExtensions: {
     prototype: MSXMLHttpRequestExtensions;
@@ -8191,8 +8999,10 @@ declare var MSCSSMatrix: {
 
 interface Worker extends AbstractWorker {
     onmessage: (ev: any) => any;
+    addEventListener(type: "message", listener: (ev: any) => any, useCapture?: boolean): void;
     postMessage(message: any, ports?: any): void;
     terminate(): void;
+    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
 }
 declare var Worker: {
     prototype: Worker;
@@ -8210,8 +9020,8 @@ interface MSMediaErrorExtensions {
 interface MSNavigatorAbilities {
     msProtocols: MSProtocolsCollection;
     msMaxTouchPoints: number;
-    msPointerEnabled: bool;
-    msManipulationViewsEnabled: bool;
+    msPointerEnabled: boolean;
+    msManipulationViewsEnabled: boolean;
 }
 declare var MSNavigatorAbilities: {
     prototype: MSNavigatorAbilities;
@@ -8219,6 +9029,7 @@ declare var MSNavigatorAbilities: {
 }
 
 declare var onpopstate: (ev: PopStateEvent) => any;
+declare function addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void;
 declare var applicationCache: ApplicationCache;
 declare function matchMedia(mediaQuery: string): MediaQueryList;
 declare function msMatchMedia(mediaQuery: string): MediaQueryList;
@@ -8238,7 +9049,7 @@ declare var console: Console;
 /////////////////////////////
 /// WorkerGlobalScope APIs 
 /////////////////////////////
-// TODO: These are only available in a Web Worker - should be in a seperate lib file
+// TODO: These are only available in a Web Worker - should be in a separate lib file
 declare function importScripts(...urls: string[]): void;
 
 
@@ -8254,11 +9065,10 @@ interface ITextWriter {
 }
 
 declare var WScript : {
-    Echo(s);
+    Echo(s: any);
     StdErr: ITextWriter;
     StdOut: ITextWriter;
     Arguments: { length: number; Item(n: number): string; };
     ScriptFullName: string;
     Quit(exitCode?: number);
 }
-