ES6 compat table node v0.10 (w or w/o --harmony) vs. node v0.11 (w or w/o --harmony) vs. io.js v0.12 (370e821) https://docs.google.com/spreadsheets/d/1NM_zGzTODZt6pCW4mCB8c74KuyZLXhxUnGfQIHh5KD4/edit?pli=1#gid=0

io.js.v0.12-370e821.txt

✘	proper tail calls (tail call optimisation)	
▼	arrow functions
✘		0 parameters	
✘		1 parameter, no brackets	
✘		multiple parameters	
✘		lexical "this" binding	
✘		"this" unchanged by call or apply	
✘		can't be bound, can be curried	
✘		lexical "arguments" binding	
✘		no line break between params and =>	
✘		no "prototype" property	
▼	const
✔		basic support	
✘		is block-scoped	
✘		redefining a const is an error	
✘		temporal dead zone	
✘		basic support (strict mode)	
✘		is block-scoped (strict mode)	
✘		redefining a const (strict mode)	
✘		temporal dead zone (strict mode)	
▼	let
✘		basic support	
✘		is block-scoped	
✘		for-loop statement scope	
✘		temporal dead zone	
✘		for-loop iteration scope	
✘		basic support (strict mode)	
✘		is block-scoped (strict mode)	
✘		for-loop statement scope (strict mode)	
✘		temporal dead zone (strict mode)	
✘		for-loop iteration scope (strict mode)	
▼	default function parameters
✘		basic functionality	
✘		explicit undefined defers to the default	
✘		defaults can refer to previous params	
✘		temporal dead zone	
✘		separate scope	
✘	rest parameters	
▼	spread (...) operator
✘		with arrays, in function calls	
✘		with arrays, in array literals	
✘		with strings, in function calls	
✘		with strings, in array literals	
✘		with generic iterables, in calls	
✘		with generic iterables, in arrays	
✘		with instances of iterables, in calls	
✘		with instances of iterables, in arrays	
▼	class
✘		class statement	
✘		is block-scoped	
✘		class expression	
✘		constructor	
✘		prototype methods	
✘		static methods	
✘		implicit strict mode	
✘		extends	
▼	super
✘		in constructors	
✘		in methods	
✘		is statically bound	
▼	object literal extensions
✘		computed properties	
✘		shorthand properties	
✘		shorthand methods	
▼	for..of loops
✔		with arrays	
✔		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
▼	generators
✔		basic functionality	
✔		correct "this" binding	
✔		sending	
✔		%GeneratorPrototype%	
✔		%GeneratorPrototype%.throw	
✘		%GeneratorPrototype%.return	
✔		yield operator precedence	
✔		yield *, arrays	
✔		yield *, strings	
✘		yield *, generic iterables	
✘		yield *, instances of iterables	
✘		shorthand generator methods	
▼	octal and binary literals
✔		octal literals	
✔		binary literals	
✔		octal supported by Number()	
✔		binary supported by Number()	
▼	template strings
✘		basic functionality	
✘		tagged template strings	
▼	RegExp "y" and "u" flags
✘		"y" flag	
✘		"u" flag	
▼	typed arrays
✔		Int8Array	
✔		Uint8Array	
✔		Uint8ClampedArray	
✔		Int16Array	
✔		Uint16Array	
✔		Int32Array	
✔		Uint32Array	
✔		Float32Array	
✔		Float64Array	
✔		DataView (Int8)	
✔		DataView (Uint8)	
✔		DataView (Int16)	
✔		DataView (Uint16)	
✔		DataView (Int32)	
✔		DataView (Uint32)	
✔		DataView (Float32)	
✔		DataView (Float64)	
✘		%TypedArray%.from	
✘		%TypedArray%.of	
✔		%TypedArray%.prototype.subarray	
✘		%TypedArray%.prototype.join	
✘		%TypedArray%.prototype.indexOf	
✘		%TypedArray%.prototype.lastIndexOf	
✘		%TypedArray%.prototype.slice	
✘		%TypedArray%.prototype.every	
✘		%TypedArray%.prototype.filter	
✘		%TypedArray%.prototype.forEach	
✘		%TypedArray%.prototype.map	
✘		%TypedArray%.prototype.reduce	
✘		%TypedArray%.prototype.reduceRight	
✘		%TypedArray%.prototype.reverse	
✘		%TypedArray%.prototype.some	
✘		%TypedArray%.prototype.sort	
✘		%TypedArray%.prototype.copyWithin	
✘		%TypedArray%.prototype.find	
✘		%TypedArray%.prototype.findIndex	
✘		%TypedArray%.prototype.fill	
✔		%TypedArray%.prototype.keys	
✔		%TypedArray%.prototype.values	
✔		%TypedArray%.prototype.entries	
▼	Map
✔		basic functionality	
✔		constructor arguments	
✔		Map.prototype.set returns this	
✔		-0 key converts to +0	
✔		Map.prototype.size	
✔		Map.prototype.delete	
✔		Map.prototype.clear	
✔		Map.prototype.forEach	
✔		Map.prototype.keys	
✔		Map.prototype.values	
✔		Map.prototype.entries	
▼	Set
✔		basic functionality	
✔		constructor arguments	
✔		Set.prototype.add returns this	
✔		-0 key converts to +0	
✔		Set.prototype.size	
✔		Set.prototype.delete	
✔		Set.prototype.clear	
✔		Set.prototype.forEach	
✔		Set.prototype.keys	
✔		Set.prototype.values	
✔		Set.prototype.entries	
▼	WeakMap
✔		basic functionality	
✔		constructor arguments	
✔		WeakMap.prototype.set returns this	
✔		WeakMap.prototype.delete	
▼	WeakSet
✔		basic functionality	
✔		constructor arguments	
✔		WeakSet.prototype.add returns this	
✔		WeakSet.prototype.delete	
▼	Proxy
✘		"get" handler	
✘		"get" handler, instances of proxies	
✘		"set" handler	
✘		"set" handler, instances of proxies	
✘		"has" handler	
✘		"has" handler, instances of proxies	
✘		"deleteProperty" handler	
✘		"getOwnPropertyDescriptor" handler	
✘		"defineProperty" handler	
✘		"getPrototypeOf" handler	
✘		"setPrototypeOf" handler	
✘		"isExtensible" handler	
✘		"preventExtensions" handler	
✘		"enumerate" handler	
✘		"ownKeys" handler	
✘		"apply" handler	
✘		"construct" handler	
✘		Proxy.revocable	
✘		Array.isArray support	
✘		JSON.stringify support	
▼	Reflect
✘		Reflect.get	
✘		Reflect.set	
✘		Reflect.has	
✘		Reflect.deleteProperty	
✘		Reflect.getOwnPropertyDescriptor	
✘		Reflect.defineProperty	
✘		Reflect.getPrototypeOf	
✘		Reflect.setPrototypeOf	
✘		Reflect.isExtensible	
✘		Reflect.preventExtensions	
✘		Reflect.enumerate	
✘		Reflect.ownKeys	
✘		Reflect.apply	
✘		Reflect.construct	
✘	block-level function declaration[12]	
▼	destructuring
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
✘		with objects	
✘		multiples in a single var statement	
✘		nested	
✘		in parameters	
✘		in for-in loop heads	
✘		in for-of loop heads	
✘		rest	
✘		nested rest	
✘		defaults	
✘		defaults in parameters	
✔	Promise	
▼	Object static methods
✘		Object.assign	
✔		Object.is	
✔		Object.getOwnPropertySymbols	
✔		Object.setPrototypeOf	
▼	function "name" property
✔		function statements	
✔		function expressions	
✘		new Function	
✘		bound functions	
✘		variables (function)	
✘		object methods (function)	
✘		accessor properties	
✘		shorthand methods	
✘		symbol-keyed methods	
✘		class statements	
✘		class expressions	
✘		variables (class)	
✘		object methods (class)	
✘		class prototype methods	
✘		class static methods	
✘		isn't writable, is configurable	
✘	Function.prototype.toMethod	
▼	String static methods
✘		String.raw	
✘		String.fromCodePoint	
▼	String.prototype methods
✘		String.prototype.codePointAt	
✘		String.prototype.normalize	
✘		String.prototype.repeat	
✘		String.prototype.startsWith	
✘		String.prototype.endsWith	
✘		String.prototype.includes	
✘	Unicode code point escapes	
▼	Symbol
✔		basic functionality	
✔		typeof support	
✔		symbol keys are hidden to pre-ES6 code	
✔		Object.defineProperty support	
✔		cannot coerce to string or number	
✔		can convert with String()	
✔		new Symbol() throws	
✘		Object(symbol)	
✔		global symbol registry	
▼	well-known symbols
✘		Symbol.hasInstance	
✘		Symbol.isConcatSpreadable	
✔		Symbol.iterator	
✘		Symbol.species	
✘		Symbol.toPrimitive	
✘		Symbol.toStringTag	
✔		Symbol.unscopables	
▼	RegExp.prototype properties
✘		RegExp.prototype.flags	
✘		RegExp.prototype[Symbol.match]	
✘		RegExp.prototype[Symbol.replace]	
✘		RegExp.prototype[Symbol.split]	
✘		RegExp.prototype[Symbol.search]	
▼	Array static methods
✘		Array.from	
✘		Array.of	
▼	Array.prototype methods
✘		Array.prototype.copyWithin	
✘		Array.prototype.find	
✘		Array.prototype.findIndex	
✘		Array.prototype.fill	
✔		Array.prototype.keys	
✘		Array.prototype.values	
✔		Array.prototype.entries	
✔		Array.prototype[Symbol.unscopables]	
▼	Number properties
✔		Number.isFinite	
✔		Number.isInteger	
✔		Number.isSafeInteger	
✔		Number.isNaN	
✔		Number.EPSILON	
✔		Number.MIN_SAFE_INTEGER	
✔		Number.MAX_SAFE_INTEGER	
▼	Math methods
✔		Math.clz32	
✔		Math.imul	
✔		Math.sign	
✔		Math.log10	
✔		Math.log2	
✔		Math.log1p	
✔		Math.expm1	
✔		Math.cosh	
✔		Math.sinh	
✔		Math.tanh	
✔		Math.acosh	
✔		Math.asinh	
✔		Math.atanh	
✔		Math.hypot	
✔		Math.trunc	
✔		Math.fround	
✔		Math.cbrt	
▼	miscellaneous
✘		duplicate property names in strict mode	
✔		no semicolon needed after do-while	
✘		no assignments allowed in for-in head	
✘		accessors aren't constructors	
✘		Object static methods accept primitives	
✔		Invalid Date	
✘		RegExp constructor can alter flags	
✘	hoisted block-level function declaration	
▼	__proto__ in object literals[20]
✔		basic support	
✘		multiple __proto__ is an error	
✘		not a computed property	
✘		not a shorthand property	
✘		not a shorthand method	
▼	Object.prototype.__proto__
✔		get prototype	
✔		set prototype	
✔		correct property descriptor	
✔	String.prototype HTML methods	
✔	RegExp.prototype.compile	

node-v0.10-harmony.txt

✘	proper tail calls (tail call optimisation)	
▼	arrow functions
✘		0 parameters	
✘		1 parameter, no brackets	
✘		multiple parameters	
✘		lexical "this" binding	
✘		"this" unchanged by call or apply	
✘		can't be bound, can be curried	
✘		lexical "arguments" binding	
✘		no line break between params and =>	
✘		no "prototype" property	
▼	const
✔		basic support	
✘		is block-scoped	
✘		redefining a const is an error	
✘		temporal dead zone	
✔		basic support (strict mode)	
✔		is block-scoped (strict mode)	
✔		redefining a const (strict mode)	
✔		temporal dead zone (strict mode)	
▼	let
✘		basic support	
✘		is block-scoped	
✘		for-loop statement scope	
✘		temporal dead zone	
✘		for-loop iteration scope	
✔		basic support (strict mode)	
✔		is block-scoped (strict mode)	
✔		for-loop statement scope (strict mode)	
✔		temporal dead zone (strict mode)	
✘		for-loop iteration scope (strict mode)	
▼	default function parameters
✘		basic functionality	
✘		explicit undefined defers to the default	
✘		defaults can refer to previous params	
✘		temporal dead zone	
✘		separate scope	
✘	rest parameters	
▼	spread (...) operator
✘		with arrays, in function calls	
✘		with arrays, in array literals	
✘		with strings, in function calls	
✘		with strings, in array literals	
✘		with generic iterables, in calls	
✘		with generic iterables, in arrays	
✘		with instances of iterables, in calls	
✘		with instances of iterables, in arrays	
▼	class
✘		class statement	
✘		is block-scoped	
✘		class expression	
✘		constructor	
✘		prototype methods	
✘		static methods	
✘		implicit strict mode	
✘		extends	
▼	super
✘		in constructors	
✘		in methods	
✘		is statically bound	
▼	object literal extensions
✘		computed properties	
✘		shorthand properties	
✘		shorthand methods	
▼	for..of loops
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
▼	generators
✘		basic functionality	
✘		correct "this" binding	
✘		sending	
✘		%GeneratorPrototype%	
✘		%GeneratorPrototype%.throw	
✘		%GeneratorPrototype%.return	
✘		yield operator precedence	
✘		yield *, arrays	
✘		yield *, strings	
✘		yield *, generic iterables	
✘		yield *, instances of iterables	
✘		shorthand generator methods	
▼	octal and binary literals
✘		octal literals	
✘		binary literals	
✘		octal supported by Number()	
✘		binary supported by Number()	
▼	template strings
✘		basic functionality	
✘		tagged template strings	
▼	RegExp "y" and "u" flags
✘		"y" flag	
✘		"u" flag	
▼	typed arrays
✔		Int8Array	
✔		Uint8Array	
✔		Uint8ClampedArray	
✔		Int16Array	
✔		Uint16Array	
✔		Int32Array	
✔		Uint32Array	
✔		Float32Array	
✔		Float64Array	
✔		DataView (Int8)	
✔		DataView (Uint8)	
✔		DataView (Int16)	
✔		DataView (Uint16)	
✔		DataView (Int32)	
✔		DataView (Uint32)	
✔		DataView (Float32)	
✔		DataView (Float64)	
✘		%TypedArray%.from	
✘		%TypedArray%.of	
✘		%TypedArray%.prototype.subarray	
✘		%TypedArray%.prototype.join	
✘		%TypedArray%.prototype.indexOf	
✘		%TypedArray%.prototype.lastIndexOf	
✘		%TypedArray%.prototype.slice	
✘		%TypedArray%.prototype.every	
✘		%TypedArray%.prototype.filter	
✘		%TypedArray%.prototype.forEach	
✘		%TypedArray%.prototype.map	
✘		%TypedArray%.prototype.reduce	
✘		%TypedArray%.prototype.reduceRight	
✘		%TypedArray%.prototype.reverse	
✘		%TypedArray%.prototype.some	
✘		%TypedArray%.prototype.sort	
✘		%TypedArray%.prototype.copyWithin	
✘		%TypedArray%.prototype.find	
✘		%TypedArray%.prototype.findIndex	
✘		%TypedArray%.prototype.fill	
✘		%TypedArray%.prototype.keys	
✘		%TypedArray%.prototype.values	
✘		%TypedArray%.prototype.entries	
▼	Map
✔		basic functionality	
✘		constructor arguments	
✘		Map.prototype.set returns this	
✘		-0 key converts to +0	
✘		Map.prototype.size	
✔		Map.prototype.delete	
✘		Map.prototype.clear	
✘		Map.prototype.forEach	
✘		Map.prototype.keys	
✘		Map.prototype.values	
✘		Map.prototype.entries	
▼	Set
✔		basic functionality	
✘		constructor arguments	
✘		Set.prototype.add returns this	
✘		-0 key converts to +0	
✘		Set.prototype.size	
✔		Set.prototype.delete	
✘		Set.prototype.clear	
✘		Set.prototype.forEach	
✘		Set.prototype.keys	
✘		Set.prototype.values	
✘		Set.prototype.entries	
▼	WeakMap
✔		basic functionality	
✘		constructor arguments	
✘		WeakMap.prototype.set returns this	
✔		WeakMap.prototype.delete	
▼	WeakSet
✘		basic functionality	
✘		constructor arguments	
✘		WeakSet.prototype.add returns this	
✘		WeakSet.prototype.delete	
▼	Proxy
✘		"get" handler	
✘		"get" handler, instances of proxies	
✘		"set" handler	
✘		"set" handler, instances of proxies	
✘		"has" handler	
✘		"has" handler, instances of proxies	
✘		"deleteProperty" handler	
✘		"getOwnPropertyDescriptor" handler	
✘		"defineProperty" handler	
✘		"getPrototypeOf" handler	
✘		"setPrototypeOf" handler	
✘		"isExtensible" handler	
✘		"preventExtensions" handler	
✘		"enumerate" handler	
✘		"ownKeys" handler	
✘		"apply" handler	
✘		"construct" handler	
✘		Proxy.revocable	
✘		Array.isArray support	
✘		JSON.stringify support	
▼	Reflect
✘		Reflect.get	
✘		Reflect.set	
✘		Reflect.has	
✘		Reflect.deleteProperty	
✘		Reflect.getOwnPropertyDescriptor	
✘		Reflect.defineProperty	
✘		Reflect.getPrototypeOf	
✘		Reflect.setPrototypeOf	
✘		Reflect.isExtensible	
✘		Reflect.preventExtensions	
✘		Reflect.enumerate	
✘		Reflect.ownKeys	
✘		Reflect.apply	
✘		Reflect.construct	
✔	block-level function declaration[12]	
▼	destructuring
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
✘		with objects	
✘		multiples in a single var statement	
✘		nested	
✘		in parameters	
✘		in for-in loop heads	
✘		in for-of loop heads	
✘		rest	
✘		nested rest	
✘		defaults	
✘		defaults in parameters	
✘	Promise	
▼	Object static methods
✘		Object.assign	
✔		Object.is	
✘		Object.getOwnPropertySymbols	
✘		Object.setPrototypeOf	
▼	function "name" property
✔		function statements	
✔		function expressions	
✘		new Function	
✘		bound functions	
✘		variables (function)	
✘		object methods (function)	
✘		accessor properties	
✘		shorthand methods	
✘		symbol-keyed methods	
✘		class statements	
✘		class expressions	
✘		variables (class)	
✘		object methods (class)	
✘		class prototype methods	
✘		class static methods	
✘		isn't writable, is configurable	
✘	Function.prototype.toMethod	
▼	String static methods
✘		String.raw	
✘		String.fromCodePoint	
▼	String.prototype methods
✘		String.prototype.codePointAt	
✘		String.prototype.normalize	
✘		String.prototype.repeat	
✘		String.prototype.startsWith	
✘		String.prototype.endsWith	
✘		String.prototype.includes	
✘	Unicode code point escapes	
▼	Symbol
✘		basic functionality	
✘		typeof support	
✘		symbol keys are hidden to pre-ES6 code	
✘		Object.defineProperty support	
✘		cannot coerce to string or number	
✘		can convert with String()	
✘		new Symbol() throws	
✘		Object(symbol)	
✘		global symbol registry	
▼	well-known symbols
✘		Symbol.hasInstance	
✘		Symbol.isConcatSpreadable	
✘		Symbol.iterator	
✘		Symbol.species	
✘		Symbol.toPrimitive	
✘		Symbol.toStringTag	
✘		Symbol.unscopables	
▼	RegExp.prototype properties
✘		RegExp.prototype.flags	
✘		RegExp.prototype[Symbol.match]	
✘		RegExp.prototype[Symbol.replace]	
✘		RegExp.prototype[Symbol.split]	
✘		RegExp.prototype[Symbol.search]	
▼	Array static methods
✘		Array.from	
✘		Array.of	
▼	Array.prototype methods
✘		Array.prototype.copyWithin	
✘		Array.prototype.find	
✘		Array.prototype.findIndex	
✘		Array.prototype.fill	
✘		Array.prototype.keys	
✘		Array.prototype.values	
✘		Array.prototype.entries	
✘		Array.prototype[Symbol.unscopables]	
▼	Number properties
✔		Number.isFinite	
✘		Number.isInteger	
✘		Number.isSafeInteger	
✔		Number.isNaN	
✘		Number.EPSILON	
✘		Number.MIN_SAFE_INTEGER	
✘		Number.MAX_SAFE_INTEGER	
▼	Math methods
✘		Math.clz32	
✘		Math.imul	
✘		Math.sign	
✘		Math.log10	
✘		Math.log2	
✘		Math.log1p	
✘		Math.expm1	
✘		Math.cosh	
✘		Math.sinh	
✘		Math.tanh	
✘		Math.acosh	
✘		Math.asinh	
✘		Math.atanh	
✘		Math.hypot	
✘		Math.trunc	
✘		Math.fround	
✘		Math.cbrt	
▼	miscellaneous
✘		duplicate property names in strict mode	
✔		no semicolon needed after do-while	
✘		no assignments allowed in for-in head	
✘		accessors aren't constructors	
✘		Object static methods accept primitives	
✔		Invalid Date	
✘		RegExp constructor can alter flags	
✘	hoisted block-level function declaration	
▼	__proto__ in object literals[20]
✔		basic support	
✘		multiple __proto__ is an error	
✘		not a computed property	
✘		not a shorthand property	
✘		not a shorthand method	
▼	Object.prototype.__proto__
✔		get prototype	
✔		set prototype	
✘		correct property descriptor	
✔	String.prototype HTML methods	
✔	RegExp.prototype.compile	

node-v0.10.txt

✘	proper tail calls (tail call optimisation)	
▼	arrow functions
✘		0 parameters	
✘		1 parameter, no brackets	
✘		multiple parameters	
✘		lexical "this" binding	
✘		"this" unchanged by call or apply	
✘		can't be bound, can be curried	
✘		lexical "arguments" binding	
✘		no line break between params and =>	
✘		no "prototype" property	
▼	const
✔		basic support	
✘		is block-scoped	
✘		redefining a const is an error	
✘		temporal dead zone	
✘		basic support (strict mode)	
✘		is block-scoped (strict mode)	
✘		redefining a const (strict mode)	
✘		temporal dead zone (strict mode)	
▼	let
✘		basic support	
✘		is block-scoped	
✘		for-loop statement scope	
✘		temporal dead zone	
✘		for-loop iteration scope	
✘		basic support (strict mode)	
✘		is block-scoped (strict mode)	
✘		for-loop statement scope (strict mode)	
✘		temporal dead zone (strict mode)	
✘		for-loop iteration scope (strict mode)	
▼	default function parameters
✘		basic functionality	
✘		explicit undefined defers to the default	
✘		defaults can refer to previous params	
✘		temporal dead zone	
✘		separate scope	
✘	rest parameters	
▼	spread (...) operator
✘		with arrays, in function calls	
✘		with arrays, in array literals	
✘		with strings, in function calls	
✘		with strings, in array literals	
✘		with generic iterables, in calls	
✘		with generic iterables, in arrays	
✘		with instances of iterables, in calls	
✘		with instances of iterables, in arrays	
▼	class
✘		class statement	
✘		is block-scoped	
✘		class expression	
✘		constructor	
✘		prototype methods	
✘		static methods	
✘		implicit strict mode	
✘		extends	
▼	super
✘		in constructors	
✘		in methods	
✘		is statically bound	
▼	object literal extensions
✘		computed properties	
✘		shorthand properties	
✘		shorthand methods	
▼	for..of loops
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
▼	generators
✘		basic functionality	
✘		correct "this" binding	
✘		sending	
✘		%GeneratorPrototype%	
✘		%GeneratorPrototype%.throw	
✘		%GeneratorPrototype%.return	
✘		yield operator precedence	
✘		yield *, arrays	
✘		yield *, strings	
✘		yield *, generic iterables	
✘		yield *, instances of iterables	
✘		shorthand generator methods	
▼	octal and binary literals
✘		octal literals	
✘		binary literals	
✘		octal supported by Number()	
✘		binary supported by Number()	
▼	template strings
✘		basic functionality	
✘		tagged template strings	
▼	RegExp "y" and "u" flags
✘		"y" flag	
✘		"u" flag	
▼	typed arrays
✔		Int8Array	
✔		Uint8Array	
✔		Uint8ClampedArray	
✔		Int16Array	
✔		Uint16Array	
✔		Int32Array	
✔		Uint32Array	
✔		Float32Array	
✔		Float64Array	
✔		DataView (Int8)	
✔		DataView (Uint8)	
✔		DataView (Int16)	
✔		DataView (Uint16)	
✔		DataView (Int32)	
✔		DataView (Uint32)	
✔		DataView (Float32)	
✔		DataView (Float64)	
✘		%TypedArray%.from	
✘		%TypedArray%.of	
✘		%TypedArray%.prototype.subarray	
✘		%TypedArray%.prototype.join	
✘		%TypedArray%.prototype.indexOf	
✘		%TypedArray%.prototype.lastIndexOf	
✘		%TypedArray%.prototype.slice	
✘		%TypedArray%.prototype.every	
✘		%TypedArray%.prototype.filter	
✘		%TypedArray%.prototype.forEach	
✘		%TypedArray%.prototype.map	
✘		%TypedArray%.prototype.reduce	
✘		%TypedArray%.prototype.reduceRight	
✘		%TypedArray%.prototype.reverse	
✘		%TypedArray%.prototype.some	
✘		%TypedArray%.prototype.sort	
✘		%TypedArray%.prototype.copyWithin	
✘		%TypedArray%.prototype.find	
✘		%TypedArray%.prototype.findIndex	
✘		%TypedArray%.prototype.fill	
✘		%TypedArray%.prototype.keys	
✘		%TypedArray%.prototype.values	
✘		%TypedArray%.prototype.entries	
▼	Map
✘		basic functionality	
✘		constructor arguments	
✘		Map.prototype.set returns this	
✘		-0 key converts to +0	
✘		Map.prototype.size	
✘		Map.prototype.delete	
✘		Map.prototype.clear	
✘		Map.prototype.forEach	
✘		Map.prototype.keys	
✘		Map.prototype.values	
✘		Map.prototype.entries	
▼	Set
✘		basic functionality	
✘		constructor arguments	
✘		Set.prototype.add returns this	
✘		-0 key converts to +0	
✘		Set.prototype.size	
✘		Set.prototype.delete	
✘		Set.prototype.clear	
✘		Set.prototype.forEach	
✘		Set.prototype.keys	
✘		Set.prototype.values	
✘		Set.prototype.entries	
▼	WeakMap
✘		basic functionality	
✘		constructor arguments	
✘		WeakMap.prototype.set returns this	
✘		WeakMap.prototype.delete	
▼	WeakSet
✘		basic functionality	
✘		constructor arguments	
✘		WeakSet.prototype.add returns this	
✘		WeakSet.prototype.delete	
▼	Proxy
✘		"get" handler	
✘		"get" handler, instances of proxies	
✘		"set" handler	
✘		"set" handler, instances of proxies	
✘		"has" handler	
✘		"has" handler, instances of proxies	
✘		"deleteProperty" handler	
✘		"getOwnPropertyDescriptor" handler	
✘		"defineProperty" handler	
✘		"getPrototypeOf" handler	
✘		"setPrototypeOf" handler	
✘		"isExtensible" handler	
✘		"preventExtensions" handler	
✘		"enumerate" handler	
✘		"ownKeys" handler	
✘		"apply" handler	
✘		"construct" handler	
✘		Proxy.revocable	
✘		Array.isArray support	
✘		JSON.stringify support	
▼	Reflect
✘		Reflect.get	
✘		Reflect.set	
✘		Reflect.has	
✘		Reflect.deleteProperty	
✘		Reflect.getOwnPropertyDescriptor	
✘		Reflect.defineProperty	
✘		Reflect.getPrototypeOf	
✘		Reflect.setPrototypeOf	
✘		Reflect.isExtensible	
✘		Reflect.preventExtensions	
✘		Reflect.enumerate	
✘		Reflect.ownKeys	
✘		Reflect.apply	
✘		Reflect.construct	
✘	block-level function declaration[12]	
▼	destructuring
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
✘		with objects	
✘		multiples in a single var statement	
✘		nested	
✘		in parameters	
✘		in for-in loop heads	
✘		in for-of loop heads	
✘		rest	
✘		nested rest	
✘		defaults	
✘		defaults in parameters	
✘	Promise	
▼	Object static methods
✘		Object.assign	
✔		Object.is	
✘		Object.getOwnPropertySymbols	
✘		Object.setPrototypeOf	
▼	function "name" property
✔		function statements	
✔		function expressions	
✘		new Function	
✘		bound functions	
✘		variables (function)	
✘		object methods (function)	
✘		accessor properties	
✘		shorthand methods	
✘		symbol-keyed methods	
✘		class statements	
✘		class expressions	
✘		variables (class)	
✘		object methods (class)	
✘		class prototype methods	
✘		class static methods	
✘		isn't writable, is configurable	
✘	Function.prototype.toMethod	
▼	String static methods
✘		String.raw	
✘		String.fromCodePoint	
▼	String.prototype methods
✘		String.prototype.codePointAt	
✘		String.prototype.normalize	
✘		String.prototype.repeat	
✘		String.prototype.startsWith	
✘		String.prototype.endsWith	
✘		String.prototype.includes	
✘	Unicode code point escapes	
▼	Symbol
✘		basic functionality	
✘		typeof support	
✘		symbol keys are hidden to pre-ES6 code	
✘		Object.defineProperty support	
✘		cannot coerce to string or number	
✘		can convert with String()	
✘		new Symbol() throws	
✘		Object(symbol)	
✘		global symbol registry	
▼	well-known symbols
✘		Symbol.hasInstance	
✘		Symbol.isConcatSpreadable	
✘		Symbol.iterator	
✘		Symbol.species	
✘		Symbol.toPrimitive	
✘		Symbol.toStringTag	
✘		Symbol.unscopables	
▼	RegExp.prototype properties
✘		RegExp.prototype.flags	
✘		RegExp.prototype[Symbol.match]	
✘		RegExp.prototype[Symbol.replace]	
✘		RegExp.prototype[Symbol.split]	
✘		RegExp.prototype[Symbol.search]	
▼	Array static methods
✘		Array.from	
✘		Array.of	
▼	Array.prototype methods
✘		Array.prototype.copyWithin	
✘		Array.prototype.find	
✘		Array.prototype.findIndex	
✘		Array.prototype.fill	
✘		Array.prototype.keys	
✘		Array.prototype.values	
✘		Array.prototype.entries	
✘		Array.prototype[Symbol.unscopables]	
▼	Number properties
✔		Number.isFinite	
✘		Number.isInteger	
✘		Number.isSafeInteger	
✔		Number.isNaN	
✘		Number.EPSILON	
✘		Number.MIN_SAFE_INTEGER	
✘		Number.MAX_SAFE_INTEGER	
▼	Math methods
✘		Math.clz32	
✘		Math.imul	
✘		Math.sign	
✘		Math.log10	
✘		Math.log2	
✘		Math.log1p	
✘		Math.expm1	
✘		Math.cosh	
✘		Math.sinh	
✘		Math.tanh	
✘		Math.acosh	
✘		Math.asinh	
✘		Math.atanh	
✘		Math.hypot	
✘		Math.trunc	
✘		Math.fround	
✘		Math.cbrt	
▼	miscellaneous
✘		duplicate property names in strict mode	
✔		no semicolon needed after do-while	
✘		no assignments allowed in for-in head	
✘		accessors aren't constructors	
✘		Object static methods accept primitives	
✔		Invalid Date	
✘		RegExp constructor can alter flags	
✘	hoisted block-level function declaration	
▼	__proto__ in object literals[20]
✔		basic support	
✘		multiple __proto__ is an error	
✘		not a computed property	
✘		not a shorthand property	
✘		not a shorthand method	
▼	Object.prototype.__proto__
✔		get prototype	
✔		set prototype	
✘		correct property descriptor	
✔	String.prototype HTML methods	
✔	RegExp.prototype.compile	

node-v0.11-harmony.txt

✘	proper tail calls (tail call optimisation)	
▼	arrow functions
✘		0 parameters	
✘		1 parameter, no brackets	
✘		multiple parameters	
✘		lexical "this" binding	
✘		"this" unchanged by call or apply	
✘		can't be bound, can be curried	
✘		lexical "arguments" binding	
✘		no line break between params and =>	
✘		no "prototype" property	
▼	const
✔		basic support	
✘		is block-scoped	
✘		redefining a const is an error	
✘		temporal dead zone	
✔		basic support (strict mode)	
✔		is block-scoped (strict mode)	
✔		redefining a const (strict mode)	
✔		temporal dead zone (strict mode)	
▼	let
✘		basic support	
✘		is block-scoped	
✘		for-loop statement scope	
✘		temporal dead zone	
✘		for-loop iteration scope	
✔		basic support (strict mode)	
✔		is block-scoped (strict mode)	
✔		for-loop statement scope (strict mode)	
✔		temporal dead zone (strict mode)	
✘		for-loop iteration scope (strict mode)	
▼	default function parameters
✘		basic functionality	
✘		explicit undefined defers to the default	
✘		defaults can refer to previous params	
✘		temporal dead zone	
✘		separate scope	
✘	rest parameters	
▼	spread (...) operator
✘		with arrays, in function calls	
✘		with arrays, in array literals	
✘		with strings, in function calls	
✘		with strings, in array literals	
✘		with generic iterables, in calls	
✘		with generic iterables, in arrays	
✘		with instances of iterables, in calls	
✘		with instances of iterables, in arrays	
▼	class
✘		class statement	
✘		is block-scoped	
✘		class expression	
✘		constructor	
✘		prototype methods	
✘		static methods	
✘		implicit strict mode	
✘		extends	
▼	super
✘		in constructors	
✘		in methods	
✘		is statically bound	
▼	object literal extensions
✘		computed properties	
✘		shorthand properties	
✘		shorthand methods	
▼	for..of loops
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
▼	generators
✔		basic functionality	
✔		correct "this" binding	
✔		sending	
✔		%GeneratorPrototype%	
✔		%GeneratorPrototype%.throw	
✘		%GeneratorPrototype%.return	
✔		yield operator precedence	
✘		yield *, arrays	
✘		yield *, strings	
✘		yield *, generic iterables	
✘		yield *, instances of iterables	
✘		shorthand generator methods	
▼	octal and binary literals
✔		octal literals	
✔		binary literals	
✔		octal supported by Number()	
✔		binary supported by Number()	
▼	template strings
✘		basic functionality	
✘		tagged template strings	
▼	RegExp "y" and "u" flags
✘		"y" flag	
✘		"u" flag	
▼	typed arrays
✔		Int8Array	
✔		Uint8Array	
✔		Uint8ClampedArray	
✔		Int16Array	
✔		Uint16Array	
✔		Int32Array	
✔		Uint32Array	
✔		Float32Array	
✔		Float64Array	
✔		DataView (Int8)	
✔		DataView (Uint8)	
✔		DataView (Int16)	
✔		DataView (Uint16)	
✔		DataView (Int32)	
✔		DataView (Uint32)	
✔		DataView (Float32)	
✔		DataView (Float64)	
✘		%TypedArray%.from	
✘		%TypedArray%.of	
✔		%TypedArray%.prototype.subarray	
✘		%TypedArray%.prototype.join	
✘		%TypedArray%.prototype.indexOf	
✘		%TypedArray%.prototype.lastIndexOf	
✘		%TypedArray%.prototype.slice	
✘		%TypedArray%.prototype.every	
✘		%TypedArray%.prototype.filter	
✘		%TypedArray%.prototype.forEach	
✘		%TypedArray%.prototype.map	
✘		%TypedArray%.prototype.reduce	
✘		%TypedArray%.prototype.reduceRight	
✘		%TypedArray%.prototype.reverse	
✘		%TypedArray%.prototype.some	
✘		%TypedArray%.prototype.sort	
✘		%TypedArray%.prototype.copyWithin	
✘		%TypedArray%.prototype.find	
✘		%TypedArray%.prototype.findIndex	
✘		%TypedArray%.prototype.fill	
✘		%TypedArray%.prototype.keys	
✘		%TypedArray%.prototype.values	
✘		%TypedArray%.prototype.entries	
▼	Map
✔		basic functionality	
✘		constructor arguments	
✘		Map.prototype.set returns this	
✔		-0 key converts to +0	
✔		Map.prototype.size	
✔		Map.prototype.delete	
✔		Map.prototype.clear	
✔		Map.prototype.forEach	
✘		Map.prototype.keys	
✘		Map.prototype.values	
✘		Map.prototype.entries	
▼	Set
✔		basic functionality	
✘		constructor arguments	
✘		Set.prototype.add returns this	
✔		-0 key converts to +0	
✔		Set.prototype.size	
✔		Set.prototype.delete	
✔		Set.prototype.clear	
✔		Set.prototype.forEach	
✘		Set.prototype.keys	
✘		Set.prototype.values	
✘		Set.prototype.entries	
▼	WeakMap
✔		basic functionality	
✘		constructor arguments	
✘		WeakMap.prototype.set returns this	
✔		WeakMap.prototype.delete	
▼	WeakSet
✔		basic functionality	
✘		constructor arguments	
✘		WeakSet.prototype.add returns this	
✔		WeakSet.prototype.delete	
▼	Proxy
✘		"get" handler	
✘		"get" handler, instances of proxies	
✘		"set" handler	
✘		"set" handler, instances of proxies	
✘		"has" handler	
✘		"has" handler, instances of proxies	
✘		"deleteProperty" handler	
✘		"getOwnPropertyDescriptor" handler	
✘		"defineProperty" handler	
✘		"getPrototypeOf" handler	
✘		"setPrototypeOf" handler	
✘		"isExtensible" handler	
✘		"preventExtensions" handler	
✘		"enumerate" handler	
✘		"ownKeys" handler	
✘		"apply" handler	
✘		"construct" handler	
✘		Proxy.revocable	
✘		Array.isArray support	
✘		JSON.stringify support	
▼	Reflect
✘		Reflect.get	
✘		Reflect.set	
✘		Reflect.has	
✘		Reflect.deleteProperty	
✘		Reflect.getOwnPropertyDescriptor	
✘		Reflect.defineProperty	
✘		Reflect.getPrototypeOf	
✘		Reflect.setPrototypeOf	
✘		Reflect.isExtensible	
✘		Reflect.preventExtensions	
✘		Reflect.enumerate	
✘		Reflect.ownKeys	
✘		Reflect.apply	
✘		Reflect.construct	
✔	block-level function declaration[12]	
▼	destructuring
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
✘		with objects	
✘		multiples in a single var statement	
✘		nested	
✘		in parameters	
✘		in for-in loop heads	
✘		in for-of loop heads	
✘		rest	
✘		nested rest	
✘		defaults	
✘		defaults in parameters	
✔	Promise	
▼	Object static methods
✘		Object.assign	
✔		Object.is	
✔		Object.getOwnPropertySymbols	
✔		Object.setPrototypeOf	
▼	function "name" property
✔		function statements	
✔		function expressions	
✘		new Function	
✘		bound functions	
✘		variables (function)	
✘		object methods (function)	
✘		accessor properties	
✘		shorthand methods	
✘		symbol-keyed methods	
✘		class statements	
✘		class expressions	
✘		variables (class)	
✘		object methods (class)	
✘		class prototype methods	
✘		class static methods	
✘		isn't writable, is configurable	
✘	Function.prototype.toMethod	
▼	String static methods
✘		String.raw	
✘		String.fromCodePoint	
▼	String.prototype methods
✘		String.prototype.codePointAt	
✘		String.prototype.normalize	
✔		String.prototype.repeat	
✔		String.prototype.startsWith	
✔		String.prototype.endsWith	
✘		String.prototype.includes	
✘	Unicode code point escapes	
▼	Symbol
✔		basic functionality	
✔		typeof support	
✔		symbol keys are hidden to pre-ES6 code	
✔		Object.defineProperty support	
✘		cannot coerce to string or number	
✘		can convert with String()	
✔		new Symbol() throws	
✘		Object(symbol)	
✔		global symbol registry	
▼	well-known symbols
✘		Symbol.hasInstance	
✘		Symbol.isConcatSpreadable	
✘		Symbol.iterator	
✘		Symbol.species	
✘		Symbol.toPrimitive	
✘		Symbol.toStringTag	
✘		Symbol.unscopables	
▼	RegExp.prototype properties
✘		RegExp.prototype.flags	
✘		RegExp.prototype[Symbol.match]	
✘		RegExp.prototype[Symbol.replace]	
✘		RegExp.prototype[Symbol.split]	
✘		RegExp.prototype[Symbol.search]	
▼	Array static methods
✘		Array.from	
✘		Array.of	
▼	Array.prototype methods
✘		Array.prototype.copyWithin	
✔		Array.prototype.find	
✔		Array.prototype.findIndex	
✔		Array.prototype.fill	
✔		Array.prototype.keys	
✔		Array.prototype.values	
✔		Array.prototype.entries	
✘		Array.prototype[Symbol.unscopables]	
▼	Number properties
✔		Number.isFinite	
✔		Number.isInteger	
✔		Number.isSafeInteger	
✔		Number.isNaN	
✔		Number.EPSILON	
✔		Number.MIN_SAFE_INTEGER	
✔		Number.MAX_SAFE_INTEGER	
▼	Math methods
✔		Math.clz32	
✔		Math.imul	
✔		Math.sign	
✔		Math.log10	
✔		Math.log2	
✔		Math.log1p	
✔		Math.expm1	
✔		Math.cosh	
✔		Math.sinh	
✔		Math.tanh	
✔		Math.acosh	
✔		Math.asinh	
✔		Math.atanh	
✔		Math.hypot	
✔		Math.trunc	
✔		Math.fround	
✔		Math.cbrt	
▼	miscellaneous
✘		duplicate property names in strict mode	
✔		no semicolon needed after do-while	
✘		no assignments allowed in for-in head	
✘		accessors aren't constructors	
✘		Object static methods accept primitives	
✔		Invalid Date	
✘		RegExp constructor can alter flags	
✘	hoisted block-level function declaration	
▼	__proto__ in object literals[20]
✔		basic support	
✘		multiple __proto__ is an error	
✘		not a computed property	
✘		not a shorthand property	
✘		not a shorthand method	
▼	Object.prototype.__proto__
✔		get prototype	
✔		set prototype	
✔		correct property descriptor	
✔	String.prototype HTML methods	
✔	RegExp.prototype.compile	

node-v0.11.txt

✘	proper tail calls (tail call optimisation)	
▼	arrow functions
✘		0 parameters	
✘		1 parameter, no brackets	
✘		multiple parameters	
✘		lexical "this" binding	
✘		"this" unchanged by call or apply	
✘		can't be bound, can be curried	
✘		lexical "arguments" binding	
✘		no line break between params and =>	
✘		no "prototype" property	
▼	const
✔		basic support	
✘		is block-scoped	
✘		redefining a const is an error	
✘		temporal dead zone	
✘		basic support (strict mode)	
✘		is block-scoped (strict mode)	
✘		redefining a const (strict mode)	
✘		temporal dead zone (strict mode)	
▼	let
✘		basic support	
✘		is block-scoped	
✘		for-loop statement scope	
✘		temporal dead zone	
✘		for-loop iteration scope	
✘		basic support (strict mode)	
✘		is block-scoped (strict mode)	
✘		for-loop statement scope (strict mode)	
✘		temporal dead zone (strict mode)	
✘		for-loop iteration scope (strict mode)	
▼	default function parameters
✘		basic functionality	
✘		explicit undefined defers to the default	
✘		defaults can refer to previous params	
✘		temporal dead zone	
✘		separate scope	
✘	rest parameters	
▼	spread (...) operator
✘		with arrays, in function calls	
✘		with arrays, in array literals	
✘		with strings, in function calls	
✘		with strings, in array literals	
✘		with generic iterables, in calls	
✘		with generic iterables, in arrays	
✘		with instances of iterables, in calls	
✘		with instances of iterables, in arrays	
▼	class
✘		class statement	
✘		is block-scoped	
✘		class expression	
✘		constructor	
✘		prototype methods	
✘		static methods	
✘		implicit strict mode	
✘		extends	
▼	super
✘		in constructors	
✘		in methods	
✘		is statically bound	
▼	object literal extensions
✘		computed properties	
✘		shorthand properties	
✘		shorthand methods	
▼	for..of loops
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
▼	generators
✘		basic functionality	
✘		correct "this" binding	
✘		sending	
✘		%GeneratorPrototype%	
✘		%GeneratorPrototype%.throw	
✘		%GeneratorPrototype%.return	
✘		yield operator precedence	
✘		yield *, arrays	
✘		yield *, strings	
✘		yield *, generic iterables	
✘		yield *, instances of iterables	
✘		shorthand generator methods	
▼	octal and binary literals
✘		octal literals	
✘		binary literals	
✘		octal supported by Number()	
✘		binary supported by Number()	
▼	template strings
✘		basic functionality	
✘		tagged template strings	
▼	RegExp "y" and "u" flags
✘		"y" flag	
✘		"u" flag	
▼	typed arrays
✔		Int8Array	
✔		Uint8Array	
✔		Uint8ClampedArray	
✔		Int16Array	
✔		Uint16Array	
✔		Int32Array	
✔		Uint32Array	
✔		Float32Array	
✔		Float64Array	
✔		DataView (Int8)	
✔		DataView (Uint8)	
✔		DataView (Int16)	
✔		DataView (Uint16)	
✔		DataView (Int32)	
✔		DataView (Uint32)	
✔		DataView (Float32)	
✔		DataView (Float64)	
✘		%TypedArray%.from	
✘		%TypedArray%.of	
✔		%TypedArray%.prototype.subarray	
✘		%TypedArray%.prototype.join	
✘		%TypedArray%.prototype.indexOf	
✘		%TypedArray%.prototype.lastIndexOf	
✘		%TypedArray%.prototype.slice	
✘		%TypedArray%.prototype.every	
✘		%TypedArray%.prototype.filter	
✘		%TypedArray%.prototype.forEach	
✘		%TypedArray%.prototype.map	
✘		%TypedArray%.prototype.reduce	
✘		%TypedArray%.prototype.reduceRight	
✘		%TypedArray%.prototype.reverse	
✘		%TypedArray%.prototype.some	
✘		%TypedArray%.prototype.sort	
✘		%TypedArray%.prototype.copyWithin	
✘		%TypedArray%.prototype.find	
✘		%TypedArray%.prototype.findIndex	
✘		%TypedArray%.prototype.fill	
✘		%TypedArray%.prototype.keys	
✘		%TypedArray%.prototype.values	
✘		%TypedArray%.prototype.entries	
▼	Map
✘		basic functionality	
✘		constructor arguments	
✘		Map.prototype.set returns this	
✘		-0 key converts to +0	
✘		Map.prototype.size	
✘		Map.prototype.delete	
✘		Map.prototype.clear	
✘		Map.prototype.forEach	
✘		Map.prototype.keys	
✘		Map.prototype.values	
✘		Map.prototype.entries	
▼	Set
✘		basic functionality	
✘		constructor arguments	
✘		Set.prototype.add returns this	
✘		-0 key converts to +0	
✘		Set.prototype.size	
✘		Set.prototype.delete	
✘		Set.prototype.clear	
✘		Set.prototype.forEach	
✘		Set.prototype.keys	
✘		Set.prototype.values	
✘		Set.prototype.entries	
▼	WeakMap
✔		basic functionality	
✘		constructor arguments	
✘		WeakMap.prototype.set returns this	
✔		WeakMap.prototype.delete	
▼	WeakSet
✔		basic functionality	
✘		constructor arguments	
✘		WeakSet.prototype.add returns this	
✔		WeakSet.prototype.delete	
▼	Proxy
✘		"get" handler	
✘		"get" handler, instances of proxies	
✘		"set" handler	
✘		"set" handler, instances of proxies	
✘		"has" handler	
✘		"has" handler, instances of proxies	
✘		"deleteProperty" handler	
✘		"getOwnPropertyDescriptor" handler	
✘		"defineProperty" handler	
✘		"getPrototypeOf" handler	
✘		"setPrototypeOf" handler	
✘		"isExtensible" handler	
✘		"preventExtensions" handler	
✘		"enumerate" handler	
✘		"ownKeys" handler	
✘		"apply" handler	
✘		"construct" handler	
✘		Proxy.revocable	
✘		Array.isArray support	
✘		JSON.stringify support	
▼	Reflect
✘		Reflect.get	
✘		Reflect.set	
✘		Reflect.has	
✘		Reflect.deleteProperty	
✘		Reflect.getOwnPropertyDescriptor	
✘		Reflect.defineProperty	
✘		Reflect.getPrototypeOf	
✘		Reflect.setPrototypeOf	
✘		Reflect.isExtensible	
✘		Reflect.preventExtensions	
✘		Reflect.enumerate	
✘		Reflect.ownKeys	
✘		Reflect.apply	
✘		Reflect.construct	
✘	block-level function declaration[12]	
▼	destructuring
✘		with arrays	
✘		with strings	
✘		with generic iterables	
✘		with instances of generic iterables	
✘		with objects	
✘		multiples in a single var statement	
✘		nested	
✘		in parameters	
✘		in for-in loop heads	
✘		in for-of loop heads	
✘		rest	
✘		nested rest	
✘		defaults	
✘		defaults in parameters	
✔	Promise	
▼	Object static methods
✘		Object.assign	
✔		Object.is	
✘		Object.getOwnPropertySymbols	
✔		Object.setPrototypeOf	
▼	function "name" property
✔		function statements	
✔		function expressions	
✘		new Function	
✘		bound functions	
✘		variables (function)	
✘		object methods (function)	
✘		accessor properties	
✘		shorthand methods	
✘		symbol-keyed methods	
✘		class statements	
✘		class expressions	
✘		variables (class)	
✘		object methods (class)	
✘		class prototype methods	
✘		class static methods	
✘		isn't writable, is configurable	
✘	Function.prototype.toMethod	
▼	String static methods
✘		String.raw	
✘		String.fromCodePoint	
▼	String.prototype methods
✘		String.prototype.codePointAt	
✘		String.prototype.normalize	
✘		String.prototype.repeat	
✘		String.prototype.startsWith	
✘		String.prototype.endsWith	
✘		String.prototype.includes	
✘	Unicode code point escapes	
▼	Symbol
✘		basic functionality	
✘		typeof support	
✘		symbol keys are hidden to pre-ES6 code	
✘		Object.defineProperty support	
✘		cannot coerce to string or number	
✘		can convert with String()	
✘		new Symbol() throws	
✘		Object(symbol)	
✘		global symbol registry	
▼	well-known symbols
✘		Symbol.hasInstance	
✘		Symbol.isConcatSpreadable	
✘		Symbol.iterator	
✘		Symbol.species	
✘		Symbol.toPrimitive	
✘		Symbol.toStringTag	
✘		Symbol.unscopables	
▼	RegExp.prototype properties
✘		RegExp.prototype.flags	
✘		RegExp.prototype[Symbol.match]	
✘		RegExp.prototype[Symbol.replace]	
✘		RegExp.prototype[Symbol.split]	
✘		RegExp.prototype[Symbol.search]	
▼	Array static methods
✘		Array.from	
✘		Array.of	
▼	Array.prototype methods
✘		Array.prototype.copyWithin	
✘		Array.prototype.find	
✘		Array.prototype.findIndex	
✘		Array.prototype.fill	
✘		Array.prototype.keys	
✘		Array.prototype.values	
✘		Array.prototype.entries	
✘		Array.prototype[Symbol.unscopables]	
▼	Number properties
✔		Number.isFinite	
✔		Number.isInteger	
✔		Number.isSafeInteger	
✔		Number.isNaN	
✔		Number.EPSILON	
✔		Number.MIN_SAFE_INTEGER	
✔		Number.MAX_SAFE_INTEGER	
▼	Math methods
✘		Math.clz32	
✔		Math.imul	
✘		Math.sign	
✘		Math.log10	
✘		Math.log2	
✘		Math.log1p	
✘		Math.expm1	
✘		Math.cosh	
✘		Math.sinh	
✘		Math.tanh	
✘		Math.acosh	
✘		Math.asinh	
✘		Math.atanh	
✘		Math.hypot	
✘		Math.trunc	
✘		Math.fround	
✘		Math.cbrt	
▼	miscellaneous
✘		duplicate property names in strict mode	
✔		no semicolon needed after do-while	
✘		no assignments allowed in for-in head	
✘		accessors aren't constructors	
✘		Object static methods accept primitives	
✔		Invalid Date	
✘		RegExp constructor can alter flags	
✘	hoisted block-level function declaration	
▼	__proto__ in object literals[20]
✔		basic support	
✘		multiple __proto__ is an error	
✘		not a computed property	
✘		not a shorthand property	
✘		not a shorthand method	
▼	Object.prototype.__proto__
✔		get prototype	
✔		set prototype	
✔		correct property descriptor	
✔	String.prototype HTML methods	
✔	RegExp.prototype.compile