=== tests/cases/compiler/typedArrays.ts ===

function CreateTypedArrayTypes() {
>CreateTypedArrayTypes : () => any[], Symbol(CreateTypedArrayTypes, Decl(typedArrays.ts, 0, 0))

    var typedArrays = [];
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>[] : undefined[]

    typedArrays[0] = Int8Array;
>typedArrays[0] = Int8Array : Int8ArrayConstructor
>typedArrays[0] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>0 : number
>Int8Array : Int8ArrayConstructor, Symbol(Int8Array, Decl(lib.d.ts, 2077, 42), Decl(lib.d.ts, 2367, 11))

    typedArrays[1] = Uint8Array;
>typedArrays[1] = Uint8Array : Uint8ArrayConstructor
>typedArrays[1] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>1 : number
>Uint8Array : Uint8ArrayConstructor, Symbol(Uint8Array, Decl(lib.d.ts, 2367, 44), Decl(lib.d.ts, 2657, 11))

    typedArrays[2] = Int16Array;
>typedArrays[2] = Int16Array : Int16ArrayConstructor
>typedArrays[2] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>2 : number
>Int16Array : Int16ArrayConstructor, Symbol(Int16Array, Decl(lib.d.ts, 2947, 60), Decl(lib.d.ts, 3237, 11))

    typedArrays[3] = Uint16Array;
>typedArrays[3] = Uint16Array : Uint16ArrayConstructor
>typedArrays[3] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>3 : number
>Uint16Array : Uint16ArrayConstructor, Symbol(Uint16Array, Decl(lib.d.ts, 3237, 46), Decl(lib.d.ts, 3527, 11))

    typedArrays[4] = Int32Array;
>typedArrays[4] = Int32Array : Int32ArrayConstructor
>typedArrays[4] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>4 : number
>Int32Array : Int32ArrayConstructor, Symbol(Int32Array, Decl(lib.d.ts, 3527, 48), Decl(lib.d.ts, 3817, 11))

    typedArrays[5] = Uint32Array;
>typedArrays[5] = Uint32Array : Uint32ArrayConstructor
>typedArrays[5] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>5 : number
>Uint32Array : Uint32ArrayConstructor, Symbol(Uint32Array, Decl(lib.d.ts, 3817, 46), Decl(lib.d.ts, 4107, 11))

    typedArrays[6] = Float32Array;
>typedArrays[6] = Float32Array : Float32ArrayConstructor
>typedArrays[6] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>6 : number
>Float32Array : Float32ArrayConstructor, Symbol(Float32Array, Decl(lib.d.ts, 4107, 48), Decl(lib.d.ts, 4397, 11))

    typedArrays[7] = Float64Array;
>typedArrays[7] = Float64Array : Float64ArrayConstructor
>typedArrays[7] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>7 : number
>Float64Array : Float64ArrayConstructor, Symbol(Float64Array, Decl(lib.d.ts, 4397, 50), Decl(lib.d.ts, 4687, 11))

    typedArrays[8] = Uint8ClampedArray;
>typedArrays[8] = Uint8ClampedArray : Uint8ClampedArrayConstructor
>typedArrays[8] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
>8 : number
>Uint8ClampedArray : Uint8ClampedArrayConstructor, Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2657, 46), Decl(lib.d.ts, 2947, 11))

    return typedArrays;
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
}

function CreateTypedArrayInstancesFromLength(obj: number) {
>CreateTypedArrayInstancesFromLength : (obj: number) => any[], Symbol(CreateTypedArrayInstancesFromLength, Decl(typedArrays.ts, 14, 1))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    var typedArrays = [];
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>[] : undefined[]

    typedArrays[0] = new Int8Array(obj);
>typedArrays[0] = new Int8Array(obj) : Int8Array
>typedArrays[0] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>0 : number
>new Int8Array(obj) : Int8Array
>Int8Array : Int8ArrayConstructor, Symbol(Int8Array, Decl(lib.d.ts, 2077, 42), Decl(lib.d.ts, 2367, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    typedArrays[1] = new Uint8Array(obj);
>typedArrays[1] = new Uint8Array(obj) : Uint8Array
>typedArrays[1] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>1 : number
>new Uint8Array(obj) : Uint8Array
>Uint8Array : Uint8ArrayConstructor, Symbol(Uint8Array, Decl(lib.d.ts, 2367, 44), Decl(lib.d.ts, 2657, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    typedArrays[2] = new Int16Array(obj);
>typedArrays[2] = new Int16Array(obj) : Int16Array
>typedArrays[2] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>2 : number
>new Int16Array(obj) : Int16Array
>Int16Array : Int16ArrayConstructor, Symbol(Int16Array, Decl(lib.d.ts, 2947, 60), Decl(lib.d.ts, 3237, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    typedArrays[3] = new Uint16Array(obj);
>typedArrays[3] = new Uint16Array(obj) : Uint16Array
>typedArrays[3] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>3 : number
>new Uint16Array(obj) : Uint16Array
>Uint16Array : Uint16ArrayConstructor, Symbol(Uint16Array, Decl(lib.d.ts, 3237, 46), Decl(lib.d.ts, 3527, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    typedArrays[4] = new Int32Array(obj);
>typedArrays[4] = new Int32Array(obj) : Int32Array
>typedArrays[4] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>4 : number
>new Int32Array(obj) : Int32Array
>Int32Array : Int32ArrayConstructor, Symbol(Int32Array, Decl(lib.d.ts, 3527, 48), Decl(lib.d.ts, 3817, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    typedArrays[5] = new Uint32Array(obj);
>typedArrays[5] = new Uint32Array(obj) : Uint32Array
>typedArrays[5] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>5 : number
>new Uint32Array(obj) : Uint32Array
>Uint32Array : Uint32ArrayConstructor, Symbol(Uint32Array, Decl(lib.d.ts, 3817, 46), Decl(lib.d.ts, 4107, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    typedArrays[6] = new Float32Array(obj);
>typedArrays[6] = new Float32Array(obj) : Float32Array
>typedArrays[6] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>6 : number
>new Float32Array(obj) : Float32Array
>Float32Array : Float32ArrayConstructor, Symbol(Float32Array, Decl(lib.d.ts, 4107, 48), Decl(lib.d.ts, 4397, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    typedArrays[7] = new Float64Array(obj);
>typedArrays[7] = new Float64Array(obj) : Float64Array
>typedArrays[7] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>7 : number
>new Float64Array(obj) : Float64Array
>Float64Array : Float64ArrayConstructor, Symbol(Float64Array, Decl(lib.d.ts, 4397, 50), Decl(lib.d.ts, 4687, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    typedArrays[8] = new Uint8ClampedArray(obj);
>typedArrays[8] = new Uint8ClampedArray(obj) : Uint8ClampedArray
>typedArrays[8] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
>8 : number
>new Uint8ClampedArray(obj) : Uint8ClampedArray
>Uint8ClampedArray : Uint8ClampedArrayConstructor, Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2657, 46), Decl(lib.d.ts, 2947, 11))
>obj : number, Symbol(obj, Decl(typedArrays.ts, 16, 45))

    return typedArrays;
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
}

function CreateTypedArrayInstancesFromArray(obj: number[]) {
>CreateTypedArrayInstancesFromArray : (obj: number[]) => any[], Symbol(CreateTypedArrayInstancesFromArray, Decl(typedArrays.ts, 29, 1))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    var typedArrays = [];
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>[] : undefined[]

    typedArrays[0] = new Int8Array(obj);
>typedArrays[0] = new Int8Array(obj) : Int8Array
>typedArrays[0] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>0 : number
>new Int8Array(obj) : Int8Array
>Int8Array : Int8ArrayConstructor, Symbol(Int8Array, Decl(lib.d.ts, 2077, 42), Decl(lib.d.ts, 2367, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    typedArrays[1] = new Uint8Array(obj);
>typedArrays[1] = new Uint8Array(obj) : Uint8Array
>typedArrays[1] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>1 : number
>new Uint8Array(obj) : Uint8Array
>Uint8Array : Uint8ArrayConstructor, Symbol(Uint8Array, Decl(lib.d.ts, 2367, 44), Decl(lib.d.ts, 2657, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    typedArrays[2] = new Int16Array(obj);
>typedArrays[2] = new Int16Array(obj) : Int16Array
>typedArrays[2] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>2 : number
>new Int16Array(obj) : Int16Array
>Int16Array : Int16ArrayConstructor, Symbol(Int16Array, Decl(lib.d.ts, 2947, 60), Decl(lib.d.ts, 3237, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    typedArrays[3] = new Uint16Array(obj);
>typedArrays[3] = new Uint16Array(obj) : Uint16Array
>typedArrays[3] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>3 : number
>new Uint16Array(obj) : Uint16Array
>Uint16Array : Uint16ArrayConstructor, Symbol(Uint16Array, Decl(lib.d.ts, 3237, 46), Decl(lib.d.ts, 3527, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    typedArrays[4] = new Int32Array(obj);
>typedArrays[4] = new Int32Array(obj) : Int32Array
>typedArrays[4] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>4 : number
>new Int32Array(obj) : Int32Array
>Int32Array : Int32ArrayConstructor, Symbol(Int32Array, Decl(lib.d.ts, 3527, 48), Decl(lib.d.ts, 3817, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    typedArrays[5] = new Uint32Array(obj);
>typedArrays[5] = new Uint32Array(obj) : Uint32Array
>typedArrays[5] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>5 : number
>new Uint32Array(obj) : Uint32Array
>Uint32Array : Uint32ArrayConstructor, Symbol(Uint32Array, Decl(lib.d.ts, 3817, 46), Decl(lib.d.ts, 4107, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    typedArrays[6] = new Float32Array(obj);
>typedArrays[6] = new Float32Array(obj) : Float32Array
>typedArrays[6] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>6 : number
>new Float32Array(obj) : Float32Array
>Float32Array : Float32ArrayConstructor, Symbol(Float32Array, Decl(lib.d.ts, 4107, 48), Decl(lib.d.ts, 4397, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    typedArrays[7] = new Float64Array(obj);
>typedArrays[7] = new Float64Array(obj) : Float64Array
>typedArrays[7] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>7 : number
>new Float64Array(obj) : Float64Array
>Float64Array : Float64ArrayConstructor, Symbol(Float64Array, Decl(lib.d.ts, 4397, 50), Decl(lib.d.ts, 4687, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    typedArrays[8] = new Uint8ClampedArray(obj);
>typedArrays[8] = new Uint8ClampedArray(obj) : Uint8ClampedArray
>typedArrays[8] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
>8 : number
>new Uint8ClampedArray(obj) : Uint8ClampedArray
>Uint8ClampedArray : Uint8ClampedArrayConstructor, Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2657, 46), Decl(lib.d.ts, 2947, 11))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 31, 44))

    return typedArrays;
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
}

function CreateIntegerTypedArraysFromArray2(obj:number[]) {
>CreateIntegerTypedArraysFromArray2 : (obj: number[]) => any[], Symbol(CreateIntegerTypedArraysFromArray2, Decl(typedArrays.ts, 44, 1))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    var typedArrays = [];
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>[] : undefined[]

    typedArrays[0] = Int8Array.from(obj);
>typedArrays[0] = Int8Array.from(obj) : Int8Array
>typedArrays[0] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>0 : number
>Int8Array.from(obj) : Int8Array
>Int8Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int8Array, Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2357, 38))
>Int8Array : Int8ArrayConstructor, Symbol(Int8Array, Decl(lib.d.ts, 2077, 42), Decl(lib.d.ts, 2367, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int8Array, Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2357, 38))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    typedArrays[1] = Uint8Array.from(obj);
>typedArrays[1] = Uint8Array.from(obj) : Uint8Array
>typedArrays[1] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>1 : number
>Uint8Array.from(obj) : Uint8Array
>Uint8Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8Array, Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2647, 39))
>Uint8Array : Uint8ArrayConstructor, Symbol(Uint8Array, Decl(lib.d.ts, 2367, 44), Decl(lib.d.ts, 2657, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8Array, Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2647, 39))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    typedArrays[2] = Int16Array.from(obj);
>typedArrays[2] = Int16Array.from(obj) : Int16Array
>typedArrays[2] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>2 : number
>Int16Array.from(obj) : Int16Array
>Int16Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int16Array, Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3227, 39))
>Int16Array : Int16ArrayConstructor, Symbol(Int16Array, Decl(lib.d.ts, 2947, 60), Decl(lib.d.ts, 3237, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int16Array, Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3227, 39))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    typedArrays[3] = Uint16Array.from(obj);
>typedArrays[3] = Uint16Array.from(obj) : Uint16Array
>typedArrays[3] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>3 : number
>Uint16Array.from(obj) : Uint16Array
>Uint16Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint16Array, Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3517, 40))
>Uint16Array : Uint16ArrayConstructor, Symbol(Uint16Array, Decl(lib.d.ts, 3237, 46), Decl(lib.d.ts, 3527, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint16Array, Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3517, 40))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    typedArrays[4] = Int32Array.from(obj);
>typedArrays[4] = Int32Array.from(obj) : Int32Array
>typedArrays[4] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>4 : number
>Int32Array.from(obj) : Int32Array
>Int32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int32Array, Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3807, 39))
>Int32Array : Int32ArrayConstructor, Symbol(Int32Array, Decl(lib.d.ts, 3527, 48), Decl(lib.d.ts, 3817, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int32Array, Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3807, 39))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    typedArrays[5] = Uint32Array.from(obj);
>typedArrays[5] = Uint32Array.from(obj) : Uint32Array
>typedArrays[5] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>5 : number
>Uint32Array.from(obj) : Uint32Array
>Uint32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint32Array, Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4097, 40))
>Uint32Array : Uint32ArrayConstructor, Symbol(Uint32Array, Decl(lib.d.ts, 3817, 46), Decl(lib.d.ts, 4107, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint32Array, Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4097, 40))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    typedArrays[6] = Float32Array.from(obj);
>typedArrays[6] = Float32Array.from(obj) : Float32Array
>typedArrays[6] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>6 : number
>Float32Array.from(obj) : Float32Array
>Float32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float32Array, Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4387, 41))
>Float32Array : Float32ArrayConstructor, Symbol(Float32Array, Decl(lib.d.ts, 4107, 48), Decl(lib.d.ts, 4397, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float32Array, Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4387, 41))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    typedArrays[7] = Float64Array.from(obj);
>typedArrays[7] = Float64Array.from(obj) : Float64Array
>typedArrays[7] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>7 : number
>Float64Array.from(obj) : Float64Array
>Float64Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float64Array, Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4677, 41))
>Float64Array : Float64ArrayConstructor, Symbol(Float64Array, Decl(lib.d.ts, 4397, 50), Decl(lib.d.ts, 4687, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float64Array, Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4677, 41))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    typedArrays[8] = Uint8ClampedArray.from(obj);
>typedArrays[8] = Uint8ClampedArray.from(obj) : Uint8ClampedArray
>typedArrays[8] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
>8 : number
>Uint8ClampedArray.from(obj) : Uint8ClampedArray
>Uint8ClampedArray.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2937, 46))
>Uint8ClampedArray : Uint8ClampedArrayConstructor, Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2657, 46), Decl(lib.d.ts, 2947, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2937, 46))
>obj : number[], Symbol(obj, Decl(typedArrays.ts, 46, 44))

    return typedArrays;
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
}

function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
>CreateIntegerTypedArraysFromArrayLike : (obj: ArrayLike<number>) => any[], Symbol(CreateIntegerTypedArraysFromArrayLike, Decl(typedArrays.ts, 59, 1))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))
>ArrayLike : ArrayLike<T>, Symbol(ArrayLike, Decl(lib.d.ts, 1404, 1))

    var typedArrays = [];
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>[] : undefined[]

    typedArrays[0] = Int8Array.from(obj);
>typedArrays[0] = Int8Array.from(obj) : Int8Array
>typedArrays[0] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>0 : number
>Int8Array.from(obj) : Int8Array
>Int8Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int8Array, Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2357, 38))
>Int8Array : Int8ArrayConstructor, Symbol(Int8Array, Decl(lib.d.ts, 2077, 42), Decl(lib.d.ts, 2367, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int8Array, Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2357, 38))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    typedArrays[1] = Uint8Array.from(obj);
>typedArrays[1] = Uint8Array.from(obj) : Uint8Array
>typedArrays[1] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>1 : number
>Uint8Array.from(obj) : Uint8Array
>Uint8Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8Array, Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2647, 39))
>Uint8Array : Uint8ArrayConstructor, Symbol(Uint8Array, Decl(lib.d.ts, 2367, 44), Decl(lib.d.ts, 2657, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8Array, Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2647, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    typedArrays[2] = Int16Array.from(obj);
>typedArrays[2] = Int16Array.from(obj) : Int16Array
>typedArrays[2] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>2 : number
>Int16Array.from(obj) : Int16Array
>Int16Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int16Array, Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3227, 39))
>Int16Array : Int16ArrayConstructor, Symbol(Int16Array, Decl(lib.d.ts, 2947, 60), Decl(lib.d.ts, 3237, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int16Array, Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3227, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    typedArrays[3] = Uint16Array.from(obj);
>typedArrays[3] = Uint16Array.from(obj) : Uint16Array
>typedArrays[3] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>3 : number
>Uint16Array.from(obj) : Uint16Array
>Uint16Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint16Array, Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3517, 40))
>Uint16Array : Uint16ArrayConstructor, Symbol(Uint16Array, Decl(lib.d.ts, 3237, 46), Decl(lib.d.ts, 3527, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint16Array, Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3517, 40))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    typedArrays[4] = Int32Array.from(obj);
>typedArrays[4] = Int32Array.from(obj) : Int32Array
>typedArrays[4] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>4 : number
>Int32Array.from(obj) : Int32Array
>Int32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int32Array, Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3807, 39))
>Int32Array : Int32ArrayConstructor, Symbol(Int32Array, Decl(lib.d.ts, 3527, 48), Decl(lib.d.ts, 3817, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int32Array, Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3807, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    typedArrays[5] = Uint32Array.from(obj);
>typedArrays[5] = Uint32Array.from(obj) : Uint32Array
>typedArrays[5] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>5 : number
>Uint32Array.from(obj) : Uint32Array
>Uint32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint32Array, Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4097, 40))
>Uint32Array : Uint32ArrayConstructor, Symbol(Uint32Array, Decl(lib.d.ts, 3817, 46), Decl(lib.d.ts, 4107, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint32Array, Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4097, 40))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    typedArrays[6] = Float32Array.from(obj);
>typedArrays[6] = Float32Array.from(obj) : Float32Array
>typedArrays[6] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>6 : number
>Float32Array.from(obj) : Float32Array
>Float32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float32Array, Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4387, 41))
>Float32Array : Float32ArrayConstructor, Symbol(Float32Array, Decl(lib.d.ts, 4107, 48), Decl(lib.d.ts, 4397, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float32Array, Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4387, 41))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    typedArrays[7] = Float64Array.from(obj);
>typedArrays[7] = Float64Array.from(obj) : Float64Array
>typedArrays[7] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>7 : number
>Float64Array.from(obj) : Float64Array
>Float64Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float64Array, Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4677, 41))
>Float64Array : Float64ArrayConstructor, Symbol(Float64Array, Decl(lib.d.ts, 4397, 50), Decl(lib.d.ts, 4687, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float64Array, Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4677, 41))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    typedArrays[8] = Uint8ClampedArray.from(obj);
>typedArrays[8] = Uint8ClampedArray.from(obj) : Uint8ClampedArray
>typedArrays[8] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
>8 : number
>Uint8ClampedArray.from(obj) : Uint8ClampedArray
>Uint8ClampedArray.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2937, 46))
>Uint8ClampedArray : Uint8ClampedArrayConstructor, Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2657, 46), Decl(lib.d.ts, 2947, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2937, 46))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 61, 47))

    return typedArrays;
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
}

/*
function CreateTypedArraysOf(obj) {
    var typedArrays = [];
    typedArrays[0] = Int8Array.of(...obj);
    typedArrays[1] = Uint8Array.of(...obj);
    typedArrays[2] = Int16Array.of(...obj);
    typedArrays[3] = Uint16Array.of(...obj);
    typedArrays[4] = Int32Array.of(...obj);
    typedArrays[5] = Uint32Array.of(...obj);
    typedArrays[6] = Float32Array.of(...obj);
    typedArrays[7] = Float64Array.of(...obj);
    typedArrays[8] = Uint8ClampedArray.of(...obj);

    return typedArrays;
}
*/

function CreateTypedArraysOf2() {
>CreateTypedArraysOf2 : () => any[], Symbol(CreateTypedArraysOf2, Decl(typedArrays.ts, 74, 1))

    var typedArrays = [];
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>[] : undefined[]

    typedArrays[0] = Int8Array.of(1,2,3,4);
>typedArrays[0] = Int8Array.of(1,2,3,4) : Int8Array
>typedArrays[0] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>0 : number
>Int8Array.of(1,2,3,4) : Int8Array
>Int8Array.of : (...items: number[]) => Int8Array, Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2351, 30))
>Int8Array : Int8ArrayConstructor, Symbol(Int8Array, Decl(lib.d.ts, 2077, 42), Decl(lib.d.ts, 2367, 11))
>of : (...items: number[]) => Int8Array, Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2351, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    typedArrays[1] = Uint8Array.of(1,2,3,4);
>typedArrays[1] = Uint8Array.of(1,2,3,4) : Uint8Array
>typedArrays[1] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>1 : number
>Uint8Array.of(1,2,3,4) : Uint8Array
>Uint8Array.of : (...items: number[]) => Uint8Array, Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2641, 30))
>Uint8Array : Uint8ArrayConstructor, Symbol(Uint8Array, Decl(lib.d.ts, 2367, 44), Decl(lib.d.ts, 2657, 11))
>of : (...items: number[]) => Uint8Array, Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2641, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    typedArrays[2] = Int16Array.of(1,2,3,4);
>typedArrays[2] = Int16Array.of(1,2,3,4) : Int16Array
>typedArrays[2] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>2 : number
>Int16Array.of(1,2,3,4) : Int16Array
>Int16Array.of : (...items: number[]) => Int16Array, Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3221, 30))
>Int16Array : Int16ArrayConstructor, Symbol(Int16Array, Decl(lib.d.ts, 2947, 60), Decl(lib.d.ts, 3237, 11))
>of : (...items: number[]) => Int16Array, Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3221, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    typedArrays[3] = Uint16Array.of(1,2,3,4);
>typedArrays[3] = Uint16Array.of(1,2,3,4) : Uint16Array
>typedArrays[3] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>3 : number
>Uint16Array.of(1,2,3,4) : Uint16Array
>Uint16Array.of : (...items: number[]) => Uint16Array, Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3511, 30))
>Uint16Array : Uint16ArrayConstructor, Symbol(Uint16Array, Decl(lib.d.ts, 3237, 46), Decl(lib.d.ts, 3527, 11))
>of : (...items: number[]) => Uint16Array, Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3511, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    typedArrays[4] = Int32Array.of(1,2,3,4);
>typedArrays[4] = Int32Array.of(1,2,3,4) : Int32Array
>typedArrays[4] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>4 : number
>Int32Array.of(1,2,3,4) : Int32Array
>Int32Array.of : (...items: number[]) => Int32Array, Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3801, 30))
>Int32Array : Int32ArrayConstructor, Symbol(Int32Array, Decl(lib.d.ts, 3527, 48), Decl(lib.d.ts, 3817, 11))
>of : (...items: number[]) => Int32Array, Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3801, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    typedArrays[5] = Uint32Array.of(1,2,3,4);
>typedArrays[5] = Uint32Array.of(1,2,3,4) : Uint32Array
>typedArrays[5] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>5 : number
>Uint32Array.of(1,2,3,4) : Uint32Array
>Uint32Array.of : (...items: number[]) => Uint32Array, Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4091, 30))
>Uint32Array : Uint32ArrayConstructor, Symbol(Uint32Array, Decl(lib.d.ts, 3817, 46), Decl(lib.d.ts, 4107, 11))
>of : (...items: number[]) => Uint32Array, Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4091, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    typedArrays[6] = Float32Array.of(1,2,3,4);
>typedArrays[6] = Float32Array.of(1,2,3,4) : Float32Array
>typedArrays[6] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>6 : number
>Float32Array.of(1,2,3,4) : Float32Array
>Float32Array.of : (...items: number[]) => Float32Array, Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4381, 30))
>Float32Array : Float32ArrayConstructor, Symbol(Float32Array, Decl(lib.d.ts, 4107, 48), Decl(lib.d.ts, 4397, 11))
>of : (...items: number[]) => Float32Array, Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4381, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    typedArrays[7] = Float64Array.of(1,2,3,4);
>typedArrays[7] = Float64Array.of(1,2,3,4) : Float64Array
>typedArrays[7] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>7 : number
>Float64Array.of(1,2,3,4) : Float64Array
>Float64Array.of : (...items: number[]) => Float64Array, Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4671, 30))
>Float64Array : Float64ArrayConstructor, Symbol(Float64Array, Decl(lib.d.ts, 4397, 50), Decl(lib.d.ts, 4687, 11))
>of : (...items: number[]) => Float64Array, Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4671, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    typedArrays[8] = Uint8ClampedArray.of(1,2,3,4);
>typedArrays[8] = Uint8ClampedArray.of(1,2,3,4) : Uint8ClampedArray
>typedArrays[8] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
>8 : number
>Uint8ClampedArray.of(1,2,3,4) : Uint8ClampedArray
>Uint8ClampedArray.of : (...items: number[]) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2931, 30))
>Uint8ClampedArray : Uint8ClampedArrayConstructor, Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2657, 46), Decl(lib.d.ts, 2947, 11))
>of : (...items: number[]) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2931, 30))
>1 : number
>2 : number
>3 : number
>4 : number

    return typedArrays;
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
}

function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:number)=> number) {
>CreateTypedArraysFromMapFn : (obj: ArrayLike<number>, mapFn: (n: number, v: number) => number) => any[], Symbol(CreateTypedArraysFromMapFn, Decl(typedArrays.ts, 106, 1))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>ArrayLike : ArrayLike<T>, Symbol(ArrayLike, Decl(lib.d.ts, 1404, 1))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
>n : number, Symbol(n, Decl(typedArrays.ts, 108, 67))
>v : number, Symbol(v, Decl(typedArrays.ts, 108, 76))

    var typedArrays = [];
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>[] : undefined[]

    typedArrays[0] = Int8Array.from(obj, mapFn);
>typedArrays[0] = Int8Array.from(obj, mapFn) : Int8Array
>typedArrays[0] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>0 : number
>Int8Array.from(obj, mapFn) : Int8Array
>Int8Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int8Array, Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2357, 38))
>Int8Array : Int8ArrayConstructor, Symbol(Int8Array, Decl(lib.d.ts, 2077, 42), Decl(lib.d.ts, 2367, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int8Array, Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2357, 38))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    typedArrays[1] = Uint8Array.from(obj, mapFn);
>typedArrays[1] = Uint8Array.from(obj, mapFn) : Uint8Array
>typedArrays[1] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>1 : number
>Uint8Array.from(obj, mapFn) : Uint8Array
>Uint8Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8Array, Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2647, 39))
>Uint8Array : Uint8ArrayConstructor, Symbol(Uint8Array, Decl(lib.d.ts, 2367, 44), Decl(lib.d.ts, 2657, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8Array, Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2647, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    typedArrays[2] = Int16Array.from(obj, mapFn);
>typedArrays[2] = Int16Array.from(obj, mapFn) : Int16Array
>typedArrays[2] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>2 : number
>Int16Array.from(obj, mapFn) : Int16Array
>Int16Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int16Array, Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3227, 39))
>Int16Array : Int16ArrayConstructor, Symbol(Int16Array, Decl(lib.d.ts, 2947, 60), Decl(lib.d.ts, 3237, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int16Array, Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3227, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    typedArrays[3] = Uint16Array.from(obj, mapFn);
>typedArrays[3] = Uint16Array.from(obj, mapFn) : Uint16Array
>typedArrays[3] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>3 : number
>Uint16Array.from(obj, mapFn) : Uint16Array
>Uint16Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint16Array, Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3517, 40))
>Uint16Array : Uint16ArrayConstructor, Symbol(Uint16Array, Decl(lib.d.ts, 3237, 46), Decl(lib.d.ts, 3527, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint16Array, Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3517, 40))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    typedArrays[4] = Int32Array.from(obj, mapFn);
>typedArrays[4] = Int32Array.from(obj, mapFn) : Int32Array
>typedArrays[4] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>4 : number
>Int32Array.from(obj, mapFn) : Int32Array
>Int32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int32Array, Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3807, 39))
>Int32Array : Int32ArrayConstructor, Symbol(Int32Array, Decl(lib.d.ts, 3527, 48), Decl(lib.d.ts, 3817, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int32Array, Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3807, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    typedArrays[5] = Uint32Array.from(obj, mapFn);
>typedArrays[5] = Uint32Array.from(obj, mapFn) : Uint32Array
>typedArrays[5] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>5 : number
>Uint32Array.from(obj, mapFn) : Uint32Array
>Uint32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint32Array, Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4097, 40))
>Uint32Array : Uint32ArrayConstructor, Symbol(Uint32Array, Decl(lib.d.ts, 3817, 46), Decl(lib.d.ts, 4107, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint32Array, Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4097, 40))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    typedArrays[6] = Float32Array.from(obj, mapFn);
>typedArrays[6] = Float32Array.from(obj, mapFn) : Float32Array
>typedArrays[6] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>6 : number
>Float32Array.from(obj, mapFn) : Float32Array
>Float32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float32Array, Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4387, 41))
>Float32Array : Float32ArrayConstructor, Symbol(Float32Array, Decl(lib.d.ts, 4107, 48), Decl(lib.d.ts, 4397, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float32Array, Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4387, 41))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    typedArrays[7] = Float64Array.from(obj, mapFn);
>typedArrays[7] = Float64Array.from(obj, mapFn) : Float64Array
>typedArrays[7] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>7 : number
>Float64Array.from(obj, mapFn) : Float64Array
>Float64Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float64Array, Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4677, 41))
>Float64Array : Float64ArrayConstructor, Symbol(Float64Array, Decl(lib.d.ts, 4397, 50), Decl(lib.d.ts, 4687, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float64Array, Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4677, 41))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
>typedArrays[8] = Uint8ClampedArray.from(obj, mapFn) : Uint8ClampedArray
>typedArrays[8] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
>8 : number
>Uint8ClampedArray.from(obj, mapFn) : Uint8ClampedArray
>Uint8ClampedArray.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2937, 46))
>Uint8ClampedArray : Uint8ClampedArrayConstructor, Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2657, 46), Decl(lib.d.ts, 2947, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2937, 46))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 108, 36))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 108, 58))

    return typedArrays;
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
}

function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v:number)=> number, thisArg: {}) {
>CreateTypedArraysFromThisObj : (obj: ArrayLike<number>, mapFn: (n: number, v: number) => number, thisArg: {}) => any[], Symbol(CreateTypedArraysFromThisObj, Decl(typedArrays.ts, 121, 1))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>ArrayLike : ArrayLike<T>, Symbol(ArrayLike, Decl(lib.d.ts, 1404, 1))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>n : number, Symbol(n, Decl(typedArrays.ts, 123, 69))
>v : number, Symbol(v, Decl(typedArrays.ts, 123, 78))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    var typedArrays = [];
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>[] : undefined[]

    typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
>typedArrays[0] = Int8Array.from(obj, mapFn, thisArg) : Int8Array
>typedArrays[0] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>0 : number
>Int8Array.from(obj, mapFn, thisArg) : Int8Array
>Int8Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int8Array, Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2357, 38))
>Int8Array : Int8ArrayConstructor, Symbol(Int8Array, Decl(lib.d.ts, 2077, 42), Decl(lib.d.ts, 2367, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int8Array, Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2357, 38))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
>typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg) : Uint8Array
>typedArrays[1] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>1 : number
>Uint8Array.from(obj, mapFn, thisArg) : Uint8Array
>Uint8Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8Array, Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2647, 39))
>Uint8Array : Uint8ArrayConstructor, Symbol(Uint8Array, Decl(lib.d.ts, 2367, 44), Decl(lib.d.ts, 2657, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8Array, Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2647, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
>typedArrays[2] = Int16Array.from(obj, mapFn, thisArg) : Int16Array
>typedArrays[2] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>2 : number
>Int16Array.from(obj, mapFn, thisArg) : Int16Array
>Int16Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int16Array, Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3227, 39))
>Int16Array : Int16ArrayConstructor, Symbol(Int16Array, Decl(lib.d.ts, 2947, 60), Decl(lib.d.ts, 3237, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int16Array, Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3227, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
>typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg) : Uint16Array
>typedArrays[3] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>3 : number
>Uint16Array.from(obj, mapFn, thisArg) : Uint16Array
>Uint16Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint16Array, Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3517, 40))
>Uint16Array : Uint16ArrayConstructor, Symbol(Uint16Array, Decl(lib.d.ts, 3237, 46), Decl(lib.d.ts, 3527, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint16Array, Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3517, 40))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
>typedArrays[4] = Int32Array.from(obj, mapFn, thisArg) : Int32Array
>typedArrays[4] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>4 : number
>Int32Array.from(obj, mapFn, thisArg) : Int32Array
>Int32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int32Array, Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3807, 39))
>Int32Array : Int32ArrayConstructor, Symbol(Int32Array, Decl(lib.d.ts, 3527, 48), Decl(lib.d.ts, 3817, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Int32Array, Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3807, 39))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
>typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg) : Uint32Array
>typedArrays[5] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>5 : number
>Uint32Array.from(obj, mapFn, thisArg) : Uint32Array
>Uint32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint32Array, Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4097, 40))
>Uint32Array : Uint32ArrayConstructor, Symbol(Uint32Array, Decl(lib.d.ts, 3817, 46), Decl(lib.d.ts, 4107, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint32Array, Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4097, 40))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
>typedArrays[6] = Float32Array.from(obj, mapFn, thisArg) : Float32Array
>typedArrays[6] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>6 : number
>Float32Array.from(obj, mapFn, thisArg) : Float32Array
>Float32Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float32Array, Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4387, 41))
>Float32Array : Float32ArrayConstructor, Symbol(Float32Array, Decl(lib.d.ts, 4107, 48), Decl(lib.d.ts, 4397, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float32Array, Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4387, 41))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
>typedArrays[7] = Float64Array.from(obj, mapFn, thisArg) : Float64Array
>typedArrays[7] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>7 : number
>Float64Array.from(obj, mapFn, thisArg) : Float64Array
>Float64Array.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float64Array, Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4677, 41))
>Float64Array : Float64ArrayConstructor, Symbol(Float64Array, Decl(lib.d.ts, 4397, 50), Decl(lib.d.ts, 4687, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Float64Array, Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4677, 41))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
>typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg) : Uint8ClampedArray
>typedArrays[8] : any
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
>8 : number
>Uint8ClampedArray.from(obj, mapFn, thisArg) : Uint8ClampedArray
>Uint8ClampedArray.from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2937, 46))
>Uint8ClampedArray : Uint8ClampedArrayConstructor, Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2657, 46), Decl(lib.d.ts, 2947, 11))
>from : (arrayLike: ArrayLike<number> | Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any) => Uint8ClampedArray, Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2937, 46))
>obj : ArrayLike<number>, Symbol(obj, Decl(typedArrays.ts, 123, 38))
>mapFn : (n: number, v: number) => number, Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
>thisArg : {}, Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

    return typedArrays;
>typedArrays : any[], Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
}