Follow up on #16223 cleaning up Array declarations (#18116)

* Follow up on #16223, Remove generic signatures from Array, ReadOnlyArray and TypedArrays

* Remove test

* Accept baselines

* Remove invalid `this: void` in callbacks

* accept baselines

src/lib/es2015.core.d.ts

@@ -10,9 +10,7 @@ interface Array<T> {
      * @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: T, index: number, obj: Array<T>) => boolean): T | undefined;
-    find(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): T | undefined;
-    find<Z>(predicate: (this: Z, value: T, index: number, obj: Array<T>) => boolean, thisArg: Z): T | undefined;
+    find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T | undefined;
 
     /**
      * Returns the index of the first element in the array where predicate is true, and -1
@@ -23,9 +21,7 @@ interface Array<T> {
      * @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: T, index: number, obj: Array<T>) => boolean): number;
-    findIndex(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: T, index: number, obj: Array<T>) => boolean, thisArg: Z): number;
+    findIndex(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): number;
 
     /**
      * Returns the this object after filling the section identified by start and end with value
@@ -56,16 +52,7 @@ interface ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): Array<U>;
-    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): Array<U>;
-    from<Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): Array<U>;
-
-
-    /**
-     * Creates an array from an array-like object.
-     * @param arrayLike An array-like object to convert to an array.
-     */
-    from<T>(arrayLike: ArrayLike<T>): Array<T>;
+    from<T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): Array<U>;
 
     /**
      * Returns a new array from a set of elements.
@@ -363,9 +350,7 @@ interface ReadonlyArray<T> {
      * @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: T, index: number, obj: ReadonlyArray<T>) => boolean): T | undefined;
-    find(predicate: (this: void, value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg: undefined): T | undefined;
-    find<Z>(predicate: (this: Z, value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg: Z): T | undefined;
+    find(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg?: any): T | undefined;
 
     /**
      * Returns the index of the first element in the array where predicate is true, and -1
@@ -376,9 +361,7 @@ interface ReadonlyArray<T> {
      * @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: T, index: number, obj: Array<T>) => boolean): number;
-    findIndex(predicate: (this: void, value: T, index: number, obj: Array<T>) => boolean, thisArg: undefined): number;
-    findIndex<Z>(predicate: (this: Z, value: T, index: number, obj: Array<T>) => boolean, thisArg: Z): number;
+    findIndex(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg?: any): number;
 }
 
 interface RegExp {

src/lib/es2015.iterable.d.ts

@@ -54,15 +54,7 @@ interface ArrayConstructor {
      * @param mapfn A mapping function to call on every element of the array.
      * @param thisArg Value of 'this' used to invoke the mapfn.
      */
-    from<T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): Array<U>;
-    from<T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): Array<U>;
-    from<Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): Array<U>;
-
-    /**
-     * Creates an array from an iterable object.
-     * @param iterable An iterable object to convert to an array.
-     */
-    from<T>(iterable: Iterable<T>): Array<T>;
+    from<T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): Array<U>;
 }
 
 interface ReadonlyArray<T> {
@@ -246,11 +238,7 @@ interface Int8ArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array;
 }
 
 /**
@@ -282,11 +270,7 @@ interface Uint8ArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array;
 }
 
 /**
@@ -321,11 +305,7 @@ interface Uint8ClampedArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray;
 }
 
 /**
@@ -359,11 +339,7 @@ interface Int16ArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array;
 }
 
 /**
@@ -395,11 +371,7 @@ interface Uint16ArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array;
 }
 
 /**
@@ -431,11 +403,7 @@ interface Int32ArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array;
 }
 
 /**
@@ -467,11 +435,7 @@ interface Uint32ArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array;
 }
 
 /**
@@ -503,11 +467,7 @@ interface Float32ArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array;
 }
 
 /**
@@ -539,9 +499,5 @@ interface Float64ArrayConstructor {
      * @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: 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;
+    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;
 }

src/lib/es5.d.ts

@@ -1635,7 +1635,7 @@ 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, thisArg?: any): Int8Array;
+    map(callbackfn: (value: number, index: number, array: Int8Array) => number, thisArg?: any): Int8Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -1902,7 +1902,7 @@ interface Uint8Array {
       * @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: Uint8Array) => number, thisArg?: any): Uint8Array;
+    map(callbackfn: (value: number, index: number, array: Uint8Array) => number, thisArg?: any): Uint8Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2169,7 +2169,7 @@ interface Uint8ClampedArray {
       * @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, thisArg?: any): Uint8ClampedArray;
+    map(callbackfn: (value: number, index: number, array: Uint8ClampedArray) => number, thisArg?: any): Uint8ClampedArray;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2366,7 +2366,7 @@ interface Int16Array {
       * @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, thisArg?: any): Int16Array;
+    filter(callbackfn: (value: number, index: number, array: Int16Array) => any, thisArg?: any): Int16Array;
 
     /**
       * Returns the value of the first element in the array where predicate is true, and undefined
@@ -2434,7 +2434,7 @@ interface Int16Array {
       * @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, thisArg?: any): Int16Array;
+    map(callbackfn: (value: number, index: number, array: Int16Array) => number, thisArg?: any): Int16Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2702,7 +2702,7 @@ interface Uint16Array {
       * @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, thisArg?: any): Uint16Array;
+    map(callbackfn: (value: number, index: number, array: Uint16Array) => number, thisArg?: any): Uint16Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3235,7 +3235,7 @@ interface Uint32Array {
       * @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, thisArg?: any): Uint32Array;
+    map(callbackfn: (value: number, index: number, array: Uint32Array) => number, thisArg?: any): Uint32Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3502,7 +3502,7 @@ interface Float32Array {
       * @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, thisArg?: any): Float32Array;
+    map(callbackfn: (value: number, index: number, array: Float32Array) => number, thisArg?: any): Float32Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3770,7 +3770,7 @@ interface Float64Array {
       * @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, thisArg?: any): Float64Array;
+    map(callbackfn: (value: number, index: number, array: Float64Array) => number, thisArg?: any): Float64Array;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of

tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols

@@ -7,9 +7,9 @@ function f(x: number, y: number, z: number) {
 >z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 1, 32))
 
     return Array.from(arguments);
->Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
->from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >arguments : Symbol(arguments)
 }
 

tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types

@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; }
 >Array : ArrayConstructor
->from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; }
 >arguments : IArguments
 }
 

tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols

@@ -7,9 +7,9 @@ function f(x: number, y: number, z: number) {
 >z : Symbol(z, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 1, 32))
 
     return Array.from(arguments);
->Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
->from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >arguments : Symbol(arguments)
 }
 

tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types

@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; }
 >Array : ArrayConstructor
->from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; }
 >arguments : IArguments
 }
 

tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols

@@ -7,9 +7,9 @@ function f(x: number, y: number, z: number) {
 >z : Symbol(z, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 1, 32))
 
     return Array.from(arguments);
->Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
->from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >arguments : Symbol(arguments)
 }
 

tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types

@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; }
 >Array : ArrayConstructor
->from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; }
 >arguments : IArguments
 }
 

tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.symbols

@@ -7,9 +7,9 @@ function f(x: number, y: number, z: number) {
 >z : Symbol(z, Decl(modularizeLibrary_TargetES6UsingES6Lib.ts, 1, 32))
 
     return Array.from(arguments);
->Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
->from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >arguments : Symbol(arguments)
 }
 

tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types

@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : { <T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; }
 >Array : ArrayConstructor
->from : { <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(iterable: Iterable<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(iterable: Iterable<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(iterable: Iterable<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : { <T, U = T>(iterable: Iterable<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any): U[]; }
 >arguments : IArguments
 }
 

tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.symbols

@@ -7,9 +7,9 @@ function f(x: number, y: number, z: number) {
 >z : Symbol(z, Decl(modularizeLibrary_UsingES5LibAndES6ArrayLib.ts, 1, 32))
 
     return Array.from(arguments);
->Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
->from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --))
 >arguments : Symbol(arguments)
 }
 

tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6ArrayLib.types

@@ -8,9 +8,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any) => U[]
 >Array : ArrayConstructor
->from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any) => U[]
 >arguments : IArguments
 }
 

tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.symbols

@@ -6,9 +6,9 @@ function f(x: number, y: number, z: number) {
 >z : Symbol(z, Decl(modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.ts, 0, 32))
 
     return Array.from(arguments);
->Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>Array.from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
->from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
+>from : Symbol(ArrayConstructor.from, Decl(lib.es2015.core.d.ts, --, --))
 >arguments : Symbol(arguments)
 }
 

tests/baselines/reference/modularizeLibrary_UsingES5LibES6ArrayLibES6WellknownSymbolLib.types

@@ -7,9 +7,9 @@ function f(x: number, y: number, z: number) {
 
     return Array.from(arguments);
 >Array.from(arguments) : any[]
->Array.from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>Array.from : <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any) => U[]
 >Array : ArrayConstructor
->from : { <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U): U[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (this: void, v: T, k: number) => U, thisArg: undefined): U[]; <Z, T, U>(arrayLike: ArrayLike<T>, mapfn: (this: Z, v: T, k: number) => U, thisArg: Z): U[]; <T>(arrayLike: ArrayLike<T>): T[]; }
+>from : <T, U = T>(arrayLike: ArrayLike<T>, mapfn?: (v: T, k: number) => U, thisArg?: any) => U[]
 >arguments : IArguments
 }
 

tests/baselines/reference/thisTypeInNativeThisAssignableMethods.js

@@ -1,709 +0,0 @@
-//// [thisTypeInNativeThisAssignableMethods.ts]
-class A {
-    options: string[];
-
-    addOptions(options: string[]) {
-        if (!this.options) {
-            this.options = [];
-        }
-        options.forEach(function (item) {
-            this.options.push(item);
-        }, this);
-        return this;
-    }
-
-    testUndefined(options: string[]) {
-        const undefinedArr: Array<undefined> = []
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }); // case1
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }, undefined); // case2
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }, null); // case3
-
-        const arrLike = {} as ArrayLike<number>
-        Array.from(arrLike, function (item) {
-            return this === undefined ? 2 : 1;
-        }, undefined)
-
-        const iterLike = [] as Iterable<number>
-        Array.from(iterLike, function (item) {
-            return this === undefined ? 2 : 1;
-        }, undefined)
-    }
-
-    test(options: string[]) {
-        const thisObject = {
-            options: [] as string[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        const arrLike = {} as ArrayLike<number>
-        Array.from(arrLike, function (item) {
-            return this.options[item].length
-        }, thisObject)
-
-        const iterLike = [] as Iterable<number>
-        Array.from(iterLike, function (item) {
-            return this.options[item].length
-        }, thisObject)
-    }
-
-    test1(options: string[]) {
-        const thisObject = {
-            options: [] as ReadonlyArray<string>
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test2(options: Int8Array[]) {
-        const thisObject = {
-            options: [] as Int8Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test3(options: Uint8Array[]) {
-        const thisObject = {
-            options: [] as Uint8Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test4(options: Float32Array[]) {
-        const thisObject = {
-            options: [] as Float32Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test5(options: Uint8ClampedArray[]) {
-        const thisObject = {
-            options: [] as Uint8ClampedArray[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test6(options: Int16Array[]) {
-        const thisObject = {
-            options: [] as Int16Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test7(options: Uint16Array[]) {
-        const thisObject = {
-            options: [] as Uint16Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test8(options: Uint32Array[]) {
-        const thisObject = {
-            options: [] as Uint32Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test9(options: Float64Array[]) {
-        const thisObject = {
-            options: [] as Float64Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-}
-
-
-//// [thisTypeInNativeThisAssignableMethods.js]
-class A {
-    addOptions(options) {
-        if (!this.options) {
-            this.options = [];
-        }
-        options.forEach(function (item) {
-            this.options.push(item);
-        }, this);
-        return this;
-    }
-    testUndefined(options) {
-        const undefinedArr = [];
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }); // case1
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }, undefined); // case2
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }, null); // case3
-        const arrLike = {};
-        Array.from(arrLike, function (item) {
-            return this === undefined ? 2 : 1;
-        }, undefined);
-        const iterLike = [];
-        Array.from(iterLike, function (item) {
-            return this === undefined ? 2 : 1;
-        }, undefined);
-    }
-    test(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        const arrLike = {};
-        Array.from(arrLike, function (item) {
-            return this.options[item].length;
-        }, thisObject);
-        const iterLike = [];
-        Array.from(iterLike, function (item) {
-            return this.options[item].length;
-        }, thisObject);
-    }
-    test1(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-    test2(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-    test3(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-    test4(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-    test5(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-    test6(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-    test7(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-    test8(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-    test9(options) {
-        const thisObject = {
-            options: []
-        };
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-}

tests/baselines/reference/typedArrays.symbols

@@ -166,65 +166,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 46, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 45, 44))
 
     return typedArrays;
@@ -241,65 +241,65 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 61, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 60, 47))
 
     return typedArrays;
@@ -457,73 +457,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 
     typedArrays[0] = Int8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[2] = Int16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[4] = Int32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[6] = Float32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[7] = Float64Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 106, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 105, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 105, 58))
 
@@ -545,81 +545,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 
     typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int8Array : Symbol(Int8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8Array : Symbol(Uint8Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int16Array : Symbol(Int16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint16Array : Symbol(Uint16Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Int32Array : Symbol(Int32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint32Array : Symbol(Uint32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float32Array : Symbol(Float32Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Float64Array : Symbol(Float64Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 121, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >obj : Symbol(obj, Decl(typedArrays.ts, 120, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 120, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 120, 98))

tests/baselines/reference/typedArrays.types

@@ -273,9 +273,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >0 : 0
 >Int8Array.from(obj) : Int8Array
->Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; }
 >Int8Array : Int8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; }
 >obj : number[]
 
     typedArrays[1] = Uint8Array.from(obj);
@@ -284,9 +284,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >1 : 1
 >Uint8Array.from(obj) : Uint8Array
->Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; }
 >Uint8Array : Uint8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; }
 >obj : number[]
 
     typedArrays[2] = Int16Array.from(obj);
@@ -295,9 +295,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >2 : 2
 >Int16Array.from(obj) : Int16Array
->Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; }
 >Int16Array : Int16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; }
 >obj : number[]
 
     typedArrays[3] = Uint16Array.from(obj);
@@ -306,9 +306,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >3 : 3
 >Uint16Array.from(obj) : Uint16Array
->Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; }
 >Uint16Array : Uint16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; }
 >obj : number[]
 
     typedArrays[4] = Int32Array.from(obj);
@@ -317,9 +317,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >4 : 4
 >Int32Array.from(obj) : Int32Array
->Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; }
 >Int32Array : Int32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; }
 >obj : number[]
 
     typedArrays[5] = Uint32Array.from(obj);
@@ -328,9 +328,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >5 : 5
 >Uint32Array.from(obj) : Uint32Array
->Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; }
 >Uint32Array : Uint32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; }
 >obj : number[]
 
     typedArrays[6] = Float32Array.from(obj);
@@ -339,9 +339,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >6 : 6
 >Float32Array.from(obj) : Float32Array
->Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; }
 >Float32Array : Float32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; }
 >obj : number[]
 
     typedArrays[7] = Float64Array.from(obj);
@@ -350,9 +350,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >7 : 7
 >Float64Array.from(obj) : Float64Array
->Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; }
 >Float64Array : Float64ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; }
 >obj : number[]
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
@@ -361,9 +361,9 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 >typedArrays : any[]
 >8 : 8
 >Uint8ClampedArray.from(obj) : Uint8ClampedArray
->Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; }
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; }
 >obj : number[]
 
     return typedArrays;
@@ -385,9 +385,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >0 : 0
 >Int8Array.from(obj) : Int8Array
->Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; }
 >Int8Array : Int8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; }
 >obj : ArrayLike<number>
 
     typedArrays[1] = Uint8Array.from(obj);
@@ -396,9 +396,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >1 : 1
 >Uint8Array.from(obj) : Uint8Array
->Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; }
 >Uint8Array : Uint8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; }
 >obj : ArrayLike<number>
 
     typedArrays[2] = Int16Array.from(obj);
@@ -407,9 +407,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >2 : 2
 >Int16Array.from(obj) : Int16Array
->Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; }
 >Int16Array : Int16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; }
 >obj : ArrayLike<number>
 
     typedArrays[3] = Uint16Array.from(obj);
@@ -418,9 +418,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >3 : 3
 >Uint16Array.from(obj) : Uint16Array
->Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; }
 >Uint16Array : Uint16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; }
 >obj : ArrayLike<number>
 
     typedArrays[4] = Int32Array.from(obj);
@@ -429,9 +429,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >4 : 4
 >Int32Array.from(obj) : Int32Array
->Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; }
 >Int32Array : Int32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; }
 >obj : ArrayLike<number>
 
     typedArrays[5] = Uint32Array.from(obj);
@@ -440,9 +440,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >5 : 5
 >Uint32Array.from(obj) : Uint32Array
->Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; }
 >Uint32Array : Uint32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; }
 >obj : ArrayLike<number>
 
     typedArrays[6] = Float32Array.from(obj);
@@ -451,9 +451,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >6 : 6
 >Float32Array.from(obj) : Float32Array
->Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; }
 >Float32Array : Float32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; }
 >obj : ArrayLike<number>
 
     typedArrays[7] = Float64Array.from(obj);
@@ -462,9 +462,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >7 : 7
 >Float64Array.from(obj) : Float64Array
->Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; }
 >Float64Array : Float64ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; }
 >obj : ArrayLike<number>
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
@@ -473,9 +473,9 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 >typedArrays : any[]
 >8 : 8
 >Uint8ClampedArray.from(obj) : Uint8ClampedArray
->Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; }
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; }
 >obj : ArrayLike<number>
 
     return typedArrays;
@@ -757,9 +757,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >0 : 0
 >Int8Array.from(obj, mapFn) : Int8Array
->Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; }
 >Int8Array : Int8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -769,9 +769,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >1 : 1
 >Uint8Array.from(obj, mapFn) : Uint8Array
->Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; }
 >Uint8Array : Uint8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -781,9 +781,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >2 : 2
 >Int16Array.from(obj, mapFn) : Int16Array
->Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; }
 >Int16Array : Int16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -793,9 +793,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >3 : 3
 >Uint16Array.from(obj, mapFn) : Uint16Array
->Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; }
 >Uint16Array : Uint16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -805,9 +805,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >4 : 4
 >Int32Array.from(obj, mapFn) : Int32Array
->Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; }
 >Int32Array : Int32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -817,9 +817,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >5 : 5
 >Uint32Array.from(obj, mapFn) : Uint32Array
->Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; }
 >Uint32Array : Uint32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -829,9 +829,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >6 : 6
 >Float32Array.from(obj, mapFn) : Float32Array
->Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; }
 >Float32Array : Float32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -841,9 +841,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >7 : 7
 >Float64Array.from(obj, mapFn) : Float64Array
->Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; }
 >Float64Array : Float64ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -853,9 +853,9 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 >typedArrays : any[]
 >8 : 8
 >Uint8ClampedArray.from(obj, mapFn) : Uint8ClampedArray
->Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; }
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 
@@ -882,9 +882,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >0 : 0
 >Int8Array.from(obj, mapFn, thisArg) : Int8Array
->Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>Int8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; }
 >Int8Array : Int8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int8Array; (arrayLike: Iterable<number>): Int8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -895,9 +895,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >1 : 1
 >Uint8Array.from(obj, mapFn, thisArg) : Uint8Array
->Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>Uint8Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; }
 >Uint8Array : Uint8ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8Array; (arrayLike: Iterable<number>): Uint8Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -908,9 +908,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >2 : 2
 >Int16Array.from(obj, mapFn, thisArg) : Int16Array
->Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>Int16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; }
 >Int16Array : Int16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int16Array; (arrayLike: Iterable<number>): Int16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -921,9 +921,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >3 : 3
 >Uint16Array.from(obj, mapFn, thisArg) : Uint16Array
->Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>Uint16Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; }
 >Uint16Array : Uint16ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint16Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint16Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint16Array; (arrayLike: Iterable<number>): Uint16Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -934,9 +934,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >4 : 4
 >Int32Array.from(obj, mapFn, thisArg) : Int32Array
->Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>Int32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; }
 >Int32Array : Int32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Int32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Int32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Int32Array; (arrayLike: Iterable<number>): Int32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -947,9 +947,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >5 : 5
 >Uint32Array.from(obj, mapFn, thisArg) : Uint32Array
->Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>Uint32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; }
 >Uint32Array : Uint32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint32Array; (arrayLike: Iterable<number>): Uint32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -960,9 +960,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >6 : 6
 >Float32Array.from(obj, mapFn, thisArg) : Float32Array
->Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>Float32Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; }
 >Float32Array : Float32ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float32Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float32Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float32Array; (arrayLike: Iterable<number>): Float32Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -973,9 +973,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >7 : 7
 >Float64Array.from(obj, mapFn, thisArg) : Float64Array
->Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>Float64Array.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; }
 >Float64Array : Float64ArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Float64Array; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Float64Array; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Float64Array; (arrayLike: Iterable<number>): Float64Array; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}
@@ -986,9 +986,9 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 >typedArrays : any[]
 >8 : 8
 >Uint8ClampedArray.from(obj, mapFn, thisArg) : Uint8ClampedArray
->Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>Uint8ClampedArray.from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; }
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
->from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn: (this: void, v: number, k: number) => number, thisArg: undefined): Uint8ClampedArray; <Z>(arrayLike: Iterable<number>, mapfn: (this: Z, v: number, k: number) => number, thisArg: Z): Uint8ClampedArray; (arrayLike: Iterable<number>): Uint8ClampedArray; }
+>from : { (arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; (arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray; }
 >obj : ArrayLike<number>
 >mapFn : (n: number, v: number) => number
 >thisArg : {}

tests/cases/compiler/thisTypeInNativeThisAssignableMethods.ts

@@ -1,398 +0,0 @@
-// @target: ES2017
-
-class A {
-    options: string[];
-
-    addOptions(options: string[]) {
-        if (!this.options) {
-            this.options = [];
-        }
-        options.forEach(function (item) {
-            this.options.push(item);
-        }, this);
-        return this;
-    }
-
-    testUndefined(options: string[]) {
-        const undefinedArr: Array<undefined> = []
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }); // case1
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }, undefined); // case2
-        options.forEach(function () {
-            undefinedArr.push(this);
-        }, null); // case3
-
-        const arrLike = {} as ArrayLike<number>
-        Array.from(arrLike, function (item) {
-            return this === undefined ? 2 : 1;
-        }, undefined)
-
-        const iterLike = [] as Iterable<number>
-        Array.from(iterLike, function (item) {
-            return this === undefined ? 2 : 1;
-        }, undefined)
-    }
-
-    test(options: string[]) {
-        const thisObject = {
-            options: [] as string[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        const arrLike = {} as ArrayLike<number>
-        Array.from(arrLike, function (item) {
-            return this.options[item].length
-        }, thisObject)
-
-        const iterLike = [] as Iterable<number>
-        Array.from(iterLike, function (item) {
-            return this.options[item].length
-        }, thisObject)
-    }
-
-    test1(options: string[]) {
-        const thisObject = {
-            options: [] as ReadonlyArray<string>
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test2(options: Int8Array[]) {
-        const thisObject = {
-            options: [] as Int8Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test3(options: Uint8Array[]) {
-        const thisObject = {
-            options: [] as Uint8Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test4(options: Float32Array[]) {
-        const thisObject = {
-            options: [] as Float32Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test5(options: Uint8ClampedArray[]) {
-        const thisObject = {
-            options: [] as Uint8ClampedArray[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test6(options: Int16Array[]) {
-        const thisObject = {
-            options: [] as Int16Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test7(options: Uint16Array[]) {
-        const thisObject = {
-            options: [] as Uint16Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test8(options: Uint32Array[]) {
-        const thisObject = {
-            options: [] as Uint32Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-
-    test9(options: Float64Array[]) {
-        const thisObject = {
-            options: [] as Float64Array[]
-        };
-
-        options.find(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.findIndex(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.forEach(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.map(function (val, index) {
-            if (val === this.options[index])
-                return this.options[index];
-        }, thisObject);
-
-        options.some(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.filter(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-
-        options.every(function (val, index) {
-            return val === this.options[index];
-        }, thisObject);
-    }
-}