Bump eslint-plugin-import to avoid vulnerability in dependency

node_modules/es-abstract/2019/AbstractRelationalComparison.js

@@ -7,15 +7,14 @@ var $TypeError = GetIntrinsic('%TypeError%');
 
 var $isNaN = require('../helpers/isNaN');
 var $isFinite = require('../helpers/isFinite');
-var isPrefixOf = require('../helpers/isPrefixOf');
 
+var IsStringPrefix = require('./IsStringPrefix');
 var ToNumber = require('./ToNumber');
 var ToPrimitive = require('./ToPrimitive');
 var Type = require('./Type');
 
-// https://262.ecma-international.org/5.1/#sec-11.8.5
+// https://262.ecma-international.org/9.0/#sec-abstract-relational-comparison
 
-// eslint-disable-next-line max-statements
 module.exports = function AbstractRelationalComparison(x, y, LeftFirst) {
 	if (Type(LeftFirst) !== 'Boolean') {
 		throw new $TypeError('Assertion failed: LeftFirst argument must be a Boolean');
@@ -29,35 +28,34 @@ module.exports = function AbstractRelationalComparison(x, y, LeftFirst) {
 		py = ToPrimitive(y, $Number);
 		px = ToPrimitive(x, $Number);
 	}
-	var bothStrings = Type(px) === 'String' && Type(py) === 'String';
-	if (!bothStrings) {
-		var nx = ToNumber(px);
-		var ny = ToNumber(py);
-		if ($isNaN(nx) || $isNaN(ny)) {
-			return undefined;
-		}
-		if ($isFinite(nx) && $isFinite(ny) && nx === ny) {
+	if (Type(px) === 'String' && Type(py) === 'String') {
+		if (IsStringPrefix(py, px)) {
 			return false;
 		}
-		if (nx === Infinity) {
-			return false;
-		}
-		if (ny === Infinity) {
+		if (IsStringPrefix(px, py)) {
 			return true;
 		}
-		if (ny === -Infinity) {
-			return false;
-		}
-		if (nx === -Infinity) {
-			return true;
-		}
-		return nx < ny; // by now, these are both nonzero, finite, and not equal
+		return px < py; // both strings, neither a prefix of the other. shortcut for steps 3 c-f
 	}
-	if (isPrefixOf(py, px)) {
+	var nx = ToNumber(px);
+	var ny = ToNumber(py);
+	if ($isNaN(nx) || $isNaN(ny)) {
+		return undefined;
+	}
+	if ($isFinite(nx) && $isFinite(ny) && nx === ny) {
 		return false;
 	}
-	if (isPrefixOf(px, py)) {
+	if (nx === Infinity) {
+		return false;
+	}
+	if (ny === Infinity) {
 		return true;
 	}
-	return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f
+	if (ny === -Infinity) {
+		return false;
+	}
+	if (nx === -Infinity) {
+		return true;
+	}
+	return nx < ny; // by now, these are both nonzero, finite, and not equal
 };

node_modules/es-abstract/2019/ArrayCreate.js

@@ -9,16 +9,17 @@ var $TypeError = GetIntrinsic('%TypeError%');
 
 var IsInteger = require('./IsInteger');
 
+var hasProto = require('has-proto')();
+
 var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1;
 
 var $setProto = GetIntrinsic('%Object.setPrototypeOf%', true) || (
-	// eslint-disable-next-line no-proto, no-negated-condition
-	[].__proto__ !== $ArrayPrototype
-		? null
-		: function (O, proto) {
+	hasProto
+		? function (O, proto) {
 			O.__proto__ = proto; // eslint-disable-line no-proto, no-param-reassign
 			return O;
 		}
+		: null
 );
 
 // https://ecma-international.org/ecma-262/6.0/#sec-arraycreate
@@ -42,12 +43,12 @@ module.exports = function ArrayCreate(length) {
 		A.length = length;
 	}
 	/* step 10, the above as a shortcut for the below
-    OrdinaryDefineOwnProperty(A, 'length', {
-        '[[Configurable]]': false,
-        '[[Enumerable]]': false,
-        '[[Value]]': length,
-        '[[Writable]]': true
-    });
-    */
+	OrdinaryDefineOwnProperty(A, 'length', {
+		'[[Configurable]]': false,
+		'[[Enumerable]]': false,
+		'[[Value]]': length,
+		'[[Writable]]': true
+	});
+	*/
 	return A;
 };

node_modules/es-abstract/2019/AsyncFromSyncIteratorContinuation.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+var $Promise = GetIntrinsic('%Promise%', true);
+
+var callBound = require('call-bind/callBound');
+
+var CreateIterResultObject = require('./CreateIterResultObject');
+var IteratorComplete = require('./IteratorComplete');
+var IteratorValue = require('./IteratorValue');
+var PromiseResolve = require('./PromiseResolve');
+var Type = require('./Type');
+
+var $then = callBound('Promise.prototype.then', true);
+
+// https://ecma-international.org/ecma-262/10.0/#sec-asyncfromsynciteratorcontinuation
+
+module.exports = function AsyncFromSyncIteratorContinuation(result) {
+	if (Type(result) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+
+	if (arguments.length > 1) {
+		throw new $SyntaxError('although AsyncFromSyncIteratorContinuation should take a second argument, it is not used in this implementation');
+	}
+
+	if (!$Promise) {
+		throw new $SyntaxError('This environment does not support Promises.');
+	}
+
+	return new Promise(function (resolve) {
+		var done = IteratorComplete(result); // step 2
+		var value = IteratorValue(result); // step 4
+		var valueWrapper = PromiseResolve($Promise, value); // step 6
+
+		// eslint-disable-next-line no-shadow
+		var onFulfilled = function (value) { // steps 8-9
+			return CreateIterResultObject(value, done); // step 8.a
+		};
+		resolve($then(valueWrapper, onFulfilled)); // step 11
+	}); // step 12
+};

node_modules/es-abstract/2019/AsyncIteratorClose.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+var $Promise = GetIntrinsic('%Promise%', true);
+
+var Call = require('./Call');
+var CompletionRecord = require('./CompletionRecord');
+var GetMethod = require('./GetMethod');
+var Type = require('./Type');
+
+var assertRecord = require('../helpers/assertRecord');
+
+var callBound = require('call-bind/callBound');
+
+var $then = callBound('Promise.prototype.then', true);
+
+// https://262.ecma-international.org/9.0/#sec-asynciteratorclose
+
+module.exports = function AsyncIteratorClose(iteratorRecord, completion) {
+	assertRecord(Type, 'Iterator Record', 'iteratorRecord', iteratorRecord); // step 1
+
+	if (!(completion instanceof CompletionRecord)) {
+		throw new $TypeError('Assertion failed: completion is not a Completion Record instance'); // step 2
+	}
+
+	if (!$then) {
+		throw new $SyntaxError('This environment does not support Promises.');
+	}
+
+	var iterator = iteratorRecord['[[Iterator]]']; // step 3
+
+	return new $Promise(function (resolve) {
+		var ret = GetMethod(iterator, 'return'); // step 4
+
+		if (typeof ret === 'undefined') {
+			resolve(completion); // step 5
+		} else {
+			resolve($then(
+				new $Promise(function (resolve2) {
+					// process.exit(42);
+					resolve2(Call(ret, iterator, [])); // step 6
+				}),
+				function (innerResult) {
+					if (Type(innerResult) !== 'Object') {
+						throw new $TypeError('`innerResult` must be an Object'); // step 10
+					}
+					return completion;
+				},
+				function (e) {
+					if (completion.type() === 'throw') {
+						completion['?'](); // step 8
+					} else {
+						throw e; // step 9
+					}
+				}
+			));
+		}
+	});
+};

node_modules/es-abstract/2019/CharacterRange.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+var $TypeError = GetIntrinsic('%TypeError%');
+var $charCodeAt = callBound('%String.prototype.charCodeAt%');
+var $push = callBound('%Array.prototype.push%');
+
+module.exports = function CharacterRange(A, B) {
+	if (A.length !== 1 || B.length !== 1) {
+		throw new $TypeError('Assertion failed: CharSets A and B contain exactly one character');
+	}
+
+	var a = A[0];
+	var b = B[0];
+
+	var i = $charCodeAt(a, 0);
+	var j = $charCodeAt(b, 0);
+
+	if (!(i <= j)) {
+		throw new $TypeError('Assertion failed: i is not <= j');
+	}
+
+	var arr = [];
+	for (var k = i; k <= j; k += 1) {
+		$push(arr, $fromCharCode(k));
+	}
+	return arr;
+};

node_modules/es-abstract/2019/CompletionRecord.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+
+var SLOT = require('internal-slot');
+
+// https://262.ecma-international.org/7.0/#sec-completion-record-specification-type
+
+var CompletionRecord = function CompletionRecord(type, value) {
+	if (!(this instanceof CompletionRecord)) {
+		return new CompletionRecord(type, value);
+	}
+	if (type !== 'normal' && type !== 'break' && type !== 'continue' && type !== 'return' && type !== 'throw') {
+		throw new $SyntaxError('Assertion failed: `type` must be one of "normal", "break", "continue", "return", or "throw"');
+	}
+	SLOT.set(this, '[[Type]]', type);
+	SLOT.set(this, '[[Value]]', value);
+	// [[Target]] slot?
+};
+
+CompletionRecord.prototype.type = function Type() {
+	return SLOT.get(this, '[[Type]]');
+};
+
+CompletionRecord.prototype.value = function Value() {
+	return SLOT.get(this, '[[Value]]');
+};
+
+CompletionRecord.prototype['?'] = function ReturnIfAbrupt() {
+	var type = SLOT.get(this, '[[Type]]');
+	var value = SLOT.get(this, '[[Value]]');
+
+	if (type === 'normal') {
+		return value;
+	}
+	if (type === 'throw') {
+		throw value;
+	}
+	throw new $SyntaxError('Completion Record is not of type "normal" or "throw": other types not supported');
+};
+
+CompletionRecord.prototype['!'] = function assert() {
+	var type = SLOT.get(this, '[[Type]]');
+
+	if (type !== 'normal') {
+		throw new $SyntaxError('Assertion failed: Completion Record is not of type "normal"');
+	}
+	return SLOT.get(this, '[[Value]]');
+};
+
+module.exports = CompletionRecord;

node_modules/es-abstract/2019/CopyDataProperties.js

@@ -55,8 +55,8 @@ module.exports = function CopyDataProperties(target, source, excludedItems) {
 		var enumerable = $isEnumerable(fromObj, nextKey) || (
 		// this is to handle string keys being non-enumerable in older engines
 			typeof source === 'string'
-            && nextKey >= 0
-            && IsInteger(ToNumber(nextKey))
+			&& nextKey >= 0
+			&& IsInteger(ToNumber(nextKey))
 		);
 		if (excluded === false && enumerable) {
 			var propValue = Get(fromObj, nextKey);

node_modules/es-abstract/2019/CreateAsyncFromSyncIterator.js

@@ -0,0 +1,121 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var AsyncFromSyncIteratorContinuation = require('./AsyncFromSyncIteratorContinuation');
+var Call = require('./Call');
+var CreateIterResultObject = require('./CreateIterResultObject');
+var Get = require('./Get');
+var GetMethod = require('./GetMethod');
+var IteratorNext = require('./IteratorNext');
+var ObjectCreate = require('./ObjectCreate');
+var Type = require('./Type');
+
+var SLOT = require('internal-slot');
+
+var assertRecord = require('../helpers/assertRecord');
+
+var $AsyncFromSyncIteratorPrototype = GetIntrinsic('%AsyncFromSyncIteratorPrototype%', true) || {
+	next: function next(value) {
+		var O = this; // step 1
+
+		SLOT.assert(O, '[[SyncIteratorRecord]]'); // step 2
+
+		var argsLength = arguments.length;
+
+		return new Promise(function (resolve) { // step 3
+			var syncIteratorRecord = SLOT.get(O, '[[SyncIteratorRecord]]'); // step 4
+			var result;
+			if (argsLength > 0) {
+				result = IteratorNext(syncIteratorRecord['[[Iterator]]'], value); // step 5.a
+			} else { // step 6
+				result = IteratorNext(syncIteratorRecord['[[Iterator]]']);// step 6.a
+			}
+			resolve(AsyncFromSyncIteratorContinuation(result)); // step 8
+		});
+	},
+	'return': function () {
+		var O = this; // step 1
+
+		SLOT.assert(O, '[[SyncIteratorRecord]]'); // step 2
+
+		var valueIsPresent = arguments.length > 0;
+		var value = valueIsPresent ? arguments[0] : void undefined;
+
+		return new Promise(function (resolve, reject) { // step 3
+			var syncIterator = SLOT.get(O, '[[SyncIteratorRecord]]')['[[Iterator]]']; // step 4
+			var iteratorReturn = GetMethod(syncIterator, 'return'); // step 5
+
+			if (typeof iteratorReturn === 'undefined') { // step 7
+				var iterResult = CreateIterResultObject(value, true); // step 7.a
+				Call(resolve, undefined, [iterResult]); // step 7.b
+				return;
+			}
+			var result;
+			if (valueIsPresent) { // step 8
+				result = Call(iteratorReturn, syncIterator, [value]); // step 8.a
+			} else { // step 9
+				result = Call(iteratorReturn, syncIterator); // step 9.a
+			}
+			if (Type(result) !== 'Object') { // step 11
+				Call(reject, undefined, [new $TypeError('Iterator `return` method returned a non-object value.')]); // step 11.a
+				return;
+			}
+
+			resolve(AsyncFromSyncIteratorContinuation(result)); // step 12
+		});
+	},
+	'throw': function () {
+		var O = this; // step 1
+
+		SLOT.assert(O, '[[SyncIteratorRecord]]'); // step 2
+
+		var valueIsPresent = arguments.length > 0;
+		var value = valueIsPresent ? arguments[0] : void undefined;
+
+		return new Promise(function (resolve, reject) { // step 3
+			var syncIterator = SLOT.get(O, '[[SyncIteratorRecord]]')['[[Iterator]]']; // step 4
+
+			var throwMethod = GetMethod(syncIterator, 'throw'); // step 5
+
+			if (typeof throwMethod === 'undefined') { // step 7
+				Call(reject, undefined, [value]); // step 7.a
+				return;
+			}
+
+			var result;
+			if (valueIsPresent) { // step 8
+				result = Call(throwMethod, syncIterator, [value]); // step 8.a
+			} else { // step 9
+				result = Call(throwMethod, syncIterator); // step 9.a
+			}
+			if (Type(result) !== 'Object') { // step 11
+				Call(reject, undefined, [new $TypeError('Iterator `throw` method returned a non-object value.')]); // step 11.a
+				return;
+			}
+
+			resolve(AsyncFromSyncIteratorContinuation(result/* , promiseCapability */)); // step 12
+		});
+	}
+};
+
+// https://ecma-international.org/ecma-262/10.0/#sec-createasyncfromsynciterator
+
+module.exports = function CreateAsyncFromSyncIterator(syncIteratorRecord) {
+	assertRecord(Type, 'Iterator Record', 'syncIteratorRecord', syncIteratorRecord);
+
+	// var asyncIterator = ObjectCreate(%AsyncFromSyncIteratorPrototype%, « [[SyncIteratorRecord]] »); // step 1
+	var asyncIterator = ObjectCreate($AsyncFromSyncIteratorPrototype);
+
+	SLOT.set(asyncIterator, '[[SyncIteratorRecord]]', syncIteratorRecord); // step 2
+
+	var nextMethod = Get(asyncIterator, 'next'); // step 3
+
+	return { // steps 3-4
+		'[[Iterator]]': asyncIterator,
+		'[[NextMethod]]': nextMethod,
+		'[[Done]]': false
+	};
+};

node_modules/es-abstract/2019/CreateDataProperty.js

@@ -25,8 +25,8 @@ module.exports = function CreateDataProperty(O, P, V) {
 	}
 	var oldDesc = OrdinaryGetOwnProperty(O, P);
 	var extensible = !oldDesc || IsExtensible(O);
-	var immutable = oldDesc && (!oldDesc['[[Writable]]'] || !oldDesc['[[Configurable]]']);
-	if (immutable || !extensible) {
+	var nonConfigurable = oldDesc && !oldDesc['[[Configurable]]'];
+	if (nonConfigurable || !extensible) {
 		return false;
 	}
 	return DefineOwnProperty(

node_modules/es-abstract/2019/DetachArrayBuffer.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isArrayBuffer = require('is-array-buffer');
+var isSharedArrayBuffer = require('is-shared-array-buffer');
+
+var MessageChannel;
+try {
+	// eslint-disable-next-line global-require
+	MessageChannel = require('worker_threads').MessageChannel;
+} catch (e) { /**/ }
+
+// https://262.ecma-international.org/9.0/#sec-detacharraybuffer
+
+/* globals postMessage */
+
+module.exports = function DetachArrayBuffer(arrayBuffer) {
+	if (!isArrayBuffer(arrayBuffer) || isSharedArrayBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot, and not a Shared Array Buffer');
+	}
+
+	// commented out since there's no way to set or access this key
+	// var key = arguments.length > 1 ? arguments[1] : void undefined;
+
+	// if (!SameValue(arrayBuffer[[ArrayBufferDetachKey]], key)) {
+	// 	throw new $TypeError('Assertion failed: `key` must be the value of the [[ArrayBufferDetachKey]] internal slot of `arrayBuffer`');
+	// }
+
+	if (typeof structuredClone === 'function') {
+		structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
+	} else if (typeof postMessage === 'function') {
+		postMessage('', '/', [arrayBuffer]); // TODO: see if this might trigger listeners
+	} else if (MessageChannel) {
+		(new MessageChannel()).port1.postMessage(null, [arrayBuffer]);
+	} else {
+		throw new $SyntaxError('DetachArrayBuffer is not supported in this environment');
+	}
+	return null;
+};

node_modules/es-abstract/2019/EnumerableOwnPropertyNames.js

@@ -19,7 +19,7 @@ var Type = require('./Type');
 
 // https://262.ecma-international.org/8.0/#sec-enumerableownproperties
 
-module.exports = function EnumerableOwnProperties(O, kind) {
+module.exports = function EnumerableOwnPropertyNames(O, kind) {
 	if (Type(O) !== 'Object') {
 		throw new $TypeError('Assertion failed: Type(O) is not Object');
 	}

node_modules/es-abstract/2019/FromPropertyDescriptor.js

@@ -1,36 +1,16 @@
 'use strict';
 
 var assertRecord = require('../helpers/assertRecord');
+var fromPropertyDescriptor = require('../helpers/fromPropertyDescriptor');
 
 var Type = require('./Type');
 
 // https://ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor
 
 module.exports = function FromPropertyDescriptor(Desc) {
-	if (typeof Desc === 'undefined') {
-		return Desc;
+	if (typeof Desc !== 'undefined') {
+		assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
 	}
 
-	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
-
-	var obj = {};
-	if ('[[Value]]' in Desc) {
-		obj.value = Desc['[[Value]]'];
-	}
-	if ('[[Writable]]' in Desc) {
-		obj.writable = Desc['[[Writable]]'];
-	}
-	if ('[[Get]]' in Desc) {
-		obj.get = Desc['[[Get]]'];
-	}
-	if ('[[Set]]' in Desc) {
-		obj.set = Desc['[[Set]]'];
-	}
-	if ('[[Enumerable]]' in Desc) {
-		obj.enumerable = Desc['[[Enumerable]]'];
-	}
-	if ('[[Configurable]]' in Desc) {
-		obj.configurable = Desc['[[Configurable]]'];
-	}
-	return obj;
+	return fromPropertyDescriptor(Desc);
 };

node_modules/es-abstract/2019/Get.js

@@ -9,12 +9,7 @@ var inspect = require('object-inspect');
 var IsPropertyKey = require('./IsPropertyKey');
 var Type = require('./Type');
 
-/**
- * 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p
- * 1. Assert: Type(O) is Object.
- * 2. Assert: IsPropertyKey(P) is true.
- * 3. Return O.[[Get]](P, O).
- */
+// https://ecma-international.org/ecma-262/6.0/#sec-get-o-p
 
 module.exports = function Get(O, P) {
 	// 7.3.1.1

node_modules/es-abstract/2019/GetGlobalObject.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var getGlobal = require('globalthis/polyfill');
+
+// https://262.ecma-international.org/6.0/#sec-getglobalobject
+
+module.exports = function GetGlobalObject() {
+	return getGlobal();
+};

node_modules/es-abstract/2019/GetIterator.js

@@ -20,8 +20,7 @@ module.exports = function GetIterator(obj, method) {
 			{
 				AdvanceStringIndex: AdvanceStringIndex,
 				GetMethod: GetMethod,
-				IsArray: IsArray,
-				Type: Type
+				IsArray: IsArray
 			},
 			obj
 		);

node_modules/es-abstract/2019/GetMethod.js

@@ -8,15 +8,9 @@ var GetV = require('./GetV');
 var IsCallable = require('./IsCallable');
 var IsPropertyKey = require('./IsPropertyKey');
 
-/**
- * 7.3.9 - https://ecma-international.org/ecma-262/6.0/#sec-getmethod
- * 1. Assert: IsPropertyKey(P) is true.
- * 2. Let func be GetV(O, P).
- * 3. ReturnIfAbrupt(func).
- * 4. If func is either undefined or null, return undefined.
- * 5. If IsCallable(func) is false, throw a TypeError exception.
- * 6. Return func.
- */
+var debug = require('object-inspect');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-getmethod
 
 module.exports = function GetMethod(O, P) {
 	// 7.3.9.1
@@ -34,7 +28,7 @@ module.exports = function GetMethod(O, P) {
 
 	// 7.3.9.5
 	if (!IsCallable(func)) {
-		throw new $TypeError(P + 'is not a function');
+		throw new $TypeError(P + ' is not a function: ' + debug(func));
 	}
 
 	// 7.3.9.6

node_modules/es-abstract/2019/GetOwnPropertyKeys.js

@@ -6,8 +6,8 @@ var hasSymbols = require('has-symbols')();
 
 var $TypeError = GetIntrinsic('%TypeError%');
 
-var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%');
-var $gOPS = hasSymbols && GetIntrinsic('%Object.getOwnPropertySymbols%');
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true);
+var $gOPS = hasSymbols && GetIntrinsic('%Object.getOwnPropertySymbols%', true);
 var keys = require('object-keys');
 
 var esType = require('./Type');

node_modules/es-abstract/2019/GetPrototypeFromConstructor.js

@@ -4,6 +4,7 @@ var GetIntrinsic = require('get-intrinsic');
 
 var $Function = GetIntrinsic('%Function%');
 var $TypeError = GetIntrinsic('%TypeError%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
 
 var Get = require('./Get');
 var IsConstructor = require('./IsConstructor');
@@ -20,7 +21,7 @@ module.exports = function GetPrototypeFromConstructor(constructor, intrinsicDefa
 	if (Type(proto) !== 'Object') {
 		if (!(constructor instanceof $Function)) {
 			// ignore other realms, for now
-			throw new $TypeError('cross-realm constructors not currently supported');
+			throw new $SyntaxError('cross-realm constructors not currently supported');
 		}
 		proto = intrinsic;
 	}

node_modules/es-abstract/2019/GetSubstitution.js

@@ -5,7 +5,7 @@ var GetIntrinsic = require('get-intrinsic');
 var $TypeError = GetIntrinsic('%TypeError%');
 
 var callBound = require('call-bind/callBound');
-var regexTester = require('../helpers/regexTester');
+var regexTester = require('safe-regex-test');
 var every = require('../helpers/every');
 
 var $charAt = callBound('String.prototype.charAt');

node_modules/es-abstract/2019/GetV.js

@@ -7,13 +7,7 @@ var $TypeError = GetIntrinsic('%TypeError%');
 var IsPropertyKey = require('./IsPropertyKey');
 var ToObject = require('./ToObject');
 
-/**
- * 7.3.2 GetV (V, P)
- * 1. Assert: IsPropertyKey(P) is true.
- * 2. Let O be ToObject(V).
- * 3. ReturnIfAbrupt(O).
- * 4. Return O.[[Get]](P, V).
- */
+// https://ecma-international.org/ecma-262/6.0/#sec-getv
 
 module.exports = function GetV(V, P) {
 	// 7.3.2.1

node_modules/es-abstract/2019/IsArray.js

@@ -1,14 +1,4 @@
 'use strict';
 
-var GetIntrinsic = require('get-intrinsic');
-
-var $Array = GetIntrinsic('%Array%');
-
-// eslint-disable-next-line global-require
-var toStr = !$Array.isArray && require('call-bind/callBound')('Object.prototype.toString');
-
 // https://ecma-international.org/ecma-262/6.0/#sec-isarray
-
-module.exports = $Array.isArray || function IsArray(argument) {
-	return toStr(argument) === '[object Array]';
-};
+module.exports = require('../helpers/IsArray');

node_modules/es-abstract/2019/IsCompatiblePropertyDescriptor.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ValidateAndApplyPropertyDescriptor = require('./ValidateAndApplyPropertyDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-iscompatiblepropertydescriptor
+
+module.exports = function IsCompatiblePropertyDescriptor(Extensible, Desc, Current) {
+	return ValidateAndApplyPropertyDescriptor(undefined, undefined, Extensible, Desc, Current);
+};

node_modules/es-abstract/2019/IsDetachedBuffer.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $byteLength = callBound('%ArrayBuffer.prototype.byteLength%', true)
+	|| function byteLength(ab) { return ab.byteLength; }; // in node < 0.11, byteLength is an own nonconfigurable property
+
+var isArrayBuffer = require('is-array-buffer');
+
+var availableTypedArrays = require('available-typed-arrays')();
+
+// https://262.ecma-international.org/6.0/#sec-isdetachedbuffer
+
+module.exports = function IsDetachedBuffer(arrayBuffer) {
+	if (!isArrayBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot');
+	}
+	if ($byteLength(arrayBuffer) === 0) {
+		try {
+			new global[availableTypedArrays[0]](arrayBuffer); // eslint-disable-line no-new
+		} catch (error) {
+			return error.name === 'TypeError';
+		}
+	}
+	return false;
+};

node_modules/es-abstract/2019/IsExtensible.js

@@ -2,13 +2,11 @@
 
 var GetIntrinsic = require('get-intrinsic');
 
-var $Object = GetIntrinsic('%Object%');
+var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true);
+var $isExtensible = GetIntrinsic('%Object.isExtensible%', true);
 
 var isPrimitive = require('../helpers/isPrimitive');
 
-var $preventExtensions = $Object.preventExtensions;
-var $isExtensible = $Object.isExtensible;
-
 // https://ecma-international.org/ecma-262/6.0/#sec-isextensible-o
 
 module.exports = $preventExtensions

node_modules/es-abstract/2019/IsSharedArrayBuffer.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+
+var isSharedArrayBuffer = require('is-shared-array-buffer');
+
+// https://262.ecma-international.org/8.0/#sec-issharedarraybuffer
+
+module.exports = function IsSharedArrayBuffer(obj) {
+	if (Type(obj) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+
+	return isSharedArrayBuffer(obj);
+};

node_modules/es-abstract/2019/IteratorClose.js

@@ -5,6 +5,7 @@ var GetIntrinsic = require('get-intrinsic');
 var $TypeError = GetIntrinsic('%TypeError%');
 
 var Call = require('./Call');
+var CompletionRecord = require('./CompletionRecord');
 var GetMethod = require('./GetMethod');
 var IsCallable = require('./IsCallable');
 var Type = require('./Type');
@@ -15,10 +16,10 @@ module.exports = function IteratorClose(iterator, completion) {
 	if (Type(iterator) !== 'Object') {
 		throw new $TypeError('Assertion failed: Type(iterator) is not Object');
 	}
-	if (!IsCallable(completion)) {
-		throw new $TypeError('Assertion failed: completion is not a thunk for a Completion Record');
+	if (!IsCallable(completion) && !(completion instanceof CompletionRecord)) {
+		throw new $TypeError('Assertion failed: completion is not a thunk representing a Completion Record, nor a Completion Record instance');
 	}
-	var completionThunk = completion;
+	var completionThunk = completion instanceof CompletionRecord ? function () { return completion['?'](); } : completion;
 
 	var iteratorReturn = GetMethod(iterator, 'return');
 

node_modules/es-abstract/2019/NormalCompletion.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var CompletionRecord = require('./CompletionRecord');
+
+// https://262.ecma-international.org/6.0/#sec-normalcompletion
+
+module.exports = function NormalCompletion(value) {
+	return new CompletionRecord('normal', value);
+};

node_modules/es-abstract/2019/NumberToRawBytes.js

@@ -0,0 +1,198 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $floor = GetIntrinsic('%Math.floor%');
+var $log = GetIntrinsic('%Math.log%');
+var $log2E = GetIntrinsic('%Math.LOG2E%');
+var $log2 = GetIntrinsic('%Math.log2%', true) || function log2(x) {
+	return $log(x) * $log2E;
+};
+var $parseInt = GetIntrinsic('%parseInt%');
+var $pow = GetIntrinsic('%Math.pow%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $reverse = callBound('Array.prototype.reverse');
+var $numberToString = callBound('Number.prototype.toString');
+var $strSlice = callBound('String.prototype.slice');
+
+var abs = require('./abs');
+var hasOwnProperty = require('./HasOwnProperty');
+var ToInt16 = require('./ToInt16');
+var ToInt32 = require('./ToInt32');
+var ToInt8 = require('./ToInt8');
+var ToUint16 = require('./ToUint16');
+var ToUint32 = require('./ToUint32');
+var ToUint8 = require('./ToUint8');
+var ToUint8Clamp = require('./ToUint8Clamp');
+var Type = require('./Type');
+
+var isNaN = require('../helpers/isNaN');
+var isFinite = require('../helpers/isFinite');
+
+var keys = require('object-keys');
+
+// https://262.ecma-international.org/8.0/#table-50
+var TypeToSizes = {
+	__proto__: null,
+	Int8: 1,
+	Uint8: 1,
+	Uint8C: 1,
+	Int16: 2,
+	Uint16: 2,
+	Int32: 4,
+	Uint32: 4,
+	Float32: 4,
+	Float64: 8
+};
+
+var TypeToAO = {
+	__proto__: null,
+	Int8: ToInt8,
+	Uint8: ToUint8,
+	Uint8C: ToUint8Clamp,
+	Int16: ToInt16,
+	Uint16: ToUint16,
+	Int32: ToInt32,
+	Uint32: ToUint32
+};
+
+// https://262.ecma-international.org/8.0/#sec-numbertorawbytes
+
+module.exports = function NumberToRawBytes(type, value, isLittleEndian) {
+	if (typeof type !== 'string' || !hasOwnProperty(TypeToSizes, type)) {
+		throw new $TypeError('Assertion failed: `type` must be a TypedArray element type: ' + keys(TypeToSizes));
+	}
+	if (Type(value) !== 'Number') {
+		throw new $TypeError('Assertion failed: `value` must be a Number');
+	}
+	if (Type(isLittleEndian) !== 'Boolean') {
+		throw new $TypeError('Assertion failed: `isLittleEndian` must be a Boolean');
+	}
+
+	var rawBytes = [];
+	var exponent;
+
+	if (type === 'Float32') { // step 1
+		if (isNaN(value)) {
+			return isLittleEndian ? [0, 0, 192, 127] : [127, 192, 0, 0]; // hardcoded
+		}
+
+		var leastSig;
+
+		if (value === 0) {
+			leastSig = Object.is(value, -0) ? 0x80 : 0;
+			return isLittleEndian ? [0, 0, 0, leastSig] : [leastSig, 0, 0, 0];
+		}
+
+		if (!isFinite(value)) {
+			leastSig = value < 0 ? 255 : 127;
+			return isLittleEndian ? [0, 0, 128, leastSig] : [leastSig, 128, 0, 0];
+		}
+
+		var sign = value < 0 ? 1 : 0;
+		value = abs(value); // eslint-disable-line no-param-reassign
+
+		exponent = 0;
+		while (value >= 2) {
+			exponent += 1;
+			value /= 2; // eslint-disable-line no-param-reassign
+		}
+
+		while (value < 1) {
+			exponent -= 1;
+			value *= 2; // eslint-disable-line no-param-reassign
+		}
+
+		var mantissa = value - 1;
+		mantissa *= $pow(2, 23);
+		mantissa = $floor(mantissa);
+
+		exponent += 127;
+		exponent = exponent << 23;
+
+		var result = sign << 31;
+		result |= exponent;
+		result |= mantissa;
+
+		var byte0 = result & 255;
+		result = result >> 8;
+		var byte1 = result & 255;
+		result = result >> 8;
+		var byte2 = result & 255;
+		result = result >> 8;
+		var byte3 = result & 255;
+
+		if (isLittleEndian) {
+			return [byte0, byte1, byte2, byte3];
+		}
+		return [byte3, byte2, byte1, byte0];
+	} else if (type === 'Float64') { // step 2
+		if (value === 0) {
+			leastSig = Object.is(value, -0) ? 0x80 : 0;
+			return isLittleEndian ? [0, 0, 0, 0, 0, 0, 0, leastSig] : [leastSig, 0, 0, 0, 0, 0, 0, 0];
+		}
+		if (isNaN(value)) {
+			return isLittleEndian ? [0, 0, 0, 0, 0, 0, 248, 127] : [127, 248, 0, 0, 0, 0, 0, 0];
+		}
+		if (!isFinite(value)) {
+			var infBytes = value < 0 ? [0, 0, 0, 0, 0, 0, 240, 255] : [0, 0, 0, 0, 0, 0, 240, 127];
+			return isLittleEndian ? infBytes : $reverse(infBytes);
+		}
+
+		var isNegative = value < 0;
+		if (isNegative) { value = -value; } // eslint-disable-line no-param-reassign
+
+		exponent = $floor($log2(value));
+		var significand = (value / $pow(2, exponent)) - 1;
+
+		var bitString = '';
+		for (var i = 0; i < 52; i++) {
+			significand *= 2;
+			if (significand >= 1) {
+				bitString += '1';
+				significand -= 1;
+			} else {
+				bitString += '0';
+			}
+		}
+
+		exponent += 1023;
+		var exponentBits = $numberToString(exponent, 2);
+		while (exponentBits.length < 11) { exponentBits = '0' + exponentBits; }
+
+		var fullBitString = (isNegative ? '1' : '0') + exponentBits + bitString;
+		while (fullBitString.length < 64) { fullBitString = '0' + fullBitString; }
+
+		for (i = 0; i < 8; i++) {
+			rawBytes[i] = $parseInt($strSlice(fullBitString, i * 8, (i + 1) * 8), 2);
+		}
+
+		return isLittleEndian ? $reverse(rawBytes) : rawBytes;
+	} // step 3
+
+	var n = TypeToSizes[type]; // step 3.a
+
+	var convOp = TypeToAO[type]; // step 3.b
+
+	var intValue = convOp(value); // step 3.c
+
+	/*
+	if (intValue >= 0) { // step 3.d
+		// Let rawBytes be a List containing the n-byte binary encoding of intValue. If isLittleEndian is false, the bytes are ordered in big endian order. Otherwise, the bytes are ordered in little endian order.
+	} else { // step 3.e
+		// Let rawBytes be a List containing the n-byte binary 2's complement encoding of intValue. If isLittleEndian is false, the bytes are ordered in big endian order. Otherwise, the bytes are ordered in little endian order.
+	}
+    */
+	if (intValue < 0) {
+		intValue = intValue >>> 0;
+	}
+	for (i = 0; i < n; i++) {
+		rawBytes[isLittleEndian ? i : n - 1 - i] = intValue & 0xff;
+		intValue = intValue >> 8;
+	}
+
+	return rawBytes; // step 4
+};

node_modules/es-abstract/2019/ObjectCreate.js

@@ -6,9 +6,14 @@ var $ObjectCreate = GetIntrinsic('%Object.create%', true);
 var $TypeError = GetIntrinsic('%TypeError%');
 var $SyntaxError = GetIntrinsic('%SyntaxError%');
 
+var IsArray = require('./IsArray');
 var Type = require('./Type');
 
-var hasProto = !({ __proto__: null } instanceof Object);
+var forEach = require('../helpers/forEach');
+
+var SLOT = require('internal-slot');
+
+var hasProto = require('has-proto')();
 
 // https://ecma-international.org/ecma-262/6.0/#sec-objectcreate
 
@@ -16,22 +21,30 @@ module.exports = function ObjectCreate(proto, internalSlotsList) {
 	if (proto !== null && Type(proto) !== 'Object') {
 		throw new $TypeError('Assertion failed: `proto` must be null or an object');
 	}
-	var slots = arguments.length < 2 ? [] : internalSlotsList;
-	if (slots.length > 0) {
-		throw new $SyntaxError('es-abstract does not yet support internal slots');
+	var slots = arguments.length < 2 ? [] : internalSlotsList; // step 1
+	if (arguments.length >= 2 && !IsArray(slots)) {
+		throw new $TypeError('Assertion failed: `internalSlotsList` must be an Array');
 	}
 
+	var O;
 	if ($ObjectCreate) {
-		return $ObjectCreate(proto);
-	}
-	if (hasProto) {
-		return { __proto__: proto };
+		O = $ObjectCreate(proto);
+	} else if (hasProto) {
+		O = { __proto__: proto };
+	} else {
+		if (proto === null) {
+			throw new $SyntaxError('native Object.create support is required to create null objects');
+		}
+		var T = function T() {};
+		T.prototype = proto;
+		O = new T();
 	}
 
-	if (proto === null) {
-		throw new $SyntaxError('native Object.create support is required to create null objects');
+	if (slots.length > 0) {
+		forEach(slots, function (slot) {
+			SLOT.set(O, slot, void undefined);
+		});
 	}
-	var T = function T() {};
-	T.prototype = proto;
-	return new T();
+
+	return O; // step 6
 };

node_modules/es-abstract/2019/ObjectDefineProperties.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var Get = require('./Get');
+var ToObject = require('./ToObject');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+
+var forEach = require('../helpers/forEach');
+var getOwnPropertyDescriptor = require('gopd');
+var OwnPropertyKeys = require('../helpers/OwnPropertyKeys');
+
+var $push = callBound('Array.prototype.push');
+
+// https://262.ecma-international.org/6.0/#sec-objectdefineproperties
+module.exports = function ObjectDefineProperties(O, Properties) {
+	var props = ToObject(Properties); // step 1
+	var keys = OwnPropertyKeys(props); // step 2
+	var descriptors = []; // step 3
+
+	forEach(keys, function (nextKey) { // step 4
+		var propDesc = ToPropertyDescriptor(getOwnPropertyDescriptor(props, nextKey)); // step 4.a
+		if (typeof propDesc !== 'undefined' && propDesc['[[Enumerable]]']) { // step 4.b
+			var descObj = Get(props, nextKey); // step 4.b.i
+			var desc = ToPropertyDescriptor(descObj); // step 4.b.ii
+			$push(descriptors, [nextKey, desc]); // step 4.b.iii
+		}
+	});
+
+	forEach(descriptors, function (pair) { // step 5
+		var P = pair[0]; // step 5.a
+		var desc = pair[1]; // step 5.b
+		desc = FromPropertyDescriptor(desc); // TODO: remove this once DefinePropertyOrThrow is fixed
+		DefinePropertyOrThrow(O, P, desc); // step 5.c
+	});
+
+	return O; // step 6
+};

node_modules/es-abstract/2019/OrdinaryDefineOwnProperty.js

@@ -2,7 +2,7 @@
 
 var GetIntrinsic = require('get-intrinsic');
 
-var $gOPD = require('../helpers/getOwnPropertyDescriptor');
+var $gOPD = require('gopd');
 var $SyntaxError = GetIntrinsic('%SyntaxError%');
 var $TypeError = GetIntrinsic('%TypeError%');
 

node_modules/es-abstract/2019/OrdinaryGetOwnProperty.js

@@ -2,7 +2,7 @@
 
 var GetIntrinsic = require('get-intrinsic');
 
-var $gOPD = require('../helpers/getOwnPropertyDescriptor');
+var $gOPD = require('gopd');
 var $TypeError = GetIntrinsic('%TypeError%');
 
 var callBound = require('call-bind/callBound');

node_modules/es-abstract/2019/OrdinarySetPrototypeOf.js

@@ -16,15 +16,15 @@ module.exports = function OrdinarySetPrototypeOf(O, V) {
 		throw new $TypeError('Assertion failed: V must be Object or Null');
 	}
 	/*
-    var extensible = IsExtensible(O);
-    var current = OrdinaryGetPrototypeOf(O);
-    if (SameValue(V, current)) {
-        return true;
-    }
-    if (!extensible) {
-        return false;
-    }
-    */
+	var extensible = IsExtensible(O);
+	var current = OrdinaryGetPrototypeOf(O);
+	if (SameValue(V, current)) {
+		return true;
+	}
+	if (!extensible) {
+		return false;
+	}
+	*/
 	try {
 		$setProto(O, V);
 	} catch (e) {
@@ -32,22 +32,22 @@ module.exports = function OrdinarySetPrototypeOf(O, V) {
 	}
 	return OrdinaryGetPrototypeOf(O) === V;
 	/*
-    var p = V;
-    var done = false;
-    while (!done) {
-        if (p === null) {
-            done = true;
-        } else if (SameValue(p, O)) {
-            return false;
-        } else {
-            if (wat) {
-                done = true;
-            } else {
-                p = p.[[Prototype]];
-            }
-        }
-     }
-     O.[[Prototype]] = V;
-     return true;
-     */
+	var p = V;
+	var done = false;
+	while (!done) {
+		if (p === null) {
+			done = true;
+		} else if (SameValue(p, O)) {
+			return false;
+		} else {
+			if (wat) {
+				done = true;
+			} else {
+				p = p.[[Prototype]];
+			}
+		}
+	}
+	O.[[Prototype]] = V;
+	return true;
+	*/
 };

node_modules/es-abstract/2019/OrdinaryToPrimitive.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Call = require('./Call');
+var Get = require('./Get');
+var IsCallable = require('./IsCallable');
+var Type = require('./Type');
+
+var inspect = require('object-inspect');
+
+// https://262.ecma-international.org/8.0/#sec-ordinarytoprimitive
+
+module.exports = function OrdinaryToPrimitive(O, hint) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (/* Type(hint) !== 'String' || */ hint !== 'string' && hint !== 'number') {
+		throw new $TypeError('Assertion failed: `hint` must be "string" or "number"');
+	}
+
+	var methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
+
+	for (var i = 0; i < methodNames.length; i += 1) {
+		var name = methodNames[i];
+		var method = Get(O, name);
+		if (IsCallable(method)) {
+			var result = Call(method, O);
+			if (Type(result) !== 'Object') {
+				return result;
+			}
+		}
+	}
+
+	throw new $TypeError('No primitive value for ' + inspect(O));
+};

node_modules/es-abstract/2019/RawBytesToNumber.js

@@ -0,0 +1,145 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $pow = GetIntrinsic('%Math.pow%');
+var $RangeError = GetIntrinsic('%RangeError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $charAt = callBound('String.prototype.charAt');
+var $reverse = callBound('Array.prototype.reverse');
+var $slice = callBound('Array.prototype.slice');
+
+var hasOwnProperty = require('./HasOwnProperty');
+var IsArray = require('./IsArray');
+var Type = require('./Type');
+
+var every = require('../helpers/every');
+var isByteValue = require('../helpers/isByteValue');
+
+var keys = require('object-keys');
+
+// https://262.ecma-international.org/8.0/#table-50
+var TypeToSizes = {
+	__proto__: null,
+	Int8: 1,
+	Uint8: 1,
+	Uint8C: 1,
+	Int16: 2,
+	Uint16: 2,
+	Int32: 4,
+	Uint32: 4,
+	Float32: 4,
+	Float64: 8
+};
+
+// https://262.ecma-international.org/8.0/#sec-rawbytestonumber
+
+module.exports = function RawBytesToNumber(type, rawBytes, isLittleEndian) {
+	if (typeof type !== 'string' || !hasOwnProperty(TypeToSizes, type)) {
+		throw new $TypeError('Assertion failed: `type` must be a TypedArray element type: ' + keys(TypeToSizes));
+	}
+	if (!IsArray(rawBytes) || !every(rawBytes, isByteValue)) {
+		throw new $TypeError('Assertion failed: `rawBytes` must be an Array of bytes');
+	}
+	if (Type(isLittleEndian) !== 'Boolean') {
+		throw new $TypeError('Assertion failed: `isLittleEndian` must be a Boolean');
+	}
+
+	var elementSize = TypeToSizes[type]; // step 1
+
+	if (rawBytes.length !== elementSize) {
+		// this assertion is not in the spec, but it'd be an editorial error if it were ever violated
+		throw new $RangeError('Assertion failed: `rawBytes` must have a length of ' + elementSize + ' for type ' + type);
+	}
+
+	// eslint-disable-next-line no-param-reassign
+	rawBytes = $slice(rawBytes, 0, elementSize);
+	if (!isLittleEndian) {
+		// eslint-disable-next-line no-param-reassign
+		rawBytes = $reverse(rawBytes); // step 2
+	}
+
+	/* eslint no-redeclare: 1 */
+	if (type === 'Float32') { // step 3
+		/*
+        Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2008 binary32 value.
+If value is an IEEE 754-2008 binary32 NaN value, return the NaN Number value.
+Return the Number value that corresponds to value.
+        */
+		var sign = (rawBytes[3] & 0x80) >> 7; // first bit
+		var exponent = ((rawBytes[3] & 0x7F) << 1) // 7 bits from index 3
+			| ((rawBytes[2] & 0x80) >> 7); // 1 bit from index 2
+		var mantissa = ((rawBytes[2] & 0x7F) << 16) // 7 bits from index 2
+			| (rawBytes[1] << 8) // 8 bits from index 1
+			| rawBytes[0]; // 8 bits from index 0
+
+		if (exponent === 0 && mantissa === 0) {
+			return sign === 0 ? 0 : -0;
+		}
+		if (exponent === 0xFF && mantissa === 0) {
+			return sign === 0 ? Infinity : -Infinity;
+		}
+		if (exponent === 0xFF && mantissa !== 0) {
+			return NaN;
+		}
+
+		exponent -= 127; // subtract the bias
+
+		// return $pow(-1, sign) * mantissa / $pow(2, 23) * $pow(2, exponent);
+		// return $pow(-1, sign) * (mantissa + 0x1000000) * $pow(2, exponent - 23);
+		return $pow(-1, sign) * (1 + (mantissa / $pow(2, 23))) * $pow(2, exponent);
+	}
+
+	if (type === 'Float64') { // step 4
+		/*
+        Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2008 binary64 value.
+If value is an IEEE 754-2008 binary64 NaN value, return the NaN Number value.
+Return the Number value that corresponds to value.
+        */
+		var sign = rawBytes[7] & 0x80 ? -1 : 1; // first bit
+		var exponent = ((rawBytes[7] & 0x7F) << 4) // 7 bits from index 7
+			| ((rawBytes[6] & 0xF0) >> 4); // 4 bits from index 6
+		var mantissa = ((rawBytes[6] & 0x0F) * 0x1000000000000) // 4 bits from index 6
+			+ (rawBytes[5] * 0x10000000000) // 8 bits from index 5
+			+ (rawBytes[4] * 0x100000000) // 8 bits from index 4
+			+ (rawBytes[3] * 0x1000000) // 8 bits from index 3
+			+ (rawBytes[2] * 0x10000) // 8 bits from index 2
+			+ (rawBytes[1] * 0x100) // 8 bits from index 1
+			+ rawBytes[0]; // 8 bits from index 0
+
+		if (exponent === 0 && mantissa === 0) {
+			return sign * 0;
+		}
+		if (exponent === 0x7FF && mantissa !== 0) {
+			return NaN;
+		}
+		if (exponent === 0x7FF && mantissa === 0) {
+			return sign * Infinity;
+		}
+
+		exponent -= 1023; // subtract the bias
+
+		return sign * (mantissa + 0x10000000000000) * $pow(2, exponent - 52);
+	}
+
+	// this is common to both branches
+	var intValue = 0;
+	for (var i = 0; i < rawBytes.length; i++) {
+		intValue |= rawBytes[i] << (8 * i);
+	}
+	/*
+	Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of an unsigned little-endian binary number.
+	*/
+
+	if ($charAt(type, 0) !== 'U') { // steps 5-6
+		// Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of a binary little-endian 2's complement number of bit length elementSize × 8.
+		var bitLength = elementSize * 8;
+		if (bitLength < 32) {
+			intValue = (intValue << (32 - bitLength)) >> (32 - bitLength);
+		}
+	}
+
+	return intValue; // step 7
+};

node_modules/es-abstract/2019/Set.js

@@ -36,12 +36,12 @@ module.exports = function Set(O, P, V, Throw) {
 			throw new $TypeError('Attempted to assign to readonly property.');
 		}
 		return true;
-	} else {
-		try {
-			O[P] = V; // eslint-disable-line no-param-reassign
-			return noThrowOnStrictViolation ? SameValue(O[P], V) : true;
-		} catch (e) {
-			return false;
-		}
 	}
+	try {
+		O[P] = V; // eslint-disable-line no-param-reassign
+		return noThrowOnStrictViolation ? SameValue(O[P], V) : true;
+	} catch (e) {
+		return false;
+	}
+
 };

node_modules/es-abstract/2019/SetFunctionName.js

@@ -6,7 +6,7 @@ var has = require('has');
 
 var $TypeError = GetIntrinsic('%TypeError%');
 
-var getSymbolDescription = require('../helpers/getSymbolDescription');
+var getSymbolDescription = require('get-symbol-description');
 
 var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
 var IsExtensible = require('./IsExtensible');

node_modules/es-abstract/2019/SetIntegrityLevel.js

@@ -4,9 +4,9 @@ var GetIntrinsic = require('get-intrinsic');
 
 var $SyntaxError = GetIntrinsic('%SyntaxError%');
 var $TypeError = GetIntrinsic('%TypeError%');
-var $preventExtensions = GetIntrinsic('%Object.preventExtensions%');
-var $gOPD = require('../helpers/getOwnPropertyDescriptor');
-var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%');
+var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true);
+var $gOPD = require('gopd');
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true);
 
 var forEach = require('../helpers/forEach');
 

node_modules/es-abstract/2019/StringCreate.js

@@ -20,7 +20,7 @@ module.exports = function StringCreate(value, prototype) {
 	}
 
 	var S = $Object(value);
-	if (S !== $StringPrototype) {
+	if (prototype !== $StringPrototype) {
 		if (setProto) {
 			setProto(S, prototype);
 		} else {

node_modules/es-abstract/2019/TestIntegrityLevel.js

@@ -2,11 +2,11 @@
 
 var GetIntrinsic = require('get-intrinsic');
 
-var $gOPD = require('../helpers/getOwnPropertyDescriptor');
-var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%');
+var $gOPD = require('gopd');
 var $TypeError = GetIntrinsic('%TypeError%');
 
 var every = require('../helpers/every');
+var OwnPropertyKeys = require('../helpers/OwnPropertyKeys');
 
 var IsDataDescriptor = require('./IsDataDescriptor');
 var IsExtensible = require('./IsExtensible');
@@ -26,7 +26,7 @@ module.exports = function TestIntegrityLevel(O, level) {
 	if (status) {
 		return false;
 	}
-	var theKeys = $gOPN(O);
+	var theKeys = OwnPropertyKeys(O);
 	return theKeys.length === 0 || every(theKeys, function (k) {
 		var currentDesc = $gOPD(O, k);
 		if (typeof currentDesc !== 'undefined') {

node_modules/es-abstract/2019/ThrowCompletion.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var CompletionRecord = require('./CompletionRecord');
+
+// https://262.ecma-international.org/9.0/#sec-throwcompletion
+
+module.exports = function ThrowCompletion(argument) {
+	return new CompletionRecord('throw', argument);
+};

node_modules/es-abstract/2019/ToNumber.js

@@ -8,7 +8,7 @@ var $RegExp = GetIntrinsic('%RegExp%');
 var $parseInteger = GetIntrinsic('%parseInt%');
 
 var callBound = require('call-bind/callBound');
-var regexTester = require('../helpers/regexTester');
+var regexTester = require('safe-regex-test');
 var isPrimitive = require('../helpers/isPrimitive');
 
 var $strSlice = callBound('String.prototype.slice');
@@ -48,12 +48,12 @@ module.exports = function ToNumber(argument) {
 			return ToNumber($parseInteger($strSlice(value, 2), 8));
 		} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {
 			return NaN;
-		} else {
-			var trimmed = $trim(value);
-			if (trimmed !== value) {
-				return ToNumber(trimmed);
-			}
 		}
+		var trimmed = $trim(value);
+		if (trimmed !== value) {
+			return ToNumber(trimmed);
+		}
+
 	}
 	return $Number(value);
 };

node_modules/es-abstract/2019/ValidateAtomicAccess.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $RangeError = GetIntrinsic('%RangeError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var ToIndex = require('./ToIndex');
+
+var isTypedArray = require('is-typed-array');
+var typedArrayLength = require('typed-array-length');
+
+// https://262.ecma-international.org/8.0/#sec-validateatomicaccess
+
+module.exports = function ValidateAtomicAccess(typedArray, requestIndex) {
+	if (!isTypedArray(typedArray)) {
+		throw new $TypeError('Assertion failed: `typedArray` must be a TypedArray'); // step 1
+	}
+
+	var accessIndex = ToIndex(requestIndex); // step 2
+
+	var length = typedArrayLength(typedArray); // step 3
+
+	/*
+	// this assertion can never be reached
+	if (!(accessIndex >= 0)) {
+		throw new $TypeError('Assertion failed: accessIndex >= 0'); // step 4
+	}
+	*/
+
+	if (accessIndex >= length) {
+		throw new $RangeError('index out of range'); // step 5
+	}
+
+	return accessIndex; // step 6
+};

node_modules/es-abstract/2019/ValidateTypedArray.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+var $taSome = callBound('%TypedArray.prototype.some%', true);
+
+var Type = require('./Type');
+
+var isTypedArray = require('is-typed-array');
+
+// https://262.ecma-international.org/6.0/#sec-validatetypedarray
+
+module.exports = function ValidateTypedArray(O) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: O must be an Object');
+	}
+	if (!isTypedArray(O)) {
+		throw new $TypeError('Assertion failed: O must be a TypedArray');
+	}
+
+	// without `.some` (like in node 0.10), there's no way to check buffer detachment, but also no way to be detached
+	if ($taSome) {
+		$taSome(O, function () { return true; });
+	}
+
+	return O.buffer;
+};

node_modules/es-abstract/2019/max.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+// https://262.ecma-international.org/6.0/#sec-algorithm-conventions
+
+module.exports = GetIntrinsic('%Math.max%');

node_modules/es-abstract/2019/min.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+// https://262.ecma-international.org/6.0/#sec-algorithm-conventions
+
+module.exports = GetIntrinsic('%Math.min%');