"use strict"; return (function f(n){ if (n <= 0) { return "foo"; } return f(n - 1); }(1e6)) === "foo";

"use strict"; function f(n){ if (n <= 0) { return "foo"; } return g(n - 1); } function g(n){ if (n <= 0) { return "bar"; } return f(n - 1); } return f(1e6) === "foo" && f(1e6+1) === "bar";

return (function (a = 1, b = 2) { return a === 3 && b === 2; }(3));

return (function (a = 1, b = 2) { return a === 1 && b === 3; }(undefined, 3));

return (function (a, b = a) { return b === 5; }(5));

return (function (a = "baz", b = "qux", c = "quux") { a = "corge"; // The arguments object is not mapped to the // parameters, even outside of strict mode. return arguments.length === 2 && arguments[0] === "foo" && arguments[1] === "bar"; }("foo", "bar"));

return (function(x = 1) { try { eval("(function(a=a){}())"); return false; } catch(e) {} try { eval("(function(a=b,b){}())"); return false; } catch(e) {} return true; }());

return (function(a=function(){ return typeof b === 'undefined'; }){ var b = 1; return a(); }());

return new Function("a = 1", "b = 2", "return a === 3 && b === 2;" )(3);

return (function (foo, ...args) { return args instanceof Array && args + "" === "bar,baz"; }("foo", "bar", "baz"));

return function(a, ...b){}.length === 1 && function(...c){}.length === 0;

return (function (foo, ...args) { foo = "qux"; // The arguments object is not mapped to the // parameters, even outside of strict mode. return arguments.length === 3 && arguments[0] === "foo" && arguments[1] === "bar" && arguments[2] === "baz"; }("foo", "bar", "baz"));

return (function (...args) { try { eval("({set e(...args){}})"); } catch(e) { return true; } }());

return new Function("a", "...b", "return b instanceof Array && a+b === 'foobar,baz';" )('foo','bar','baz');

return Math.max(...[1, 2, 3]) === 3

return [...[1, 2, 3]][2] === 3;

var a = Array(...[,,]); return "0" in a && "1" in a && '' + a[0] + a[1] === "undefinedundefined";

var a = [...[,,]]; return "0" in a && "1" in a && '' + a[0] + a[1] === "undefinedundefined";

return Math.max(..."1234") === 4;

return ["a", ..."bcd", "e"][3] === "d";

return Array(..."𠮷𠮶")[0] === "𠮷";

return [..."𠮷𠮶"][0] === "𠮷";

var iterable = (function*(){ yield 1; yield 2; yield 3; }()); return Math.max(...iterable) === 3;

var iterable = (function*(){ yield "b"; yield "c"; yield "d"; }()); return ["a", ...iterable, "e"][3] === "d";

var iterable = global.__createIterableObject([1, 2, 3]); return Math.max(...iterable) === 3;

var iterable = global.__createIterableObject(["b", "c", "d"]); return ["a", ...iterable, "e"][3] === "d";

var iterable = global.__createIterableObject([1, 2, 3]); return Math.max(...Object.create(iterable)) === 3;

var iterable = global.__createIterableObject(["b", "c", "d"]); return ["a", ...Object.create(iterable), "e"][3] === "d";

try { Math.max(...2); } catch(e) { return Math.max(...[1, 2, 3]) === 3; }

var x = 'y'; return ({ [x]: 1 }).y === 1;

var a = 7, b = 8, c = {a,b}; return c.a === 7 && c.b === 8;

return ({ y() { return 2; } }).y() === 2;

return ({ "foo bar"() { return 4; } })["foo bar"]() === 4;

var x = 'y'; return ({ [x](){ return 1 } }).y() === 1;

var x = 'y', valueSet, obj = { get [x] () { return 1 }, set [x] (value) { valueSet = value } }; obj.y = 'foo'; return obj.y === 1 && valueSet === 'foo';

var arr = [5]; for (var item of arr) return item === 5;

var arr = [,,]; var count = 0; for (var item of arr) count += (item === void undefined); return count === 2;

var str = ""; for (var item of "foo") str += item; return str === "foo";

var str = ""; for (var item of "𠮷𠮶") str += item + " "; return str === "𠮷 𠮶 ";

var result = ""; var iterable = (function*(){ yield 1; yield 2; yield 3; }()); for (var item of iterable) { result += item; } return result === "123";

var result = ""; var iterable = global.__createIterableObject([1, 2, 3]); for (var item of iterable) { result += item; } return result === "123";

var result = ""; var iterable = global.__createIterableObject([1, 2, 3]); for (var item of Object.create(iterable)) { result += item; } return result === "123";

var closed = false; var iter = __createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); for (var it of iter) break; return closed;

var closed = false; var iter = __createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); try { for (var it of iter) throw 0; } catch(e){} return closed;

return 0o10 === 8 && 0O10 === 8;

return 0b10 === 2 && 0B10 === 2;

return Number('0o1') === 1;

return Number('0b1') === 1;

var a = "ba", b = "QUX"; return `foo bar ${a + "z"} ${b.toLowerCase()}` === "foo bar\nbaz qux";

var a = { toString: function() { return "foo"; }, valueOf: function() { return "bar"; } }; return `${a}` === "foo";

var called = false; function fn(parts, a, b) { called = true; return parts instanceof Array && parts[0] === "foo" && parts[1] === "bar\n" && parts.raw[0] === "foo" && parts.raw[1] === "bar\\n" && a === 123 && b === 456; } return fn `foo${123}bar\n${456}` && called;

return (function(parts) { return Object.isFrozen(parts) && Object.isFrozen(parts.raw); }) `foo${0}bar${0}baz`;

var cr = eval("`x" + String.fromCharCode(13) + "y`"); var lf = eval("`x" + String.fromCharCode(10) + "y`"); var crlf = eval("`x" + String.fromCharCode(13,10) + "y`"); return cr.length === 3 && lf.length === 3 && crlf.length === 3 && cr[1] === lf[1] && lf[1] === crlf[1] && crlf[1] === '\n';

// TemplateStrings caching was changed from per-contents to // per-call-site. // https://github.com/tc39/ecma262/pull/890 function strings(array) { return array; } function getStrings() { return strings`foo`; } var original = getStrings(); var other = strings`foo`; return original === getStrings() && original !== other;

function strings(array) { return array; } function getStrings() { return strings`foo`; } var original = getStrings(); var newed = new getStrings(); return original === getStrings() && original === newed;

var re = new RegExp('\\w', 'y'); re.exec('xy'); return (re.exec('xy')[0] === 'y');

var re = new RegExp('yy', 'y'); re.lastIndex = 3; var result = re.exec('xxxyyxx')[0]; return result === 'yy' && re.lastIndex === 5;

return "𠮷".match(/^.$/u)[0].length === 2;

return "𠮷x".match(/^.x$/u)[0].length === 3;

return "𝌆".match(/\u{1d306}/u)[0].length === 2;

return "ſ".match(/S/iu) && "S".match(/ſ/iu);

var [a, , [b], c] = [5, null, [6]]; return a === 5 && b === 6 && c === void undefined;

var [a, , b] = [,,,]; return a === void undefined && b === void undefined;

var [a, b, c] = "ab"; return a === "a" && b === "b" && c === void undefined;

var [c] = "𠮷𠮶"; return c === "𠮷";

var [a, b, c] = (function*(){ yield 1; yield 2; }()); return a === 1 && b === 2 && c === void undefined;

var [a, b, c] = global.__createIterableObject([1, 2]); return a === 1 && b === 2 && c === void undefined;

var [a, b, c] = Object.create(global.__createIterableObject([1, 2])); return a === 1 && b === 2 && c === void undefined;

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); var [a, b] = iter; return closed;

var [a,] = [1]; return a === 1;

var {c, x:d, e} = {c:7, x:8}; return c === 7 && d === 8 && e === void undefined;

var {toFixed} = 2; var {slice} = ''; return toFixed === Number.prototype.toFixed && slice === String.prototype.slice;

var {a,} = {a:1}; return a === 1;

try { var {a} = null; return false; } catch(e) { if (!(e instanceof TypeError)) return false; } try { var {b} = void undefined; return false; } catch(e) { if (!(e instanceof TypeError)) return false; } return true;

var qux = "corge"; var { [qux]: grault } = { corge: "garply" }; return grault === "garply";

var [a,b] = [5,6], {c,d} = {c:7,d:8}; return a === 5 && b === 6 && c === 7 && d === 8;

var [e, {x:f, g}] = [9, {x:10}]; var {h, x:[i]} = {h:11, x:[12]}; return e === 9 && f === 10 && g === void undefined && h === 11 && i === 12;

for(var [i, j, k] in { qux: 1 }) { return i === "q" && j === "u" && k === "x"; }

for(var [i, j, k] of [[1,2,3]]) { return i === 1 && j === 2 && k === 3; }

try { throw [1,2]; } catch([i,j]) { try { throw { k: 3, l: 4 }; } catch({k, l}) { return i === 1 && j === 2 && k === 3 && l === 4; } }

var [a, ...b] = [3, 4, 5]; var [c, ...d] = [6]; return a === 3 && b instanceof Array && (b + "") === "4,5" && c === 6 && d instanceof Array && d.length === 0;

var {a = 1, b = 0, z:c = 3} = {b:2, z:undefined}; var [d = 0, e = 5, f = 6] = [4,,undefined]; return a === 1 && b === 2 && c === 3 && d === 4 && e === 5 && f === 6;

var {a, b = 2} = {a:1}; try { eval("let {c = c} = {};"); return false; } catch(e){} try { eval("let {c = d, d} = {d:1};"); return false; } catch(e){} return a === 1 && b === 2;

var a,b,c; [a, , [b], c] = [5, null, [6]]; return a === 5 && b === 6 && c === void undefined;

var a, b; [a, , b] = [,,,]; return a === void undefined && b === void undefined;

var a,b,c; [a, b, c] = "ab"; return a === "a" && b === "b" && c === void undefined;

var c; [c] = "𠮷𠮶"; return c === "𠮷";

var a,b,c; [a, b, c] = (function*(){ yield 1; yield 2; }()); return a === 1 && b === 2 && c === void undefined;

var a,b,c; [a, b, c] = global.__createIterableObject([1, 2]); return a === 1 && b === 2 && c === void undefined;

var a,b,c; [a, b, c] = Object.create(global.__createIterableObject([1, 2])); return a === 1 && b === 2 && c === void undefined;

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); var a,b; [a, b] = iter; return closed;

var a, b, iterable = [1,2]; return ([a, b] = iterable) === iterable;

var a,b,c,d; [a,b] = [c,d] = [1,2]; return a === 1 && b === 2 && c === 1 && d === 2;

var a; [a,] = [1]; return a === 1;

var c,d,e; ({c, x:d, e} = {c:7, x:8}); return c === 7 && d === 8 && e === void undefined;

var toFixed, slice; ({toFixed} = 2); ({slice} = ''); return toFixed === Number.prototype.toFixed && slice === String.prototype.slice;

var a; ({a,} = {a:1}); return a === 1;

var a, b, obj = { a:1, b:2 }; return ({a,b} = obj) === obj;

var a, b; ({a,b} = {a:1,b:2}); try { eval("({a,b}) = {a:3,b:4};"); } catch(e) { return a === 1 && b === 2; }

var a,b,c,d; ({a,b} = {c,d} = {a:1,b:2,c:3,d:4}); return a === 1 && b === 2 && c === 3 && d === 4;

var a,b; try { ({a} = null); return false; } catch(e) { if (!(e instanceof TypeError)) return false; } try { ({b} = void undefined); return false; } catch(e) { if (!(e instanceof TypeError)) return false; } return true;

var grault, qux = "corge"; ({ [qux]: grault } = { corge: "garply" }); return grault === "garply";

var e,f,g,h,i; [e, {x:f, g}] = [9, {x:10}]; ({h, x:[i]} = {h:11, x:[12]}); return e === 9 && f === 10 && g === void undefined && h === 11 && i === 12;

var a,b,c,d; [a, ...b] = [3, 4, 5]; [c, ...d] = [6]; return a === 3 && b instanceof Array && (b + "") === "4,5" && c === 6 && d instanceof Array && d.length === 0;

var a = [1, 2, 3], first, last; [first, ...[a[2], last]] = a; return first === 1 && last === 3 && (a + "") === "1,2,2";

[] = [1,2]; ({} = {a:1,b:2}); return true;

var a,b,c,d,e,f; ({a = 1, b = 0, z:c = 3} = {b:2, z:undefined}); [d = 0, e = 5, f = 6] = [4,,undefined]; return a === 1 && b === 2 && c === 3 && d === 4 && e === 5 && f === 6;

return function([a, , [b], c]) { return a === 5 && b === 6 && c === void undefined; }([5, null, [6]]);

return function([a, , b]) { return a === void undefined && b === void undefined; }([,,,]);

return function([a, b, c]) { return a === "a" && b === "b" && c === void undefined; }("ab");

return function([c]) { return c === "𠮷"; }("𠮷𠮶");

return function([a, b, c]) { return a === 1 && b === 2 && c === void undefined; }(function*(){ yield 1; yield 2; }());

return function([a, b, c]) { return a === 1 && b === 2 && c === void undefined; }(global.__createIterableObject([1, 2]));

return function([a, b, c]) { return a === 1 && b === 2 && c === void undefined; }(Object.create(global.__createIterableObject([1, 2])));

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); (function([a,b]) {}(iter)); return closed;

return function([a,]) { return a === 1; }([1]);

return function({c, x:d, e}) { return c === 7 && d === 8 && e === void undefined; }({c:7, x:8});

return function({toFixed}, {slice}) { return toFixed === Number.prototype.toFixed && slice === String.prototype.slice; }(2,'');

return function({a,}) { return a === 1; }({a:1});

try { (function({a}){}(null)); return false; } catch(e) {} try { (function({b}){}(undefined)); return false; } catch(e) {} return true;

var qux = "corge"; return function({ [qux]: grault }) { return grault === "garply"; }({ corge: "garply" });

return function([e, {x:f, g}], {h, x:[i]}) { return e === 9 && f === 10 && g === void undefined && h === 11 && i === 12; }([9, {x:10}],{h:11, x:[12]});

return (function({a, x:b, y:e}, [c, d]) { return arguments[0].a === 1 && arguments[0].x === 2 && !("y" in arguments[0]) && arguments[1] + '' === "3,4"; }({a:1, x:2}, [3, 4]));

return new Function("{a, x:b, y:e}","[c, d]", "return a === 1 && b === 2 && c === 3 && " + "d === 4 && e === void undefined;" )({a:1, x:2}, [3, 4]);

return function({a, b}, [c, d]){}.length === 2;

return function([a, ...b], [c, ...d]) { return a === 3 && b instanceof Array && (b + "") === "4,5" && c === 6 && d instanceof Array && d.length === 0; }([3, 4, 5], [6]);

return function ([],{}){ return arguments[0] + '' === "3,4" && arguments[1].x === "foo"; }([3,4],{x:"foo"});

return (function({a = 1, b = 0, c = 3, x:d = 0, y:e = 5}, [f = 6, g = 0, h = 8]) { return a === 1 && b === 2 && c === 3 && d === 4 && e === 5 && f === 6 && g === 7 && h === 8; }({b:2, c:undefined, x:4},[, 7, undefined]));

return (function({a=function(){ return typeof b === 'undefined'; }}){ var b = 1; return a(); }({}));

return new Function("{a = 1, b = 0, c = 3, x:d = 0, y:e = 5}", "return a === 1 && b === 2 && c === 3 && d === 4 && e === 5;" )({b:2, c:undefined, x:4});

return ((a, {b: x = 0, c: y = 3}) => { return a === 1 && x === 2 && y === 3; })(1, {b: 2});

return ((a, {b = 0, c = 3}) => { return a === 1 && b === 2 && c === 3; })(1, {b: 2});

try { eval('var d = function d([d]) { return d };if (d([true]) !== true) return false;'); } catch (e) { return !(e instanceof SyntaxError); } try { eval('var f = function f([id, id]) { return id }'); return false; } catch (e) { return e instanceof SyntaxError; }

return '\u{1d306}' === '\ud834\udf06';

var \u{102C0} = 2; return \u{102C0} === 2;

var o = { \u{102C0} : 2 }; return o['\ud800\udec0'] === 2;

var o = { '\ud800\udec0' : 2 }; return o.\u{102C0} === 2;

var passed = false; new function f() { passed = (new.target === f); }(); (function() { passed &= (new.target === void undefined); }()); return passed;

var passed = false; new function f() { passed = (new.target === f); }(); try { Function("new.target = function(){};"); } catch(e) { return passed; }

const foo = 123; return (foo === 123);

const bar = 123; { const bar = 456; } return bar === 123;

try { { const bar = 456; } const bar = 123; return bar === 123; } catch(e) { return false; }

const bar = 1; try { Function("if(true) const baz = 1;")(); } catch(e) { return true; }

const baz = 1; try { Function("const foo = 1; foo = 2;")(); } catch(e) { return true; }

const baz = 1; for(const baz = 0; false;) {} return baz === 1;

var scopes = []; for(const i in { a:1, b:1 }) { scopes.push(function(){ return i; }); } return (scopes[0]() === "a" && scopes[1]() === "b");

var scopes = []; for(const i of ['a','b']) { scopes.push(function(){ return i; }); } return (scopes[0]() === "a" && scopes[1]() === "b");

var passed = (function(){ try { qux; } catch(e) { return true; }}()); function fn() { passed &= qux === 456; } const qux = 456; fn(); return passed;

"use strict"; const foo = 123; return (foo === 123);

'use strict'; const bar = 123; { const bar = 456; } return bar === 123;

'use strict'; try { { const bar = 456; } const bar = 123; return bar === 123; } catch(e) { return false; }

'use strict'; const bar = 1; try { Function("'use strict'; if(true) const baz = 1;")(); } catch(e) { return true; }

'use strict'; const baz = 1; try { Function("'use strict'; const foo = 1; foo = 2;")(); } catch(e) { return true; }

'use strict'; const baz = 1; for(const baz = 0; false;) {} return baz === 1;

'use strict'; var scopes = []; for(const i in { a:1, b:1 }) { scopes.push(function(){ return i; }); } return (scopes[0]() === "a" && scopes[1]() === "b");

'use strict'; var scopes = []; for(const i of ['a','b']) { scopes.push(function(){ return i; }); } return (scopes[0]() === "a" && scopes[1]() === "b");

'use strict'; var passed = (function(){ try { qux; } catch(e) { return true; }}()); function fn() { passed &= qux === 456; } const qux = 456; fn(); return passed;

let foo = 123; return (foo === 123);

let bar = 123; { let bar = 456; } return bar === 123;

try { { let bar = 456; } let bar = 123; return bar === 123; } catch(e) { return false; }

let bar = 1; try { Function("if(true) let baz = 1;")(); } catch(e) { return true; }

let baz = 1; for(let baz = 0; false;) {} return baz === 1;

var passed = (function(){ try { qux; } catch(e) { return true; }}()); function fn() { passed &= qux === 456; } let qux = 456; fn(); return passed;

let scopes = []; for(let i = 0; i < 2; i++) { scopes.push(function(){ return i; }); } let passed = (scopes[0]() === 0 && scopes[1]() === 1); scopes = []; for(let i in { a:1, b:1 }) { scopes.push(function(){ return i; }); } passed &= (scopes[0]() === "a" && scopes[1]() === "b"); return passed;

try { Function("function f(e) { for (let e in {}) e }"); return true; } catch(e) { return false; }

'use strict'; let foo = 123; return (foo === 123);

'use strict'; let bar = 123; { let bar = 456; } return bar === 123;

'use strict'; try { { let bar = 456; } let bar = 123; return bar === 123; } catch(e) { return false; }

'use strict'; let bar = 1; try { Function("'use strict'; if(true) let baz = 1;")(); } catch(e) { return true; }

'use strict'; let baz = 1; for(let baz = 0; false;) {} return baz === 1;

'use strict'; var passed = (function(){ try { qux; } catch(e) { return true; }}()); function fn() { passed &= qux === 456; } let qux = 456; fn(); return passed;

'use strict'; let scopes = []; for(let i = 0; i < 2; i++) { scopes.push(function(){ return i; }); } let passed = (scopes[0]() === 0 && scopes[1]() === 1); scopes = []; for(let i in { a:1, b:1 }) { scopes.push(function(){ return i; }); } passed &= (scopes[0]() === "a" && scopes[1]() === "b"); return passed;

try { Function("'use strict'; function f(e) { for (let e in {}) e }"); return true; } catch(e) { return false; }

'use strict'; if (f() !== 1) return false; function f() { return 1; } { if (f() !== 2) return false; function f() { return 2; } if (f() !== 2) return false; } if (f() !== 1) return false; return true;

return (() => 5)() === 5;

var b = x => x + "foo"; return (b("fee fie foe ") === "fee fie foe foo");

var c = (v, w, x, y, z) => "" + v + w + x + y + z; return (c(6, 5, 4, 3, 2) === "65432");

var d = { x : "bar", y : function() { return z => this.x + z; }}.y(); var e = { x : "baz", y : d }; return d("ley") === "barley" && e.y("ley") === "barley";

var d = { x : "foo", y : function() { return () => this.x; }}; var e = { x : "bar" }; return d.y().call(e) === "foo" && d.y().apply(e) === "foo";

var d = { x : "bar", y : function() { return z => this.x + z; }}; var e = { x : "baz" }; return d.y().bind(e, "ley")() === "barley";

var f = (function() { return z => arguments[0]; }(5)); return f(6) === 5;

return (() => { try { Function("x\n => 2")(); } catch(e) { return true; } })();

return (() => { try { Function("0 || () => 2")(); } catch(e) { return true; } })();

var a = () => 5; return !a.hasOwnProperty("prototype");

var received; class B { constructor (arg) { received = arg; } } class C extends B { constructor () { var callSuper = () => super('foo'); callSuper(); } } return new C instanceof C && received === 'foo'

class B { qux() { return "quux"; } } class C extends B { baz() { return x => super.qux(); } } var arrow = new C().baz(); return arrow() === "quux";

function C() { return x => new.target; } return new C()() === C && C()() === void undefined;

class C {} return typeof C === "function";

class C {} var c1 = C; { class C {} var c2 = C; } return C === c1;

return typeof class C {} === "function";

return typeof class {} === "function";

class C { constructor() { this.x = 1; } } return C.prototype.constructor === C && new C().x === 1;

class C { method() { return 2; } } return typeof C.prototype.method === "function" && new C().method() === 2;

class C { "foo bar"() { return 2; } } return typeof C.prototype["foo bar"] === "function" && new C()["foo bar"]() === 2;

var foo = "method"; class C { [foo]() { return 2; } } return typeof C.prototype.method === "function" && new C().method() === 2;

class C { ; method() { return 2; }; method2() { return 2; } method3() { return 2; }; } return typeof C.prototype.method === "function" && typeof C.prototype.method2 === "function" && typeof C.prototype.method3 === "function";

class C { static method() { return 3; } } return typeof C.method === "function" && C.method() === 3;

var foo = "method"; class C { static [foo]() { return 3; } } return typeof C.method === "function" && C.method() === 3;

var baz = false; class C { get foo() { return "foo"; } set bar(x) { baz = x; } } new C().bar = true; return new C().foo === "foo" && baz;

var garply = "foo", grault = "bar", baz = false; class C { get [garply]() { return "foo"; } set [grault](x) { baz = x; } } new C().bar = true; return new C().foo === "foo" && baz;

var baz = false; class C { static get foo() { return "foo"; } static set bar(x) { baz = x; } } C.bar = true; return C.foo === "foo" && baz;

var garply = "foo", grault = "bar", baz = false; class C { static get [garply]() { return "foo"; } static set [grault](x) { baz = x; } } C.bar = true; return C.foo === "foo" && baz;

class C { method() { return typeof C === "function"; } } var M = C.prototype.method; C = void undefined; return C === void undefined && M();

try { var B = class C { [C](){} } } catch(e) { return true; }

class C { foo() {} static bar() {} } return !C.prototype.propertyIsEnumerable("foo") && !C.propertyIsEnumerable("bar");

class C { static method() { return this === void undefined; } } return (0,C.method)();

class C {} try { C(); } catch(e) { return true; }

class B {} class C extends B {} return new C() instanceof B && B.isPrototypeOf(C);

var B; class C extends (B = class {}) {} return new C() instanceof B && B.isPrototypeOf(C);

class C extends null { constructor() { return Object.create(null); } } return Function.prototype.isPrototypeOf(C) && Object.getPrototypeOf(C.prototype) === null;

var passed = false; new function f() { passed = new.target === f; }(); class A { constructor() { passed &= new.target === B; } } class B extends A {} new B(); return passed;

var passed = false; class B { constructor(a) { passed = (a === "barbaz"); } } class C extends B { constructor(a) { super("bar" + a); } } new C("baz"); return passed;

class B { constructor(a) { return ["foo" + a]; } } class C extends B { constructor(a) { return super("bar" + a); } } return new C("baz")[0] === "foobarbaz";

class B {} B.prototype.qux = "foo"; B.prototype.corge = "baz"; class C extends B { quux(a) { return super.qux + a + super["corge"]; } } C.prototype.qux = "garply"; return new C().quux("bar") === "foobarbaz";

class B { qux(a) { return "foo" + a; } } class C extends B { qux(a) { return super.qux("bar" + a); } } return new C().qux("baz") === "foobarbaz";

class B { qux(a) { return this.foo + a; } } class C extends B { qux(a) { return super.qux("bar" + a); } } var obj = new C(); obj.foo = "foo"; return obj.qux("baz") === "foobarbaz";

var passed; class B { constructor() { passed = (new.target === C); } } class C extends B { constructor() { super(); } } new C(); return passed;

class B { qux() { return "bar"; } } class C extends B { qux() { return super.qux() + this.corge; } } var obj = { qux: C.prototype.qux, corge: "ley" }; return obj.qux() === "barley";

// checks that super() is *not* a synonym of super.constructor() var passed; class B { constructor() { passed = true; } }; B.prototype.constructor = function () { passed = false; }; class C extends B { }; new C; return passed;

function * generator(){ yield 5; yield 6; }; var iterator = generator(); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var generator = function * (){ yield 5; yield 6; }; var iterator = generator(); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

function * generator(){ yield this.x; yield this.y; }; var iterator = { g: generator, x: 5, y: 6 }.g(); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

function * generator(){ yield this.x; yield this.y; }; try { (new generator()).next(); } catch (e) { return true; }

var sent; function * generator(){ sent = [yield 5, yield 6]; }; var iterator = generator(); iterator.next(); iterator.next("foo"); iterator.next("bar"); return sent[0] === "foo" && sent[1] === "bar";

function * generatorFn(){} var ownProto = Object.getPrototypeOf(generatorFn()); var passed = ownProto === generatorFn.prototype; var sharedProto = Object.getPrototypeOf(ownProto); passed &= sharedProto !== Object.prototype && sharedProto === Object.getPrototypeOf(function*(){}.prototype) && sharedProto.hasOwnProperty('next'); return passed;

function * generatorFn(){} var g = generatorFn(); var ownProto = Object.getPrototypeOf(g); var passed = ownProto === generatorFn.prototype; var sharedProto = Object.getPrototypeOf(ownProto); var iterProto = Object.getPrototypeOf(sharedProto); passed &= iterProto.hasOwnProperty(Symbol.iterator) && !sharedProto .hasOwnProperty(Symbol.iterator) && !ownProto .hasOwnProperty(Symbol.iterator) && g[Symbol.iterator]() === g; return passed;

function * g (){} var iterator = new g.constructor("a","b","c","yield a; yield b; yield c;")(5,6,7); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === 7 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; passed &= g.constructor === (function*(){}).constructor; return passed;

var passed = false; function * generator(){ try { yield 5; yield 6; } catch(e) { passed = (e === "foo"); } }; var iterator = generator(); iterator.next(); iterator.throw("foo"); return passed;

function * generator(){ yield 5; yield 6; }; var iterator = generator(); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.return("quxquux"); passed &= item.value === "quxquux" && item.done === true; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var passed; function * generator(){ passed = yield 0 ? true : false; }; var iterator = generator(); iterator.next(); iterator.next(true); return passed;

var iterator = (function * generator() { yield * [5, 6]; }()); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var iterator = (function * generator() { yield * [,,]; }()); var item = iterator.next(); var passed = item.value === void undefined && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var iterator = (function * generator() { yield * "56"; }()); var item = iterator.next(); var passed = item.value === "5" && item.done === false; item = iterator.next(); passed &= item.value === "6" && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var iterator = (function * generator() { yield * "𠮷𠮶"; }()); var item = iterator.next(); var passed = item.value === "𠮷" && item.done === false; item = iterator.next(); passed &= item.value === "𠮶" && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var iterator = (function * generator() { yield * (function*(){ yield 5; yield 6; yield 7; }()); }()); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === 7 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var iterator = (function * generator() { yield * global.__createIterableObject([5, 6, 7]); }()); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === 7 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var iterator = (function * generator() { yield * Object.create(__createIterableObject([5, 6, 7])); }()); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === 7 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var iterator = (function * generator() { yield * [5]; }()); var item = iterator.next(); var passed = item.value === 5 && item.done === false; iterator = (function * generator() { yield * 5; }()); try { iterator.next(); } catch (e) { return passed; }

var closed = ''; var iter = __createIterableObject([1, 2, 3], { 'return': function(){ closed += 'a'; return {done: true}; } }); var gen = (function* generator(){ try { yield *iter; } finally { closed += 'b'; } })(); gen.next(); gen['return'](); return closed === 'ab';

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'throw': undefined, 'return': function() { closed = true; return {done: true}; } }); var gen = (function*(){ try { yield *iter; } catch(e){} })(); gen.next(); gen['throw'](); return closed;

var o = { * generator() { yield 5; yield 6; } }; var iterator = o.generator(); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var o = { * "foo bar"() { yield 5; yield 6; } }; var iterator = o["foo bar"](); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var garply = "generator"; var o = { * [garply] () { yield 5; yield 6; } }; var iterator = o.generator(); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

class C { * generator() { yield 5; yield 6; } }; var iterator = new C().generator(); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

var garply = "generator"; class C { * [garply] () { yield 5; yield 6; } } var iterator = new C().generator(); var item = iterator.next(); var passed = item.value === 5 && item.done === false; item = iterator.next(); passed &= item.value === 6 && item.done === false; item = iterator.next(); passed &= item.value === void undefined && item.done === true; return passed;

class C { * generator() { yield 5; yield 6; } }; try { Function("class D { * constructor() { return {}; } }"); } catch(e) { return true; }

var buffer = new ArrayBuffer(64); var view = new Int8Array(buffer); view[0] = 0x80; return view[0] === -0x80;

var buffer = new ArrayBuffer(64); var view = new Uint8Array(buffer); view[0] = 0x100; return view[0] === 0;

var buffer = new ArrayBuffer(64); var view = new Uint8ClampedArray(buffer); view[0] = 0x100; return view[0] === 0xFF;

var buffer = new ArrayBuffer(64); var view = new Int16Array(buffer); view[0] = 0x8000; return view[0] === -0x8000;

var buffer = new ArrayBuffer(64); var view = new Uint16Array(buffer); view[0] = 0x10000; return view[0] === 0;

var buffer = new ArrayBuffer(64); var view = new Int32Array(buffer); view[0] = 0x80000000; return view[0] === -0x80000000;

var buffer = new ArrayBuffer(64); var view = new Uint32Array(buffer); view[0] = 0x100000000; return view[0] === 0;

var buffer = new ArrayBuffer(64); var view = new Float32Array(buffer); view[0] = 0.1; return view[0] === 0.10000000149011612;

var buffer = new ArrayBuffer(64); var view = new Float64Array(buffer); view[0] = 0.1; return view[0] === 0.1;

var buffer = new ArrayBuffer(64); var view = new DataView(buffer); view.setInt8 (0, 0x80); return view.getInt8(0) === -0x80;

var buffer = new ArrayBuffer(64); var view = new DataView(buffer); view.setUint8(0, 0x100); return view.getUint8(0) === 0;

var buffer = new ArrayBuffer(64); var view = new DataView(buffer); view.setInt16(0, 0x8000); return view.getInt16(0) === -0x8000;

var buffer = new ArrayBuffer(64); var view = new DataView(buffer); view.setUint16(0, 0x10000); return view.getUint16(0) === 0;

var buffer = new ArrayBuffer(64); var view = new DataView(buffer); view.setInt32(0, 0x80000000); return view.getInt32(0) === -0x80000000;

var buffer = new ArrayBuffer(64); var view = new DataView(buffer); view.setUint32(0, 0x100000000); return view.getUint32(0) === 0;

var buffer = new ArrayBuffer(64); var view = new DataView(buffer); view.setFloat32(0, 0.1); return view.getFloat32(0) === 0.10000000149011612;

var buffer = new ArrayBuffer(64); var view = new DataView(buffer); view.setFloat64(0, 0.1); return view.getFloat64(0) === 0.1;

return typeof ArrayBuffer[Symbol.species] === 'function';

var buffer = new ArrayBuffer(64); var constructors = [ 'ArrayBuffer', 'DataView', 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array' ]; return constructors.every(function (constructor) { try { if (constructor in global) { global[constructor](constructor === "ArrayBuffer" ? 64 : buffer); } return false; } catch(e) { return true; } });

var constructors = [ 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array' ]; for(var i = 0; i < constructors.length; i++){ var arr = new global[constructors[i]](__createIterableObject([1, 2, 3])); if(arr.length !== 3 || arr[0] !== 1 || arr[1] !== 2 || arr[2] !== 3)return false; } return true;

var constructors = [ 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array' ]; var constructor = Object.getPrototypeOf(Int8Array); var prototype = Object.getPrototypeOf(Int8Array.prototype); if(constructor === Function.prototype || prototype === Object.prototype)return false; for(var i = 0; i < constructors.length; i+=1) { if (!(constructors[i] in global && Object.getPrototypeOf(global[constructors[i]]) === constructor && Object.getPrototypeOf(global[constructors[i]].prototype) === prototype && Object.getOwnPropertyNames(global[constructors[i]].prototype).sort() + '' === "BYTES_PER_ELEMENT,constructor")) { return false; } } return true;

return typeof Int8Array.from === "function" && typeof Uint8Array.from === "function" && typeof Uint8ClampedArray.from === "function" && typeof Int16Array.from === "function" && typeof Uint16Array.from === "function" && typeof Int32Array.from === "function" && typeof Uint32Array.from === "function" && typeof Float32Array.from === "function" && typeof Float64Array.from === "function";

return typeof Int8Array.of === "function" && typeof Uint8Array.of === "function" && typeof Uint8ClampedArray.of === "function" && typeof Int16Array.of === "function" && typeof Uint16Array.of === "function" && typeof Int32Array.of === "function" && typeof Uint32Array.of === "function" && typeof Float32Array.of === "function" && typeof Float64Array.of === "function";

return typeof Int8Array.prototype.subarray === "function" && typeof Uint8Array.prototype.subarray === "function" && typeof Uint8ClampedArray.prototype.subarray === "function" && typeof Int16Array.prototype.subarray === "function" && typeof Uint16Array.prototype.subarray === "function" && typeof Int32Array.prototype.subarray === "function" && typeof Uint32Array.prototype.subarray === "function" && typeof Float32Array.prototype.subarray === "function" && typeof Float64Array.prototype.subarray === "function";

return typeof Int8Array.prototype.join === "function" && typeof Uint8Array.prototype.join === "function" && typeof Uint8ClampedArray.prototype.join === "function" && typeof Int16Array.prototype.join === "function" && typeof Uint16Array.prototype.join === "function" && typeof Int32Array.prototype.join === "function" && typeof Uint32Array.prototype.join === "function" && typeof Float32Array.prototype.join === "function" && typeof Float64Array.prototype.join === "function";

return typeof Int8Array.prototype.indexOf === "function" && typeof Uint8Array.prototype.indexOf === "function" && typeof Uint8ClampedArray.prototype.indexOf === "function" && typeof Int16Array.prototype.indexOf === "function" && typeof Uint16Array.prototype.indexOf === "function" && typeof Int32Array.prototype.indexOf === "function" && typeof Uint32Array.prototype.indexOf === "function" && typeof Float32Array.prototype.indexOf === "function" && typeof Float64Array.prototype.indexOf === "function";

return typeof Int8Array.prototype.lastIndexOf === "function" && typeof Uint8Array.prototype.lastIndexOf === "function" && typeof Uint8ClampedArray.prototype.lastIndexOf === "function" && typeof Int16Array.prototype.lastIndexOf === "function" && typeof Uint16Array.prototype.lastIndexOf === "function" && typeof Int32Array.prototype.lastIndexOf === "function" && typeof Uint32Array.prototype.lastIndexOf === "function" && typeof Float32Array.prototype.lastIndexOf === "function" && typeof Float64Array.prototype.lastIndexOf === "function";

return typeof Int8Array.prototype.slice === "function" && typeof Uint8Array.prototype.slice === "function" && typeof Uint8ClampedArray.prototype.slice === "function" && typeof Int16Array.prototype.slice === "function" && typeof Uint16Array.prototype.slice === "function" && typeof Int32Array.prototype.slice === "function" && typeof Uint32Array.prototype.slice === "function" && typeof Float32Array.prototype.slice === "function" && typeof Float64Array.prototype.slice === "function";

return typeof Int8Array.prototype.every === "function" && typeof Uint8Array.prototype.every === "function" && typeof Uint8ClampedArray.prototype.every === "function" && typeof Int16Array.prototype.every === "function" && typeof Uint16Array.prototype.every === "function" && typeof Int32Array.prototype.every === "function" && typeof Uint32Array.prototype.every === "function" && typeof Float32Array.prototype.every === "function" && typeof Float64Array.prototype.every === "function";

return typeof Int8Array.prototype.filter === "function" && typeof Uint8Array.prototype.filter === "function" && typeof Uint8ClampedArray.prototype.filter === "function" && typeof Int16Array.prototype.filter === "function" && typeof Uint16Array.prototype.filter === "function" && typeof Int32Array.prototype.filter === "function" && typeof Uint32Array.prototype.filter === "function" && typeof Float32Array.prototype.filter === "function" && typeof Float64Array.prototype.filter === "function";

return typeof Int8Array.prototype.forEach === "function" && typeof Uint8Array.prototype.forEach === "function" && typeof Uint8ClampedArray.prototype.forEach === "function" && typeof Int16Array.prototype.forEach === "function" && typeof Uint16Array.prototype.forEach === "function" && typeof Int32Array.prototype.forEach === "function" && typeof Uint32Array.prototype.forEach === "function" && typeof Float32Array.prototype.forEach === "function" && typeof Float64Array.prototype.forEach === "function";

return typeof Int8Array.prototype.map === "function" && typeof Uint8Array.prototype.map === "function" && typeof Uint8ClampedArray.prototype.map === "function" && typeof Int16Array.prototype.map === "function" && typeof Uint16Array.prototype.map === "function" && typeof Int32Array.prototype.map === "function" && typeof Uint32Array.prototype.map === "function" && typeof Float32Array.prototype.map === "function" && typeof Float64Array.prototype.map === "function";

return typeof Int8Array.prototype.reduce === "function" && typeof Uint8Array.prototype.reduce === "function" && typeof Uint8ClampedArray.prototype.reduce === "function" && typeof Int16Array.prototype.reduce === "function" && typeof Uint16Array.prototype.reduce === "function" && typeof Int32Array.prototype.reduce === "function" && typeof Uint32Array.prototype.reduce === "function" && typeof Float32Array.prototype.reduce === "function" && typeof Float64Array.prototype.reduce === "function";

return typeof Int8Array.prototype.reduceRight === "function" && typeof Uint8Array.prototype.reduceRight === "function" && typeof Uint8ClampedArray.prototype.reduceRight === "function" && typeof Int16Array.prototype.reduceRight === "function" && typeof Uint16Array.prototype.reduceRight === "function" && typeof Int32Array.prototype.reduceRight === "function" && typeof Uint32Array.prototype.reduceRight === "function" && typeof Float32Array.prototype.reduceRight === "function" && typeof Float64Array.prototype.reduceRight === "function";

return typeof Int8Array.prototype.reverse === "function" && typeof Uint8Array.prototype.reverse === "function" && typeof Uint8ClampedArray.prototype.reverse === "function" && typeof Int16Array.prototype.reverse === "function" && typeof Uint16Array.prototype.reverse === "function" && typeof Int32Array.prototype.reverse === "function" && typeof Uint32Array.prototype.reverse === "function" && typeof Float32Array.prototype.reverse === "function" && typeof Float64Array.prototype.reverse === "function";

return typeof Int8Array.prototype.some === "function" && typeof Uint8Array.prototype.some === "function" && typeof Uint8ClampedArray.prototype.some === "function" && typeof Int16Array.prototype.some === "function" && typeof Uint16Array.prototype.some === "function" && typeof Int32Array.prototype.some === "function" && typeof Uint32Array.prototype.some === "function" && typeof Float32Array.prototype.some === "function" && typeof Float64Array.prototype.some === "function";

return typeof Int8Array.prototype.sort === "function" && typeof Uint8Array.prototype.sort === "function" && typeof Uint8ClampedArray.prototype.sort === "function" && typeof Int16Array.prototype.sort === "function" && typeof Uint16Array.prototype.sort === "function" && typeof Int32Array.prototype.sort === "function" && typeof Uint32Array.prototype.sort === "function" && typeof Float32Array.prototype.sort === "function" && typeof Float64Array.prototype.sort === "function";

return typeof Int8Array.prototype.copyWithin === "function" && typeof Uint8Array.prototype.copyWithin === "function" && typeof Uint8ClampedArray.prototype.copyWithin === "function" && typeof Int16Array.prototype.copyWithin === "function" && typeof Uint16Array.prototype.copyWithin === "function" && typeof Int32Array.prototype.copyWithin === "function" && typeof Uint32Array.prototype.copyWithin === "function" && typeof Float32Array.prototype.copyWithin === "function" && typeof Float64Array.prototype.copyWithin === "function";

return typeof Int8Array.prototype.find === "function" && typeof Uint8Array.prototype.find === "function" && typeof Uint8ClampedArray.prototype.find === "function" && typeof Int16Array.prototype.find === "function" && typeof Uint16Array.prototype.find === "function" && typeof Int32Array.prototype.find === "function" && typeof Uint32Array.prototype.find === "function" && typeof Float32Array.prototype.find === "function" && typeof Float64Array.prototype.find === "function";

return typeof Int8Array.prototype.findIndex === "function" && typeof Uint8Array.prototype.findIndex === "function" && typeof Uint8ClampedArray.prototype.findIndex === "function" && typeof Int16Array.prototype.findIndex === "function" && typeof Uint16Array.prototype.findIndex === "function" && typeof Int32Array.prototype.findIndex === "function" && typeof Uint32Array.prototype.findIndex === "function" && typeof Float32Array.prototype.findIndex === "function" && typeof Float64Array.prototype.findIndex === "function";

return typeof Int8Array.prototype.fill === "function" && typeof Uint8Array.prototype.fill === "function" && typeof Uint8ClampedArray.prototype.fill === "function" && typeof Int16Array.prototype.fill === "function" && typeof Uint16Array.prototype.fill === "function" && typeof Int32Array.prototype.fill === "function" && typeof Uint32Array.prototype.fill === "function" && typeof Float32Array.prototype.fill === "function" && typeof Float64Array.prototype.fill === "function";

return typeof Int8Array.prototype.keys === "function" && typeof Uint8Array.prototype.keys === "function" && typeof Uint8ClampedArray.prototype.keys === "function" && typeof Int16Array.prototype.keys === "function" && typeof Uint16Array.prototype.keys === "function" && typeof Int32Array.prototype.keys === "function" && typeof Uint32Array.prototype.keys === "function" && typeof Float32Array.prototype.keys === "function" && typeof Float64Array.prototype.keys === "function";

return typeof Int8Array.prototype.values === "function" && typeof Uint8Array.prototype.values === "function" && typeof Uint8ClampedArray.prototype.values === "function" && typeof Int16Array.prototype.values === "function" && typeof Uint16Array.prototype.values === "function" && typeof Int32Array.prototype.values === "function" && typeof Uint32Array.prototype.values === "function" && typeof Float32Array.prototype.values === "function" && typeof Float64Array.prototype.values === "function";

return typeof Int8Array.prototype.entries === "function" && typeof Uint8Array.prototype.entries === "function" && typeof Uint8ClampedArray.prototype.entries === "function" && typeof Int16Array.prototype.entries === "function" && typeof Uint16Array.prototype.entries === "function" && typeof Int32Array.prototype.entries === "function" && typeof Uint32Array.prototype.entries === "function" && typeof Float32Array.prototype.entries === "function" && typeof Float64Array.prototype.entries === "function";

return typeof Int8Array.prototype[Symbol.iterator] === "function" && typeof Uint8Array.prototype[Symbol.iterator] === "function" && typeof Uint8ClampedArray.prototype[Symbol.iterator] === "function" && typeof Int16Array.prototype[Symbol.iterator] === "function" && typeof Uint16Array.prototype[Symbol.iterator] === "function" && typeof Int32Array.prototype[Symbol.iterator] === "function" && typeof Uint32Array.prototype[Symbol.iterator] === "function" && typeof Float32Array.prototype[Symbol.iterator] === "function" && typeof Float64Array.prototype[Symbol.iterator] === "function";

return typeof Int8Array[Symbol.species] === "function" && typeof Uint8Array[Symbol.species] === "function" && typeof Uint8ClampedArray[Symbol.species] === "function" && typeof Int16Array[Symbol.species] === "function" && typeof Uint16Array[Symbol.species] === "function" && typeof Int32Array[Symbol.species] === "function" && typeof Uint32Array[Symbol.species] === "function" && typeof Float32Array[Symbol.species] === "function" && typeof Float64Array[Symbol.species] === "function";

var key = {}; var map = new Map(); map.set(key, 123); return map.has(key) && map.get(key) === 123;

var key1 = {}; var key2 = {}; var map = new Map([[key1, 123], [key2, 456]]); return map.has(key1) && map.get(key1) === 123 && map.has(key2) && map.get(key2) === 456;

new Map(); try { Map(); return false; } catch(e) { return true; }

new Map(null); return true;

var passed = false; var _set = Map.prototype.set; Map.prototype.set = function(k, v) { passed = true; }; new Map([ [1, 2] ]); Map.prototype.set = _set; return passed;

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); try { new Map(iter); } catch(e){} return closed;

var map = new Map(); return map.set(0, 0) === map;

var map = new Map(); map.set(-0, "foo"); var k; map.forEach(function (value, key) { k = 1 / key; }); return k === Infinity && map.get(+0) === "foo";

var key = {}; var map = new Map(); map.set(key, 123); return map.size === 1;

return typeof Map.prototype.delete === "function";

return typeof Map.prototype.clear === "function";

return typeof Map.prototype.forEach === "function";

return typeof Map.prototype.keys === "function";

return typeof Map.prototype.values === "function";

return typeof Map.prototype.entries === "function";

return typeof Map.prototype[Symbol.iterator] === "function";

new Map(); var obj = {}; try { Map.prototype.has(obj); } catch(e) { return true; }

// Iterator instance var iterator = new Map()[Symbol.iterator](); // %MapIteratorPrototype% var proto1 = Object.getPrototypeOf(iterator); // %IteratorPrototype% var proto2 = Object.getPrototypeOf(proto1); return proto2.hasOwnProperty(Symbol.iterator) && !proto1 .hasOwnProperty(Symbol.iterator) && !iterator .hasOwnProperty(Symbol.iterator) && iterator[Symbol.iterator]() === iterator;

var prop = Object.getOwnPropertyDescriptor(Map, Symbol.species); return 'get' in prop && Map[Symbol.species] === Map;

var obj = {}; var set = new Set(); set.add(123); set.add(123); return set.has(123);

var obj1 = {}; var obj2 = {}; var set = new Set([obj1, obj2]); return set.has(obj1) && set.has(obj2);

new Set(); try { Set(); return false; } catch(e) { return true; }

new Set(null); return true;

var passed = false; var _add = Set.prototype.add; Set.prototype.add = function(v) { passed = true; }; new Set([1]); Set.prototype.add = _add; return passed;

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); var add = Set.prototype.add; Set.prototype.add = function(){ throw 0 }; try { new Set(iter); } catch(e){} Set.prototype.add = add; return closed;

var set = new Set(); return set.add(0) === set;

var set = new Set(); set.add(-0); var k; set.forEach(function (value) { k = 1 / value; }); return k === Infinity && set.has(+0);

var obj = {}; var set = new Set(); set.add(123); set.add(123); set.add(456); return set.size === 2;

return typeof Set.prototype.delete === "function";

return typeof Set.prototype.clear === "function";

return typeof Set.prototype.forEach === "function";

return typeof Set.prototype.keys === "function";

return typeof Set.prototype.values === "function";

return typeof Set.prototype.entries === "function";

return typeof Set.prototype[Symbol.iterator] === "function";

new Set(); var obj = {}; try { Set.prototype.has(obj); } catch(e) { return true; }

// Iterator instance var iterator = new Set()[Symbol.iterator](); // %SetIteratorPrototype% var proto1 = Object.getPrototypeOf(iterator); // %IteratorPrototype% var proto2 = Object.getPrototypeOf(proto1); return proto2.hasOwnProperty(Symbol.iterator) && !proto1 .hasOwnProperty(Symbol.iterator) && !iterator .hasOwnProperty(Symbol.iterator) && iterator[Symbol.iterator]() === iterator;

var prop = Object.getOwnPropertyDescriptor(Set, Symbol.species); return 'get' in prop && Set[Symbol.species] === Set;

var key = {}; var weakmap = new WeakMap(); weakmap.set(key, 123); return weakmap.has(key) && weakmap.get(key) === 123;

var key1 = {}; var key2 = {}; var weakmap = new WeakMap([[key1, 123], [key2, 456]]); return weakmap.has(key1) && weakmap.get(key1) === 123 && weakmap.has(key2) && weakmap.get(key2) === 456;

new WeakMap(); try { WeakMap(); return false; } catch(e) { return true; }

new WeakMap(null); return true;

var passed = false; var _set = WeakMap.prototype.set; WeakMap.prototype.set = function(k, v) { passed = true; }; new WeakMap([ [{ }, 42] ]); WeakMap.prototype.set = _set; return passed;

var f = Object.freeze({}); var m = new WeakMap; m.set(f, 42); return m.get(f) === 42;

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); try { new WeakMap(iter); } catch(e){} return closed;

var weakmap = new WeakMap(); var key = {}; return weakmap.set(key, 0) === weakmap;

return typeof WeakMap.prototype.delete === "function";

if (!("clear" in WeakMap.prototype)) { return true; } var m = new WeakMap(); var key = {}; m.set(key, 2); m.clear(); return m.has(key);

var m = new WeakMap; return m.has(1) === false && m.get(1) === void undefined && m.delete(1) === false;

new WeakMap(); var obj = {}; try { WeakMap.prototype.has(obj); } catch(e) { return true; }

var obj1 = {}; var weakset = new WeakSet(); weakset.add(obj1); weakset.add(obj1); return weakset.has(obj1);

var obj1 = {}, obj2 = {}; var weakset = new WeakSet([obj1, obj2]); return weakset.has(obj1) && weakset.has(obj2);

new WeakSet(); try { WeakSet(); return false; } catch(e) { return true; }

new WeakSet(null); return true;

var passed = false; var _add = WeakSet.prototype.add; WeakSet.prototype.add = function(v) { passed = true; }; new WeakSet([ { } ]); WeakSet.prototype.add = _add; return passed;

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); try { new WeakSet(iter); } catch(e){} return closed;

var weakset = new WeakSet(); var obj = {}; return weakset.add(obj) === weakset;

return typeof WeakSet.prototype.delete === "function";

if (!("clear" in WeakSet.prototype)) { return true; } var s = new WeakSet(); var key = {}; s.add(key); s.clear(); return s.has(key);

var s = new WeakSet; return s.has(1) === false && s.delete(1) === false;

new WeakSet(); var obj = {}; try { WeakSet.prototype.has(obj); } catch(e) { return true; }

new Proxy({}, {}); try { Proxy({}, {}); return false; } catch(e) { return true; }

new Proxy({}, {}); return !Proxy.hasOwnProperty('prototype');

var proxied = { }; var proxy = new Proxy(proxied, { get: function (t, k, r) { return t === proxied && k === "foo" && r === proxy && 5; } }); return proxy.foo === 5;

var proxied = { }; var proxy = Object.create(new Proxy(proxied, { get: function (t, k, r) { return t === proxied && k === "foo" && r === proxy && 5; } })); return proxy.foo === 5;

var passed = false; var proxied = { }; var proxy = new Proxy(proxied, { get: function () { passed = true; return 4; } }); // The value reported for a property must be the same as the value of the corresponding // target object property if the target object property is a non-writable, // non-configurable own data property. Object.defineProperty(proxied, "foo", { value: 5, enumerable: true }); try { proxy.foo; return false; } catch(e) {} // The value reported for a property must be undefined if the corresponding target // object property is a non-configurable own accessor property that has undefined // as its [[Get]] attribute. Object.defineProperty(proxied, "bar", { set: function(){}, enumerable: true }); try { proxy.bar; return false; } catch(e) {} return passed;

var proxied = { }; var passed = false; var proxy = new Proxy(proxied, { set: function (t, k, v, r) { passed = t === proxied && k + v === "foobar" && r === proxy; } }); proxy.foo = "bar"; return passed;

var proxied = { }; var passed = false; var proxy = Object.create(new Proxy(proxied, { set: function (t, k, v, r) { passed = t === proxied && k + v === "foobar" && r === proxy; } })); proxy.foo = "bar"; return passed;

var passed = false; new Proxy({},{}); // Cannot change the value of a property to be different from the value of // the corresponding target object if the corresponding target object // property is a non-writable, non-configurable own data property. var proxied = {}; var proxy = new Proxy(proxied, { set: function () { passed = true; return true; } }); Object.defineProperty(proxied, "foo", { value: 2, enumerable: true }); proxy.foo = 2; try { proxy.foo = 4; return false; } catch(e) {} // Cannot set the value of a property if the corresponding target // object property is a non-configurable own accessor property // that has undefined as its [[Set]] attribute. Object.defineProperty(proxied, "bar", { get: function(){}, enumerable: true }); try { proxy.bar = 2; return false; } catch(e) {} return passed;

var proxied = {}; var passed = false; "foo" in new Proxy(proxied, { has: function (t, k) { passed = t === proxied && k === "foo"; } }); return passed;

var proxied = {}; var passed = false; "foo" in Object.create(new Proxy(proxied, { has: function (t, k) { passed = t === proxied && k === "foo"; } })); return passed;

var passed = false; new Proxy({},{}); // A property cannot be reported as non-existent, if it exists as a // non-configurable own property of the target object. var proxied = {}; var proxy = new Proxy(proxied, { has: function () { passed = true; return false; } }); Object.defineProperty(proxied, "foo", { value: 2, writable: true, enumerable: true }); try { 'foo' in proxy; return false; } catch(e) {} // A property cannot be reported as non-existent, if it exists as an // own property of the target object and the target object is not extensible. proxied.bar = 2; Object.preventExtensions(proxied); try { 'bar' in proxy; return false; } catch(e) {} return passed;

var proxied = {}; var passed = false; delete new Proxy(proxied, { deleteProperty: function (t, k) { passed = t === proxied && k === "foo"; } }).foo; return passed;

var passed = false; new Proxy({},{}); // A property cannot be reported as deleted, if it exists as a non-configurable // own property of the target object. var proxied = {}; Object.defineProperty(proxied, "foo", { value: 2, writable: true, enumerable: true }); try { delete new Proxy(proxied, { deleteProperty: function () { passed = true; return true; } }).foo; return false; } catch(e) {} return passed;

var proxied = {}; var fakeDesc = { value: "foo", configurable: true }; var returnedDesc = Object.getOwnPropertyDescriptor( new Proxy(proxied, { getOwnPropertyDescriptor: function (t, k) { return t === proxied && k === "foo" && fakeDesc; } }), "foo" ); return (returnedDesc.value === fakeDesc.value && returnedDesc.configurable === fakeDesc.configurable && returnedDesc.writable === false && returnedDesc.enumerable === false);

var passed = false; new Proxy({},{}); // A property cannot be reported as non-existent, if it exists as a non-configurable // own property of the target object. var proxied = {}; var proxy = new Proxy(proxied, { getOwnPropertyDescriptor: function () { passed = true; return undefined; } }); Object.defineProperty(proxied, "foo", { value: 2, writable: true, enumerable: true }); try { Object.getOwnPropertyDescriptor(proxy, "foo"); return false; } catch(e) {} // A property cannot be reported as non-existent, if it exists as an own property // of the target object and the target object is not extensible. proxied.bar = 3; Object.preventExtensions(proxied); try { Object.getOwnPropertyDescriptor(proxy, "bar"); return false; } catch(e) {} // A property cannot be reported as existent, if it does not exists as an own property // of the target object and the target object is not extensible. try { Object.getOwnPropertyDescriptor(new Proxy(proxied, { getOwnPropertyDescriptor: function() { return { value: 2, configurable: true, writable: true, enumerable: true }; }}), "baz"); return false; } catch(e) {} // A property cannot be reported as non-configurable, if it does not exists as an own // property of the target object or if it exists as a configurable own property of // the target object. try { Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: function() { return { value: 2, configurable: false, writable: true, enumerable: true }; }}), "baz"); return false; } catch(e) {} try { Object.getOwnPropertyDescriptor(new Proxy({baz:1}, { getOwnPropertyDescriptor: function() { return { value: 1, configurable: false, writable: true, enumerable: true }; }}), "baz"); return false; } catch(e) {} return passed;

var proxied = {}; var passed = false; Object.defineProperty( new Proxy(proxied, { defineProperty: function (t, k, d) { passed = t === proxied && k === "foo" && d.value === 5; return true; } }), "foo", { value: 5, configurable: true } ); return passed;

var passed = false; new Proxy({},{}); // A property cannot be added, if the target object is not extensible. var proxied = Object.preventExtensions({}); var proxy = new Proxy(proxied, { defineProperty: function() { passed = true; return true; } }); try { Object.defineProperty(proxy, "foo", { value: 2 }); return false; } catch(e) {} // A property cannot be non-configurable, unless there exists a corresponding // non-configurable own property of the target object. try { Object.defineProperty( new Proxy({ bar: true }, { defineProperty: function () { return true; } }), "bar", { value: 5, configurable: false, writable: true, enumerable: true } ); return false; } catch(e) {} return passed;

var proxied = {}; var fakeProto = {}; var proxy = new Proxy(proxied, { getPrototypeOf: function (t) { return t === proxied && fakeProto; } }); return Object.getPrototypeOf(proxy) === fakeProto;

var passed = false; new Proxy({},{}); // If the target object is not extensible, [[GetPrototypeOf]] applied to the proxy object // must return the same value as [[GetPrototypeOf]] applied to the proxy object's target object. try { Object.getPrototypeOf(new Proxy(Object.preventExtensions({}), { getPrototypeOf: function () { passed = true; return {}; } })); return false; } catch(e) {} return passed;

var proxied = {}; var newProto = {}; var passed = false; Object.setPrototypeOf( new Proxy(proxied, { setPrototypeOf: function (t, p) { passed = t === proxied && p === newProto; return true; } }), newProto ); return passed;

var passed = false; new Proxy({},{}); Object.setPrototypeOf({},{}); // If the target object is not extensible, the argument value must be the // same as the result of [[GetPrototypeOf]] applied to target object. try { Object.setPrototypeOf( new Proxy(Object.preventExtensions({}), { setPrototypeOf: function () { passed = true; return true; } }),{}); return false; } catch(e) {} return passed;

var proxied = {}; var passed = false; Object.isExtensible( new Proxy(proxied, { isExtensible: function (t) { passed = t === proxied; return true; } }) ); return passed;

var passed = false; new Proxy({},{}); // [[IsExtensible]] applied to the proxy object must return the same value // as [[IsExtensible]] applied to the proxy object's target object with the same argument. try { Object.isExtensible(new Proxy({}, { isExtensible: function (t) { passed = true; return false; } })); return false; } catch(e) {} try { Object.isExtensible(new Proxy(Object.preventExtensions({}), { isExtensible: function (t) { return true; } })); return false; } catch(e) {} return true;

var proxied = {}; var passed = false; Object.preventExtensions( new Proxy(proxied, { preventExtensions: function (t) { passed = t === proxied; return Object.preventExtensions(proxied); } }) ); return passed;

var passed = false; new Proxy({},{}); // [[PreventExtensions]] applied to the proxy object only returns true // if [[IsExtensible]] applied to the proxy object's target object is false. try { Object.preventExtensions(new Proxy({}, { preventExtensions: function () { passed = true; return true; } })); return false; } catch(e) {} return passed;

var proxied = {}; var passed = false; Object.keys( new Proxy(proxied, { ownKeys: function (t) { passed = t === proxied; return []; } }) ); return passed;

var passed = false; new Proxy({},{}); // The Type of each result List element is either String or Symbol. try { Object.keys(new Proxy({}, { ownKeys: function () { passed = true; return [2]; }})); return false; } catch(e) {} // The result List must contain the keys of all non-configurable own properties of the target object. var proxied = {}; Object.defineProperty(proxied, "foo", { value: 2, writable: true, enumerable: true }); try { Object.keys(new Proxy(proxied, { ownKeys: function () { return []; }})); return false; } catch(e) {} // If the target object is not extensible, then the result List must contain all the keys // of the own properties of the target object and no other values. try { Object.keys(new Proxy(Object.preventExtensions({b:1}), { ownKeys: function () { return ['a']; }})); return false; } catch(e) {} return passed;

var proxied = function(){}; var passed = false; var host = { method: new Proxy(proxied, { apply: function (t, thisArg, args) { passed = t === proxied && thisArg === host && args + "" === "foo,bar"; } }) }; host.method("foo", "bar"); return passed;

var passed = false; new Proxy(function(){}, { apply: function () { passed = true; } })(); // A Proxy exotic object only has a [[Call]] internal method if the // initial value of its [[ProxyTarget]] internal slot is an object // that has a [[Call]] internal method. try { new Proxy({}, { apply: function () {} })(); return false; } catch(e) {} return passed;

var proxied = function(){}; var passed = false; new new Proxy(proxied, { construct: function (t, args) { passed = t === proxied && args + "" === "foo,bar"; return {}; } })("foo","bar"); return passed;

var passed = false; new Proxy({},{}); // A Proxy exotic object only has a [[Construct]] internal method if the // initial value of its [[ProxyTarget]] internal slot is an object // that has a [[Construct]] internal method. try { new new Proxy({}, { construct: function (t, args) { return {}; } })(); return false; } catch(e) {} // The result of [[Construct]] must be an Object. try { new new Proxy(function(){}, { construct: function (t, args) { passed = true; return 5; } })(); return false; } catch(e) {} return passed;

var obj = Proxy.revocable({}, { get: function() { return 5; } }); var passed = (obj.proxy.foo === 5); obj.revoke(); try { obj.proxy.foo; } catch(e) { passed &= e instanceof TypeError; } return passed;

return Array.isArray(new Proxy([], {}));

return JSON.stringify(new Proxy(['foo'], {})) === '["foo"]';

return Reflect.get({ qux: 987 }, "qux") === 987;

var obj = {}; Reflect.set(obj, "quux", 654); return obj.quux === 654;

return Reflect.has({ qux: 987 }, "qux");

var obj = { bar: 456 }; Reflect.deleteProperty(obj, "bar"); return !("bar" in obj);

var obj = { baz: 789 }; var desc = Reflect.getOwnPropertyDescriptor(obj, "baz"); return desc.value === 789 && desc.configurable && desc.writable && desc.enumerable;

var obj = {}; Reflect.defineProperty(obj, "foo", { value: 123 }); return obj.foo === 123 && Reflect.defineProperty(Object.freeze({}), "foo", { value: 123 }) === false;

return Reflect.getPrototypeOf([]) === Array.prototype;

var obj = {}; Reflect.setPrototypeOf(obj, Array.prototype); return obj instanceof Array;

return Reflect.isExtensible({}) && !Reflect.isExtensible(Object.preventExtensions({}));

var obj = {}; Reflect.preventExtensions(obj); return !Object.isExtensible(obj);

var obj = Object.create({ C: true }); obj.A = true; Object.defineProperty(obj, 'B', { value: true, enumerable: false }); return Reflect.ownKeys(obj).sort() + '' === "A,B";

var s1 = Symbol(), s2 = Symbol(), s3 = Symbol(); var proto = {}; proto[s1] = true; var obj = Object.create(proto); obj[s2] = true; Object.defineProperty(obj, s3, { value: true, enumerable: false }); var keys = Reflect.ownKeys(obj); return keys.indexOf(s2) >-1 && keys.indexOf(s3) >-1 && keys.length === 2;

return Reflect.apply(Array.prototype.push, [1,2], [3,4,5]) === 5;

return Reflect.construct(function(a, b, c) { this.qux = a + b + c; }, ["foo", "bar", "baz"]).qux === "foobarbaz";

return Reflect.construct(function(a, b, c) { if (new.target === Object) { this.qux = a + b + c; } }, ["foo", "bar", "baz"], Object).qux === "foobarbaz";

function F(){} var obj = Reflect.construct(function(){ this.y = 1; }, [], F); return obj.y === 1 && obj instanceof F;

function F(){} var obj = Reflect.construct(Array, [], F); obj[2] = 'foo'; return obj.length === 3 && obj instanceof F;

function F(){} var obj = Reflect.construct(RegExp, ["baz","g"], F); return RegExp.prototype.exec.call(obj, "foobarbaz")[0] === "baz" && obj.lastIndex === 9 && obj instanceof F;

function F(){} var obj = Reflect.construct(Function, ["return 2"], F); return obj() === 2 && obj instanceof F;

function F(){} var p1 = Reflect.construct(Promise,[function(resolve, reject) { resolve("foo"); }], F); var p2 = Reflect.construct(Promise,[function(resolve, reject) { reject("quux"); }], F); var score = +(p1 instanceof F && p2 instanceof F); function thenFn(result) { score += (result === "foo"); check(); } function catchFn(result) { score += (result === "quux"); check(); } function shouldNotRun(result) { score = -Infinity; } p1.then = p2.then = Promise.prototype.then; p1.catch = p2.catch = Promise.prototype.catch; p1.then(thenFn, shouldNotRun); p2.then(shouldNotRun, catchFn); p1.catch(shouldNotRun); p2.catch(catchFn); function check() { if (score === 4) asyncTestPassed(); }

var p1 = new Promise(function(resolve, reject) { resolve("foo"); }); var p2 = new Promise(function(resolve, reject) { reject("quux"); }); var score = 0; function thenFn(result) { score += (result === "foo"); check(); } function catchFn(result) { score += (result === "quux"); check(); } function shouldNotRun(result) { score = -Infinity; } p1.then(thenFn, shouldNotRun); p2.then(shouldNotRun, catchFn); p1.catch(shouldNotRun); p2.catch(catchFn); p1.then(function() { // Promise.prototype.then() should return a new Promise score += p1.then() !== p1; check(); }); function check() { if (score === 4) asyncTestPassed(); }

new Promise(function(){}); try { Promise(function(){}); return false; } catch(e) { return true; }

new Promise(function(){}); try { Promise.prototype.then(function(){}); } catch (e) { return true; }

var fulfills = Promise.all([ new Promise(function(resolve) { setTimeout(resolve,2000,"foo"); }), new Promise(function(resolve) { setTimeout(resolve,1000,"bar"); }) ]); var rejects = Promise.all([ new Promise(function(_, reject) { setTimeout(reject, 2000,"baz"); }), new Promise(function(_, reject) { setTimeout(reject, 1000,"qux"); }) ]); var score = 0; fulfills.then(function(result) { score += (result + "" === "foo,bar"); check(); }); rejects.catch(function(result) { score += (result === "qux"); check(); }); function check() { if (score === 2) asyncTestPassed(); }

var fulfills = Promise.all(global.__createIterableObject([ new Promise(function(resolve) { setTimeout(resolve,2000,"foo"); }), new Promise(function(resolve) { setTimeout(resolve,1000,"bar"); }) ])); var rejects = Promise.all(global.__createIterableObject([ new Promise(function(_, reject) { setTimeout(reject, 2000,"baz"); }), new Promise(function(_, reject) { setTimeout(reject, 1000,"qux"); }) ])); var score = 0; fulfills.then(function(result) { score += (result + "" === "foo,bar"); check(); }); rejects.catch(function(result) { score += (result === "qux"); check(); }); function check() { if (score === 2) asyncTestPassed(); }

var fulfills = Promise.race([ new Promise(function(resolve) { setTimeout(resolve,1000,"foo"); }), new Promise(function(_, reject) { setTimeout(reject, 2000,"bar"); }) ]); var rejects = Promise.race([ new Promise(function(_, reject) { setTimeout(reject, 1000,"baz"); }), new Promise(function(resolve) { setTimeout(resolve,2000,"qux"); }) ]); var score = 0; fulfills.then(function(result) { score += (result === "foo"); check(); }); rejects.catch(function(result) { score += (result === "baz"); check(); }); function check() { if (score === 2) asyncTestPassed(); }

var fulfills = Promise.race(global.__createIterableObject([ new Promise(function(resolve) { setTimeout(resolve,1000,"foo"); }), new Promise(function(_, reject) { setTimeout(reject, 2000,"bar"); }) ])); var rejects = Promise.race(global.__createIterableObject([ new Promise(function(_, reject) { setTimeout(reject, 1000,"baz"); }), new Promise(function(resolve) { setTimeout(resolve,2000,"qux"); }) ])); var score = 0; fulfills.then(function(result) { score += (result === "foo"); check(); }); rejects.catch(function(result) { score += (result === "baz"); check(); }); function check() { if (score === 2) asyncTestPassed(); }

var prop = Object.getOwnPropertyDescriptor(Promise, Symbol.species); return 'get' in prop && Promise[Symbol.species] === Promise;

var object = {}; var symbol = Symbol(); var value = {}; object[symbol] = value; return object[symbol] === value;

return typeof Symbol() === "symbol";

var object = {}; var symbol = Symbol(); object[symbol] = 1; for (var x in object){} var passed = !x; if (Object.keys && Object.getOwnPropertyNames) { passed &= Object.keys(object).length === 0 && Object.getOwnPropertyNames(object).length === 0; } return passed;

var object = {}; var symbol = Symbol(); var value = {}; if (Object.defineProperty) { Object.defineProperty(object, symbol, { value: value }); return object[symbol] === value; } return passed;

var symbol = Symbol(); var passed = symbol.foo === void undefined; Symbol.prototype.foo = 2; passed &= symbol.foo === 2; delete Symbol.prototype.foo; return passed;

var symbol = Symbol(); try { symbol + ""; return false; } catch(e) {} try { symbol + 0; return false; } catch(e) {} return true;

return String(Symbol("foo")) === "Symbol(foo)";

var symbol = Symbol(); try { new Symbol(); } catch(e) { return true; }

var symbol = Symbol(); var symbolObject = Object(symbol); return typeof symbolObject === "object" && symbolObject instanceof Symbol && symbolObject == symbol && // eslint-disable-line eqeqeq symbolObject !== symbol && symbolObject.valueOf() === symbol;

var object = { foo: Symbol() }; object[Symbol()] = 1; var array = [Symbol()]; return JSON.stringify(object) === '{}' && JSON.stringify(array) === '[null]' && JSON.stringify(Symbol()) === void undefined;

var testSymbolObject = function (sym) { var object = { foo: sym }; try { // some browsers throw a TypeError when setting symbol object keys. // this isn't part of this test, so, ignore it if so. object[sym] = 1; } catch (e) {} // some browsers throw a TypeError when setting symbol object keys. var array = [sym]; return JSON.stringify(object) === '{"foo":{}}' && JSON.stringify(array) === '[{}]' && JSON.stringify(sym) === '{}'; }; var objSym = Object(Symbol()); var symNoToJSON = Object(Symbol()); Object.defineProperty(symNoToJSON, 'toJSON', { enumerable: false, value: null }); // ensure it overrides the prototype, but is not callable return testSymbolObject(objSym) && testSymbolObject(symNoToJSON);

var symbol = Symbol.for('foo'); return Symbol.for('foo') === symbol && Symbol.keyFor(symbol) === 'foo';

var passed = false; var obj = { foo: true }; var C = function(){}; Object.defineProperty(C, Symbol.hasInstance, { value: function(inst) { passed = inst.foo; return false; } }); obj instanceof C; return passed;

var a = [], b = []; b[Symbol.isConcatSpreadable] = false; a = a.concat(b); return a[0] === b;

if (typeof Symbol !== 'function' || !Symbol.isConcatSpreadable) { return null; } var spreadableHasPoisonedIndex = { length: Math.pow(2, 53) - 1 }; spreadableHasPoisonedIndex[Symbol.isConcatSpreadable] = true; Object.defineProperty(spreadableHasPoisonedIndex, 0, { get: function () { throw new SyntaxError(); } }); try { [].concat(spreadableHasPoisonedIndex); return false; } catch (e) { return !!e && e.name === 'SyntaxError'; }

return "iterator" in Symbol;

return (function() { return typeof arguments[Symbol.iterator] === 'function' && Object.hasOwnProperty.call(arguments, Symbol.iterator); }());

return "species" in Symbol;

var obj = []; obj.constructor = {}; obj.constructor[Symbol.species] = function() { return { foo: 1 }; }; return Array.prototype.concat.call(obj, []).foo === 1;

var obj = []; obj.constructor = {}; obj.constructor[Symbol.species] = function() { return { foo: 1 }; }; return Array.prototype.filter.call(obj, Boolean).foo === 1;

var obj = []; obj.constructor = {}; obj.constructor[Symbol.species] = function() { return { foo: 1 }; }; return Array.prototype.map.call(obj, Boolean).foo === 1;

var obj = []; obj.constructor = {}; obj.constructor[Symbol.species] = function() { return { foo: 1 }; }; return Array.prototype.slice.call(obj, 0).foo === 1;

var obj = []; obj.constructor = {}; obj.constructor[Symbol.species] = function() { return { foo: 1 }; }; return Array.prototype.splice.call(obj, 0).foo === 1;

var passed = false; var obj = { constructor: {} }; obj[Symbol.split] = RegExp.prototype[Symbol.split]; obj.constructor[Symbol.species] = function() { passed = true; return /./; }; "".split(obj); return passed;

var promise = new Promise(function(resolve){ resolve(42); }); var FakePromise1 = promise.constructor = function(exec){ exec(function(){}, function(){}); }; var FakePromise2 = function(exec){ exec(function(){}, function(){}); }; Object.defineProperty(FakePromise1, Symbol.species, {value: FakePromise2}); return promise.then(function(){}) instanceof FakePromise2;

var O = {}; O[Symbol.replace] = function(){ return 42; }; return ''.replace(O) === 42;

var O = {}; O[Symbol.search] = function(){ return 42; }; return ''.search(O) === 42;

var O = {}; O[Symbol.split] = function(){ return 42; }; return ''.split(O) === 42;

var O = {}; O[Symbol.match] = function(){ return 42; }; return ''.match(O) === 42;

var re = /./; re[Symbol.match] = false; var foo = {constructor: RegExp}; foo[Symbol.match] = true; return RegExp(re) !== re && RegExp(foo) === foo;

var re = /./; try { '/./'.startsWith(re); } catch(e){ re[Symbol.match] = false; return '/./'.startsWith(re); }

var re = /./; try { '/./'.endsWith(re); } catch(e){ re[Symbol.match] = false; return '/./'.endsWith(re); }

var re = /./; try { '/./'.includes(re); } catch(e){ re[Symbol.match] = false; return '/./'.includes(re); }

var a = {}, b = {}, c = {}; var passed = 0; a[Symbol.toPrimitive] = function(hint) { passed += hint === "number"; return 0; }; b[Symbol.toPrimitive] = function(hint) { passed += hint === "string"; return 0; }; c[Symbol.toPrimitive] = function(hint) { passed += hint === "default"; return 0; }; a >= 0; b in {}; c == 0; // eslint-disable-line eqeqeq return passed === 3;

var a = {}; a[Symbol.toStringTag] = "foo"; return (a + "") === "[object foo]";

var s = Symbol.toStringTag; var passed = true; [ [Array.prototype, []], [String.prototype, ''], [arguments, arguments], [Function.prototype, function(){}], [Error.prototype, new Error()], [Boolean.prototype, true], [Number.prototype, 2], [Date.prototype, new Date()], [RegExp.prototype, /./] ].forEach(function(pair){ pair[0][s] = "foo"; passed &= (Object.prototype.toString.call(pair[1]) === "[object foo]"); delete pair[0][s]; }); return passed;

var passed = true; var s = Symbol.toStringTag; [ [String, "String Iterator"], [Array, "Array Iterator"], [Map, "Map Iterator"], [Set, "Set Iterator"] ].forEach(function(pair){ var iterProto = Object.getPrototypeOf(new pair[0]()[Symbol.iterator]()); passed = passed && iterProto.hasOwnProperty(s) && iterProto[s] === pair[1]; }); passed = passed && Object.getPrototypeOf(function*(){})[s] === "GeneratorFunction" && Object.getPrototypeOf(function*(){}())[s] === "Generator" && Map.prototype[s] === "Map" && Set.prototype[s] === "Set" && ArrayBuffer.prototype[s] === "ArrayBuffer" && DataView.prototype[s] === "DataView" && Promise.prototype[s] === "Promise" && Symbol.prototype[s] === "Symbol" && typeof Object.getOwnPropertyDescriptor( Object.getPrototypeOf(Int8Array).prototype, Symbol.toStringTag).get === "function"; return passed;

var s = Symbol.toStringTag; return Math[s] === "Math" && JSON[s] === "JSON";

var a = { foo: 1, bar: 2 }; a[Symbol.unscopables] = { bar: true }; with (a) { return foo === 1 && typeof bar === "undefined"; }

var o = Object.assign({a:true}, {b:true}, {c:true}); return "a" in o && "b" in o && "c" in o;

return typeof Object.is === 'function' && Object.is(NaN, NaN) && !Object.is(-0, 0);

var o = {}; var sym = Symbol(), sym2 = Symbol(), sym3 = Symbol(); o[sym] = true; o[sym2] = true; o[sym3] = true; var result = Object.getOwnPropertySymbols(o); return result[0] === sym && result[1] === sym2 && result[2] === sym3;

return Object.setPrototypeOf({}, Array.prototype) instanceof Array;

function foo(){}; return foo.name === 'foo' && (function(){}).name === '';

return (function foo(){}).name === 'foo' && (function(){}).name === '';

return (new Function).name === "anonymous";

function foo() {}; return foo.bind({}).name === "bound foo" && (function(){}).bind({}).name === "bound ";

var foo = function() {}; var bar = function baz() {}; return foo.name === "foo" && bar.name === "baz";

var o = { foo: function(){}, bar: function baz(){}}; o.qux = function(){}; return o.foo.name === "foo" && o.bar.name === "baz" && o.qux.name === "";

var o = { get foo(){}, set foo(x){} }; var descriptor = Object.getOwnPropertyDescriptor(o, "foo"); return descriptor.get.name === "get foo" && descriptor.set.name === "set foo";

var o = { foo(){} }; return o.foo.name === "foo";

var f = "foo"; return ({f() { return f; }}).f() === "foo";

var sym1 = Symbol("foo"); var sym2 = Symbol(); var o = { [sym1]: function(){}, [sym2]: function(){} }; return o[sym1].name === "[foo]" && o[sym2].name === "";

class foo {}; class bar { static name() {} }; return foo.name === "foo" && typeof bar.name === "function";

return class foo {}.name === "foo" && typeof class bar { static name() {} }.name === "function";

var foo = class {}; var bar = class baz {}; var qux = class { static name() {} }; return foo.name === "foo" && bar.name === "baz" && typeof qux.name === "function";

var o = { foo: class {}, bar: class baz {}}; o.qux = class {}; return o.foo.name === "foo" && o.bar.name === "baz" && o.qux.name === "";

class C { foo(){} }; return (new C).foo.name === "foo";

class C { static foo(){} }; return C.foo.name === "foo";

var descriptor = Object.getOwnPropertyDescriptor(function f(){},"name"); return descriptor.enumerable === false && descriptor.writable === false && descriptor.configurable === true;

return typeof String.raw === 'function';

return typeof String.fromCodePoint === 'function';

return typeof String.prototype.codePointAt === 'function';

return typeof String.prototype.normalize === "function" && "c\u0327\u0301".normalize("NFC") === "\u1e09" && "\u1e09".normalize("NFD") === "c\u0327\u0301";

return typeof String.prototype.repeat === 'function' && "foo".repeat(3) === "foofoofoo";

return typeof String.prototype.startsWith === 'function' && "foobar".startsWith("foo");

try { "a".startsWith(/./); } catch(e) { return typeof String.prototype.startsWith === 'function'; }

return typeof String.prototype.endsWith === 'function' && "foobar".endsWith("bar");

try { "a".endsWith(/./); } catch(e) { return typeof String.prototype.endsWith === 'function'; }

return typeof String.prototype.includes === 'function' && "foobar".includes("oba");

return typeof String.prototype[Symbol.iterator] === 'function';

// Iterator instance var iterator = ''[Symbol.iterator](); // %StringIteratorPrototype% var proto1 = Object.getPrototypeOf(iterator); // %IteratorPrototype% var proto2 = Object.getPrototypeOf(proto1); return proto2.hasOwnProperty(Symbol.iterator) && !proto1 .hasOwnProperty(Symbol.iterator) && !iterator .hasOwnProperty(Symbol.iterator) && iterator[Symbol.iterator]() === iterator;

return /./igm.flags === "gim" && /./.flags === "";

return typeof RegExp.prototype[Symbol.match] === 'function';

return typeof RegExp.prototype[Symbol.replace] === 'function';

return typeof RegExp.prototype[Symbol.split] === 'function';

return typeof RegExp.prototype[Symbol.search] === 'function';

var prop = Object.getOwnPropertyDescriptor(RegExp, Symbol.species); return 'get' in prop && RegExp[Symbol.species] === RegExp;

return Array.from({ 0: "foo", 1: "bar", length: 2 }) + '' === "foo,bar";

var iterable = (function*(){ yield 1; yield 2; yield 3; }()); return Array.from(iterable) + '' === "1,2,3";

var iterable = global.__createIterableObject([1, 2, 3]); return Array.from(iterable) + '' === "1,2,3";

var iterable = global.__createIterableObject([1, 2, 3]); return Array.from(Object.create(iterable)) + '' === "1,2,3";

return Array.from({ 0: "foo", 1: "bar", length: 2 }, function(e, i) { return e + this.baz + i; }, { baz: "d" }) + '' === "food0,bard1";

var iterable = (function*(){ yield "foo"; yield "bar"; yield "bal"; }()); return Array.from(iterable, function(e, i) { return e + this.baz + i; }, { baz: "d" }) + '' === "food0,bard1,bald2";

var iterable = global.__createIterableObject(["foo", "bar", "bal"]); return Array.from(iterable, function(e, i) { return e + this.baz + i; }, { baz: "d" }) + '' === "food0,bard1,bald2";

var iterable = global.__createIterableObject(["foo", "bar", "bal"]); return Array.from(Object.create(iterable), function(e, i) { return e + this.baz + i; }, { baz: "d" }) + '' === "food0,bard1,bald2";

var closed = false; var iter = global.__createIterableObject([1, 2, 3], { 'return': function(){ closed = true; return {}; } }); try { Array.from(iter, function() { throw 42 }); } catch(e){} return closed;

return typeof Array.of === 'function' && Array.of(2)[0] === 2;

var prop = Object.getOwnPropertyDescriptor(Array, Symbol.species); return 'get' in prop && Array[Symbol.species] === Array;

return typeof Array.prototype.copyWithin === 'function';

return typeof Array.prototype.find === 'function';

return typeof Array.prototype.findIndex === 'function';

return typeof Array.prototype.fill === 'function';

return typeof Array.prototype.keys === 'function';

return typeof Array.prototype.values === 'function';

return typeof Array.prototype.entries === 'function';

if ([0, 1, 2].splice(0).length !== 3) { // IE <= 8 and other pre-ES6 engines fail this check return false; } var a = [1, 2]; var result = a.splice(); if (a.length !== 2 || result.length !== 0) { // Safari 5.0 has this bug return false; } var obj = {}; Array.prototype.splice.call(obj, 0, 0, 1); if (obj.length !== 1) { return false; } var spliceWorksWithLargeSparseArrays = (function () { // Per https://github.com/es-shims/es5-shim/issues/295 // Safari 7/8 breaks with sparse arrays of size 1e5 or greater var arr = new Array(1e5); // note: the index MUST be 8 or larger or the test will false pass arr[8] = 'x'; arr.splice(1, 1); for (var i = 0; i < arr.length; i += 1) { if (arr[i] === 'x') { return i === 7; } } return false; }()); var spliceWorksWithSmallSparseArrays = (function () { // Per https://github.com/es-shims/es5-shim/issues/295 // Opera 12.15 breaks on this, no idea why. var n = 256; var arr = []; arr[n] = 'a'; arr.splice(n + 1, 0, 'b'); return arr[n] === 'a'; }()); return spliceWorksWithLargeSparseArrays && spliceWorksWithSmallSparseArrays;

return typeof Array.prototype[Symbol.iterator] === 'function';

// Iterator instance var iterator = [][Symbol.iterator](); // %ArrayIteratorPrototype% var proto1 = Object.getPrototypeOf(iterator); // %IteratorPrototype% var proto2 = Object.getPrototypeOf(proto1); return proto2.hasOwnProperty(Symbol.iterator) && !proto1 .hasOwnProperty(Symbol.iterator) && !iterator .hasOwnProperty(Symbol.iterator) && iterator[Symbol.iterator]() === iterator;

var unscopables = Array.prototype[Symbol.unscopables]; if (!unscopables) { return false; } var ns = "find,findIndex,fill,copyWithin,entries,keys,values".split(","); for (var i = 0; i < ns.length; i++) { if (Array.prototype[ns[i]] && !unscopables[ns[i]]) return false; } return true;

return typeof Number.isFinite === 'function';

return typeof Number.isInteger === 'function';

return typeof Number.isSafeInteger === 'function';

return typeof Number.isNaN === 'function';

var actualGlobal = Function('return this')(); return typeof Number.parseFloat === 'function' && Number.parseFloat === actualGlobal.parseFloat;

var actualGlobal = Function('return this')(); return typeof Number.parseInt === 'function' && Number.parseInt === actualGlobal.parseInt;

return typeof Number.EPSILON === 'number';

return typeof Number.MIN_SAFE_INTEGER === 'number';

return typeof Number.MAX_SAFE_INTEGER === 'number';

return typeof Math.clz32 === "function";

return typeof Math.imul === "function";

return typeof Math.sign === "function";

return typeof Math.log10 === "function";

return typeof Math.log2 === "function";

return typeof Math.log1p === "function";

return typeof Math.expm1 === "function";

return typeof Math.cosh === "function";

return typeof Math.sinh === "function";

return typeof Math.tanh === "function";

return typeof Math.acosh === "function";

return typeof Math.asinh === "function";

return typeof Math.atanh === "function";

return typeof Math.trunc === "function";

return typeof Math.fround === "function";

return typeof Math.cbrt === "function";

return Math.hypot() === 0 && Math.hypot(1) === 1 && Math.hypot(9, 12, 20) === 25 && Math.hypot(27, 36, 60, 100) === 125;

var tp = Date.prototype[Symbol.toPrimitive]; return tp.call(Object(2), "number") === 2 && tp.call(Object(2), "string") === "2" && tp.call(Object(2), "default") === "2";

class C extends Array {} var c = new C(); var len1 = c.length; c[2] = 'foo'; var len2 = c.length; return len1 === 0 && len2 === 3;

class C extends Array {} var c = new C(); c[2] = 'foo'; c.length = 1; return c.length === 1 && !(2 in c);

class C extends Array {} var c = new C(); return c instanceof C && c instanceof Array && Object.getPrototypeOf(C) === Array;

class C extends Array {} return Array.isArray(new C());

class C extends Array {} var c = new C(); return c.concat(1) instanceof C;

class C extends Array {} var c = new C(); return c.filter(Boolean) instanceof C;

class C extends Array {} var c = new C(); return c.map(Boolean) instanceof C;

class C extends Array {} var c = new C(); c.push(2,4,6); return c.slice(1,2) instanceof C;

class C extends Array {} var c = new C(); c.push(2,4,6); return c.splice(1,2) instanceof C;

class C extends Array {} return C.from({ length: 0 }) instanceof C;

class C extends Array {} return C.of(0) instanceof C;

class R extends RegExp {} var r = new R("baz","g"); return r.global && r.source === "baz";

class R extends RegExp {} var r = new R("baz","g"); return r instanceof R && r instanceof RegExp && Object.getPrototypeOf(R) === RegExp;

class R extends RegExp {} var r = new R("baz","g"); return r.exec("foobarbaz")[0] === "baz" && r.lastIndex === 9;

class R extends RegExp {} var r = new R("baz"); return r.test("foobarbaz");

class C extends Function {} var c = new C("return 'foo';"); return c() === 'foo';

class C extends Function {} var c = new C("return 'foo';"); return c instanceof C && c instanceof Function && Object.getPrototypeOf(C) === Function;

class C extends Function {} var c = new C("this.bar = 2;"); c.prototype.baz = 3; return new c().bar === 2 && new c().baz === 3;

class C extends Function {} var c = new C("x", "return this.bar + x;"); return c.call({bar:1}, 2) === 3;

class C extends Function {} var c = new C("x", "return this.bar + x;"); return c.apply({bar:1}, [2]) === 3;

class C extends Function {} var c = new C("x", "y", "return this.bar + x + y;").bind({bar:1}, 2); return c(6) === 9 && c instanceof C;

class P extends Promise {} var p1 = new P(function(resolve, reject) { resolve("foo"); }); var p2 = new P(function(resolve, reject) { reject("quux"); }); var score = +(p1 instanceof P); function thenFn(result) { score += (result === "foo"); check(); } function catchFn(result) { score += (result === "quux"); check(); } function shouldNotRun(result) { score = -Infinity; } p1.then(thenFn, shouldNotRun); p2.then(shouldNotRun, catchFn); p1.catch(shouldNotRun); p2.catch(catchFn); p1.then(function() { // P.prototype.then() should return a new P score += p1.then() instanceof P && p1.then() !== p1; check(); }); function check() { if (score === 5) asyncTestPassed(); }

class C extends Promise {} var c = new C(function(resolve, reject) { resolve("foo"); }); return c instanceof C && c instanceof Promise && Object.getPrototypeOf(C) === Promise;

class P extends Promise {} var fulfills = P.all([ new Promise(function(resolve) { setTimeout(resolve,2000,"foo"); }), new Promise(function(resolve) { setTimeout(resolve,1000,"bar"); }) ]); var rejects = P.all([ new Promise(function(_, reject) { setTimeout(reject, 2000,"baz"); }), new Promise(function(_, reject) { setTimeout(reject, 1000,"qux"); }) ]); var score = +(fulfills instanceof P); fulfills.then(function(result) { score += (result + "" === "foo,bar"); check(); }); rejects.catch(function(result) { score += (result === "qux"); check(); }); function check() { if (score === 3) asyncTestPassed(); }

class P extends Promise {} var fulfills = P.race([ new Promise(function(resolve) { setTimeout(resolve,1000,"foo"); }), new Promise(function(_, reject) { setTimeout(reject, 2000,"bar"); }) ]); var rejects = P.race([ new Promise(function(_, reject) { setTimeout(reject, 1000,"baz"); }), new Promise(function(resolve) { setTimeout(resolve,2000,"qux"); }) ]); var score = +(fulfills instanceof P); fulfills.then(function(result) { score += (result === "foo"); check(); }); rejects.catch(function(result) { score += (result === "baz"); check(); }); function check() { if (score === 3) asyncTestPassed(); }

class C extends Boolean {} var c = new C(true); return c instanceof Boolean && c instanceof C && c == true; // eslint-disable-line eqeqeq

class C extends Number {} var c = new C(6); return c instanceof Number && c instanceof C && +c === 6;

class C extends String {} var c = new C("golly"); return c instanceof String && c instanceof C && c + '' === "golly" && c[0] === "g" && c.length === 5;

class C extends Error {} var c = new C(); return c instanceof Error && c instanceof C && Object.prototype.toString.call(c) === "[object Error]";

var key = {}; class M extends Map {} var map = new M(); map.set(key, 123); return map instanceof M && map.has(key) && map.get(key) === 123;

var obj = {}; class S extends Set {} var set = new S(); set.add(123); set.add(123); return set instanceof S && set.has(123);

function correctProtoBound(proto) { var f = function(){}; if (Object.setPrototypeOf) { Object.setPrototypeOf(f, proto); } else { f.__proto__ = proto; } var boundF = Function.prototype.bind.call(f, null); return Object.getPrototypeOf(boundF) === proto; } return correctProtoBound(Function.prototype) && correctProtoBound({}) && correctProtoBound(null);

function correctProtoBound(proto) { var f = function*(){}; if (Object.setPrototypeOf) { Object.setPrototypeOf(f, proto); } else { f.__proto__ = proto; } var boundF = Function.prototype.bind.call(f, null); return Object.getPrototypeOf(boundF) === proto; } return correctProtoBound(Function.prototype) && correctProtoBound({}) && correctProtoBound(null);

function correctProtoBound(proto) { var f = ()=>5; if (Object.setPrototypeOf) { Object.setPrototypeOf(f, proto); } else { f.__proto__ = proto; } var boundF = Function.prototype.bind.call(f, null); return Object.getPrototypeOf(boundF) === proto; } return correctProtoBound(Function.prototype) && correctProtoBound({}) && correctProtoBound(null);

function correctProtoBound(proto) { class C {} if (Object.setPrototypeOf) { Object.setPrototypeOf(C, proto); } else { C.__proto__ = proto; } var boundF = Function.prototype.bind.call(C, null); return Object.getPrototypeOf(boundF) === proto; } return correctProtoBound(Function.prototype) && correctProtoBound({}) && correctProtoBound(null);

function correctProtoBound(superclass) { class C extends superclass { constructor() { return Object.create(null); } } var boundF = Function.prototype.bind.call(C, null); return Object.getPrototypeOf(boundF) === Object.getPrototypeOf(C); } return correctProtoBound(function(){}) && correctProtoBound(Array) && correctProtoBound(null);

// ToPrimitive -> Get -> [[Get]] var get = []; var p = new Proxy({toString:Function()}, { get: function(o, k) { get.push(k); return o[k]; }}); p + 3; return get[0] === Symbol.toPrimitive && get.slice(1) + '' === "valueOf,toString";

// CreateListFromArrayLike -> Get -> [[Get]] var get = []; var p = new Proxy({length:2, 0:0, 1:0}, { get: function(o, k) { get.push(k); return o[k]; }}); Function.prototype.apply({}, p); return get + '' === "length,0,1";

// InstanceofOperator -> GetMethod -> GetV -> [[Get]] // InstanceofOperator -> OrdinaryHasInstance -> Get -> [[Get]] var get = []; var p = new Proxy(Function(), { get: function(o, k) { get.push(k); return o[k]; }}); ({}) instanceof p; return get[0] === Symbol.hasInstance && get.slice(1) + '' === "prototype";

// HasBinding -> Get -> [[Get]] var get = []; var p = new Proxy({foo:1}, { get: function(o, k) { get.push(k); return o[k]; }}); p[Symbol.unscopables] = p; with(p) { typeof foo; } return get[0] === Symbol.unscopables && get.slice(1) + '' === "foo";

// CreateDynamicFunction -> GetPrototypeFromConstructor -> Get -> [[Get]] var get = []; var p = new Proxy(Function, { get: function(o, k) { get.push(k); return o[k]; }}); new p; return get + '' === "prototype";

// ClassDefinitionEvaluation -> Get -> [[Get]] var get = []; var p = new Proxy(Function(), { get: function(o, k) { get.push(k); return o[k]; }}); class C extends p {} return get + '' === "prototype";

// IteratorComplete -> Get -> [[Get]] // IteratorValue -> Get -> [[Get]] var get = []; var iterable = {}; iterable[Symbol.iterator] = function() { return { next: function() { return new Proxy({ value: 2, done: false }, { get: function(o, k) { get.push(k); return o[k]; }}); } }; } var i = 0; for(var e of iterable) { if (++i >= 2) break; } return get + '' === "done,value,done,value";

// ToPropertyDescriptor -> Get -> [[Get]] var get = []; var p = new Proxy({ enumerable: true, configurable: true, value: true, writable: true, get: Function(), set: Function() }, { get: function(o, k) { get.push(k); return o[k]; }}); try { // This will throw, since it will have true for both "get" and "value", // but not before performing a Get on every property. Object.defineProperty({}, "foo", p); } catch(e) { return get + '' === "enumerable,configurable,value,writable,get,set"; }

// Object.assign -> Get -> [[Get]] var get = []; var p = new Proxy({foo:1, bar:2}, { get: function(o, k) { get.push(k); return o[k]; }}); Object.assign({}, p); return get + '' === "foo,bar";

// Object.defineProperties -> Get -> [[Get]] var get = []; var p = new Proxy({foo:{}, bar:{}}, { get: function(o, k) { get.push(k); return o[k]; }}); Object.defineProperties({}, p); return get + '' === "foo,bar";

// Function.prototype.bind -> Get -> [[Get]] var get = []; var p = new Proxy(Function(), { get: function(o, k) { get.push(k); return o[k]; }}); Function.prototype.bind.call(p); return get + '' === "length,name";

// Error.prototype.toString -> Get -> [[Get]] var get = []; var p = new Proxy({}, { get: function(o, k) { get.push(k); return o[k]; }}); Error.prototype.toString.call(p); return get + '' === "name,message";