diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index 2f8a1efba7699..27ad9e1236299 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -153,11 +153,7 @@ interface String {
     [Symbol.iterator](): IterableIterator<string>;
 }
 
-/**
- * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested
- * number of bytes could not be allocated an exception is raised.
- */
-interface Int8Array {
+interface TypedArray {
     [Symbol.iterator](): IterableIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
@@ -185,30 +181,9 @@ interface Int8ArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array;
-
     from(arrayLike: Iterable<number>): Int8Array;
 }
 
-/**
- * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Uint8Array {
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Returns an array of key, value pairs for every entry in the array
-     */
-    entries(): IterableIterator<[number, number]>;
-    /**
-     * Returns an list of keys in the array
-     */
-    keys(): IterableIterator<number>;
-    /**
-     * Returns an list of values in the array
-     */
-    values(): IterableIterator<number>;
-}
-
 interface Uint8ArrayConstructor {
     new (elements: Iterable<number>): Uint8Array;
 
@@ -221,36 +196,12 @@ interface Uint8ArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array;
-
     from(arrayLike: Iterable<number>): Uint8Array;
 }
 
-/**
- * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0.
- * If the requested number of bytes could not be allocated an exception is raised.
- */
-interface Uint8ClampedArray {
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Returns an array of key, value pairs for every entry in the array
-     */
-    entries(): IterableIterator<[number, number]>;
-
-    /**
-     * Returns an list of keys in the array
-     */
-    keys(): IterableIterator<number>;
-
-    /**
-     * Returns an list of values in the array
-     */
-    values(): IterableIterator<number>;
-}
-
 interface Uint8ClampedArrayConstructor {
     new (elements: Iterable<number>): Uint8ClampedArray;
 
-
     /**
      * Creates an array from an array-like or iterable object.
      * @param arrayLike An array-like or iterable object to convert to an array.
@@ -260,32 +211,9 @@ interface Uint8ClampedArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray;
-
     from(arrayLike: Iterable<number>): Uint8ClampedArray;
 }
 
-/**
- * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Int16Array {
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Returns an array of key, value pairs for every entry in the array
-     */
-    entries(): IterableIterator<[number, number]>;
-
-    /**
-     * Returns an list of keys in the array
-     */
-    keys(): IterableIterator<number>;
-
-    /**
-     * Returns an list of values in the array
-     */
-    values(): IterableIterator<number>;
-}
-
 interface Int16ArrayConstructor {
     new (elements: Iterable<number>): Int16Array;
 
@@ -298,30 +226,9 @@ interface Int16ArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array;
-
     from(arrayLike: Iterable<number>): Int16Array;
 }
 
-/**
- * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Uint16Array {
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Returns an array of key, value pairs for every entry in the array
-     */
-    entries(): IterableIterator<[number, number]>;
-    /**
-     * Returns an list of keys in the array
-     */
-    keys(): IterableIterator<number>;
-    /**
-     * Returns an list of values in the array
-     */
-    values(): IterableIterator<number>;
-}
-
 interface Uint16ArrayConstructor {
     new (elements: Iterable<number>): Uint16Array;
 
@@ -334,30 +241,9 @@ interface Uint16ArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array;
-
     from(arrayLike: Iterable<number>): Uint16Array;
 }
 
-/**
- * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Int32Array {
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Returns an array of key, value pairs for every entry in the array
-     */
-    entries(): IterableIterator<[number, number]>;
-    /**
-     * Returns an list of keys in the array
-     */
-    keys(): IterableIterator<number>;
-    /**
-     * Returns an list of values in the array
-     */
-    values(): IterableIterator<number>;
-}
-
 interface Int32ArrayConstructor {
     new (elements: Iterable<number>): Int32Array;
 
@@ -370,30 +256,9 @@ interface Int32ArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array;
-
     from(arrayLike: Iterable<number>): Int32Array;
 }
 
-/**
- * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Uint32Array {
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Returns an array of key, value pairs for every entry in the array
-     */
-    entries(): IterableIterator<[number, number]>;
-    /**
-     * Returns an list of keys in the array
-     */
-    keys(): IterableIterator<number>;
-    /**
-     * Returns an list of values in the array
-     */
-    values(): IterableIterator<number>;
-}
-
 interface Uint32ArrayConstructor {
     new (elements: Iterable<number>): Uint32Array;
 
@@ -406,30 +271,9 @@ interface Uint32ArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array;
-
     from(arrayLike: Iterable<number>): Uint32Array;
 }
 
-/**
- * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number
- * of bytes could not be allocated an exception is raised.
- */
-interface Float32Array {
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Returns an array of key, value pairs for every entry in the array
-     */
-    entries(): IterableIterator<[number, number]>;
-    /**
-     * Returns an list of keys in the array
-     */
-    keys(): IterableIterator<number>;
-    /**
-     * Returns an list of values in the array
-     */
-    values(): IterableIterator<number>;
-}
-
 interface Float32ArrayConstructor {
     new (elements: Iterable<number>): Float32Array;
 
@@ -442,30 +286,9 @@ interface Float32ArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array;
-
     from(arrayLike: Iterable<number>): Float32Array;
 }
 
-/**
- * A typed array of 64-bit float values. The contents are initialized to 0. If the requested
- * number of bytes could not be allocated an exception is raised.
- */
-interface Float64Array {
-    [Symbol.iterator](): IterableIterator<number>;
-    /**
-     * Returns an array of key, value pairs for every entry in the array
-     */
-    entries(): IterableIterator<[number, number]>;
-    /**
-     * Returns an list of keys in the array
-     */
-    keys(): IterableIterator<number>;
-    /**
-     * Returns an list of values in the array
-     */
-    values(): IterableIterator<number>;
-}
-
 interface Float64ArrayConstructor {
     new (elements: Iterable<number>): Float64Array;
 
@@ -478,6 +301,5 @@ interface Float64ArrayConstructor {
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array;
     from(arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array;
     from<Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array;
-
     from(arrayLike: Iterable<number>): Float64Array;
 }
diff --git a/src/lib/es2016.array.include.d.ts b/src/lib/es2016.array.include.d.ts
index 1012c18407b0b..e20d6a73ae8a1 100644
--- a/src/lib/es2016.array.include.d.ts
+++ b/src/lib/es2016.array.include.d.ts
@@ -16,7 +16,7 @@ interface ReadonlyArray<T> {
     includes(searchElement: T, fromIndex?: number): boolean;
 }
 
-interface Int8Array {
+interface TypedArray {
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
@@ -24,75 +24,3 @@ interface Int8Array {
      */
     includes(searchElement: number, fromIndex?: number): boolean;
 }
-
-interface Uint8Array {
-    /**
-     * Determines whether an array includes a certain element, returning true or false as appropriate.
-     * @param searchElement The element to search for.
-     * @param fromIndex The position in this array at which to begin searching for searchElement.
-     */
-    includes(searchElement: number, fromIndex?: number): boolean;
-}
-
-interface Uint8ClampedArray {
-    /**
-     * Determines whether an array includes a certain element, returning true or false as appropriate.
-     * @param searchElement The element to search for.
-     * @param fromIndex The position in this array at which to begin searching for searchElement.
-     */
-    includes(searchElement: number, fromIndex?: number): boolean;
-}
-
-interface Int16Array {
-    /**
-     * Determines whether an array includes a certain element, returning true or false as appropriate.
-     * @param searchElement The element to search for.
-     * @param fromIndex The position in this array at which to begin searching for searchElement.
-     */
-    includes(searchElement: number, fromIndex?: number): boolean;
-}
-
-interface Uint16Array {
-    /**
-     * Determines whether an array includes a certain element, returning true or false as appropriate.
-     * @param searchElement The element to search for.
-     * @param fromIndex The position in this array at which to begin searching for searchElement.
-     */
-    includes(searchElement: number, fromIndex?: number): boolean;
-}
-
-interface Int32Array {
-    /**
-     * Determines whether an array includes a certain element, returning true or false as appropriate.
-     * @param searchElement The element to search for.
-     * @param fromIndex The position in this array at which to begin searching for searchElement.
-     */
-    includes(searchElement: number, fromIndex?: number): boolean;
-}
-
-interface Uint32Array {
-    /**
-     * Determines whether an array includes a certain element, returning true or false as appropriate.
-     * @param searchElement The element to search for.
-     * @param fromIndex The position in this array at which to begin searching for searchElement.
-     */
-    includes(searchElement: number, fromIndex?: number): boolean;
-}
-
-interface Float32Array {
-    /**
-     * Determines whether an array includes a certain element, returning true or false as appropriate.
-     * @param searchElement The element to search for.
-     * @param fromIndex The position in this array at which to begin searching for searchElement.
-     */
-    includes(searchElement: number, fromIndex?: number): boolean;
-}
-
-interface Float64Array {
-    /**
-     * Determines whether an array includes a certain element, returning true or false as appropriate.
-     * @param searchElement The element to search for.
-     * @param fromIndex The position in this array at which to begin searching for searchElement.
-     */
-    includes(searchElement: number, fromIndex?: number): boolean;
-}
\ No newline at end of file
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index 74be3b812ec6c..bd49d7263f64f 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1391,6 +1391,7 @@ interface ArrayBufferConstructor {
     new (byteLength: number): ArrayBuffer;
     isView(arg: any): arg is ArrayBufferView;
 }
+
 declare const ArrayBuffer: ArrayBufferConstructor;
 
 interface ArrayBufferView {
@@ -1541,13 +1542,25 @@ interface DataView {
 interface DataViewConstructor {
     new (buffer: ArrayBuffer, byteOffset?: number, byteLength?: number): DataView;
 }
+
 declare const DataView: DataViewConstructor;
 
 /**
- * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested
- * number of bytes could not be allocated an exception is raised.
+ * A typed array of integer values, presenting a view of an underlying binary data buffer.
+ *
+ * Every TypedArray is one of the following:
+ *
+ *   - Int8Array
+ *   - Uint8Array
+ *   - Uint8ClampedArray
+ *   - Int16Array
+ *   - Uint16Array
+ *   - Int32Array
+ *   - Uint32Array
+ *   - Float32Array
+ *   - Float64Array
  */
-interface Int8Array {
+interface TypedArray {
     /**
      * The size in bytes of each element in the array.
      */
@@ -1587,9 +1600,9 @@ interface Int8Array {
      * @param thisArg An object to which the this keyword can refer in the callbackfn function.
      * If thisArg is omitted, undefined is used as the this value.
      */
-    every(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => boolean, thisArg: Z): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: this) => boolean): boolean;
+    every(callbackfn: (this: void, value: number, index: number, array: this) => boolean, thisArg: undefined): boolean;
+    every<Z>(callbackfn: (this: Z, value: number, index: number, array: this) => boolean, thisArg: Z): boolean;
 
     /**
      * Returns the this object after filling the section identified by start and end with value
@@ -1608,9 +1621,9 @@ interface Int8Array {
      * @param thisArg An object to which the this keyword can refer in the callbackfn function.
      * If thisArg is omitted, undefined is used as the this value.
      */
-    filter(callbackfn: (this: void, value: number, index: number, array: Int8Array) => any): Int8Array;
-    filter(callbackfn: (this: void, value: number, index: number, array: Int8Array) => any, thisArg: undefined): Int8Array;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => any, thisArg: Z): Int8Array;
+    filter(callbackfn: (this: void, value: number, index: number, array: this) => any): this;
+    filter(callbackfn: (this: void, value: number, index: number, array: this) => any, thisArg: undefined): this;
+    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: this) => any, thisArg: Z): this;
 
     /**
      * Returns the value of the first element in the array where predicate is true, and undefined
@@ -1621,9 +1634,9 @@ interface Int8Array {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
+    find(predicate: (this: void, value: number, index: number, array: this) => boolean): number | undefined;
+    find(predicate: (this: void, value: number, index: number, array: this) => boolean, thisArg: undefined): number | undefined;
+    find<Z>(predicate: (this: Z, value: number, index: number, array: this) => boolean, thisArg: Z): number | undefined;
 
     /**
      * Returns the index of the first element in the array where predicate is true, and -1
@@ -1634,9 +1647,9 @@ interface Int8Array {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
+    findIndex(predicate: (this: void, value: number, index: number, array: this) => boolean): number;
+    findIndex(predicate: (this: void, value: number, index: number, array: this) => boolean, thisArg: undefined): number;
+    findIndex<Z>(predicate: (this: Z, value: number, index: number, array: this) => boolean, thisArg: Z): number;
 
     /**
      * Performs the specified action for each element in an array.
@@ -1645,9 +1658,9 @@ interface Int8Array {
      * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
      * If thisArg is omitted, undefined is used as the this value.
      */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Int8Array) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Int8Array) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => void, thisArg: Z): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: this) => void): void;
+    forEach(callbackfn: (this: void, value: number, index: number, array: this) => void, thisArg: undefined): void;
+    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: this) => void, thisArg: Z): void;
 
     /**
      * Returns the index of the first occurrence of a value in an array.
@@ -1685,9 +1698,9 @@ interface Int8Array {
      * @param thisArg An object to which the this keyword can refer in the callbackfn function.
      * If thisArg is omitted, undefined is used as the this value.
      */
-    map(callbackfn: (this: void, value: number, index: number, array: Int8Array) => number): Int8Array;
-    map(callbackfn: (this: void, value: number, index: number, array: Int8Array) => number, thisArg: undefined): Int8Array;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => number, thisArg: Z): Int8Array;
+    map(callbackfn: (this: void, value: number, index: number, array: this) => number): this;
+    map(callbackfn: (this: void, value: number, index: number, array: this) => number, thisArg: undefined): this;
+    map<Z>(callbackfn: (this: Z, value: number, index: number, array: this) => number, thisArg: Z): this;
 
     /**
      * Calls the specified callback function for all the elements in an array. The return value of
@@ -1699,7 +1712,7 @@ interface Int8Array {
      * the accumulation. The first call to the callbackfn function provides this value as an argument
      * instead of an array value.
      */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue?: number): number;
 
     /**
      * Calls the specified callback function for all the elements in an array. The return value of
@@ -1711,7 +1724,7 @@ interface Int8Array {
      * the accumulation. The first call to the callbackfn function provides this value as an argument
      * instead of an array value.
      */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U, initialValue: U): U;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U;
 
     /**
      * Calls the specified callback function for all the elements in an array, in descending order.
@@ -1723,7 +1736,7 @@ interface Int8Array {
      * the accumulation. The first call to the callbackfn function provides this value as an
      * argument instead of an array value.
      */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number, initialValue?: number): number;
 
     /**
      * Calls the specified callback function for all the elements in an array, in descending order.
@@ -1735,12 +1748,12 @@ interface Int8Array {
      * the accumulation. The first call to the callbackfn function provides this value as an argument
      * instead of an array value.
      */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int8Array) => U, initialValue: U): U;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U, initialValue: U): U;
 
     /**
      * Reverses the elements in an Array.
      */
-    reverse(): Int8Array;
+    reverse(): this;
 
     /**
      * Sets a value or an array of values.
@@ -1754,7 +1767,7 @@ interface Int8Array {
      * @param start The beginning of the specified portion of the array.
      * @param end The end of the specified portion of the array.
      */
-    slice(start?: number, end?: number): Int8Array;
+    slice(start?: number, end?: number): this;
 
     /**
      * Determines whether the specified callback function returns true for any element of an array.
@@ -1764,9 +1777,9 @@ interface Int8Array {
      * @param thisArg An object to which the this keyword can refer in the callbackfn function.
      * If thisArg is omitted, undefined is used as the this value.
      */
-    some(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Int8Array) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Int8Array) => boolean, thisArg: Z): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: this) => boolean): boolean;
+    some(callbackfn: (this: void, value: number, index: number, array: this) => boolean, thisArg: undefined): boolean;
+    some<Z>(callbackfn: (this: Z, value: number, index: number, array: this) => boolean, thisArg: Z): boolean;
 
     /**
      * Sorts an array.
@@ -1781,7 +1794,7 @@ interface Int8Array {
      * @param begin The index of the beginning of the array.
      * @param end The index of the end of the array.
      */
-    subarray(begin: number, end?: number): Int8Array;
+    subarray(begin: number, end?: number): this;
 
     /**
      * Converts a number to a string by using the current locale.
@@ -1795,12 +1808,21 @@ interface Int8Array {
 
     [index: number]: number;
 }
+
+/**
+ * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested
+ * number of bytes could not be allocated an exception is raised.
+ */
+interface Int8Array extends TypedArray {
+}
+
 interface Int8ArrayConstructor {
-    readonly prototype: Int8Array;
     new (length: number): Int8Array;
     new (array: ArrayLike<number>): Int8Array;
     new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int8Array;
 
+    readonly prototype: Int8Array;
+
     /**
      * The size in bytes of each element in the array.
      */
@@ -1821,1977 +1843,259 @@ interface Int8ArrayConstructor {
     from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array;
     from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array;
-
     from(arrayLike: ArrayLike<number>): Int8Array;
-
 }
+
 declare const Int8Array: Int8ArrayConstructor;
 
 /**
  * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the
  * requested number of bytes could not be allocated an exception is raised.
  */
-interface Uint8Array {
+interface Uint8Array extends TypedArray {
+}
+
+interface Uint8ArrayConstructor {
+    new (length: number): Uint8Array;
+    new (array: ArrayLike<number>): Uint8Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint8Array;
+
+    readonly prototype: Uint8Array;
+
     /**
      * The size in bytes of each element in the array.
      */
     readonly BYTES_PER_ELEMENT: number;
 
     /**
-     * The ArrayBuffer instance referenced by the array.
+     * Returns a new array from a set of elements.
+     * @param items A set of elements to include in the new array object.
      */
-    readonly buffer: ArrayBuffer;
+    of(...items: number[]): Uint8Array;
 
     /**
-     * The length in bytes of the array.
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    readonly byteLength: number;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array;
+    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array;
+    from(arrayLike: ArrayLike<number>): Uint8Array;
+}
+
+declare const Uint8Array: Uint8ArrayConstructor;
+
+/**
+ * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0.
+ * If the requested number of bytes could not be allocated an exception is raised.
+ */
+interface Uint8ClampedArray extends TypedArray {
+}
+
+interface Uint8ClampedArrayConstructor {
+    new (length: number): Uint8ClampedArray;
+    new (array: ArrayLike<number>): Uint8ClampedArray;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint8ClampedArray;
+
+    readonly prototype: Uint8ClampedArray;
 
     /**
-     * The offset in bytes of the array.
+     * The size in bytes of each element in the array.
      */
-    readonly byteOffset: number;
+    readonly BYTES_PER_ELEMENT: number;
 
     /**
-     * Returns the this object after copying a section of the array identified by start and end
-     * to the same array starting at position target
-     * @param target If target is negative, it is treated as length+target where length is the
-     * length of the array.
-     * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end.
-     * @param end If not specified, length of the this object is used as its default value.
+     * Returns a new array from a set of elements.
+     * @param items A set of elements to include in the new array object.
      */
-    copyWithin(target: number, start: number, end?: number): this;
+    of(...items: number[]): Uint8ClampedArray;
 
     /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in array1 until the callbackfn returns false,
-     * or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    every(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => boolean, thisArg: Z): boolean;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray;
+    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray;
+    from(arrayLike: ArrayLike<number>): Uint8ClampedArray;
+}
+
+declare const Uint8ClampedArray: Uint8ClampedArrayConstructor;
+
+/**
+ * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the
+ * requested number of bytes could not be allocated an exception is raised.
+ */
+interface Int16Array extends TypedArray {
+}
+
+interface Int16ArrayConstructor {
+    new (length: number): Int16Array;
+    new (array: ArrayLike<number>): Int16Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int16Array;
+
+    readonly prototype: Int16Array;
 
     /**
-     * Returns the this object after filling the section identified by start and end with value
-     * @param value value to fill array section with
-     * @param start index to start filling the array at. If start is negative, it is treated as
-     * length+start where length is the length of the array.
-     * @param end index to stop filling the array at. If end is negative, it is treated as
-     * length+end.
+     * The size in bytes of each element in the array.
      */
-    fill(value: number, start?: number, end?: number): this;
+    readonly BYTES_PER_ELEMENT: number;
 
     /**
-     * Returns the elements of an array that meet the condition specified in a callback function.
-     * @param callbackfn A function that accepts up to three arguments. The filter method calls
-     * the callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
+     * Returns a new array from a set of elements.
+     * @param items A set of elements to include in the new array object.
      */
-    filter(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => any): Uint8Array;
-    filter(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => any, thisArg: undefined): Uint8Array;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => any, thisArg: Z): Uint8Array;
+    of(...items: number[]): Int16Array;
 
     /**
-     * Returns the value of the first element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found, find
-     * immediately returns that element value. Otherwise, find returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array;
+    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array;
+    from(arrayLike: ArrayLike<number>): Int16Array;
+}
+
+declare const Int16Array: Int16ArrayConstructor;
+
+/**
+ * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the
+ * requested number of bytes could not be allocated an exception is raised.
+ */
+interface Uint16Array extends TypedArray {
+}
+
+interface Uint16ArrayConstructor {
+    new (length: number): Uint16Array;
+    new (array: ArrayLike<number>): Uint16Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint16Array;
+
+    readonly prototype: Uint16Array;
 
     /**
-     * Returns the index of the first element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
+     * The size in bytes of each element in the array.
      */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
+    readonly BYTES_PER_ELEMENT: number;
 
     /**
-     * Performs the specified action for each element in an array.
-     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
+     * Returns a new array from a set of elements.
+     * @param items A set of elements to include in the new array object.
      */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => void, thisArg: Z): void;
+    of(...items: number[]): Uint16Array;
 
     /**
-     * Returns the index of the first occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     *  search starts at index 0.
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    indexOf(searchElement: number, fromIndex?: number): number;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array;
+    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array;
+    from(arrayLike: ArrayLike<number>): Uint16Array;
+}
+
+declare const Uint16Array: Uint16ArrayConstructor;
+
+/**
+ * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the
+ * requested number of bytes could not be allocated an exception is raised.
+ */
+interface Int32Array extends TypedArray {
+}
+
+interface Int32ArrayConstructor {
+    new (length: number): Int32Array;
+    new (array: ArrayLike<number>): Int32Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int32Array;
+
+    readonly prototype: Int32Array;
 
     /**
-     * Adds all the elements of an array separated by the specified separator string.
-     * @param separator A string used to separate one element of an array from the next in the
-     * resulting String. If omitted, the array elements are separated with a comma.
+     * The size in bytes of each element in the array.
      */
-    join(separator?: string): string;
+    readonly BYTES_PER_ELEMENT: number;
 
     /**
-     * Returns the index of the last occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     * search starts at index 0.
+     * Returns a new array from a set of elements.
+     * @param items A set of elements to include in the new array object.
      */
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
+    of(...items: number[]): Int32Array;
 
     /**
-     * The length of the array.
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    readonly length: number;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array;
+    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array;
+    from(arrayLike: ArrayLike<number>): Int32Array;
+}
+
+declare const Int32Array: Int32ArrayConstructor;
+
+/**
+ * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the
+ * requested number of bytes could not be allocated an exception is raised.
+ */
+interface Uint32Array extends TypedArray {
+}
+
+interface Uint32ArrayConstructor {
+    new (length: number): Uint32Array;
+    new (array: ArrayLike<number>): Uint32Array;
+    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint32Array;
+
+    readonly prototype: Uint32Array;
 
     /**
-     * Calls a defined callback function on each element of an array, and returns an array that
-     * contains the results.
-     * @param callbackfn A function that accepts up to three arguments. The map method calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
+     * The size in bytes of each element in the array.
      */
-    map(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => number): Uint8Array;
-    map(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => number, thisArg: undefined): Uint8Array;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => number, thisArg: Z): Uint8Array;
+    readonly BYTES_PER_ELEMENT: number;
 
     /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
+     * Returns a new array from a set of elements.
+     * @param items A set of elements to include in the new array object.
      */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue?: number): number;
+    of(...items: number[]): Uint32Array;
 
     /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U, initialValue: U): U;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an
-     * argument instead of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array) => U, initialValue: U): U;
-
-    /**
-     * Reverses the elements in an Array.
-     */
-    reverse(): Uint8Array;
-
-    /**
-     * Sets a value or an array of values.
-     * @param array A typed or untyped array of values to set.
-     * @param offset The index in the current array at which the values are to be written.
-     */
-    set(array: ArrayLike<number>, offset?: number): void;
-
-    /**
-     * Returns a section of an array.
-     * @param start The beginning of the specified portion of the array.
-     * @param end The end of the specified portion of the array.
-     */
-    slice(start?: number, end?: number): Uint8Array;
-
-    /**
-     * Determines whether the specified callback function returns true for any element of an array.
-     * @param callbackfn A function that accepts up to three arguments. The some method calls the
-     * callbackfn function for each element in array1 until the callbackfn returns true, or until
-     * the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    some(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Uint8Array) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
-     */
-    sort(compareFn?: (a: number, b: number) => number): this;
-
-    /**
-     * Gets a new Uint8Array view of the ArrayBuffer store for this array, referencing the elements
-     * at begin, inclusive, up to end, exclusive.
-     * @param begin The index of the beginning of the array.
-     * @param end The index of the end of the array.
-     */
-    subarray(begin: number, end?: number): Uint8Array;
-
-    /**
-     * Converts a number to a string by using the current locale.
-     */
-    toLocaleString(): string;
-
-    /**
-     * Returns a string representation of an array.
-     */
-    toString(): string;
-
-    [index: number]: number;
-}
-
-interface Uint8ArrayConstructor {
-    readonly prototype: Uint8Array;
-    new (length: number): Uint8Array;
-    new (array: ArrayLike<number>): Uint8Array;
-    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint8Array;
-
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * Returns a new array from a set of elements.
-     * @param items A set of elements to include in the new array object.
-     */
-    of(...items: number[]): Uint8Array;
-
-    /**
-     * Creates an array from an array-like or iterable object.
-     * @param arrayLike An array-like or iterable object to convert to an array.
-     * @param mapfn A mapping function to call on every element of the array.
-     * @param thisArg Value of 'this' used to invoke the mapfn.
-     */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array;
-    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array;
-
-    from(arrayLike: ArrayLike<number>): Uint8Array;
-
-}
-declare const Uint8Array: Uint8ArrayConstructor;
-
-/**
- * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0.
- * If the requested number of bytes could not be allocated an exception is raised.
- */
-interface Uint8ClampedArray {
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * The ArrayBuffer instance referenced by the array.
-     */
-    readonly buffer: ArrayBuffer;
-
-    /**
-     * The length in bytes of the array.
-     */
-    readonly byteLength: number;
-
-    /**
-     * The offset in bytes of the array.
-     */
-    readonly byteOffset: number;
-
-    /**
-     * Returns the this object after copying a section of the array identified by start and end
-     * to the same array starting at position target
-     * @param target If target is negative, it is treated as length+target where length is the
-     * length of the array.
-     * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end.
-     * @param end If not specified, length of the this object is used as its default value.
-     */
-    copyWithin(target: number, start: number, end?: number): this;
-
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in array1 until the callbackfn returns false,
-     * or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    every(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Returns the this object after filling the section identified by start and end with value
-     * @param value value to fill array section with
-     * @param start index to start filling the array at. If start is negative, it is treated as
-     * length+start where length is the length of the array.
-     * @param end index to stop filling the array at. If end is negative, it is treated as
-     * length+end.
-     */
-    fill(value: number, start?: number, end?: number): this;
-
-    /**
-     * Returns the elements of an array that meet the condition specified in a callback function.
-     * @param callbackfn A function that accepts up to three arguments. The filter method calls
-     * the callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    filter(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => any): Uint8ClampedArray;
-    filter(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => any, thisArg: undefined): Uint8ClampedArray;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => any, thisArg: Z): Uint8ClampedArray;
-
-    /**
-     * Returns the value of the first element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found, find
-     * immediately returns that element value. Otherwise, find returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
-
-    /**
-     * Returns the index of the first element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
-
-    /**
-     * Performs the specified action for each element in an array.
-     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => void, thisArg: Z): void;
-
-    /**
-     * Returns the index of the first occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     *  search starts at index 0.
-     */
-    indexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * Adds all the elements of an array separated by the specified separator string.
-     * @param separator A string used to separate one element of an array from the next in the
-     * resulting String. If omitted, the array elements are separated with a comma.
-     */
-    join(separator?: string): string;
-
-    /**
-     * Returns the index of the last occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     * search starts at index 0.
-     */
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * The length of the array.
-     */
-    readonly length: number;
-
-    /**
-     * Calls a defined callback function on each element of an array, and returns an array that
-     * contains the results.
-     * @param callbackfn A function that accepts up to three arguments. The map method calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    map(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => number): Uint8ClampedArray;
-    map(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: undefined): Uint8ClampedArray;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => number, thisArg: Z): Uint8ClampedArray;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U, initialValue: U): U;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an
-     * argument instead of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => U, initialValue: U): U;
-
-    /**
-     * Reverses the elements in an Array.
-     */
-    reverse(): Uint8ClampedArray;
-
-    /**
-     * Sets a value or an array of values.
-     * @param array A typed or untyped array of values to set.
-     * @param offset The index in the current array at which the values are to be written.
-     */
-    set(array: ArrayLike<number>, offset?: number): void;
-
-    /**
-     * Returns a section of an array.
-     * @param start The beginning of the specified portion of the array.
-     * @param end The end of the specified portion of the array.
-     */
-    slice(start?: number, end?: number): Uint8ClampedArray;
-
-    /**
-     * Determines whether the specified callback function returns true for any element of an array.
-     * @param callbackfn A function that accepts up to three arguments. The some method calls the
-     * callbackfn function for each element in array1 until the callbackfn returns true, or until
-     * the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    some(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint8ClampedArray) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
-     */
-    sort(compareFn?: (a: number, b: number) => number): this;
-
-    /**
-     * Gets a new Uint8ClampedArray view of the ArrayBuffer store for this array, referencing the elements
-     * at begin, inclusive, up to end, exclusive.
-     * @param begin The index of the beginning of the array.
-     * @param end The index of the end of the array.
-     */
-    subarray(begin: number, end?: number): Uint8ClampedArray;
-
-    /**
-     * Converts a number to a string by using the current locale.
-     */
-    toLocaleString(): string;
-
-    /**
-     * Returns a string representation of an array.
-     */
-    toString(): string;
-
-    [index: number]: number;
-}
-
-interface Uint8ClampedArrayConstructor {
-    readonly prototype: Uint8ClampedArray;
-    new (length: number): Uint8ClampedArray;
-    new (array: ArrayLike<number>): Uint8ClampedArray;
-    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint8ClampedArray;
-
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * Returns a new array from a set of elements.
-     * @param items A set of elements to include in the new array object.
-     */
-    of(...items: number[]): Uint8ClampedArray;
-
-    /**
-     * Creates an array from an array-like or iterable object.
-     * @param arrayLike An array-like or iterable object to convert to an array.
-     * @param mapfn A mapping function to call on every element of the array.
-     * @param thisArg Value of 'this' used to invoke the mapfn.
-     */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray;
-    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray;
-
-    from(arrayLike: ArrayLike<number>): Uint8ClampedArray;
-}
-declare const Uint8ClampedArray: Uint8ClampedArrayConstructor;
-
-/**
- * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Int16Array {
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * The ArrayBuffer instance referenced by the array.
-     */
-    readonly buffer: ArrayBuffer;
-
-    /**
-     * The length in bytes of the array.
-     */
-    readonly byteLength: number;
-
-    /**
-     * The offset in bytes of the array.
-     */
-    readonly byteOffset: number;
-
-    /**
-     * Returns the this object after copying a section of the array identified by start and end
-     * to the same array starting at position target
-     * @param target If target is negative, it is treated as length+target where length is the
-     * length of the array.
-     * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end.
-     * @param end If not specified, length of the this object is used as its default value.
-     */
-    copyWithin(target: number, start: number, end?: number): this;
-
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in array1 until the callbackfn returns false,
-     * or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    every(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Returns the this object after filling the section identified by start and end with value
-     * @param value value to fill array section with
-     * @param start index to start filling the array at. If start is negative, it is treated as
-     * length+start where length is the length of the array.
-     * @param end index to stop filling the array at. If end is negative, it is treated as
-     * length+end.
-     */
-    fill(value: number, start?: number, end?: number): this;
-
-    /**
-     * Returns the elements of an array that meet the condition specified in a callback function.
-     * @param callbackfn A function that accepts up to three arguments. The filter method calls
-     * the callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    filter(callbackfn: (this: void, value: number, index: number, array: Int16Array) => any): Int16Array;
-    filter(callbackfn: (this: void, value: number, index: number, array: Int16Array) => any, thisArg: undefined): Int16Array;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => any, thisArg: Z): Int16Array;
-
-    /**
-     * Returns the value of the first element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found, find
-     * immediately returns that element value. Otherwise, find returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
-
-    /**
-     * Returns the index of the first element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
-
-    /**
-     * Performs the specified action for each element in an array.
-     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Int16Array) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Int16Array) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => void, thisArg: Z): void;
-
-    /**
-     * Returns the index of the first occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     *  search starts at index 0.
-     */
-    indexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * Adds all the elements of an array separated by the specified separator string.
-     * @param separator A string used to separate one element of an array from the next in the
-     * resulting String. If omitted, the array elements are separated with a comma.
-     */
-    join(separator?: string): string;
-
-    /**
-     * Returns the index of the last occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     * search starts at index 0.
-     */
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * The length of the array.
-     */
-    readonly length: number;
-
-    /**
-     * Calls a defined callback function on each element of an array, and returns an array that
-     * contains the results.
-     * @param callbackfn A function that accepts up to three arguments. The map method calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    map(callbackfn: (this: void, value: number, index: number, array: Int16Array) => number): Int16Array;
-    map(callbackfn: (this: void, value: number, index: number, array: Int16Array) => number, thisArg: undefined): Int16Array;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => number, thisArg: Z): Int16Array;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U, initialValue: U): U;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an
-     * argument instead of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int16Array) => U, initialValue: U): U;
-
-    /**
-     * Reverses the elements in an Array.
-     */
-    reverse(): Int16Array;
-
-    /**
-     * Sets a value or an array of values.
-     * @param array A typed or untyped array of values to set.
-     * @param offset The index in the current array at which the values are to be written.
-     */
-    set(array: ArrayLike<number>, offset?: number): void;
-
-    /**
-     * Returns a section of an array.
-     * @param start The beginning of the specified portion of the array.
-     * @param end The end of the specified portion of the array.
-     */
-    slice(start?: number, end?: number): Int16Array;
-
-    /**
-     * Determines whether the specified callback function returns true for any element of an array.
-     * @param callbackfn A function that accepts up to three arguments. The some method calls the
-     * callbackfn function for each element in array1 until the callbackfn returns true, or until
-     * the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    some(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Int16Array) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Int16Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
-     */
-    sort(compareFn?: (a: number, b: number) => number): this;
-
-    /**
-     * Gets a new Int16Array view of the ArrayBuffer store for this array, referencing the elements
-     * at begin, inclusive, up to end, exclusive.
-     * @param begin The index of the beginning of the array.
-     * @param end The index of the end of the array.
-     */
-    subarray(begin: number, end?: number): Int16Array;
-
-    /**
-     * Converts a number to a string by using the current locale.
-     */
-    toLocaleString(): string;
-
-    /**
-     * Returns a string representation of an array.
-     */
-    toString(): string;
-
-    [index: number]: number;
-}
-
-interface Int16ArrayConstructor {
-    readonly prototype: Int16Array;
-    new (length: number): Int16Array;
-    new (array: ArrayLike<number>): Int16Array;
-    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int16Array;
-
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * Returns a new array from a set of elements.
-     * @param items A set of elements to include in the new array object.
-     */
-    of(...items: number[]): Int16Array;
-
-    /**
-     * Creates an array from an array-like or iterable object.
-     * @param arrayLike An array-like or iterable object to convert to an array.
-     * @param mapfn A mapping function to call on every element of the array.
-     * @param thisArg Value of 'this' used to invoke the mapfn.
-     */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array;
-    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array;
-
-    from(arrayLike: ArrayLike<number>): Int16Array;
-
-}
-declare const Int16Array: Int16ArrayConstructor;
-
-/**
- * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Uint16Array {
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * The ArrayBuffer instance referenced by the array.
-     */
-    readonly buffer: ArrayBuffer;
-
-    /**
-     * The length in bytes of the array.
-     */
-    readonly byteLength: number;
-
-    /**
-     * The offset in bytes of the array.
-     */
-    readonly byteOffset: number;
-
-    /**
-     * Returns the this object after copying a section of the array identified by start and end
-     * to the same array starting at position target
-     * @param target If target is negative, it is treated as length+target where length is the
-     * length of the array.
-     * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end.
-     * @param end If not specified, length of the this object is used as its default value.
-     */
-    copyWithin(target: number, start: number, end?: number): this;
-
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in array1 until the callbackfn returns false,
-     * or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    every(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Returns the this object after filling the section identified by start and end with value
-     * @param value value to fill array section with
-     * @param start index to start filling the array at. If start is negative, it is treated as
-     * length+start where length is the length of the array.
-     * @param end index to stop filling the array at. If end is negative, it is treated as
-     * length+end.
-     */
-    fill(value: number, start?: number, end?: number): this;
-
-    /**
-     * Returns the elements of an array that meet the condition specified in a callback function.
-     * @param callbackfn A function that accepts up to three arguments. The filter method calls
-     * the callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    filter(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => any): Uint16Array;
-    filter(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => any, thisArg: undefined): Uint16Array;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => any, thisArg: Z): Uint16Array;
-
-    /**
-     * Returns the value of the first element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found, find
-     * immediately returns that element value. Otherwise, find returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
-
-    /**
-     * Returns the index of the first element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
-
-    /**
-     * Performs the specified action for each element in an array.
-     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => void, thisArg: Z): void;
-
-    /**
-     * Returns the index of the first occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     *  search starts at index 0.
-     */
-    indexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * Adds all the elements of an array separated by the specified separator string.
-     * @param separator A string used to separate one element of an array from the next in the
-     * resulting String. If omitted, the array elements are separated with a comma.
-     */
-    join(separator?: string): string;
-
-    /**
-     * Returns the index of the last occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     * search starts at index 0.
-     */
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * The length of the array.
-     */
-    readonly length: number;
-
-    /**
-     * Calls a defined callback function on each element of an array, and returns an array that
-     * contains the results.
-     * @param callbackfn A function that accepts up to three arguments. The map method calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    map(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => number): Uint16Array;
-    map(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => number, thisArg: undefined): Uint16Array;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => number, thisArg: Z): Uint16Array;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U, initialValue: U): U;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an
-     * argument instead of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint16Array) => U, initialValue: U): U;
-
-    /**
-     * Reverses the elements in an Array.
-     */
-    reverse(): Uint16Array;
-
-    /**
-     * Sets a value or an array of values.
-     * @param array A typed or untyped array of values to set.
-     * @param offset The index in the current array at which the values are to be written.
-     */
-    set(array: ArrayLike<number>, offset?: number): void;
-
-    /**
-     * Returns a section of an array.
-     * @param start The beginning of the specified portion of the array.
-     * @param end The end of the specified portion of the array.
-     */
-    slice(start?: number, end?: number): Uint16Array;
-
-    /**
-     * Determines whether the specified callback function returns true for any element of an array.
-     * @param callbackfn A function that accepts up to three arguments. The some method calls the
-     * callbackfn function for each element in array1 until the callbackfn returns true, or until
-     * the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    some(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Uint16Array) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint16Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
-     */
-    sort(compareFn?: (a: number, b: number) => number): this;
-
-    /**
-     * Gets a new Uint16Array view of the ArrayBuffer store for this array, referencing the elements
-     * at begin, inclusive, up to end, exclusive.
-     * @param begin The index of the beginning of the array.
-     * @param end The index of the end of the array.
-     */
-    subarray(begin: number, end?: number): Uint16Array;
-
-    /**
-     * Converts a number to a string by using the current locale.
-     */
-    toLocaleString(): string;
-
-    /**
-     * Returns a string representation of an array.
-     */
-    toString(): string;
-
-    [index: number]: number;
-}
-
-interface Uint16ArrayConstructor {
-    readonly prototype: Uint16Array;
-    new (length: number): Uint16Array;
-    new (array: ArrayLike<number>): Uint16Array;
-    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint16Array;
-
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * Returns a new array from a set of elements.
-     * @param items A set of elements to include in the new array object.
-     */
-    of(...items: number[]): Uint16Array;
-
-    /**
-     * Creates an array from an array-like or iterable object.
-     * @param arrayLike An array-like or iterable object to convert to an array.
-     * @param mapfn A mapping function to call on every element of the array.
-     * @param thisArg Value of 'this' used to invoke the mapfn.
-     */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array;
-    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array;
-
-    from(arrayLike: ArrayLike<number>): Uint16Array;
-
-}
-declare const Uint16Array: Uint16ArrayConstructor;
-/**
- * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Int32Array {
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * The ArrayBuffer instance referenced by the array.
-     */
-    readonly buffer: ArrayBuffer;
-
-    /**
-     * The length in bytes of the array.
-     */
-    readonly byteLength: number;
-
-    /**
-     * The offset in bytes of the array.
-     */
-    readonly byteOffset: number;
-
-    /**
-     * Returns the this object after copying a section of the array identified by start and end
-     * to the same array starting at position target
-     * @param target If target is negative, it is treated as length+target where length is the
-     * length of the array.
-     * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end.
-     * @param end If not specified, length of the this object is used as its default value.
-     */
-    copyWithin(target: number, start: number, end?: number): this;
-
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in array1 until the callbackfn returns false,
-     * or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    every(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Returns the this object after filling the section identified by start and end with value
-     * @param value value to fill array section with
-     * @param start index to start filling the array at. If start is negative, it is treated as
-     * length+start where length is the length of the array.
-     * @param end index to stop filling the array at. If end is negative, it is treated as
-     * length+end.
-     */
-    fill(value: number, start?: number, end?: number): this;
-
-    /**
-     * Returns the elements of an array that meet the condition specified in a callback function.
-     * @param callbackfn A function that accepts up to three arguments. The filter method calls
-     * the callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    filter(callbackfn: (this: void, value: number, index: number, array: Int32Array) => any): Int32Array;
-    filter(callbackfn: (this: void, value: number, index: number, array: Int32Array) => any, thisArg: undefined): Int32Array;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => any, thisArg: Z): Int32Array;
-
-    /**
-     * Returns the value of the first element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found, find
-     * immediately returns that element value. Otherwise, find returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
-
-    /**
-     * Returns the index of the first element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
-
-    /**
-     * Performs the specified action for each element in an array.
-     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Int32Array) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Int32Array) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => void, thisArg: Z): void;
-
-    /**
-     * Returns the index of the first occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     *  search starts at index 0.
-     */
-    indexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * Adds all the elements of an array separated by the specified separator string.
-     * @param separator A string used to separate one element of an array from the next in the
-     * resulting String. If omitted, the array elements are separated with a comma.
-     */
-    join(separator?: string): string;
-
-    /**
-     * Returns the index of the last occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     * search starts at index 0.
-     */
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * The length of the array.
-     */
-    readonly length: number;
-
-    /**
-     * Calls a defined callback function on each element of an array, and returns an array that
-     * contains the results.
-     * @param callbackfn A function that accepts up to three arguments. The map method calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    map(callbackfn: (this: void, value: number, index: number, array: Int32Array) => number): Int32Array;
-    map(callbackfn: (this: void, value: number, index: number, array: Int32Array) => number, thisArg: undefined): Int32Array;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => number, thisArg: Z): Int32Array;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U, initialValue: U): U;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an
-     * argument instead of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Int32Array) => U, initialValue: U): U;
-
-    /**
-     * Reverses the elements in an Array.
-     */
-    reverse(): Int32Array;
-
-    /**
-     * Sets a value or an array of values.
-     * @param array A typed or untyped array of values to set.
-     * @param offset The index in the current array at which the values are to be written.
-     */
-    set(array: ArrayLike<number>, offset?: number): void;
-
-    /**
-     * Returns a section of an array.
-     * @param start The beginning of the specified portion of the array.
-     * @param end The end of the specified portion of the array.
-     */
-    slice(start?: number, end?: number): Int32Array;
-
-    /**
-     * Determines whether the specified callback function returns true for any element of an array.
-     * @param callbackfn A function that accepts up to three arguments. The some method calls the
-     * callbackfn function for each element in array1 until the callbackfn returns true, or until
-     * the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    some(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Int32Array) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Int32Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
-     */
-    sort(compareFn?: (a: number, b: number) => number): this;
-
-    /**
-     * Gets a new Int32Array view of the ArrayBuffer store for this array, referencing the elements
-     * at begin, inclusive, up to end, exclusive.
-     * @param begin The index of the beginning of the array.
-     * @param end The index of the end of the array.
-     */
-    subarray(begin: number, end?: number): Int32Array;
-
-    /**
-     * Converts a number to a string by using the current locale.
-     */
-    toLocaleString(): string;
-
-    /**
-     * Returns a string representation of an array.
-     */
-    toString(): string;
-
-    [index: number]: number;
-}
-
-interface Int32ArrayConstructor {
-    readonly prototype: Int32Array;
-    new (length: number): Int32Array;
-    new (array: ArrayLike<number>): Int32Array;
-    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int32Array;
-
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * Returns a new array from a set of elements.
-     * @param items A set of elements to include in the new array object.
-     */
-    of(...items: number[]): Int32Array;
-
-    /**
-     * Creates an array from an array-like or iterable object.
-     * @param arrayLike An array-like or iterable object to convert to an array.
-     * @param mapfn A mapping function to call on every element of the array.
-     * @param thisArg Value of 'this' used to invoke the mapfn.
-     */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array;
-    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array;
-
-    from(arrayLike: ArrayLike<number>): Int32Array;
-}
-declare const Int32Array: Int32ArrayConstructor;
-
-/**
- * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the
- * requested number of bytes could not be allocated an exception is raised.
- */
-interface Uint32Array {
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * The ArrayBuffer instance referenced by the array.
-     */
-    readonly buffer: ArrayBuffer;
-
-    /**
-     * The length in bytes of the array.
-     */
-    readonly byteLength: number;
-
-    /**
-     * The offset in bytes of the array.
-     */
-    readonly byteOffset: number;
-
-    /**
-     * Returns the this object after copying a section of the array identified by start and end
-     * to the same array starting at position target
-     * @param target If target is negative, it is treated as length+target where length is the
-     * length of the array.
-     * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end.
-     * @param end If not specified, length of the this object is used as its default value.
-     */
-    copyWithin(target: number, start: number, end?: number): this;
-
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in array1 until the callbackfn returns false,
-     * or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    every(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Returns the this object after filling the section identified by start and end with value
-     * @param value value to fill array section with
-     * @param start index to start filling the array at. If start is negative, it is treated as
-     * length+start where length is the length of the array.
-     * @param end index to stop filling the array at. If end is negative, it is treated as
-     * length+end.
-     */
-    fill(value: number, start?: number, end?: number): this;
-
-    /**
-     * Returns the elements of an array that meet the condition specified in a callback function.
-     * @param callbackfn A function that accepts up to three arguments. The filter method calls
-     * the callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    filter(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => any): Uint32Array;
-    filter(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => any, thisArg: undefined): Uint32Array;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => any, thisArg: Z): Uint32Array;
-
-    /**
-     * Returns the value of the first element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found, find
-     * immediately returns that element value. Otherwise, find returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
-
-    /**
-     * Returns the index of the first element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
-
-    /**
-     * Performs the specified action for each element in an array.
-     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => void, thisArg: Z): void;
-
-    /**
-     * Returns the index of the first occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     *  search starts at index 0.
-     */
-    indexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * Adds all the elements of an array separated by the specified separator string.
-     * @param separator A string used to separate one element of an array from the next in the
-     * resulting String. If omitted, the array elements are separated with a comma.
-     */
-    join(separator?: string): string;
-
-    /**
-     * Returns the index of the last occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     * search starts at index 0.
-     */
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * The length of the array.
-     */
-    readonly length: number;
-
-    /**
-     * Calls a defined callback function on each element of an array, and returns an array that
-     * contains the results.
-     * @param callbackfn A function that accepts up to three arguments. The map method calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    map(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => number): Uint32Array;
-    map(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => number, thisArg: undefined): Uint32Array;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => number, thisArg: Z): Uint32Array;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U, initialValue: U): U;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an
-     * argument instead of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint32Array) => U, initialValue: U): U;
-
-    /**
-     * Reverses the elements in an Array.
-     */
-    reverse(): Uint32Array;
-
-    /**
-     * Sets a value or an array of values.
-     * @param array A typed or untyped array of values to set.
-     * @param offset The index in the current array at which the values are to be written.
-     */
-    set(array: ArrayLike<number>, offset?: number): void;
-
-    /**
-     * Returns a section of an array.
-     * @param start The beginning of the specified portion of the array.
-     * @param end The end of the specified portion of the array.
-     */
-    slice(start?: number, end?: number): Uint32Array;
-
-    /**
-     * Determines whether the specified callback function returns true for any element of an array.
-     * @param callbackfn A function that accepts up to three arguments. The some method calls the
-     * callbackfn function for each element in array1 until the callbackfn returns true, or until
-     * the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    some(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Uint32Array) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Uint32Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
-     */
-    sort(compareFn?: (a: number, b: number) => number): this;
-
-    /**
-     * Gets a new Uint32Array view of the ArrayBuffer store for this array, referencing the elements
-     * at begin, inclusive, up to end, exclusive.
-     * @param begin The index of the beginning of the array.
-     * @param end The index of the end of the array.
-     */
-    subarray(begin: number, end?: number): Uint32Array;
-
-    /**
-     * Converts a number to a string by using the current locale.
-     */
-    toLocaleString(): string;
-
-    /**
-     * Returns a string representation of an array.
-     */
-    toString(): string;
-
-    [index: number]: number;
-}
-
-interface Uint32ArrayConstructor {
-    readonly prototype: Uint32Array;
-    new (length: number): Uint32Array;
-    new (array: ArrayLike<number>): Uint32Array;
-    new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint32Array;
-
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * Returns a new array from a set of elements.
-     * @param items A set of elements to include in the new array object.
-     */
-    of(...items: number[]): Uint32Array;
-
-    /**
-     * Creates an array from an array-like or iterable object.
-     * @param arrayLike An array-like or iterable object to convert to an array.
-     * @param mapfn A mapping function to call on every element of the array.
-     * @param thisArg Value of 'this' used to invoke the mapfn.
-     */
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array;
-    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array;
-    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array;
-
-    from(arrayLike: ArrayLike<number>): Uint32Array;
-}
-declare const Uint32Array: Uint32ArrayConstructor;
-
-/**
- * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number
- * of bytes could not be allocated an exception is raised.
- */
-interface Float32Array {
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * The ArrayBuffer instance referenced by the array.
-     */
-    readonly buffer: ArrayBuffer;
-
-    /**
-     * The length in bytes of the array.
-     */
-    readonly byteLength: number;
-
-    /**
-     * The offset in bytes of the array.
-     */
-    readonly byteOffset: number;
-
-    /**
-     * Returns the this object after copying a section of the array identified by start and end
-     * to the same array starting at position target
-     * @param target If target is negative, it is treated as length+target where length is the
-     * length of the array.
-     * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end.
-     * @param end If not specified, length of the this object is used as its default value.
-     */
-    copyWithin(target: number, start: number, end?: number): this;
-
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in array1 until the callbackfn returns false,
-     * or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    every(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Returns the this object after filling the section identified by start and end with value
-     * @param value value to fill array section with
-     * @param start index to start filling the array at. If start is negative, it is treated as
-     * length+start where length is the length of the array.
-     * @param end index to stop filling the array at. If end is negative, it is treated as
-     * length+end.
-     */
-    fill(value: number, start?: number, end?: number): this;
-
-    /**
-     * Returns the elements of an array that meet the condition specified in a callback function.
-     * @param callbackfn A function that accepts up to three arguments. The filter method calls
-     * the callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    filter(callbackfn: (this: void, value: number, index: number, array: Float32Array) => any): Float32Array;
-    filter(callbackfn: (this: void, value: number, index: number, array: Float32Array) => any, thisArg: undefined): Float32Array;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => any, thisArg: Z): Float32Array;
-
-    /**
-     * Returns the value of the first element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found, find
-     * immediately returns that element value. Otherwise, find returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
-
-    /**
-     * Returns the index of the first element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
-
-    /**
-     * Performs the specified action for each element in an array.
-     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Float32Array) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Float32Array) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => void, thisArg: Z): void;
-
-    /**
-     * Returns the index of the first occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     *  search starts at index 0.
-     */
-    indexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * Adds all the elements of an array separated by the specified separator string.
-     * @param separator A string used to separate one element of an array from the next in the
-     * resulting String. If omitted, the array elements are separated with a comma.
-     */
-    join(separator?: string): string;
-
-    /**
-     * Returns the index of the last occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     * search starts at index 0.
-     */
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * The length of the array.
-     */
-    readonly length: number;
-
-    /**
-     * Calls a defined callback function on each element of an array, and returns an array that
-     * contains the results.
-     * @param callbackfn A function that accepts up to three arguments. The map method calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    map(callbackfn: (this: void, value: number, index: number, array: Float32Array) => number): Float32Array;
-    map(callbackfn: (this: void, value: number, index: number, array: Float32Array) => number, thisArg: undefined): Float32Array;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => number, thisArg: Z): Float32Array;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an
-     * argument instead of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float32Array) => U, initialValue: U): U;
-
-    /**
-     * Reverses the elements in an Array.
-     */
-    reverse(): Float32Array;
-
-    /**
-     * Sets a value or an array of values.
-     * @param array A typed or untyped array of values to set.
-     * @param offset The index in the current array at which the values are to be written.
-     */
-    set(array: ArrayLike<number>, offset?: number): void;
-
-    /**
-     * Returns a section of an array.
-     * @param start The beginning of the specified portion of the array.
-     * @param end The end of the specified portion of the array.
-     */
-    slice(start?: number, end?: number): Float32Array;
-
-    /**
-     * Determines whether the specified callback function returns true for any element of an array.
-     * @param callbackfn A function that accepts up to three arguments. The some method calls the
-     * callbackfn function for each element in array1 until the callbackfn returns true, or until
-     * the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    some(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Float32Array) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Float32Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
-     */
-    sort(compareFn?: (a: number, b: number) => number): this;
-
-    /**
-     * Gets a new Float32Array view of the ArrayBuffer store for this array, referencing the elements
-     * at begin, inclusive, up to end, exclusive.
-     * @param begin The index of the beginning of the array.
-     * @param end The index of the end of the array.
-     */
-    subarray(begin: number, end?: number): Float32Array;
-
-    /**
-     * Converts a number to a string by using the current locale.
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    toLocaleString(): string;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array;
+    from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array;
+    from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array;
+    from(arrayLike: ArrayLike<number>): Uint32Array;
+}
 
-    /**
-     * Returns a string representation of an array.
-     */
-    toString(): string;
+declare const Uint32Array: Uint32ArrayConstructor;
 
-    [index: number]: number;
+/**
+ * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number
+ * of bytes could not be allocated an exception is raised.
+ */
+interface Float32Array extends TypedArray {
 }
 
 interface Float32ArrayConstructor {
-    readonly prototype: Float32Array;
     new (length: number): Float32Array;
     new (array: ArrayLike<number>): Float32Array;
     new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float32Array;
 
+    readonly prototype: Float32Array;
+
     /**
      * The size in bytes of each element in the array.
      */
@@ -3812,271 +2116,25 @@ interface Float32ArrayConstructor {
     from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array;
     from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array;
-
     from(arrayLike: ArrayLike<number>): Float32Array;
-
 }
+
 declare const Float32Array: Float32ArrayConstructor;
 
 /**
  * A typed array of 64-bit float values. The contents are initialized to 0. If the requested
  * number of bytes could not be allocated an exception is raised.
  */
-interface Float64Array {
-    /**
-     * The size in bytes of each element in the array.
-     */
-    readonly BYTES_PER_ELEMENT: number;
-
-    /**
-     * The ArrayBuffer instance referenced by the array.
-     */
-    readonly buffer: ArrayBuffer;
-
-    /**
-     * The length in bytes of the array.
-     */
-    readonly byteLength: number;
-
-    /**
-     * The offset in bytes of the array.
-     */
-    readonly byteOffset: number;
-
-    /**
-     * Returns the this object after copying a section of the array identified by start and end
-     * to the same array starting at position target
-     * @param target If target is negative, it is treated as length+target where length is the
-     * length of the array.
-     * @param start If start is negative, it is treated as length+start. If end is negative, it
-     * is treated as length+end.
-     * @param end If not specified, length of the this object is used as its default value.
-     */
-    copyWithin(target: number, start: number, end?: number): this;
-
-    /**
-     * Determines whether all the members of an array satisfy the specified test.
-     * @param callbackfn A function that accepts up to three arguments. The every method calls
-     * the callbackfn function for each element in array1 until the callbackfn returns false,
-     * or until the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    every(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean): boolean;
-    every(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean;
-    every<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Returns the this object after filling the section identified by start and end with value
-     * @param value value to fill array section with
-     * @param start index to start filling the array at. If start is negative, it is treated as
-     * length+start where length is the length of the array.
-     * @param end index to stop filling the array at. If end is negative, it is treated as
-     * length+end.
-     */
-    fill(value: number, start?: number, end?: number): this;
-
-    /**
-     * Returns the elements of an array that meet the condition specified in a callback function.
-     * @param callbackfn A function that accepts up to three arguments. The filter method calls
-     * the callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    filter(callbackfn: (this: void, value: number, index: number, array: Float64Array) => any): Float64Array;
-    filter(callbackfn: (this: void, value: number, index: number, array: Float64Array) => any, thisArg: undefined): Float64Array;
-    filter<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => any, thisArg: Z): Float64Array;
-
-    /**
-     * Returns the value of the first element in the array where predicate is true, and undefined
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found, find
-     * immediately returns that element value. Otherwise, find returns undefined.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number | undefined;
-    find(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number | undefined;
-    find<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number | undefined;
-
-    /**
-     * Returns the index of the first element in the array where predicate is true, and -1
-     * otherwise.
-     * @param predicate find calls predicate once for each element of the array, in ascending
-     * order, until it finds one where predicate returns true. If such an element is found,
-     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
-     * @param thisArg If provided, it will be used as the this value for each invocation of
-     * predicate. If it is not provided, undefined is used instead.
-     */
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean): number;
-    findIndex(predicate: (this: void, value: number, index: number, obj: Array<number>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: number, index: number, obj: Array<number>) => boolean, thisArg: Z): number;
-
-    /**
-     * Performs the specified action for each element in an array.
-     * @param callbackfn  A function that accepts up to three arguments. forEach calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg  An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    forEach(callbackfn: (this: void, value: number, index: number, array: Float64Array) => void): void;
-    forEach(callbackfn: (this: void, value: number, index: number, array: Float64Array) => void, thisArg: undefined): void;
-    forEach<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => void, thisArg: Z): void;
-
-    /**
-     * Returns the index of the first occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     *  search starts at index 0.
-     */
-    indexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * Adds all the elements of an array separated by the specified separator string.
-     * @param separator A string used to separate one element of an array from the next in the
-     * resulting String. If omitted, the array elements are separated with a comma.
-     */
-    join(separator?: string): string;
-
-    /**
-     * Returns the index of the last occurrence of a value in an array.
-     * @param searchElement The value to locate in the array.
-     * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the
-     * search starts at index 0.
-     */
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-
-    /**
-     * The length of the array.
-     */
-    readonly length: number;
-
-    /**
-     * Calls a defined callback function on each element of an array, and returns an array that
-     * contains the results.
-     * @param callbackfn A function that accepts up to three arguments. The map method calls the
-     * callbackfn function one time for each element in the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    map(callbackfn: (this: void, value: number, index: number, array: Float64Array) => number): Float64Array;
-    map(callbackfn: (this: void, value: number, index: number, array: Float64Array) => number, thisArg: undefined): Float64Array;
-    map<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => number, thisArg: Z): Float64Array;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array. The return value of
-     * the callback function is the accumulated result, and is provided as an argument in the next
-     * call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduce method calls the
-     * callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an
-     * argument instead of an array value.
-     */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue?: number): number;
-
-    /**
-     * Calls the specified callback function for all the elements in an array, in descending order.
-     * The return value of the callback function is the accumulated result, and is provided as an
-     * argument in the next call to the callback function.
-     * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls
-     * the callbackfn function one time for each element in the array.
-     * @param initialValue If initialValue is specified, it is used as the initial value to start
-     * the accumulation. The first call to the callbackfn function provides this value as an argument
-     * instead of an array value.
-     */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float64Array) => U, initialValue: U): U;
-
-    /**
-     * Reverses the elements in an Array.
-     */
-    reverse(): Float64Array;
-
-    /**
-     * Sets a value or an array of values.
-     * @param array A typed or untyped array of values to set.
-     * @param offset The index in the current array at which the values are to be written.
-     */
-    set(array: ArrayLike<number>, offset?: number): void;
-
-    /**
-     * Returns a section of an array.
-     * @param start The beginning of the specified portion of the array.
-     * @param end The end of the specified portion of the array.
-     */
-    slice(start?: number, end?: number): Float64Array;
-
-    /**
-     * Determines whether the specified callback function returns true for any element of an array.
-     * @param callbackfn A function that accepts up to three arguments. The some method calls the
-     * callbackfn function for each element in array1 until the callbackfn returns true, or until
-     * the end of the array.
-     * @param thisArg An object to which the this keyword can refer in the callbackfn function.
-     * If thisArg is omitted, undefined is used as the this value.
-     */
-    some(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean): boolean;
-    some(callbackfn: (this: void, value: number, index: number, array: Float64Array) => boolean, thisArg: undefined): boolean;
-    some<Z>(callbackfn: (this: Z, value: number, index: number, array: Float64Array) => boolean, thisArg: Z): boolean;
-
-    /**
-     * Sorts an array.
-     * @param compareFn The name of the function used to determine the order of the elements. If
-     * omitted, the elements are sorted in ascending, ASCII character order.
-     */
-    sort(compareFn?: (a: number, b: number) => number): this;
-
-    /**
-     * Gets a new Float64Array view of the ArrayBuffer store for this array, referencing the elements
-     * at begin, inclusive, up to end, exclusive.
-     * @param begin The index of the beginning of the array.
-     * @param end The index of the end of the array.
-     */
-    subarray(begin: number, end?: number): Float64Array;
-
-    /**
-     * Converts a number to a string by using the current locale.
-     */
-    toLocaleString(): string;
-
-    /**
-     * Returns a string representation of an array.
-     */
-    toString(): string;
-
-    [index: number]: number;
+interface Float64Array extends TypedArray {
 }
 
 interface Float64ArrayConstructor {
-    readonly prototype: Float64Array;
     new (length: number): Float64Array;
     new (array: ArrayLike<number>): Float64Array;
     new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float64Array;
 
+    readonly prototype: Float64Array;
+
     /**
      * The size in bytes of each element in the array.
      */
@@ -4097,9 +2155,9 @@ interface Float64ArrayConstructor {
     from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array;
     from(arrayLike: ArrayLike<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array;
     from<Z>(arrayLike: ArrayLike<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array;
-
     from(arrayLike: ArrayLike<number>): Float64Array;
 }
+
 declare const Float64Array: Float64ArrayConstructor;
 
 /////////////////////////////