diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index dc082c8f0a62e..1403efae348ab 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -316,6 +316,11 @@ interface Array<T> {
     copyWithin(target: number, start: number, end?: number): T[];
 }
 
+interface IArguments {
+    /** Iterator */
+    [Symbol.iterator](): IterableIterator<any>;
+}
+
 interface ArrayConstructor {
     /**
       * Creates an array from an array-like object.
diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt
new file mode 100644
index 0000000000000..d607ab65d2973
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator01_ES5.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/compiler/argumentsObjectIterator01_ES5.ts(4,21): error TS2495: Type 'IArguments' is not an array type or a string type.
+
+
+==== tests/cases/compiler/argumentsObjectIterator01_ES5.ts (1 errors) ====
+    
+    function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+        let result = [];
+        for (let arg of arguments) {
+                        ~~~~~~~~~
+!!! error TS2495: Type 'IArguments' is not an array type or a string type.
+            result.push(arg + arg);
+        }
+        return <[any, any, any]>result;
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.js b/tests/baselines/reference/argumentsObjectIterator01_ES5.js
new file mode 100644
index 0000000000000..bc51d6f55824d
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator01_ES5.js
@@ -0,0 +1,19 @@
+//// [argumentsObjectIterator01_ES5.ts]
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+    let result = [];
+    for (let arg of arguments) {
+        result.push(arg + arg);
+    }
+    return <[any, any, any]>result;
+}
+
+//// [argumentsObjectIterator01_ES5.js]
+function doubleAndReturnAsArray(x, y, z) {
+    var result = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        var arg = arguments[_i];
+        result.push(arg + arg);
+    }
+    return result;
+}
diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.js b/tests/baselines/reference/argumentsObjectIterator01_ES6.js
new file mode 100644
index 0000000000000..03744f16b994b
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.js
@@ -0,0 +1,18 @@
+//// [argumentsObjectIterator01_ES6.ts]
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+    let result = [];
+    for (let arg of arguments) {
+        result.push(arg + arg);
+    }
+    return <[any, any, any]>result;
+}
+
+//// [argumentsObjectIterator01_ES6.js]
+function doubleAndReturnAsArray(x, y, z) {
+    let result = [];
+    for (let arg of arguments) {
+        result.push(arg + arg);
+    }
+    return result;
+}
diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols
new file mode 100644
index 0000000000000..b4351e579f587
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols
@@ -0,0 +1,25 @@
+=== tests/cases/compiler/argumentsObjectIterator01_ES6.ts ===
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+>doubleAndReturnAsArray : Symbol(doubleAndReturnAsArray, Decl(argumentsObjectIterator01_ES6.ts, 0, 0))
+>x : Symbol(x, Decl(argumentsObjectIterator01_ES6.ts, 1, 32))
+>y : Symbol(y, Decl(argumentsObjectIterator01_ES6.ts, 1, 42))
+>z : Symbol(z, Decl(argumentsObjectIterator01_ES6.ts, 1, 53))
+
+    let result = [];
+>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7))
+
+    for (let arg of arguments) {
+>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12))
+>arguments : Symbol(arguments)
+
+        result.push(arg + arg);
+>result.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7))
+>push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12))
+>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12))
+    }
+    return <[any, any, any]>result;
+>result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7))
+}
diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.types b/tests/baselines/reference/argumentsObjectIterator01_ES6.types
new file mode 100644
index 0000000000000..04e3bfe081fb2
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.types
@@ -0,0 +1,29 @@
+=== tests/cases/compiler/argumentsObjectIterator01_ES6.ts ===
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+>doubleAndReturnAsArray : (x: number, y: number, z: number) => [number, number, number]
+>x : number
+>y : number
+>z : number
+
+    let result = [];
+>result : any[]
+>[] : undefined[]
+
+    for (let arg of arguments) {
+>arg : any
+>arguments : IArguments
+
+        result.push(arg + arg);
+>result.push(arg + arg) : number
+>result.push : (...items: any[]) => number
+>result : any[]
+>push : (...items: any[]) => number
+>arg + arg : any
+>arg : any
+>arg : any
+    }
+    return <[any, any, any]>result;
+><[any, any, any]>result : [any, any, any]
+>result : any[]
+}
diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt
new file mode 100644
index 0000000000000..125f69b90b2fb
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES5.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/compiler/argumentsObjectIterator02_ES5.ts(3,26): error TS2304: Cannot find name 'Symbol'.
+
+
+==== tests/cases/compiler/argumentsObjectIterator02_ES5.ts (1 errors) ====
+    
+    function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+        let blah = arguments[Symbol.iterator];
+                             ~~~~~~
+!!! error TS2304: Cannot find name 'Symbol'.
+    
+        let result = [];
+        for (let arg of blah()) {
+            result.push(arg + arg);
+        }
+        return <[any, any, any]>result;
+    }
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES5.js b/tests/baselines/reference/argumentsObjectIterator02_ES5.js
new file mode 100644
index 0000000000000..366bf8de199e7
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES5.js
@@ -0,0 +1,24 @@
+//// [argumentsObjectIterator02_ES5.ts]
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+    let blah = arguments[Symbol.iterator];
+
+    let result = [];
+    for (let arg of blah()) {
+        result.push(arg + arg);
+    }
+    return <[any, any, any]>result;
+}
+
+
+
+//// [argumentsObjectIterator02_ES5.js]
+function doubleAndReturnAsArray(x, y, z) {
+    var blah = arguments[Symbol.iterator];
+    var result = [];
+    for (var _i = 0, _a = blah(); _i < _a.length; _i++) {
+        var arg = _a[_i];
+        result.push(arg + arg);
+    }
+    return result;
+}
diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.js b/tests/baselines/reference/argumentsObjectIterator02_ES6.js
new file mode 100644
index 0000000000000..9b9415afd29a6
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.js
@@ -0,0 +1,23 @@
+//// [argumentsObjectIterator02_ES6.ts]
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+    let blah = arguments[Symbol.iterator];
+
+    let result = [];
+    for (let arg of blah()) {
+        result.push(arg + arg);
+    }
+    return <[any, any, any]>result;
+}
+
+
+
+//// [argumentsObjectIterator02_ES6.js]
+function doubleAndReturnAsArray(x, y, z) {
+    let blah = arguments[Symbol.iterator];
+    let result = [];
+    for (let arg of blah()) {
+        result.push(arg + arg);
+    }
+    return result;
+}
diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
new file mode 100644
index 0000000000000..9b68573b37806
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
@@ -0,0 +1,34 @@
+=== tests/cases/compiler/argumentsObjectIterator02_ES6.ts ===
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+>doubleAndReturnAsArray : Symbol(doubleAndReturnAsArray, Decl(argumentsObjectIterator02_ES6.ts, 0, 0))
+>x : Symbol(x, Decl(argumentsObjectIterator02_ES6.ts, 1, 32))
+>y : Symbol(y, Decl(argumentsObjectIterator02_ES6.ts, 1, 42))
+>z : Symbol(z, Decl(argumentsObjectIterator02_ES6.ts, 1, 53))
+
+    let blah = arguments[Symbol.iterator];
+>blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7))
+>arguments : Symbol(arguments)
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 1186, 52), Decl(lib.d.ts, 1292, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 1236, 31))
+
+    let result = [];
+>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7))
+
+    for (let arg of blah()) {
+>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12))
+>blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7))
+
+        result.push(arg + arg);
+>result.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7))
+>push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29))
+>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12))
+>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12))
+    }
+    return <[any, any, any]>result;
+>result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7))
+}
+
+
diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.types b/tests/baselines/reference/argumentsObjectIterator02_ES6.types
new file mode 100644
index 0000000000000..3812107f3be52
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.types
@@ -0,0 +1,40 @@
+=== tests/cases/compiler/argumentsObjectIterator02_ES6.ts ===
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+>doubleAndReturnAsArray : (x: number, y: number, z: number) => [number, number, number]
+>x : number
+>y : number
+>z : number
+
+    let blah = arguments[Symbol.iterator];
+>blah : () => IterableIterator<any>
+>arguments[Symbol.iterator] : () => IterableIterator<any>
+>arguments : IArguments
+>Symbol.iterator : symbol
+>Symbol : SymbolConstructor
+>iterator : symbol
+
+    let result = [];
+>result : any[]
+>[] : undefined[]
+
+    for (let arg of blah()) {
+>arg : any
+>blah() : IterableIterator<any>
+>blah : () => IterableIterator<any>
+
+        result.push(arg + arg);
+>result.push(arg + arg) : number
+>result.push : (...items: any[]) => number
+>result : any[]
+>push : (...items: any[]) => number
+>arg + arg : any
+>arg : any
+>arg : any
+    }
+    return <[any, any, any]>result;
+><[any, any, any]>result : [any, any, any]
+>result : any[]
+}
+
+
diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt b/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt
new file mode 100644
index 0000000000000..c39ea23831766
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator03_ES5.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/compiler/argumentsObjectIterator03_ES5.ts(3,9): error TS2461: Type 'IArguments' is not an array type.
+
+
+==== tests/cases/compiler/argumentsObjectIterator03_ES5.ts (1 errors) ====
+    
+    function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] {
+        let [x, y, z] = arguments;
+            ~~~~~~~~~
+!!! error TS2461: Type 'IArguments' is not an array type.
+        
+        return [z, y, x];
+    }
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES5.js b/tests/baselines/reference/argumentsObjectIterator03_ES5.js
new file mode 100644
index 0000000000000..7ea7e7b6593b6
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator03_ES5.js
@@ -0,0 +1,15 @@
+//// [argumentsObjectIterator03_ES5.ts]
+
+function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] {
+    let [x, y, z] = arguments;
+    
+    return [z, y, x];
+}
+
+
+
+//// [argumentsObjectIterator03_ES5.js]
+function asReversedTuple(a, b, c) {
+    var x = arguments[0], y = arguments[1], z = arguments[2];
+    return [z, y, x];
+}
diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.js b/tests/baselines/reference/argumentsObjectIterator03_ES6.js
new file mode 100644
index 0000000000000..788887e86eb1d
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.js
@@ -0,0 +1,15 @@
+//// [argumentsObjectIterator03_ES6.ts]
+
+function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] {
+    let [x, y, z] = arguments;
+    
+    return [z, y, x];
+}
+
+
+
+//// [argumentsObjectIterator03_ES6.js]
+function asReversedTuple(a, b, c) {
+    let [x, y, z] = arguments;
+    return [z, y, x];
+}
diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols
new file mode 100644
index 0000000000000..97677123f3508
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.symbols
@@ -0,0 +1,21 @@
+=== tests/cases/compiler/argumentsObjectIterator03_ES6.ts ===
+
+function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] {
+>asReversedTuple : Symbol(asReversedTuple, Decl(argumentsObjectIterator03_ES6.ts, 0, 0))
+>a : Symbol(a, Decl(argumentsObjectIterator03_ES6.ts, 1, 25))
+>b : Symbol(b, Decl(argumentsObjectIterator03_ES6.ts, 1, 35))
+>c : Symbol(c, Decl(argumentsObjectIterator03_ES6.ts, 1, 46))
+
+    let [x, y, z] = arguments;
+>x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 2, 9))
+>y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 2, 11))
+>z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 2, 14))
+>arguments : Symbol(arguments)
+    
+    return [z, y, x];
+>z : Symbol(z, Decl(argumentsObjectIterator03_ES6.ts, 2, 14))
+>y : Symbol(y, Decl(argumentsObjectIterator03_ES6.ts, 2, 11))
+>x : Symbol(x, Decl(argumentsObjectIterator03_ES6.ts, 2, 9))
+}
+
+
diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES6.types b/tests/baselines/reference/argumentsObjectIterator03_ES6.types
new file mode 100644
index 0000000000000..95188dee0c8b3
--- /dev/null
+++ b/tests/baselines/reference/argumentsObjectIterator03_ES6.types
@@ -0,0 +1,22 @@
+=== tests/cases/compiler/argumentsObjectIterator03_ES6.ts ===
+
+function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] {
+>asReversedTuple : (a: number, b: string, c: boolean) => [boolean, string, number]
+>a : number
+>b : string
+>c : boolean
+
+    let [x, y, z] = arguments;
+>x : any
+>y : any
+>z : any
+>arguments : IArguments
+    
+    return [z, y, x];
+>[z, y, x] : [any, any, any]
+>z : any
+>y : any
+>x : any
+}
+
+
diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols
index 3b435de2e51be..d8717c2c6d29b 100644
--- a/tests/baselines/reference/arrayLiterals2ES6.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES6.symbols
@@ -79,7 +79,7 @@ interface myArray2 extends Array<Number|String> { }
 >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 
 var d0 = [1, true, ...temp, ];  // has type (string|number|boolean)[]
 >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3))
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
index 033ad46ece1b8..6af2560504dd1 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
@@ -9,17 +9,17 @@
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 function a1(...x: (number|string)[]) { }
@@ -34,7 +34,7 @@ function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36))
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
index d23b624a023f5..84c21ff77e663 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
@@ -9,17 +9,17 @@
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 function a1(...x: (number|string)[]) { }
@@ -34,7 +34,7 @@ function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12))
 >Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 1439, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36))
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index 18e1063f1e639..ce86a2bd59a85 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
@@ -5,7 +5,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         let arguments = 100;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
index 6885b359416aa..f396414521edb 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
@@ -8,7 +8,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         const arguments = 100;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
index ae6be6f7951f7..b484e2d72e171 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
@@ -8,7 +8,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
index c8bf211897a49..10c43123fa365 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
@@ -9,7 +9,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
index cc867dd2c72ef..4598ec0a30593 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
@@ -9,7 +9,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1694, 1))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 1699, 1))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments;
diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols
index 93f6c4f7dd6fe..019f44118cea5 100644
--- a/tests/baselines/reference/for-of37.symbols
+++ b/tests/baselines/reference/for-of37.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of37.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of37.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
 
 for (var v of map) {
 >v : Symbol(v, Decl(for-of37.ts, 1, 8))
diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols
index fab42d9172459..db15a4dcb87d3 100644
--- a/tests/baselines/reference/for-of38.symbols
+++ b/tests/baselines/reference/for-of38.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of38.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of38.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
 
 for (var [k, v] of map) {
 >k : Symbol(k, Decl(for-of38.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols
index 1cd3538f98747..625ee544225de 100644
--- a/tests/baselines/reference/for-of40.symbols
+++ b/tests/baselines/reference/for-of40.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of40.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of40.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
 
 for (var [k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of40.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols
index 9fda4cb4e0a64..343c5a38c971e 100644
--- a/tests/baselines/reference/for-of45.symbols
+++ b/tests/baselines/reference/for-of45.symbols
@@ -5,7 +5,7 @@ var k: string, v: boolean;
 
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of45.ts, 1, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
 
 for ([k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of45.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols
index c176e1aca0cf1..f16364548ce1d 100644
--- a/tests/baselines/reference/for-of50.symbols
+++ b/tests/baselines/reference/for-of50.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of50.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of50.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
 
 for (const [k, v] of map) {
 >k : Symbol(k, Decl(for-of50.ts, 1, 12))
diff --git a/tests/baselines/reference/for-of57.symbols b/tests/baselines/reference/for-of57.symbols
index 27aed0777ba7f..574d52e4c5680 100644
--- a/tests/baselines/reference/for-of57.symbols
+++ b/tests/baselines/reference/for-of57.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of57.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(for-of57.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1663, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
 
 for (let num of iter) { }
 >num : Symbol(num, Decl(for-of57.ts, 1, 8))
diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols
index 0f50713b43d6c..7b2a27b9992dd 100644
--- a/tests/baselines/reference/iterableArrayPattern30.symbols
+++ b/tests/baselines/reference/iterableArrayPattern30.symbols
@@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
 >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11))
 >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18))
 >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21))
->Map : Symbol(Map, Decl(lib.d.ts, 1867, 1), Decl(lib.d.ts, 1889, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 1872, 1), Decl(lib.d.ts, 1894, 11))
 
diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols
index 76d94dc29233b..a900c56ecabe4 100644
--- a/tests/baselines/reference/iterableContextualTyping1.symbols
+++ b/tests/baselines/reference/iterableContextualTyping1.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts ===
 var iter: Iterable<(x: string) => number> = [s => s.length];
 >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1663, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
 >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
diff --git a/tests/baselines/reference/iteratorSpreadInArray11.symbols b/tests/baselines/reference/iteratorSpreadInArray11.symbols
index b128803aa50f7..548e026744a34 100644
--- a/tests/baselines/reference/iteratorSpreadInArray11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray11.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 1663, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 1668, 1))
 
 var array = [...iter];
 >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3))
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index 78faacdb1f14a..615de521b83f7 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -22,13 +22,13 @@ interface T3 {
 
 function f1(): Promise<T1> {
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4854, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4774, 1), Decl(lib.d.ts, 4859, 11))
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4836, 39), Decl(lib.d.ts, 4843, 54))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4769, 1), Decl(lib.d.ts, 4854, 11))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4836, 39), Decl(lib.d.ts, 4843, 54))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4841, 39), Decl(lib.d.ts, 4848, 54))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 4774, 1), Decl(lib.d.ts, 4859, 11))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 4841, 39), Decl(lib.d.ts, 4848, 54))
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
@@ -47,12 +47,12 @@ function f2(x: T1): T2 {
 
 var x3 = f1()
 >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3))
->f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 4774, 22), Decl(lib.d.ts, 4781, 158))
->f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 4774, 22), Decl(lib.d.ts, 4781, 158))
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 4779, 22), Decl(lib.d.ts, 4786, 158))
+>f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 4779, 22), Decl(lib.d.ts, 4786, 158))
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
 
     .then(f2, (e: Error) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 4774, 22), Decl(lib.d.ts, 4781, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, 4779, 22), Decl(lib.d.ts, 4786, 158))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
@@ -62,7 +62,7 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 4774, 22), Decl(lib.d.ts, 4781, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, 4779, 22), Decl(lib.d.ts, 4786, 158))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
index 0cfe0d854beaf..4d7c4d6ac4edd 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts ===
 var x = `abc${ new String("Hi") }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1538, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 1543, 1))
 
diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols
index 27b72cc54f1cb..c4015c3492d95 100644
--- a/tests/baselines/reference/typedArrays.symbols
+++ b/tests/baselines/reference/typedArrays.symbols
@@ -8,39 +8,39 @@ function CreateTypedArrayTypes() {
 
     typedArrays[0] = Int8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
 
     typedArrays[1] = Uint8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
 
     typedArrays[2] = Int16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
 
     typedArrays[3] = Uint16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
 
     typedArrays[4] = Int32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
 
     typedArrays[5] = Uint32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
 
     typedArrays[6] = Float32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
 
     typedArrays[7] = Float64Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
 
     typedArrays[8] = Uint8ClampedArray;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
@@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     return typedArrays;
@@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     return typedArrays;
@@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     return typedArrays;
@@ -242,65 +242,65 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     return typedArrays;
@@ -332,57 +332,57 @@ function CreateTypedArraysOf2() {
 
     typedArrays[0] = Int8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2381, 30))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2381, 30))
+>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2386, 30))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
+>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 2386, 30))
 
     typedArrays[1] = Uint8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2671, 30))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2671, 30))
+>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2676, 30))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
+>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 2676, 30))
 
     typedArrays[2] = Int16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3251, 30))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3251, 30))
+>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3256, 30))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
+>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 3256, 30))
 
     typedArrays[3] = Uint16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3541, 30))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3541, 30))
+>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3546, 30))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
+>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 3546, 30))
 
     typedArrays[4] = Int32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3831, 30))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3831, 30))
+>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3836, 30))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
+>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3836, 30))
 
     typedArrays[5] = Uint32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4121, 30))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4121, 30))
+>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4126, 30))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
+>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 4126, 30))
 
     typedArrays[6] = Float32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4411, 30))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4411, 30))
+>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4416, 30))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
+>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 4416, 30))
 
     typedArrays[7] = Float64Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4701, 30))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4701, 30))
+>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4706, 30))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
+>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 4706, 30))
 
     typedArrays[8] = Uint8ClampedArray.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2961, 30))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2961, 30))
+>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2966, 30))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
+>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2966, 30))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
@@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 
     typedArrays[0] = Int8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[2] = Int16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[4] = Int32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[6] = Float32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[7] = Float64Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
@@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 
     typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2107, 42), Decl(lib.d.ts, 2397, 11))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2387, 38))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 2112, 42), Decl(lib.d.ts, 2402, 11))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 2392, 38))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2397, 44), Decl(lib.d.ts, 2687, 11))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2677, 39))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 2402, 44), Decl(lib.d.ts, 2692, 11))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 2682, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2977, 60), Decl(lib.d.ts, 3267, 11))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3257, 39))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2982, 60), Decl(lib.d.ts, 3272, 11))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 3262, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3267, 46), Decl(lib.d.ts, 3557, 11))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3547, 40))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 3272, 46), Decl(lib.d.ts, 3562, 11))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 3552, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3557, 48), Decl(lib.d.ts, 3847, 11))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3837, 39))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 3562, 48), Decl(lib.d.ts, 3852, 11))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3842, 39))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3847, 46), Decl(lib.d.ts, 4137, 11))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4127, 40))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3852, 46), Decl(lib.d.ts, 4142, 11))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 4132, 40))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4137, 48), Decl(lib.d.ts, 4427, 11))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4417, 41))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 4142, 48), Decl(lib.d.ts, 4432, 11))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 4422, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4427, 50), Decl(lib.d.ts, 4717, 11))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4707, 41))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 4432, 50), Decl(lib.d.ts, 4722, 11))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 4712, 41))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2687, 46), Decl(lib.d.ts, 2977, 11))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2967, 46))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 2692, 46), Decl(lib.d.ts, 2982, 11))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2972, 46))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
diff --git a/tests/cases/compiler/argumentsObjectIterator01_ES5.ts b/tests/cases/compiler/argumentsObjectIterator01_ES5.ts
new file mode 100644
index 0000000000000..1813eb9a16698
--- /dev/null
+++ b/tests/cases/compiler/argumentsObjectIterator01_ES5.ts
@@ -0,0 +1,9 @@
+//@target: ES5
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+    let result = [];
+    for (let arg of arguments) {
+        result.push(arg + arg);
+    }
+    return <[any, any, any]>result;
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/argumentsObjectIterator01_ES6.ts b/tests/cases/compiler/argumentsObjectIterator01_ES6.ts
new file mode 100644
index 0000000000000..4e566affa37b2
--- /dev/null
+++ b/tests/cases/compiler/argumentsObjectIterator01_ES6.ts
@@ -0,0 +1,9 @@
+//@target: ES6
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+    let result = [];
+    for (let arg of arguments) {
+        result.push(arg + arg);
+    }
+    return <[any, any, any]>result;
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/argumentsObjectIterator02_ES5.ts b/tests/cases/compiler/argumentsObjectIterator02_ES5.ts
new file mode 100644
index 0000000000000..b348765827e86
--- /dev/null
+++ b/tests/cases/compiler/argumentsObjectIterator02_ES5.ts
@@ -0,0 +1,12 @@
+//@target: ES5
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+    let blah = arguments[Symbol.iterator];
+
+    let result = [];
+    for (let arg of blah()) {
+        result.push(arg + arg);
+    }
+    return <[any, any, any]>result;
+}
+
diff --git a/tests/cases/compiler/argumentsObjectIterator02_ES6.ts b/tests/cases/compiler/argumentsObjectIterator02_ES6.ts
new file mode 100644
index 0000000000000..10d5b01cc6237
--- /dev/null
+++ b/tests/cases/compiler/argumentsObjectIterator02_ES6.ts
@@ -0,0 +1,12 @@
+//@target: ES6
+
+function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] {
+    let blah = arguments[Symbol.iterator];
+
+    let result = [];
+    for (let arg of blah()) {
+        result.push(arg + arg);
+    }
+    return <[any, any, any]>result;
+}
+
diff --git a/tests/cases/compiler/argumentsObjectIterator03_ES5.ts b/tests/cases/compiler/argumentsObjectIterator03_ES5.ts
new file mode 100644
index 0000000000000..8059ca3aa22b5
--- /dev/null
+++ b/tests/cases/compiler/argumentsObjectIterator03_ES5.ts
@@ -0,0 +1,8 @@
+//@target: ES5
+
+function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] {
+    let [x, y, z] = arguments;
+    
+    return [z, y, x];
+}
+
diff --git a/tests/cases/compiler/argumentsObjectIterator03_ES6.ts b/tests/cases/compiler/argumentsObjectIterator03_ES6.ts
new file mode 100644
index 0000000000000..21b4988508425
--- /dev/null
+++ b/tests/cases/compiler/argumentsObjectIterator03_ES6.ts
@@ -0,0 +1,8 @@
+//@target: ES6
+
+function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] {
+    let [x, y, z] = arguments;
+    
+    return [z, y, x];
+}
+