Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/es-abstract/2020/AbstractEqualityComparison.js b/node_modules/es-abstract/2020/AbstractEqualityComparison.js
new file mode 100644
index 0000000..c776194
--- /dev/null
+++ b/node_modules/es-abstract/2020/AbstractEqualityComparison.js
@@ -0,0 +1,37 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-abstract-equality-comparison
+
+module.exports = function AbstractEqualityComparison(x, y) {
+ var xType = Type(x);
+ var yType = Type(y);
+ if (xType === yType) {
+ return x === y; // ES6+ specified this shortcut anyways.
+ }
+ if (x == null && y == null) {
+ return true;
+ }
+ if (xType === 'Number' && yType === 'String') {
+ return AbstractEqualityComparison(x, ToNumber(y));
+ }
+ if (xType === 'String' && yType === 'Number') {
+ return AbstractEqualityComparison(ToNumber(x), y);
+ }
+ if (xType === 'Boolean') {
+ return AbstractEqualityComparison(ToNumber(x), y);
+ }
+ if (yType === 'Boolean') {
+ return AbstractEqualityComparison(x, ToNumber(y));
+ }
+ if ((xType === 'String' || xType === 'Number' || xType === 'Symbol') && yType === 'Object') {
+ return AbstractEqualityComparison(x, ToPrimitive(y));
+ }
+ if (xType === 'Object' && (yType === 'String' || yType === 'Number' || yType === 'Symbol')) {
+ return AbstractEqualityComparison(ToPrimitive(x), y);
+ }
+ return false;
+};
diff --git a/node_modules/es-abstract/2020/AbstractRelationalComparison.js b/node_modules/es-abstract/2020/AbstractRelationalComparison.js
new file mode 100644
index 0000000..0dfed5f
--- /dev/null
+++ b/node_modules/es-abstract/2020/AbstractRelationalComparison.js
@@ -0,0 +1,63 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Number = GetIntrinsic('%Number%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var isPrefixOf = require('../helpers/isPrefixOf');
+
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/5.1/#sec-11.8.5
+
+// 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');
+ }
+ var px;
+ var py;
+ if (LeftFirst) {
+ px = ToPrimitive(x, $Number);
+ py = ToPrimitive(y, $Number);
+ } else {
+ 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) {
+ return false;
+ }
+ if (nx === Infinity) {
+ return false;
+ }
+ if (ny === Infinity) {
+ 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
+ }
+ if (isPrefixOf(py, px)) {
+ return false;
+ }
+ if (isPrefixOf(px, py)) {
+ return true;
+ }
+ return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f
+};
diff --git a/node_modules/es-abstract/2020/AddEntriesFromIterable.js b/node_modules/es-abstract/2020/AddEntriesFromIterable.js
new file mode 100644
index 0000000..a0a5e71
--- /dev/null
+++ b/node_modules/es-abstract/2020/AddEntriesFromIterable.js
@@ -0,0 +1,52 @@
+'use strict';
+
+var inspect = require('object-inspect');
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Call = require('./Call');
+var Get = require('./Get');
+var GetIterator = require('./GetIterator');
+var IsCallable = require('./IsCallable');
+var IteratorClose = require('./IteratorClose');
+var IteratorStep = require('./IteratorStep');
+var IteratorValue = require('./IteratorValue');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/10.0//#sec-add-entries-from-iterable
+
+module.exports = function AddEntriesFromIterable(target, iterable, adder) {
+ if (!IsCallable(adder)) {
+ throw new $TypeError('Assertion failed: `adder` is not callable');
+ }
+ if (iterable == null) {
+ throw new $TypeError('Assertion failed: `iterable` is present, and not nullish');
+ }
+ var iteratorRecord = GetIterator(iterable);
+ while (true) { // eslint-disable-line no-constant-condition
+ var next = IteratorStep(iteratorRecord);
+ if (!next) {
+ return target;
+ }
+ var nextItem = IteratorValue(next);
+ if (Type(nextItem) !== 'Object') {
+ var error = new $TypeError('iterator next must return an Object, got ' + inspect(nextItem));
+ return IteratorClose(
+ iteratorRecord,
+ function () { throw error; } // eslint-disable-line no-loop-func
+ );
+ }
+ try {
+ var k = Get(nextItem, '0');
+ var v = Get(nextItem, '1');
+ Call(adder, target, [k, v]);
+ } catch (e) {
+ return IteratorClose(
+ iteratorRecord,
+ function () { throw e; }
+ );
+ }
+ }
+};
diff --git a/node_modules/es-abstract/2020/AdvanceStringIndex.js b/node_modules/es-abstract/2020/AdvanceStringIndex.js
new file mode 100644
index 0000000..0e62c4a
--- /dev/null
+++ b/node_modules/es-abstract/2020/AdvanceStringIndex.js
@@ -0,0 +1,34 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var CodePointAt = require('./CodePointAt');
+var IsInteger = require('./IsInteger');
+var Type = require('./Type');
+
+var MAX_SAFE_INTEGER = require('../helpers/maxSafeInteger');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://262.ecma-international.org/6.0/#sec-advancestringindex
+
+module.exports = function AdvanceStringIndex(S, index, unicode) {
+ if (Type(S) !== 'String') {
+ throw new $TypeError('Assertion failed: `S` must be a String');
+ }
+ if (!IsInteger(index) || index < 0 || index > MAX_SAFE_INTEGER) {
+ throw new $TypeError('Assertion failed: `length` must be an integer >= 0 and <= 2**53');
+ }
+ if (Type(unicode) !== 'Boolean') {
+ throw new $TypeError('Assertion failed: `unicode` must be a Boolean');
+ }
+ if (!unicode) {
+ return index + 1;
+ }
+ var length = S.length;
+ if ((index + 1) >= length) {
+ return index + 1;
+ }
+ var cp = CodePointAt(S, index);
+ return index + cp['[[CodeUnitCount]]'];
+};
diff --git a/node_modules/es-abstract/2020/ArrayCreate.js b/node_modules/es-abstract/2020/ArrayCreate.js
new file mode 100644
index 0000000..4d20e2e
--- /dev/null
+++ b/node_modules/es-abstract/2020/ArrayCreate.js
@@ -0,0 +1,53 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $ArrayPrototype = GetIntrinsic('%Array.prototype%');
+var $RangeError = GetIntrinsic('%RangeError%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsInteger = require('./IsInteger');
+
+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) {
+ O.__proto__ = proto; // eslint-disable-line no-proto, no-param-reassign
+ return O;
+ }
+);
+
+// https://ecma-international.org/ecma-262/6.0/#sec-arraycreate
+
+module.exports = function ArrayCreate(length) {
+ if (!IsInteger(length) || length < 0) {
+ throw new $TypeError('Assertion failed: `length` must be an integer Number >= 0');
+ }
+ if (length > MAX_ARRAY_LENGTH) {
+ throw new $RangeError('length is greater than (2**32 - 1)');
+ }
+ var proto = arguments.length > 1 ? arguments[1] : $ArrayPrototype;
+ var A = []; // steps 5 - 7, and 9
+ if (proto !== $ArrayPrototype) { // step 8
+ if (!$setProto) {
+ throw new $SyntaxError('ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]');
+ }
+ $setProto(A, proto);
+ }
+ if (length !== 0) { // bypasses the need for step 2
+ A.length = length;
+ }
+ /* step 10, the above as a shortcut for the below
+ OrdinaryDefineOwnProperty(A, 'length', {
+ '[[Configurable]]': false,
+ '[[Enumerable]]': false,
+ '[[Value]]': length,
+ '[[Writable]]': true
+ });
+ */
+ return A;
+};
diff --git a/node_modules/es-abstract/2020/ArraySetLength.js b/node_modules/es-abstract/2020/ArraySetLength.js
new file mode 100644
index 0000000..08db9c2
--- /dev/null
+++ b/node_modules/es-abstract/2020/ArraySetLength.js
@@ -0,0 +1,85 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $RangeError = GetIntrinsic('%RangeError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var assign = require('object.assign');
+
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+
+var IsArray = require('./IsArray');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty');
+var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty');
+var ToNumber = require('./ToNumber');
+var ToString = require('./ToString');
+var ToUint32 = require('./ToUint32');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-arraysetlength
+
+// eslint-disable-next-line max-statements, max-lines-per-function
+module.exports = function ArraySetLength(A, Desc) {
+ if (!IsArray(A)) {
+ throw new $TypeError('Assertion failed: A must be an Array');
+ }
+ if (!isPropertyDescriptor({
+ Type: Type,
+ IsDataDescriptor: IsDataDescriptor,
+ IsAccessorDescriptor: IsAccessorDescriptor
+ }, Desc)) {
+ throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
+ }
+ if (!('[[Value]]' in Desc)) {
+ return OrdinaryDefineOwnProperty(A, 'length', Desc);
+ }
+ var newLenDesc = assign({}, Desc);
+ var newLen = ToUint32(Desc['[[Value]]']);
+ var numberLen = ToNumber(Desc['[[Value]]']);
+ if (newLen !== numberLen) {
+ throw new $RangeError('Invalid array length');
+ }
+ newLenDesc['[[Value]]'] = newLen;
+ var oldLenDesc = OrdinaryGetOwnProperty(A, 'length');
+ if (!IsDataDescriptor(oldLenDesc)) {
+ throw new $TypeError('Assertion failed: an array had a non-data descriptor on `length`');
+ }
+ var oldLen = oldLenDesc['[[Value]]'];
+ if (newLen >= oldLen) {
+ return OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
+ }
+ if (!oldLenDesc['[[Writable]]']) {
+ return false;
+ }
+ var newWritable;
+ if (!('[[Writable]]' in newLenDesc) || newLenDesc['[[Writable]]']) {
+ newWritable = true;
+ } else {
+ newWritable = false;
+ newLenDesc['[[Writable]]'] = true;
+ }
+ var succeeded = OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
+ if (!succeeded) {
+ return false;
+ }
+ while (newLen < oldLen) {
+ oldLen -= 1;
+ // eslint-disable-next-line no-param-reassign
+ var deleteSucceeded = delete A[ToString(oldLen)];
+ if (!deleteSucceeded) {
+ newLenDesc['[[Value]]'] = oldLen + 1;
+ if (!newWritable) {
+ newLenDesc['[[Writable]]'] = false;
+ OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
+ return false;
+ }
+ }
+ }
+ if (!newWritable) {
+ return OrdinaryDefineOwnProperty(A, 'length', { '[[Writable]]': false });
+ }
+ return true;
+};
diff --git a/node_modules/es-abstract/2020/ArraySpeciesCreate.js b/node_modules/es-abstract/2020/ArraySpeciesCreate.js
new file mode 100644
index 0000000..26d63b5
--- /dev/null
+++ b/node_modules/es-abstract/2020/ArraySpeciesCreate.js
@@ -0,0 +1,46 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Array = GetIntrinsic('%Array%');
+var $species = GetIntrinsic('%Symbol.species%', true);
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var IsConstructor = require('./IsConstructor');
+var IsInteger = require('./IsInteger');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-arrayspeciescreate
+
+module.exports = function ArraySpeciesCreate(originalArray, length) {
+ if (!IsInteger(length) || length < 0) {
+ throw new $TypeError('Assertion failed: length must be an integer >= 0');
+ }
+ var len = length === 0 ? 0 : length;
+ var C;
+ var isArray = IsArray(originalArray);
+ if (isArray) {
+ C = Get(originalArray, 'constructor');
+ // TODO: figure out how to make a cross-realm normal Array, a same-realm Array
+ // if (IsConstructor(C)) {
+ // if C is another realm's Array, C = undefined
+ // Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ?
+ // }
+ if ($species && Type(C) === 'Object') {
+ C = Get(C, $species);
+ if (C === null) {
+ C = void 0;
+ }
+ }
+ }
+ if (typeof C === 'undefined') {
+ return $Array(len);
+ }
+ if (!IsConstructor(C)) {
+ throw new $TypeError('C must be a constructor');
+ }
+ return new C(len); // Construct(C, len);
+};
+
diff --git a/node_modules/es-abstract/2020/BigInt/add.js b/node_modules/es-abstract/2020/BigInt/add.js
new file mode 100644
index 0000000..22b5db4
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/add.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-add
+
+module.exports = function BigIntAdd(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ // shortcut for the actual spec mechanics
+ return x + y;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/bitwiseAND.js b/node_modules/es-abstract/2020/BigInt/bitwiseAND.js
new file mode 100644
index 0000000..83cd2c3
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/bitwiseAND.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var BigIntBitwiseOp = require('../BigIntBitwiseOp');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseAND
+
+module.exports = function BigIntBitwiseAND(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+ return BigIntBitwiseOp('&', x, y);
+};
diff --git a/node_modules/es-abstract/2020/BigInt/bitwiseNOT.js b/node_modules/es-abstract/2020/BigInt/bitwiseNOT.js
new file mode 100644
index 0000000..9a444df
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/bitwiseNOT.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseNOT
+
+module.exports = function BigIntBitwiseNOT(x) {
+ if (Type(x) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` argument must be a BigInt');
+ }
+ return -x - $BigInt(1);
+};
diff --git a/node_modules/es-abstract/2020/BigInt/bitwiseOR.js b/node_modules/es-abstract/2020/BigInt/bitwiseOR.js
new file mode 100644
index 0000000..3c1b571
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/bitwiseOR.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var BigIntBitwiseOp = require('../BigIntBitwiseOp');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseOR
+
+module.exports = function BigIntBitwiseOR(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+ return BigIntBitwiseOp('|', x, y);
+};
diff --git a/node_modules/es-abstract/2020/BigInt/bitwiseXOR.js b/node_modules/es-abstract/2020/BigInt/bitwiseXOR.js
new file mode 100644
index 0000000..45f8217
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/bitwiseXOR.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var BigIntBitwiseOp = require('../BigIntBitwiseOp');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseXOR
+
+module.exports = function BigIntBitwiseXOR(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+ return BigIntBitwiseOp('^', x, y);
+};
diff --git a/node_modules/es-abstract/2020/BigInt/divide.js b/node_modules/es-abstract/2020/BigInt/divide.js
new file mode 100644
index 0000000..5706e7d
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/divide.js
@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $RangeError = GetIntrinsic('%RangeError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-divide
+
+module.exports = function BigIntDivide(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+ if (y === $BigInt(0)) {
+ throw new $RangeError('Division by zero');
+ }
+ // shortcut for the actual spec mechanics
+ return x / y;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/equal.js b/node_modules/es-abstract/2020/BigInt/equal.js
new file mode 100644
index 0000000..a28826d
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/equal.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-equal
+
+module.exports = function BigIntEqual(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+ // shortcut for the actual spec mechanics
+ return x === y;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/exponentiate.js b/node_modules/es-abstract/2020/BigInt/exponentiate.js
new file mode 100644
index 0000000..2365838
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/exponentiate.js
@@ -0,0 +1,31 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $RangeError = GetIntrinsic('%RangeError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-exponentiate
+
+module.exports = function BigIntExponentiate(base, exponent) {
+ if (Type(base) !== 'BigInt' || Type(exponent) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `base` and `exponent` arguments must be BigInts');
+ }
+ if (exponent < $BigInt(0)) {
+ throw new $RangeError('Exponent must be positive');
+ }
+ if (/* base === $BigInt(0) && */ exponent === $BigInt(0)) {
+ return $BigInt(1);
+ }
+
+ var square = base;
+ var remaining = exponent;
+ while (remaining > $BigInt(0)) {
+ square += exponent;
+ --remaining; // eslint-disable-line no-plusplus
+ }
+ return square;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/index.js b/node_modules/es-abstract/2020/BigInt/index.js
new file mode 100644
index 0000000..63ec52d
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/index.js
@@ -0,0 +1,43 @@
+'use strict';
+
+var add = require('./add');
+var bitwiseAND = require('./bitwiseAND');
+var bitwiseNOT = require('./bitwiseNOT');
+var bitwiseOR = require('./bitwiseOR');
+var bitwiseXOR = require('./bitwiseXOR');
+var divide = require('./divide');
+var equal = require('./equal');
+var exponentiate = require('./exponentiate');
+var leftShift = require('./leftShift');
+var lessThan = require('./lessThan');
+var multiply = require('./multiply');
+var remainder = require('./remainder');
+var sameValue = require('./sameValue');
+var sameValueZero = require('./sameValueZero');
+var signedRightShift = require('./signedRightShift');
+var subtract = require('./subtract');
+var toString = require('./toString');
+var unaryMinus = require('./unaryMinus');
+var unsignedRightShift = require('./unsignedRightShift');
+
+module.exports = {
+ add: add,
+ bitwiseAND: bitwiseAND,
+ bitwiseNOT: bitwiseNOT,
+ bitwiseOR: bitwiseOR,
+ bitwiseXOR: bitwiseXOR,
+ divide: divide,
+ equal: equal,
+ exponentiate: exponentiate,
+ leftShift: leftShift,
+ lessThan: lessThan,
+ multiply: multiply,
+ remainder: remainder,
+ sameValue: sameValue,
+ sameValueZero: sameValueZero,
+ signedRightShift: signedRightShift,
+ subtract: subtract,
+ toString: toString,
+ unaryMinus: unaryMinus,
+ unsignedRightShift: unsignedRightShift
+};
diff --git a/node_modules/es-abstract/2020/BigInt/leftShift.js b/node_modules/es-abstract/2020/BigInt/leftShift.js
new file mode 100644
index 0000000..d2a5702
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/leftShift.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-leftShift
+
+module.exports = function BigIntLeftShift(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ // shortcut for the actual spec mechanics
+ return x << y;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/lessThan.js b/node_modules/es-abstract/2020/BigInt/lessThan.js
new file mode 100644
index 0000000..0b3cd6b
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/lessThan.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-lessThan
+
+module.exports = function BigIntLessThan(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ // shortcut for the actual spec mechanics
+ return x < y;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/multiply.js b/node_modules/es-abstract/2020/BigInt/multiply.js
new file mode 100644
index 0000000..6e5d56c
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/multiply.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-multiply
+
+module.exports = function BigIntMultiply(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ // shortcut for the actual spec mechanics
+ return x * y;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/remainder.js b/node_modules/es-abstract/2020/BigInt/remainder.js
new file mode 100644
index 0000000..d2dc678
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/remainder.js
@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $RangeError = GetIntrinsic('%RangeError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+var zero = $BigInt && $BigInt(0);
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-remainder
+
+module.exports = function BigIntRemainder(n, d) {
+ if (Type(n) !== 'BigInt' || Type(d) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `n` and `d` arguments must be BigInts');
+ }
+
+ if (d === zero) {
+ throw new $RangeError('Division by zero');
+ }
+
+ if (n === zero) {
+ return zero;
+ }
+
+ // shortcut for the actual spec mechanics
+ return n % d;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/sameValue.js b/node_modules/es-abstract/2020/BigInt/sameValue.js
new file mode 100644
index 0000000..63ff063
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/sameValue.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+var BigIntEqual = require('./equal');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-sameValue
+
+module.exports = function BigIntSameValue(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ return BigIntEqual(x, y);
+};
diff --git a/node_modules/es-abstract/2020/BigInt/sameValueZero.js b/node_modules/es-abstract/2020/BigInt/sameValueZero.js
new file mode 100644
index 0000000..39f262c
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/sameValueZero.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+var BigIntEqual = require('./equal');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-sameValueZero
+
+module.exports = function BigIntSameValueZero(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ return BigIntEqual(x, y);
+};
diff --git a/node_modules/es-abstract/2020/BigInt/signedRightShift.js b/node_modules/es-abstract/2020/BigInt/signedRightShift.js
new file mode 100644
index 0000000..f63c642
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/signedRightShift.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+var BigIntLeftShift = require('./leftShift');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-signedRightShift
+
+module.exports = function BigIntSignedRightShift(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ return BigIntLeftShift(x, -y);
+};
diff --git a/node_modules/es-abstract/2020/BigInt/subtract.js b/node_modules/es-abstract/2020/BigInt/subtract.js
new file mode 100644
index 0000000..0490784
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/subtract.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-subtract
+
+module.exports = function BigIntSubtract(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ // shortcut for the actual spec mechanics
+ return x - y;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/toString.js b/node_modules/es-abstract/2020/BigInt/toString.js
new file mode 100644
index 0000000..858d955
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/toString.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-tostring
+
+module.exports = function BigIntToString(x) {
+ if (Type(x) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` must be a BigInt');
+ }
+
+ return $String(x);
+};
diff --git a/node_modules/es-abstract/2020/BigInt/unaryMinus.js b/node_modules/es-abstract/2020/BigInt/unaryMinus.js
new file mode 100644
index 0000000..ee0f7ef
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/unaryMinus.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+var zero = $BigInt && $BigInt(0);
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-unaryMinus
+
+module.exports = function BigIntUnaryMinus(x) {
+ if (Type(x) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` argument must be a BigInt');
+ }
+
+ if (x === zero) {
+ return zero;
+ }
+
+ return -x;
+};
diff --git a/node_modules/es-abstract/2020/BigInt/unsignedRightShift.js b/node_modules/es-abstract/2020/BigInt/unsignedRightShift.js
new file mode 100644
index 0000000..7ad94f7
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigInt/unsignedRightShift.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-unsignedRightShift
+
+module.exports = function BigIntUnsignedRightShift(x, y) {
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+ }
+
+ throw new $TypeError('BigInts have no unsigned right shift, use >> instead');
+};
diff --git a/node_modules/es-abstract/2020/BigIntBitwiseOp.js b/node_modules/es-abstract/2020/BigIntBitwiseOp.js
new file mode 100644
index 0000000..1af4cad
--- /dev/null
+++ b/node_modules/es-abstract/2020/BigIntBitwiseOp.js
@@ -0,0 +1,66 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+// var $BigInt = GetIntrinsic('%BigInt%', true);
+// var $pow = GetIntrinsic('%Math.pow%');
+
+// var BinaryAnd = require('./BinaryAnd');
+// var BinaryOr = require('./BinaryOr');
+// var BinaryXor = require('./BinaryXor');
+var Type = require('./Type');
+// var modulo = require('./modulo');
+
+// var zero = $BigInt && $BigInt(0);
+// var negOne = $BigInt && $BigInt(-1);
+// var two = $BigInt && $BigInt(2);
+
+// https://262.ecma-international.org/11.0/#sec-bigintbitwiseop
+
+module.exports = function BigIntBitwiseOp(op, x, y) {
+ if (op !== '&' && op !== '|' && op !== '^') {
+ throw new $TypeError('Assertion failed: `op` must be `&`, `|`, or `^`');
+ }
+ if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+ throw new $TypeError('`x` and `y` must be BigInts');
+ }
+
+ if (op === '&') {
+ return x & y;
+ }
+ if (op === '|') {
+ return x | y;
+ }
+ return x ^ y;
+ /*
+ var result = zero;
+ var shift = 0;
+ while (x !== zero && x !== negOne && y !== zero && y !== negOne) {
+ var xDigit = modulo(x, two);
+ var yDigit = modulo(y, two);
+ if (op === '&') {
+ result += $pow(2, shift) * BinaryAnd(xDigit, yDigit);
+ } else if (op === '|') {
+ result += $pow(2, shift) * BinaryOr(xDigit, yDigit);
+ } else if (op === '^') {
+ result += $pow(2, shift) * BinaryXor(xDigit, yDigit);
+ }
+ shift += 1;
+ x = (x - xDigit) / two;
+ y = (y - yDigit) / two;
+ }
+ var tmp;
+ if (op === '&') {
+ tmp = BinaryAnd(modulo(x, two), modulo(y, two));
+ } else if (op === '|') {
+ tmp = BinaryAnd(modulo(x, two), modulo(y, two));
+ } else {
+ tmp = BinaryXor(modulo(x, two), modulo(y, two));
+ }
+ if (tmp !== 0) {
+ result -= $pow(2, shift);
+ }
+ return result;
+ */
+};
diff --git a/node_modules/es-abstract/2020/BinaryAnd.js b/node_modules/es-abstract/2020/BinaryAnd.js
new file mode 100644
index 0000000..c617f38
--- /dev/null
+++ b/node_modules/es-abstract/2020/BinaryAnd.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://262.ecma-international.org/11.0/#sec-binaryand
+
+module.exports = function BinaryAnd(x, y) {
+ if ((x !== 0 && x !== 1) || (y !== 0 && y !== 1)) {
+ throw new $TypeError('Assertion failed: `x` and `y` must be either 0 or 1');
+ }
+ return x & y;
+};
diff --git a/node_modules/es-abstract/2020/BinaryOr.js b/node_modules/es-abstract/2020/BinaryOr.js
new file mode 100644
index 0000000..6de0955
--- /dev/null
+++ b/node_modules/es-abstract/2020/BinaryOr.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://262.ecma-international.org/11.0/#sec-binaryor
+
+module.exports = function BinaryOr(x, y) {
+ if ((x !== 0 && x !== 1) || (y !== 0 && y !== 1)) {
+ throw new $TypeError('Assertion failed: `x` and `y` must be either 0 or 1');
+ }
+ return x | y;
+};
diff --git a/node_modules/es-abstract/2020/BinaryXor.js b/node_modules/es-abstract/2020/BinaryXor.js
new file mode 100644
index 0000000..189d7d8
--- /dev/null
+++ b/node_modules/es-abstract/2020/BinaryXor.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://262.ecma-international.org/11.0/#sec-binaryxor
+
+module.exports = function BinaryXor(x, y) {
+ if ((x !== 0 && x !== 1) || (y !== 0 && y !== 1)) {
+ throw new $TypeError('Assertion failed: `x` and `y` must be either 0 or 1');
+ }
+ return x ^ y;
+};
diff --git a/node_modules/es-abstract/2020/Call.js b/node_modules/es-abstract/2020/Call.js
new file mode 100644
index 0000000..4b238c6
--- /dev/null
+++ b/node_modules/es-abstract/2020/Call.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsArray = require('./IsArray');
+
+var $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('%Function.prototype.apply%');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-call
+
+module.exports = function Call(F, V) {
+ var argumentsList = arguments.length > 2 ? arguments[2] : [];
+ if (!IsArray(argumentsList)) {
+ throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List');
+ }
+ return $apply(F, V, argumentsList);
+};
diff --git a/node_modules/es-abstract/2020/CanonicalNumericIndexString.js b/node_modules/es-abstract/2020/CanonicalNumericIndexString.js
new file mode 100644
index 0000000..feb878c
--- /dev/null
+++ b/node_modules/es-abstract/2020/CanonicalNumericIndexString.js
@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var SameValue = require('./SameValue');
+var ToNumber = require('./ToNumber');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-canonicalnumericindexstring
+
+module.exports = function CanonicalNumericIndexString(argument) {
+ if (Type(argument) !== 'String') {
+ throw new $TypeError('Assertion failed: `argument` must be a String');
+ }
+ if (argument === '-0') { return -0; }
+ var n = ToNumber(argument);
+ if (SameValue(ToString(n), argument)) { return n; }
+ return void 0;
+};
diff --git a/node_modules/es-abstract/2020/CodePointAt.js b/node_modules/es-abstract/2020/CodePointAt.js
new file mode 100644
index 0000000..b887631
--- /dev/null
+++ b/node_modules/es-abstract/2020/CodePointAt.js
@@ -0,0 +1,58 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var callBound = require('call-bind/callBound');
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+var Type = require('./Type');
+var UTF16DecodeSurrogatePair = require('./UTF16DecodeSurrogatePair');
+
+var $charAt = callBound('String.prototype.charAt');
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+
+// https://262.ecma-international.org/11.0/#sec-codepointat
+
+module.exports = function CodePointAt(string, position) {
+ if (Type(string) !== 'String') {
+ throw new $TypeError('Assertion failed: `string` must be a String');
+ }
+ var size = string.length;
+ if (position < 0 || position >= size) {
+ throw new $TypeError('Assertion failed: `position` must be >= 0, and < the length of `string`');
+ }
+ var first = $charCodeAt(string, position);
+ var cp = $charAt(string, position);
+ var firstIsLeading = isLeadingSurrogate(first);
+ var firstIsTrailing = isTrailingSurrogate(first);
+ if (!firstIsLeading && !firstIsTrailing) {
+ return {
+ '[[CodePoint]]': cp,
+ '[[CodeUnitCount]]': 1,
+ '[[IsUnpairedSurrogate]]': false
+ };
+ }
+ if (firstIsTrailing || (position + 1 === size)) {
+ return {
+ '[[CodePoint]]': cp,
+ '[[CodeUnitCount]]': 1,
+ '[[IsUnpairedSurrogate]]': true
+ };
+ }
+ var second = $charCodeAt(string, position + 1);
+ if (!isTrailingSurrogate(second)) {
+ return {
+ '[[CodePoint]]': cp,
+ '[[CodeUnitCount]]': 1,
+ '[[IsUnpairedSurrogate]]': true
+ };
+ }
+
+ return {
+ '[[CodePoint]]': UTF16DecodeSurrogatePair(first, second),
+ '[[CodeUnitCount]]': 2,
+ '[[IsUnpairedSurrogate]]': false
+ };
+};
diff --git a/node_modules/es-abstract/2020/CompletePropertyDescriptor.js b/node_modules/es-abstract/2020/CompletePropertyDescriptor.js
new file mode 100644
index 0000000..548bf41
--- /dev/null
+++ b/node_modules/es-abstract/2020/CompletePropertyDescriptor.js
@@ -0,0 +1,39 @@
+'use strict';
+
+var has = require('has');
+
+var assertRecord = require('../helpers/assertRecord');
+
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsGenericDescriptor = require('./IsGenericDescriptor');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-completepropertydescriptor
+
+module.exports = function CompletePropertyDescriptor(Desc) {
+ /* eslint no-param-reassign: 0 */
+ assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+ if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) {
+ if (!has(Desc, '[[Value]]')) {
+ Desc['[[Value]]'] = void 0;
+ }
+ if (!has(Desc, '[[Writable]]')) {
+ Desc['[[Writable]]'] = false;
+ }
+ } else {
+ if (!has(Desc, '[[Get]]')) {
+ Desc['[[Get]]'] = void 0;
+ }
+ if (!has(Desc, '[[Set]]')) {
+ Desc['[[Set]]'] = void 0;
+ }
+ }
+ if (!has(Desc, '[[Enumerable]]')) {
+ Desc['[[Enumerable]]'] = false;
+ }
+ if (!has(Desc, '[[Configurable]]')) {
+ Desc['[[Configurable]]'] = false;
+ }
+ return Desc;
+};
diff --git a/node_modules/es-abstract/2020/CopyDataProperties.js b/node_modules/es-abstract/2020/CopyDataProperties.js
new file mode 100644
index 0000000..7bd7dda
--- /dev/null
+++ b/node_modules/es-abstract/2020/CopyDataProperties.js
@@ -0,0 +1,64 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+var forEach = require('../helpers/forEach');
+var every = require('../helpers/every');
+var OwnPropertyKeys = require('../helpers/OwnPropertyKeys');
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+var CreateDataPropertyOrThrow = require('./CreateDataPropertyOrThrow');
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var IsInteger = require('./IsInteger');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var ToNumber = require('./ToNumber');
+var ToObject = require('./ToObject');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-copydataproperties
+
+module.exports = function CopyDataProperties(target, source, excludedItems) {
+ if (Type(target) !== 'Object') {
+ throw new $TypeError('Assertion failed: "target" must be an Object');
+ }
+
+ if (!IsArray(excludedItems) || !every(excludedItems, IsPropertyKey)) {
+ throw new $TypeError('Assertion failed: "excludedItems" must be a List of Property Keys');
+ }
+
+ if (typeof source === 'undefined' || source === null) {
+ return target;
+ }
+
+ var from = ToObject(source);
+
+ var sourceKeys = OwnPropertyKeys(from);
+ forEach(sourceKeys, function (nextKey) {
+ var excluded = false;
+
+ forEach(excludedItems, function (e) {
+ if (SameValue(e, nextKey) === true) {
+ excluded = true;
+ }
+ });
+
+ var enumerable = $isEnumerable(from, nextKey) || (
+ // this is to handle string keys being non-enumerable in older engines
+ typeof source === 'string'
+ && nextKey >= 0
+ && IsInteger(ToNumber(nextKey))
+ );
+ if (excluded === false && enumerable) {
+ var propValue = Get(from, nextKey);
+ CreateDataPropertyOrThrow(target, nextKey, propValue);
+ }
+ });
+
+ return target;
+};
diff --git a/node_modules/es-abstract/2020/CreateDataProperty.js b/node_modules/es-abstract/2020/CreateDataProperty.js
new file mode 100644
index 0000000..ff5ca30
--- /dev/null
+++ b/node_modules/es-abstract/2020/CreateDataProperty.js
@@ -0,0 +1,45 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsExtensible = require('./IsExtensible');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-createdataproperty
+
+module.exports = function CreateDataProperty(O, P, V) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+ }
+ var oldDesc = OrdinaryGetOwnProperty(O, P);
+ var extensible = !oldDesc || IsExtensible(O);
+ var immutable = oldDesc && (!oldDesc['[[Writable]]'] || !oldDesc['[[Configurable]]']);
+ if (immutable || !extensible) {
+ return false;
+ }
+ return DefineOwnProperty(
+ IsDataDescriptor,
+ SameValue,
+ FromPropertyDescriptor,
+ O,
+ P,
+ {
+ '[[Configurable]]': true,
+ '[[Enumerable]]': true,
+ '[[Value]]': V,
+ '[[Writable]]': true
+ }
+ );
+};
diff --git a/node_modules/es-abstract/2020/CreateDataPropertyOrThrow.js b/node_modules/es-abstract/2020/CreateDataPropertyOrThrow.js
new file mode 100644
index 0000000..2f7c410
--- /dev/null
+++ b/node_modules/es-abstract/2020/CreateDataPropertyOrThrow.js
@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var CreateDataProperty = require('./CreateDataProperty');
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// // https://ecma-international.org/ecma-262/6.0/#sec-createdatapropertyorthrow
+
+module.exports = function CreateDataPropertyOrThrow(O, P, V) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+ }
+ var success = CreateDataProperty(O, P, V);
+ if (!success) {
+ throw new $TypeError('unable to create data property');
+ }
+ return success;
+};
diff --git a/node_modules/es-abstract/2020/CreateHTML.js b/node_modules/es-abstract/2020/CreateHTML.js
new file mode 100644
index 0000000..ccded1e
--- /dev/null
+++ b/node_modules/es-abstract/2020/CreateHTML.js
@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $replace = callBound('String.prototype.replace');
+
+var RequireObjectCoercible = require('./RequireObjectCoercible');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-createhtml
+
+module.exports = function CreateHTML(string, tag, attribute, value) {
+ if (Type(tag) !== 'String' || Type(attribute) !== 'String') {
+ throw new $TypeError('Assertion failed: `tag` and `attribute` must be strings');
+ }
+ var str = RequireObjectCoercible(string);
+ var S = ToString(str);
+ var p1 = '<' + tag;
+ if (attribute !== '') {
+ var V = ToString(value);
+ var escapedV = $replace(V, /\x22/g, '"');
+ p1 += '\x20' + attribute + '\x3D\x22' + escapedV + '\x22';
+ }
+ return p1 + '>' + S + '</' + tag + '>';
+};
diff --git a/node_modules/es-abstract/2020/CreateIterResultObject.js b/node_modules/es-abstract/2020/CreateIterResultObject.js
new file mode 100644
index 0000000..eea77a5
--- /dev/null
+++ b/node_modules/es-abstract/2020/CreateIterResultObject.js
@@ -0,0 +1,19 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-createiterresultobject
+
+module.exports = function CreateIterResultObject(value, done) {
+ if (Type(done) !== 'Boolean') {
+ throw new $TypeError('Assertion failed: Type(done) is not Boolean');
+ }
+ return {
+ value: value,
+ done: done
+ };
+};
diff --git a/node_modules/es-abstract/2020/CreateListFromArrayLike.js b/node_modules/es-abstract/2020/CreateListFromArrayLike.js
new file mode 100644
index 0000000..3e9f5f4
--- /dev/null
+++ b/node_modules/es-abstract/2020/CreateListFromArrayLike.js
@@ -0,0 +1,44 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $indexOf = callBound('Array.prototype.indexOf', true) || callBound('String.prototype.indexOf');
+var $push = callBound('Array.prototype.push');
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var LengthOfArrayLike = require('./LengthOfArrayLike');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-createlistfromarraylike
+
+module.exports = function CreateListFromArrayLike(obj) {
+ var elementTypes = arguments.length > 1
+ ? arguments[1]
+ : ['Undefined', 'Null', 'Boolean', 'String', 'Symbol', 'Number', 'Object'];
+
+ if (Type(obj) !== 'Object') {
+ throw new $TypeError('Assertion failed: `obj` must be an Object');
+ }
+ if (!IsArray(elementTypes)) {
+ throw new $TypeError('Assertion failed: `elementTypes`, if provided, must be an array');
+ }
+ var len = LengthOfArrayLike(obj);
+ var list = [];
+ var index = 0;
+ while (index < len) {
+ var indexName = ToString(index);
+ var next = Get(obj, indexName);
+ var nextType = Type(next);
+ if ($indexOf(elementTypes, nextType) < 0) {
+ throw new $TypeError('item type ' + nextType + ' is not a valid elementType');
+ }
+ $push(list, next);
+ index += 1;
+ }
+ return list;
+};
diff --git a/node_modules/es-abstract/2020/CreateMethodProperty.js b/node_modules/es-abstract/2020/CreateMethodProperty.js
new file mode 100644
index 0000000..53274a5
--- /dev/null
+++ b/node_modules/es-abstract/2020/CreateMethodProperty.js
@@ -0,0 +1,40 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-createmethodproperty
+
+module.exports = function CreateMethodProperty(O, P, V) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+ }
+
+ var newDesc = {
+ '[[Configurable]]': true,
+ '[[Enumerable]]': false,
+ '[[Value]]': V,
+ '[[Writable]]': true
+ };
+ return DefineOwnProperty(
+ IsDataDescriptor,
+ SameValue,
+ FromPropertyDescriptor,
+ O,
+ P,
+ newDesc
+ );
+};
diff --git a/node_modules/es-abstract/2020/DateFromTime.js b/node_modules/es-abstract/2020/DateFromTime.js
new file mode 100644
index 0000000..20e4f2e
--- /dev/null
+++ b/node_modules/es-abstract/2020/DateFromTime.js
@@ -0,0 +1,54 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $EvalError = GetIntrinsic('%EvalError%');
+
+var DayWithinYear = require('./DayWithinYear');
+var InLeapYear = require('./InLeapYear');
+var MonthFromTime = require('./MonthFromTime');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.5
+
+module.exports = function DateFromTime(t) {
+ var m = MonthFromTime(t);
+ var d = DayWithinYear(t);
+ if (m === 0) {
+ return d + 1;
+ }
+ if (m === 1) {
+ return d - 30;
+ }
+ var leap = InLeapYear(t);
+ if (m === 2) {
+ return d - 58 - leap;
+ }
+ if (m === 3) {
+ return d - 89 - leap;
+ }
+ if (m === 4) {
+ return d - 119 - leap;
+ }
+ if (m === 5) {
+ return d - 150 - leap;
+ }
+ if (m === 6) {
+ return d - 180 - leap;
+ }
+ if (m === 7) {
+ return d - 211 - leap;
+ }
+ if (m === 8) {
+ return d - 242 - leap;
+ }
+ if (m === 9) {
+ return d - 272 - leap;
+ }
+ if (m === 10) {
+ return d - 303 - leap;
+ }
+ if (m === 11) {
+ return d - 333 - leap;
+ }
+ throw new $EvalError('Assertion failed: MonthFromTime returned an impossible value: ' + m);
+};
diff --git a/node_modules/es-abstract/2020/DateString.js b/node_modules/es-abstract/2020/DateString.js
new file mode 100644
index 0000000..939c14c
--- /dev/null
+++ b/node_modules/es-abstract/2020/DateString.js
@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var weekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+var $isNaN = require('../helpers/isNaN');
+var padTimeComponent = require('../helpers/padTimeComponent');
+
+var Type = require('./Type');
+var WeekDay = require('./WeekDay');
+var MonthFromTime = require('./MonthFromTime');
+var YearFromTime = require('./YearFromTime');
+var DateFromTime = require('./DateFromTime');
+
+// https://262.ecma-international.org/9.0/#sec-datestring
+
+module.exports = function DateString(tv) {
+ if (Type(tv) !== 'Number' || $isNaN(tv)) {
+ throw new $TypeError('Assertion failed: `tv` must be a non-NaN Number');
+ }
+ var weekday = weekdays[WeekDay(tv)];
+ var month = months[MonthFromTime(tv)];
+ var day = padTimeComponent(DateFromTime(tv));
+ var year = padTimeComponent(YearFromTime(tv), 4);
+ return weekday + '\x20' + month + '\x20' + day + '\x20' + year;
+};
diff --git a/node_modules/es-abstract/2020/Day.js b/node_modules/es-abstract/2020/Day.js
new file mode 100644
index 0000000..51d0103
--- /dev/null
+++ b/node_modules/es-abstract/2020/Day.js
@@ -0,0 +1,11 @@
+'use strict';
+
+var floor = require('./floor');
+
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.2
+
+module.exports = function Day(t) {
+ return floor(t / msPerDay);
+};
diff --git a/node_modules/es-abstract/2020/DayFromYear.js b/node_modules/es-abstract/2020/DayFromYear.js
new file mode 100644
index 0000000..341bf22
--- /dev/null
+++ b/node_modules/es-abstract/2020/DayFromYear.js
@@ -0,0 +1,10 @@
+'use strict';
+
+var floor = require('./floor');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function DayFromYear(y) {
+ return (365 * (y - 1970)) + floor((y - 1969) / 4) - floor((y - 1901) / 100) + floor((y - 1601) / 400);
+};
+
diff --git a/node_modules/es-abstract/2020/DayWithinYear.js b/node_modules/es-abstract/2020/DayWithinYear.js
new file mode 100644
index 0000000..4c58094
--- /dev/null
+++ b/node_modules/es-abstract/2020/DayWithinYear.js
@@ -0,0 +1,11 @@
+'use strict';
+
+var Day = require('./Day');
+var DayFromYear = require('./DayFromYear');
+var YearFromTime = require('./YearFromTime');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.4
+
+module.exports = function DayWithinYear(t) {
+ return Day(t) - DayFromYear(YearFromTime(t));
+};
diff --git a/node_modules/es-abstract/2020/DaysInYear.js b/node_modules/es-abstract/2020/DaysInYear.js
new file mode 100644
index 0000000..7116c69
--- /dev/null
+++ b/node_modules/es-abstract/2020/DaysInYear.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var modulo = require('./modulo');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function DaysInYear(y) {
+ if (modulo(y, 4) !== 0) {
+ return 365;
+ }
+ if (modulo(y, 100) !== 0) {
+ return 366;
+ }
+ if (modulo(y, 400) !== 0) {
+ return 365;
+ }
+ return 366;
+};
diff --git a/node_modules/es-abstract/2020/DefinePropertyOrThrow.js b/node_modules/es-abstract/2020/DefinePropertyOrThrow.js
new file mode 100644
index 0000000..26f2714
--- /dev/null
+++ b/node_modules/es-abstract/2020/DefinePropertyOrThrow.js
@@ -0,0 +1,50 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-definepropertyorthrow
+
+module.exports = function DefinePropertyOrThrow(O, P, desc) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+ }
+
+ var Desc = isPropertyDescriptor({
+ Type: Type,
+ IsDataDescriptor: IsDataDescriptor,
+ IsAccessorDescriptor: IsAccessorDescriptor
+ }, desc) ? desc : ToPropertyDescriptor(desc);
+ if (!isPropertyDescriptor({
+ Type: Type,
+ IsDataDescriptor: IsDataDescriptor,
+ IsAccessorDescriptor: IsAccessorDescriptor
+ }, Desc)) {
+ throw new $TypeError('Assertion failed: Desc is not a valid Property Descriptor');
+ }
+
+ return DefineOwnProperty(
+ IsDataDescriptor,
+ SameValue,
+ FromPropertyDescriptor,
+ O,
+ P,
+ Desc
+ );
+};
diff --git a/node_modules/es-abstract/2020/DeletePropertyOrThrow.js b/node_modules/es-abstract/2020/DeletePropertyOrThrow.js
new file mode 100644
index 0000000..30d5e57
--- /dev/null
+++ b/node_modules/es-abstract/2020/DeletePropertyOrThrow.js
@@ -0,0 +1,27 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-deletepropertyorthrow
+
+module.exports = function DeletePropertyOrThrow(O, P) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+ }
+
+ // eslint-disable-next-line no-param-reassign
+ var success = delete O[P];
+ if (!success) {
+ throw new $TypeError('Attempt to delete property failed.');
+ }
+ return success;
+};
diff --git a/node_modules/es-abstract/2020/EnumerableOwnPropertyNames.js b/node_modules/es-abstract/2020/EnumerableOwnPropertyNames.js
new file mode 100644
index 0000000..44171b9
--- /dev/null
+++ b/node_modules/es-abstract/2020/EnumerableOwnPropertyNames.js
@@ -0,0 +1,43 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var objectKeys = require('object-keys');
+
+var callBound = require('call-bind/callBound');
+
+var callBind = require('call-bind');
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+var $pushApply = callBind.apply(GetIntrinsic('%Array.prototype.push%'));
+
+var forEach = require('../helpers/forEach');
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/8.0/#sec-enumerableownproperties
+
+module.exports = function EnumerableOwnProperties(O, kind) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+
+ var keys = objectKeys(O);
+ if (kind === 'key') {
+ return keys;
+ }
+ if (kind === 'value' || kind === 'key+value') {
+ var results = [];
+ forEach(keys, function (key) {
+ if ($isEnumerable(O, key)) {
+ $pushApply(results, [
+ kind === 'value' ? O[key] : [key, O[key]]
+ ]);
+ }
+ });
+ return results;
+ }
+ throw new $TypeError('Assertion failed: "kind" is not "key", "value", or "key+value": ' + kind);
+};
diff --git a/node_modules/es-abstract/2020/FlattenIntoArray.js b/node_modules/es-abstract/2020/FlattenIntoArray.js
new file mode 100644
index 0000000..6429ee7
--- /dev/null
+++ b/node_modules/es-abstract/2020/FlattenIntoArray.js
@@ -0,0 +1,58 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var MAX_SAFE_INTEGER = require('../helpers/maxSafeInteger');
+
+var Call = require('./Call');
+var CreateDataPropertyOrThrow = require('./CreateDataPropertyOrThrow');
+var Get = require('./Get');
+var HasProperty = require('./HasProperty');
+var IsArray = require('./IsArray');
+var LengthOfArrayLike = require('./LengthOfArrayLike');
+var ToString = require('./ToString');
+
+// https://262.ecma-international.org/11.0/#sec-flattenintoarray
+
+// eslint-disable-next-line max-params
+module.exports = function FlattenIntoArray(target, source, sourceLen, start, depth) {
+ var mapperFunction;
+ if (arguments.length > 5) {
+ mapperFunction = arguments[5];
+ }
+
+ var targetIndex = start;
+ var sourceIndex = 0;
+ while (sourceIndex < sourceLen) {
+ var P = ToString(sourceIndex);
+ var exists = HasProperty(source, P);
+ if (exists === true) {
+ var element = Get(source, P);
+ if (typeof mapperFunction !== 'undefined') {
+ if (arguments.length <= 6) {
+ throw new $TypeError('Assertion failed: thisArg is required when mapperFunction is provided');
+ }
+ element = Call(mapperFunction, arguments[6], [element, sourceIndex, source]);
+ }
+ var shouldFlatten = false;
+ if (depth > 0) {
+ shouldFlatten = IsArray(element);
+ }
+ if (shouldFlatten) {
+ var elementLen = LengthOfArrayLike(element);
+ targetIndex = FlattenIntoArray(target, element, elementLen, targetIndex, depth - 1);
+ } else {
+ if (targetIndex >= MAX_SAFE_INTEGER) {
+ throw new $TypeError('index too large');
+ }
+ CreateDataPropertyOrThrow(target, ToString(targetIndex), element);
+ targetIndex += 1;
+ }
+ }
+ sourceIndex += 1;
+ }
+
+ return targetIndex;
+};
diff --git a/node_modules/es-abstract/2020/FromPropertyDescriptor.js b/node_modules/es-abstract/2020/FromPropertyDescriptor.js
new file mode 100644
index 0000000..9a69a26
--- /dev/null
+++ b/node_modules/es-abstract/2020/FromPropertyDescriptor.js
@@ -0,0 +1,36 @@
+'use strict';
+
+var assertRecord = require('../helpers/assertRecord');
+
+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;
+ }
+
+ 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;
+};
diff --git a/node_modules/es-abstract/2020/Get.js b/node_modules/es-abstract/2020/Get.js
new file mode 100644
index 0000000..681055a
--- /dev/null
+++ b/node_modules/es-abstract/2020/Get.js
@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+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).
+ */
+
+module.exports = function Get(O, P) {
+ // 7.3.1.1
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ // 7.3.1.2
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P));
+ }
+ // 7.3.1.3
+ return O[P];
+};
diff --git a/node_modules/es-abstract/2020/GetIterator.js b/node_modules/es-abstract/2020/GetIterator.js
new file mode 100644
index 0000000..0e74c17
--- /dev/null
+++ b/node_modules/es-abstract/2020/GetIterator.js
@@ -0,0 +1,65 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $asyncIterator = GetIntrinsic('%Symbol.asyncIterator%', true);
+
+var inspect = require('object-inspect');
+var hasSymbols = require('has-symbols')();
+
+var getIteratorMethod = require('../helpers/getIteratorMethod');
+var AdvanceStringIndex = require('./AdvanceStringIndex');
+var Call = require('./Call');
+var GetMethod = require('./GetMethod');
+var IsArray = require('./IsArray');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/9.0/#sec-getiterator
+module.exports = function GetIterator(obj, hint, method) {
+ var actualHint = hint;
+ if (arguments.length < 2) {
+ actualHint = 'sync';
+ }
+ if (actualHint !== 'sync' && actualHint !== 'async') {
+ throw new $TypeError("Assertion failed: `hint` must be one of 'sync' or 'async', got " + inspect(hint));
+ }
+
+ var actualMethod = method;
+ if (arguments.length < 3) {
+ if (actualHint === 'async') {
+ if (hasSymbols && $asyncIterator) {
+ actualMethod = GetMethod(obj, $asyncIterator);
+ }
+ if (actualMethod === undefined) {
+ throw new $TypeError("async from sync iterators aren't currently supported");
+ }
+ } else {
+ actualMethod = getIteratorMethod(
+ {
+ AdvanceStringIndex: AdvanceStringIndex,
+ GetMethod: GetMethod,
+ IsArray: IsArray,
+ Type: Type
+ },
+ obj
+ );
+ }
+ }
+ var iterator = Call(actualMethod, obj);
+ if (Type(iterator) !== 'Object') {
+ throw new $TypeError('iterator must return an object');
+ }
+
+ return iterator;
+
+ // TODO: This should return an IteratorRecord
+ /*
+ var nextMethod = GetV(iterator, 'next');
+ return {
+ '[[Iterator]]': iterator,
+ '[[NextMethod]]': nextMethod,
+ '[[Done]]': false
+ };
+ */
+};
diff --git a/node_modules/es-abstract/2020/GetMethod.js b/node_modules/es-abstract/2020/GetMethod.js
new file mode 100644
index 0000000..775d3fb
--- /dev/null
+++ b/node_modules/es-abstract/2020/GetMethod.js
@@ -0,0 +1,42 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+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.
+ */
+
+module.exports = function GetMethod(O, P) {
+ // 7.3.9.1
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+ }
+
+ // 7.3.9.2
+ var func = GetV(O, P);
+
+ // 7.3.9.4
+ if (func == null) {
+ return void 0;
+ }
+
+ // 7.3.9.5
+ if (!IsCallable(func)) {
+ throw new $TypeError(P + 'is not a function');
+ }
+
+ // 7.3.9.6
+ return func;
+};
diff --git a/node_modules/es-abstract/2020/GetOwnPropertyKeys.js b/node_modules/es-abstract/2020/GetOwnPropertyKeys.js
new file mode 100644
index 0000000..b8f4167
--- /dev/null
+++ b/node_modules/es-abstract/2020/GetOwnPropertyKeys.js
@@ -0,0 +1,31 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var hasSymbols = require('has-symbols')();
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%');
+var $gOPS = hasSymbols && GetIntrinsic('%Object.getOwnPropertySymbols%');
+var keys = require('object-keys');
+
+var esType = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-getownpropertykeys
+
+module.exports = function GetOwnPropertyKeys(O, Type) {
+ if (esType(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ if (Type === 'Symbol') {
+ return $gOPS ? $gOPS(O) : [];
+ }
+ if (Type === 'String') {
+ if (!$gOPN) {
+ return keys(O);
+ }
+ return $gOPN(O);
+ }
+ throw new $TypeError('Assertion failed: `Type` must be `"String"` or `"Symbol"`');
+};
diff --git a/node_modules/es-abstract/2020/GetPrototypeFromConstructor.js b/node_modules/es-abstract/2020/GetPrototypeFromConstructor.js
new file mode 100644
index 0000000..5f369ca
--- /dev/null
+++ b/node_modules/es-abstract/2020/GetPrototypeFromConstructor.js
@@ -0,0 +1,28 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Function = GetIntrinsic('%Function%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var IsConstructor = require('./IsConstructor');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-getprototypefromconstructor
+
+module.exports = function GetPrototypeFromConstructor(constructor, intrinsicDefaultProto) {
+ var intrinsic = GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic
+ if (!IsConstructor(constructor)) {
+ throw new $TypeError('Assertion failed: `constructor` must be a constructor');
+ }
+ var proto = Get(constructor, 'prototype');
+ if (Type(proto) !== 'Object') {
+ if (!(constructor instanceof $Function)) {
+ // ignore other realms, for now
+ throw new $TypeError('cross-realm constructors not currently supported');
+ }
+ proto = intrinsic;
+ }
+ return proto;
+};
diff --git a/node_modules/es-abstract/2020/GetSubstitution.js b/node_modules/es-abstract/2020/GetSubstitution.js
new file mode 100644
index 0000000..a5a7a1b
--- /dev/null
+++ b/node_modules/es-abstract/2020/GetSubstitution.js
@@ -0,0 +1,128 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+var regexTester = require('../helpers/regexTester');
+var every = require('../helpers/every');
+
+var $charAt = callBound('String.prototype.charAt');
+var $strSlice = callBound('String.prototype.slice');
+var $indexOf = callBound('String.prototype.indexOf');
+var $parseInt = parseInt;
+
+var isDigit = regexTester(/^[0-9]$/);
+
+var inspect = require('object-inspect');
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var IsInteger = require('./IsInteger');
+var ToObject = require('./ToObject');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+var canDistinguishSparseFromUndefined = 0 in [undefined]; // IE 6 - 8 have a bug where this returns false
+
+var isStringOrHole = function (capture, index, arr) {
+ return Type(capture) === 'String' || (canDistinguishSparseFromUndefined ? !(index in arr) : Type(capture) === 'Undefined');
+};
+
+// http://262.ecma-international.org/9.0/#sec-getsubstitution
+
+// eslint-disable-next-line max-statements, max-params, max-lines-per-function
+module.exports = function GetSubstitution(matched, str, position, captures, namedCaptures, replacement) {
+ if (Type(matched) !== 'String') {
+ throw new $TypeError('Assertion failed: `matched` must be a String');
+ }
+ var matchLength = matched.length;
+
+ if (Type(str) !== 'String') {
+ throw new $TypeError('Assertion failed: `str` must be a String');
+ }
+ var stringLength = str.length;
+
+ if (!IsInteger(position) || position < 0 || position > stringLength) {
+ throw new $TypeError('Assertion failed: `position` must be a nonnegative integer, and less than or equal to the length of `string`, got ' + inspect(position));
+ }
+
+ if (!IsArray(captures) || !every(captures, isStringOrHole)) {
+ throw new $TypeError('Assertion failed: `captures` must be a List of Strings, got ' + inspect(captures));
+ }
+
+ if (Type(replacement) !== 'String') {
+ throw new $TypeError('Assertion failed: `replacement` must be a String');
+ }
+
+ var tailPos = position + matchLength;
+ var m = captures.length;
+ if (Type(namedCaptures) !== 'Undefined') {
+ namedCaptures = ToObject(namedCaptures); // eslint-disable-line no-param-reassign
+ }
+
+ var result = '';
+ for (var i = 0; i < replacement.length; i += 1) {
+ // if this is a $, and it's not the end of the replacement
+ var current = $charAt(replacement, i);
+ var isLast = (i + 1) >= replacement.length;
+ var nextIsLast = (i + 2) >= replacement.length;
+ if (current === '$' && !isLast) {
+ var next = $charAt(replacement, i + 1);
+ if (next === '$') {
+ result += '$';
+ i += 1;
+ } else if (next === '&') {
+ result += matched;
+ i += 1;
+ } else if (next === '`') {
+ result += position === 0 ? '' : $strSlice(str, 0, position - 1);
+ i += 1;
+ } else if (next === "'") {
+ result += tailPos >= stringLength ? '' : $strSlice(str, tailPos);
+ i += 1;
+ } else {
+ var nextNext = nextIsLast ? null : $charAt(replacement, i + 2);
+ if (isDigit(next) && next !== '0' && (nextIsLast || !isDigit(nextNext))) {
+ // $1 through $9, and not followed by a digit
+ var n = $parseInt(next, 10);
+ // if (n > m, impl-defined)
+ result += n <= m && Type(captures[n - 1]) === 'Undefined' ? '' : captures[n - 1];
+ i += 1;
+ } else if (isDigit(next) && (nextIsLast || isDigit(nextNext))) {
+ // $00 through $99
+ var nn = next + nextNext;
+ var nnI = $parseInt(nn, 10) - 1;
+ // if nn === '00' or nn > m, impl-defined
+ result += nn <= m && Type(captures[nnI]) === 'Undefined' ? '' : captures[nnI];
+ i += 2;
+ } else if (next === '<') {
+ // eslint-disable-next-line max-depth
+ if (Type(namedCaptures) === 'Undefined') {
+ result += '$<';
+ i += 2;
+ } else {
+ var endIndex = $indexOf(replacement, '>', i);
+ // eslint-disable-next-line max-depth
+ if (endIndex > -1) {
+ var groupName = $strSlice(replacement, i + '$<'.length, endIndex);
+ var capture = Get(namedCaptures, groupName);
+ // eslint-disable-next-line max-depth
+ if (Type(capture) !== 'Undefined') {
+ result += ToString(capture);
+ }
+ i += ('<' + groupName + '>').length;
+ }
+ }
+ } else {
+ result += '$';
+ }
+ }
+ } else {
+ // the final $, or else not a $
+ result += $charAt(replacement, i);
+ }
+ }
+ return result;
+};
diff --git a/node_modules/es-abstract/2020/GetV.js b/node_modules/es-abstract/2020/GetV.js
new file mode 100644
index 0000000..2d8cc82
--- /dev/null
+++ b/node_modules/es-abstract/2020/GetV.js
@@ -0,0 +1,29 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+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).
+ */
+
+module.exports = function GetV(V, P) {
+ // 7.3.2.1
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+ }
+
+ // 7.3.2.2-3
+ var O = ToObject(V);
+
+ // 7.3.2.4
+ return O[P];
+};
diff --git a/node_modules/es-abstract/2020/HasOwnProperty.js b/node_modules/es-abstract/2020/HasOwnProperty.js
new file mode 100644
index 0000000..04d2849
--- /dev/null
+++ b/node_modules/es-abstract/2020/HasOwnProperty.js
@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var has = require('has');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-hasownproperty
+
+module.exports = function HasOwnProperty(O, P) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: `O` must be an Object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: `P` must be a Property Key');
+ }
+ return has(O, P);
+};
diff --git a/node_modules/es-abstract/2020/HasProperty.js b/node_modules/es-abstract/2020/HasProperty.js
new file mode 100644
index 0000000..b341654
--- /dev/null
+++ b/node_modules/es-abstract/2020/HasProperty.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-hasproperty
+
+module.exports = function HasProperty(O, P) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: `O` must be an Object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: `P` must be a Property Key');
+ }
+ return P in O;
+};
diff --git a/node_modules/es-abstract/2020/HourFromTime.js b/node_modules/es-abstract/2020/HourFromTime.js
new file mode 100644
index 0000000..f963bfb
--- /dev/null
+++ b/node_modules/es-abstract/2020/HourFromTime.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+var timeConstants = require('../helpers/timeConstants');
+var msPerHour = timeConstants.msPerHour;
+var HoursPerDay = timeConstants.HoursPerDay;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.10
+
+module.exports = function HourFromTime(t) {
+ return modulo(floor(t / msPerHour), HoursPerDay);
+};
diff --git a/node_modules/es-abstract/2020/InLeapYear.js b/node_modules/es-abstract/2020/InLeapYear.js
new file mode 100644
index 0000000..bfe0c45
--- /dev/null
+++ b/node_modules/es-abstract/2020/InLeapYear.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $EvalError = GetIntrinsic('%EvalError%');
+
+var DaysInYear = require('./DaysInYear');
+var YearFromTime = require('./YearFromTime');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function InLeapYear(t) {
+ var days = DaysInYear(YearFromTime(t));
+ if (days === 365) {
+ return 0;
+ }
+ if (days === 366) {
+ return 1;
+ }
+ throw new $EvalError('Assertion failed: there are not 365 or 366 days in a year, got: ' + days);
+};
diff --git a/node_modules/es-abstract/2020/InstanceofOperator.js b/node_modules/es-abstract/2020/InstanceofOperator.js
new file mode 100644
index 0000000..a3c4d23
--- /dev/null
+++ b/node_modules/es-abstract/2020/InstanceofOperator.js
@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $hasInstance = GetIntrinsic('Symbol.hasInstance', true);
+
+var Call = require('./Call');
+var GetMethod = require('./GetMethod');
+var IsCallable = require('./IsCallable');
+var OrdinaryHasInstance = require('./OrdinaryHasInstance');
+var ToBoolean = require('./ToBoolean');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-instanceofoperator
+
+module.exports = function InstanceofOperator(O, C) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ var instOfHandler = $hasInstance ? GetMethod(C, $hasInstance) : void 0;
+ if (typeof instOfHandler !== 'undefined') {
+ return ToBoolean(Call(instOfHandler, C, [O]));
+ }
+ if (!IsCallable(C)) {
+ throw new $TypeError('`C` is not Callable');
+ }
+ return OrdinaryHasInstance(C, O);
+};
diff --git a/node_modules/es-abstract/2020/Invoke.js b/node_modules/es-abstract/2020/Invoke.js
new file mode 100644
index 0000000..d4214ee
--- /dev/null
+++ b/node_modules/es-abstract/2020/Invoke.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Call = require('./Call');
+var IsArray = require('./IsArray');
+var GetV = require('./GetV');
+var IsPropertyKey = require('./IsPropertyKey');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-invoke
+
+module.exports = function Invoke(O, P) {
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: P must be a Property Key');
+ }
+ var argumentsList = arguments.length > 2 ? arguments[2] : [];
+ if (!IsArray(argumentsList)) {
+ throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List');
+ }
+ var func = GetV(O, P);
+ return Call(func, O, argumentsList);
+};
diff --git a/node_modules/es-abstract/2020/IsAccessorDescriptor.js b/node_modules/es-abstract/2020/IsAccessorDescriptor.js
new file mode 100644
index 0000000..78563e7
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsAccessorDescriptor.js
@@ -0,0 +1,23 @@
+'use strict';
+
+var has = require('has');
+
+var assertRecord = require('../helpers/assertRecord');
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isaccessordescriptor
+
+module.exports = function IsAccessorDescriptor(Desc) {
+ if (typeof Desc === 'undefined') {
+ return false;
+ }
+
+ assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+ if (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) {
+ return false;
+ }
+
+ return true;
+};
diff --git a/node_modules/es-abstract/2020/IsArray.js b/node_modules/es-abstract/2020/IsArray.js
new file mode 100644
index 0000000..f933cec
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsArray.js
@@ -0,0 +1,14 @@
+'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]';
+};
diff --git a/node_modules/es-abstract/2020/IsBigIntElementType.js b/node_modules/es-abstract/2020/IsBigIntElementType.js
new file mode 100644
index 0000000..e3f58a9
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsBigIntElementType.js
@@ -0,0 +1,7 @@
+'use strict';
+
+// https://262.ecma-international.org/11.0/#sec-isbigintelementtype
+
+module.exports = function IsBigIntElementType(type) {
+ return type === 'BigUint64' || type === 'BigInt64';
+};
diff --git a/node_modules/es-abstract/2020/IsCallable.js b/node_modules/es-abstract/2020/IsCallable.js
new file mode 100644
index 0000000..3a69b19
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsCallable.js
@@ -0,0 +1,5 @@
+'use strict';
+
+// http://262.ecma-international.org/5.1/#sec-9.11
+
+module.exports = require('is-callable');
diff --git a/node_modules/es-abstract/2020/IsConcatSpreadable.js b/node_modules/es-abstract/2020/IsConcatSpreadable.js
new file mode 100644
index 0000000..141b334
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsConcatSpreadable.js
@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $isConcatSpreadable = GetIntrinsic('%Symbol.isConcatSpreadable%', true);
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var ToBoolean = require('./ToBoolean');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isconcatspreadable
+
+module.exports = function IsConcatSpreadable(O) {
+ if (Type(O) !== 'Object') {
+ return false;
+ }
+ if ($isConcatSpreadable) {
+ var spreadable = Get(O, $isConcatSpreadable);
+ if (typeof spreadable !== 'undefined') {
+ return ToBoolean(spreadable);
+ }
+ }
+ return IsArray(O);
+};
diff --git a/node_modules/es-abstract/2020/IsConstructor.js b/node_modules/es-abstract/2020/IsConstructor.js
new file mode 100644
index 0000000..fe626e1
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsConstructor.js
@@ -0,0 +1,40 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic.js');
+
+var $construct = GetIntrinsic('%Reflect.construct%', true);
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+try {
+ DefinePropertyOrThrow({}, '', { '[[Get]]': function () {} });
+} catch (e) {
+ // Accessor properties aren't supported
+ DefinePropertyOrThrow = null;
+}
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isconstructor
+
+if (DefinePropertyOrThrow && $construct) {
+ var isConstructorMarker = {};
+ var badArrayLike = {};
+ DefinePropertyOrThrow(badArrayLike, 'length', {
+ '[[Get]]': function () {
+ throw isConstructorMarker;
+ },
+ '[[Enumerable]]': true
+ });
+
+ module.exports = function IsConstructor(argument) {
+ try {
+ // `Reflect.construct` invokes `IsConstructor(target)` before `Get(args, 'length')`:
+ $construct(argument, badArrayLike);
+ } catch (err) {
+ return err === isConstructorMarker;
+ }
+ };
+} else {
+ module.exports = function IsConstructor(argument) {
+ // unfortunately there's no way to truly check this without try/catch `new argument` in old environments
+ return typeof argument === 'function' && !!argument.prototype;
+ };
+}
diff --git a/node_modules/es-abstract/2020/IsDataDescriptor.js b/node_modules/es-abstract/2020/IsDataDescriptor.js
new file mode 100644
index 0000000..00d14a6
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsDataDescriptor.js
@@ -0,0 +1,23 @@
+'use strict';
+
+var has = require('has');
+
+var assertRecord = require('../helpers/assertRecord');
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor
+
+module.exports = function IsDataDescriptor(Desc) {
+ if (typeof Desc === 'undefined') {
+ return false;
+ }
+
+ assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+ if (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) {
+ return false;
+ }
+
+ return true;
+};
diff --git a/node_modules/es-abstract/2020/IsExtensible.js b/node_modules/es-abstract/2020/IsExtensible.js
new file mode 100644
index 0000000..9df5b80
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsExtensible.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Object = GetIntrinsic('%Object%');
+
+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
+ ? function IsExtensible(obj) {
+ return !isPrimitive(obj) && $isExtensible(obj);
+ }
+ : function IsExtensible(obj) {
+ return !isPrimitive(obj);
+ };
diff --git a/node_modules/es-abstract/2020/IsGenericDescriptor.js b/node_modules/es-abstract/2020/IsGenericDescriptor.js
new file mode 100644
index 0000000..95b1d35
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsGenericDescriptor.js
@@ -0,0 +1,23 @@
+'use strict';
+
+var assertRecord = require('../helpers/assertRecord');
+
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isgenericdescriptor
+
+module.exports = function IsGenericDescriptor(Desc) {
+ if (typeof Desc === 'undefined') {
+ return false;
+ }
+
+ assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+ if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) {
+ return true;
+ }
+
+ return false;
+};
diff --git a/node_modules/es-abstract/2020/IsInteger.js b/node_modules/es-abstract/2020/IsInteger.js
new file mode 100644
index 0000000..f4d1a2a
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsInteger.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var abs = require('./abs');
+var floor = require('./floor');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isinteger
+
+module.exports = function IsInteger(argument) {
+ if (typeof argument !== 'number' || $isNaN(argument) || !$isFinite(argument)) {
+ return false;
+ }
+ var absValue = abs(argument);
+ return floor(absValue) === absValue;
+};
diff --git a/node_modules/es-abstract/2020/IsNoTearConfiguration.js b/node_modules/es-abstract/2020/IsNoTearConfiguration.js
new file mode 100644
index 0000000..f0d2808
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsNoTearConfiguration.js
@@ -0,0 +1,16 @@
+'use strict';
+
+var IsUnclampedIntegerElementType = require('./IsUnclampedIntegerElementType');
+var IsBigIntElementType = require('./IsBigIntElementType');
+
+// https://262.ecma-international.org/11.0/#sec-isnotearconfiguration
+
+module.exports = function IsNoTearConfiguration(type, order) {
+ if (IsUnclampedIntegerElementType(type)) {
+ return true;
+ }
+ if (IsBigIntElementType(type) && order !== 'Init' && order !== 'Unordered') {
+ return true;
+ }
+ return false;
+};
diff --git a/node_modules/es-abstract/2020/IsNonNegativeInteger.js b/node_modules/es-abstract/2020/IsNonNegativeInteger.js
new file mode 100644
index 0000000..ae1f69c
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsNonNegativeInteger.js
@@ -0,0 +1,9 @@
+'use strict';
+
+var IsInteger = require('./IsInteger');
+
+// https://262.ecma-international.org/11.0/#sec-isnonnegativeinteger
+
+module.exports = function IsNonNegativeInteger(argument) {
+ return !!IsInteger(argument) && argument >= 0;
+};
diff --git a/node_modules/es-abstract/2020/IsPromise.js b/node_modules/es-abstract/2020/IsPromise.js
new file mode 100644
index 0000000..a551ae0
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsPromise.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+
+var $PromiseThen = callBound('Promise.prototype.then', true);
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ispromise
+
+module.exports = function IsPromise(x) {
+ if (Type(x) !== 'Object') {
+ return false;
+ }
+ if (!$PromiseThen) { // Promises are not supported
+ return false;
+ }
+ try {
+ $PromiseThen(x); // throws if not a promise
+ } catch (e) {
+ return false;
+ }
+ return true;
+};
diff --git a/node_modules/es-abstract/2020/IsPropertyKey.js b/node_modules/es-abstract/2020/IsPropertyKey.js
new file mode 100644
index 0000000..f43ab58
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsPropertyKey.js
@@ -0,0 +1,7 @@
+'use strict';
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ispropertykey
+
+module.exports = function IsPropertyKey(argument) {
+ return typeof argument === 'string' || typeof argument === 'symbol';
+};
diff --git a/node_modules/es-abstract/2020/IsRegExp.js b/node_modules/es-abstract/2020/IsRegExp.js
new file mode 100644
index 0000000..e105481
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsRegExp.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $match = GetIntrinsic('%Symbol.match%', true);
+
+var hasRegExpMatcher = require('is-regex');
+
+var ToBoolean = require('./ToBoolean');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-isregexp
+
+module.exports = function IsRegExp(argument) {
+ if (!argument || typeof argument !== 'object') {
+ return false;
+ }
+ if ($match) {
+ var isRegExp = argument[$match];
+ if (typeof isRegExp !== 'undefined') {
+ return ToBoolean(isRegExp);
+ }
+ }
+ return hasRegExpMatcher(argument);
+};
diff --git a/node_modules/es-abstract/2020/IsStringPrefix.js b/node_modules/es-abstract/2020/IsStringPrefix.js
new file mode 100644
index 0000000..4958544
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsStringPrefix.js
@@ -0,0 +1,47 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isPrefixOf = require('../helpers/isPrefixOf');
+
+// var callBound = require('call-bind/callBound');
+
+// var $charAt = callBound('String.prototype.charAt');
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/9.0/#sec-isstringprefix
+
+module.exports = function IsStringPrefix(p, q) {
+ if (Type(p) !== 'String') {
+ throw new $TypeError('Assertion failed: "p" must be a String');
+ }
+
+ if (Type(q) !== 'String') {
+ throw new $TypeError('Assertion failed: "q" must be a String');
+ }
+
+ return isPrefixOf(p, q);
+ /*
+ if (p === q || p === '') {
+ return true;
+ }
+
+ var pLength = p.length;
+ var qLength = q.length;
+ if (pLength >= qLength) {
+ return false;
+ }
+
+ // assert: pLength < qLength
+
+ for (var i = 0; i < pLength; i += 1) {
+ if ($charAt(p, i) !== $charAt(q, i)) {
+ return false;
+ }
+ }
+ return true;
+ */
+};
diff --git a/node_modules/es-abstract/2020/IsUnclampedIntegerElementType.js b/node_modules/es-abstract/2020/IsUnclampedIntegerElementType.js
new file mode 100644
index 0000000..15237b1
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsUnclampedIntegerElementType.js
@@ -0,0 +1,12 @@
+'use strict';
+
+// https://262.ecma-international.org/11.0/#sec-isunclampedintegerelementtype
+
+module.exports = function IsUnclampedIntegerElementType(type) {
+ return type === 'Int8'
+ || type === 'Uint8'
+ || type === 'Int16'
+ || type === 'Uint16'
+ || type === 'Int32'
+ || type === 'Uint32';
+};
diff --git a/node_modules/es-abstract/2020/IsUnsignedElementType.js b/node_modules/es-abstract/2020/IsUnsignedElementType.js
new file mode 100644
index 0000000..5eb1e7c
--- /dev/null
+++ b/node_modules/es-abstract/2020/IsUnsignedElementType.js
@@ -0,0 +1,11 @@
+'use strict';
+
+// https://262.ecma-international.org/11.0/#sec-isunsignedelementtype
+
+module.exports = function IsUnsignedElementType(type) {
+ return type === 'Uint8'
+ || type === 'Uint8C'
+ || type === 'Uint16'
+ || type === 'Uint32'
+ || type === 'BigUint64';
+};
diff --git a/node_modules/es-abstract/2020/IterableToList.js b/node_modules/es-abstract/2020/IterableToList.js
new file mode 100644
index 0000000..d994d74
--- /dev/null
+++ b/node_modules/es-abstract/2020/IterableToList.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+var $arrayPush = callBound('Array.prototype.push');
+
+var GetIterator = require('./GetIterator');
+var IteratorStep = require('./IteratorStep');
+var IteratorValue = require('./IteratorValue');
+
+// https://262.ecma-international.org/9.0/#sec-iterabletolist
+
+module.exports = function IterableToList(items, method) {
+ var iterator = GetIterator(items, 'sync', method);
+ var values = [];
+ var next = true;
+ while (next) {
+ next = IteratorStep(iterator);
+ if (next) {
+ var nextValue = IteratorValue(next);
+ $arrayPush(values, nextValue);
+ }
+ }
+ return values;
+};
diff --git a/node_modules/es-abstract/2020/IteratorClose.js b/node_modules/es-abstract/2020/IteratorClose.js
new file mode 100644
index 0000000..dd1118d
--- /dev/null
+++ b/node_modules/es-abstract/2020/IteratorClose.js
@@ -0,0 +1,50 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Call = require('./Call');
+var GetMethod = require('./GetMethod');
+var IsCallable = require('./IsCallable');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-iteratorclose
+
+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');
+ }
+ var completionThunk = completion;
+
+ var iteratorReturn = GetMethod(iterator, 'return');
+
+ if (typeof iteratorReturn === 'undefined') {
+ return completionThunk();
+ }
+
+ var completionRecord;
+ try {
+ var innerResult = Call(iteratorReturn, iterator, []);
+ } catch (e) {
+ // if we hit here, then "e" is the innerResult completion that needs re-throwing
+
+ // if the completion is of type "throw", this will throw.
+ completionThunk();
+ completionThunk = null; // ensure it's not called twice.
+
+ // if not, then return the innerResult completion
+ throw e;
+ }
+ completionRecord = completionThunk(); // if innerResult worked, then throw if the completion does
+ completionThunk = null; // ensure it's not called twice.
+
+ if (Type(innerResult) !== 'Object') {
+ throw new $TypeError('iterator .return must return an object');
+ }
+
+ return completionRecord;
+};
diff --git a/node_modules/es-abstract/2020/IteratorComplete.js b/node_modules/es-abstract/2020/IteratorComplete.js
new file mode 100644
index 0000000..ed4efa3
--- /dev/null
+++ b/node_modules/es-abstract/2020/IteratorComplete.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var ToBoolean = require('./ToBoolean');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-iteratorcomplete
+
+module.exports = function IteratorComplete(iterResult) {
+ if (Type(iterResult) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(iterResult) is not Object');
+ }
+ return ToBoolean(Get(iterResult, 'done'));
+};
diff --git a/node_modules/es-abstract/2020/IteratorNext.js b/node_modules/es-abstract/2020/IteratorNext.js
new file mode 100644
index 0000000..cf80655
--- /dev/null
+++ b/node_modules/es-abstract/2020/IteratorNext.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Invoke = require('./Invoke');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-iteratornext
+
+module.exports = function IteratorNext(iterator, value) {
+ var result = Invoke(iterator, 'next', arguments.length < 2 ? [] : [value]);
+ if (Type(result) !== 'Object') {
+ throw new $TypeError('iterator next must return an object');
+ }
+ return result;
+};
diff --git a/node_modules/es-abstract/2020/IteratorStep.js b/node_modules/es-abstract/2020/IteratorStep.js
new file mode 100644
index 0000000..41b9d1b
--- /dev/null
+++ b/node_modules/es-abstract/2020/IteratorStep.js
@@ -0,0 +1,13 @@
+'use strict';
+
+var IteratorComplete = require('./IteratorComplete');
+var IteratorNext = require('./IteratorNext');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-iteratorstep
+
+module.exports = function IteratorStep(iterator) {
+ var result = IteratorNext(iterator);
+ var done = IteratorComplete(result);
+ return done === true ? false : result;
+};
+
diff --git a/node_modules/es-abstract/2020/IteratorValue.js b/node_modules/es-abstract/2020/IteratorValue.js
new file mode 100644
index 0000000..d15d8ae
--- /dev/null
+++ b/node_modules/es-abstract/2020/IteratorValue.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-iteratorvalue
+
+module.exports = function IteratorValue(iterResult) {
+ if (Type(iterResult) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(iterResult) is not Object');
+ }
+ return Get(iterResult, 'value');
+};
+
diff --git a/node_modules/es-abstract/2020/LengthOfArrayLike.js b/node_modules/es-abstract/2020/LengthOfArrayLike.js
new file mode 100644
index 0000000..132c4d5
--- /dev/null
+++ b/node_modules/es-abstract/2020/LengthOfArrayLike.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var ToLength = require('./ToLength');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-lengthofarraylike
+
+module.exports = function LengthOfArrayLike(obj) {
+ if (Type(obj) !== 'Object') {
+ throw new $TypeError('Assertion failed: `obj` must be an Object');
+ }
+ return ToLength(Get(obj, 'length'));
+};
+
+// TODO: use this all over
diff --git a/node_modules/es-abstract/2020/MakeDate.js b/node_modules/es-abstract/2020/MakeDate.js
new file mode 100644
index 0000000..efeb645
--- /dev/null
+++ b/node_modules/es-abstract/2020/MakeDate.js
@@ -0,0 +1,13 @@
+'use strict';
+
+var $isFinite = require('../helpers/isFinite');
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.13
+
+module.exports = function MakeDate(day, time) {
+ if (!$isFinite(day) || !$isFinite(time)) {
+ return NaN;
+ }
+ return (day * msPerDay) + time;
+};
diff --git a/node_modules/es-abstract/2020/MakeDay.js b/node_modules/es-abstract/2020/MakeDay.js
new file mode 100644
index 0000000..13f5686
--- /dev/null
+++ b/node_modules/es-abstract/2020/MakeDay.js
@@ -0,0 +1,33 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $DateUTC = GetIntrinsic('%Date.UTC%');
+
+var $isFinite = require('../helpers/isFinite');
+
+var DateFromTime = require('./DateFromTime');
+var Day = require('./Day');
+var floor = require('./floor');
+var modulo = require('./modulo');
+var MonthFromTime = require('./MonthFromTime');
+var ToInteger = require('./ToInteger');
+var YearFromTime = require('./YearFromTime');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.12
+
+module.exports = function MakeDay(year, month, date) {
+ if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) {
+ return NaN;
+ }
+ var y = ToInteger(year);
+ var m = ToInteger(month);
+ var dt = ToInteger(date);
+ var ym = y + floor(m / 12);
+ var mn = modulo(m, 12);
+ var t = $DateUTC(ym, mn, 1);
+ if (YearFromTime(t) !== ym || MonthFromTime(t) !== mn || DateFromTime(t) !== 1) {
+ return NaN;
+ }
+ return Day(t) + dt - 1;
+};
diff --git a/node_modules/es-abstract/2020/MakeTime.js b/node_modules/es-abstract/2020/MakeTime.js
new file mode 100644
index 0000000..34cb4dc
--- /dev/null
+++ b/node_modules/es-abstract/2020/MakeTime.js
@@ -0,0 +1,23 @@
+'use strict';
+
+var $isFinite = require('../helpers/isFinite');
+var timeConstants = require('../helpers/timeConstants');
+var msPerSecond = timeConstants.msPerSecond;
+var msPerMinute = timeConstants.msPerMinute;
+var msPerHour = timeConstants.msPerHour;
+
+var ToInteger = require('./ToInteger');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.11
+
+module.exports = function MakeTime(hour, min, sec, ms) {
+ if (!$isFinite(hour) || !$isFinite(min) || !$isFinite(sec) || !$isFinite(ms)) {
+ return NaN;
+ }
+ var h = ToInteger(hour);
+ var m = ToInteger(min);
+ var s = ToInteger(sec);
+ var milli = ToInteger(ms);
+ var t = (h * msPerHour) + (m * msPerMinute) + (s * msPerSecond) + milli;
+ return t;
+};
diff --git a/node_modules/es-abstract/2020/MinFromTime.js b/node_modules/es-abstract/2020/MinFromTime.js
new file mode 100644
index 0000000..a0c631d
--- /dev/null
+++ b/node_modules/es-abstract/2020/MinFromTime.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+var timeConstants = require('../helpers/timeConstants');
+var msPerMinute = timeConstants.msPerMinute;
+var MinutesPerHour = timeConstants.MinutesPerHour;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.10
+
+module.exports = function MinFromTime(t) {
+ return modulo(floor(t / msPerMinute), MinutesPerHour);
+};
diff --git a/node_modules/es-abstract/2020/MonthFromTime.js b/node_modules/es-abstract/2020/MonthFromTime.js
new file mode 100644
index 0000000..a482a7d
--- /dev/null
+++ b/node_modules/es-abstract/2020/MonthFromTime.js
@@ -0,0 +1,47 @@
+'use strict';
+
+var DayWithinYear = require('./DayWithinYear');
+var InLeapYear = require('./InLeapYear');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.4
+
+module.exports = function MonthFromTime(t) {
+ var day = DayWithinYear(t);
+ if (0 <= day && day < 31) {
+ return 0;
+ }
+ var leap = InLeapYear(t);
+ if (31 <= day && day < (59 + leap)) {
+ return 1;
+ }
+ if ((59 + leap) <= day && day < (90 + leap)) {
+ return 2;
+ }
+ if ((90 + leap) <= day && day < (120 + leap)) {
+ return 3;
+ }
+ if ((120 + leap) <= day && day < (151 + leap)) {
+ return 4;
+ }
+ if ((151 + leap) <= day && day < (181 + leap)) {
+ return 5;
+ }
+ if ((181 + leap) <= day && day < (212 + leap)) {
+ return 6;
+ }
+ if ((212 + leap) <= day && day < (243 + leap)) {
+ return 7;
+ }
+ if ((243 + leap) <= day && day < (273 + leap)) {
+ return 8;
+ }
+ if ((273 + leap) <= day && day < (304 + leap)) {
+ return 9;
+ }
+ if ((304 + leap) <= day && day < (334 + leap)) {
+ return 10;
+ }
+ if ((334 + leap) <= day && day < (365 + leap)) {
+ return 11;
+ }
+};
diff --git a/node_modules/es-abstract/2020/Number/add.js b/node_modules/es-abstract/2020/Number/add.js
new file mode 100644
index 0000000..c2c2063
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/add.js
@@ -0,0 +1,44 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isNaN = require('../../helpers/isNaN');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-add
+
+module.exports = function NumberAdd(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+
+ if (isNaN(x) || isNaN(y) || (x === Infinity && y === -Infinity) || (x === -Infinity && y === Infinity)) {
+ return NaN;
+ }
+
+ if ((x === Infinity && y === Infinity) || (x === -Infinity && y === -Infinity)) {
+ return x;
+ }
+
+ if (x === Infinity) {
+ return x;
+ }
+
+ if (y === Infinity) {
+ return y;
+ }
+
+ if (x === y && x === 0) {
+ return Infinity / x === -Infinity && Infinity / y === -Infinity ? -0 : +0;
+ }
+
+ if (x === -y || -x === y) {
+ return +0;
+ }
+
+ // shortcut for the actual spec mechanics
+ return x + y;
+};
diff --git a/node_modules/es-abstract/2020/Number/bitwiseAND.js b/node_modules/es-abstract/2020/Number/bitwiseAND.js
new file mode 100644
index 0000000..a715980
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/bitwiseAND.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var NumberBitwiseOp = require('../NumberBitwiseOp');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseAND
+
+module.exports = function NumberBitwiseAND(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+ return NumberBitwiseOp('&', x, y);
+};
diff --git a/node_modules/es-abstract/2020/Number/bitwiseNOT.js b/node_modules/es-abstract/2020/Number/bitwiseNOT.js
new file mode 100644
index 0000000..ae8032a
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/bitwiseNOT.js
@@ -0,0 +1,19 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var ToInt32 = require('../ToInt32');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseNOT
+
+module.exports = function NumberBitwiseNOT(x) {
+ if (Type(x) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` argument must be a Number');
+ }
+ var oldValue = ToInt32(x);
+ // Return the result of applying the bitwise operator op to lnum and rnum. The result is a signed 32-bit integer.
+ return ~oldValue;
+};
diff --git a/node_modules/es-abstract/2020/Number/bitwiseOR.js b/node_modules/es-abstract/2020/Number/bitwiseOR.js
new file mode 100644
index 0000000..c5e67b9
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/bitwiseOR.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var NumberBitwiseOp = require('../NumberBitwiseOp');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseOR
+
+module.exports = function NumberBitwiseOR(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+ return NumberBitwiseOp('|', x, y);
+};
diff --git a/node_modules/es-abstract/2020/Number/bitwiseXOR.js b/node_modules/es-abstract/2020/Number/bitwiseXOR.js
new file mode 100644
index 0000000..a4030e9
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/bitwiseXOR.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var NumberBitwiseOp = require('../NumberBitwiseOp');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseXOR
+
+module.exports = function NumberBitwiseXOR(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+ return NumberBitwiseOp('^', x, y);
+};
diff --git a/node_modules/es-abstract/2020/Number/divide.js b/node_modules/es-abstract/2020/Number/divide.js
new file mode 100644
index 0000000..6524462
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/divide.js
@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isFinite = require('../../helpers/isFinite');
+var isNaN = require('../../helpers/isNaN');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-divide
+
+module.exports = function NumberDivide(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+ if (isNaN(x) || isNaN(y) || (!isFinite(x) && !isFinite(y))) {
+ return NaN;
+ }
+ // shortcut for the actual spec mechanics
+ return x / y;
+};
diff --git a/node_modules/es-abstract/2020/Number/equal.js b/node_modules/es-abstract/2020/Number/equal.js
new file mode 100644
index 0000000..db68afa
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/equal.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isNaN = require('../../helpers/isNaN');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-equal
+
+module.exports = function NumberEqual(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+ if (isNaN(x) || isNaN(y)) {
+ return false;
+ }
+ // shortcut for the actual spec mechanics
+ return x === y;
+};
diff --git a/node_modules/es-abstract/2020/Number/exponentiate.js b/node_modules/es-abstract/2020/Number/exponentiate.js
new file mode 100644
index 0000000..bafa7b1
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/exponentiate.js
@@ -0,0 +1,77 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+// var isNegativeZero = require('is-negative-zero');
+
+var $pow = GetIntrinsic('%Math.pow%');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+/*
+var abs = require('../../helpers/abs');
+var isFinite = require('../../helpers/isFinite');
+var isNaN = require('../../helpers/isNaN');
+
+var IsInteger = require('../IsInteger');
+*/
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-exponentiate
+
+/* eslint max-lines-per-function: 0, max-statements: 0 */
+
+module.exports = function NumberExponentiate(base, exponent) {
+ if (Type(base) !== 'Number' || Type(exponent) !== 'Number') {
+ throw new $TypeError('Assertion failed: `base` and `exponent` arguments must be Numbers');
+ }
+ return $pow(base, exponent);
+ /*
+ if (isNaN(exponent)) {
+ return NaN;
+ }
+ if (exponent === 0) {
+ return 1;
+ }
+ if (isNaN(base)) {
+ return NaN;
+ }
+ var aB = abs(base);
+ if (aB > 1 && exponent === Infinity) {
+ return Infinity;
+ }
+ if (aB > 1 && exponent === -Infinity) {
+ return 0;
+ }
+ if (aB === 1 && (exponent === Infinity || exponent === -Infinity)) {
+ return NaN;
+ }
+ if (aB < 1 && exponent === Infinity) {
+ return +0;
+ }
+ if (aB < 1 && exponent === -Infinity) {
+ return Infinity;
+ }
+ if (base === Infinity) {
+ return exponent > 0 ? Infinity : 0;
+ }
+ if (base === -Infinity) {
+ var isOdd = true;
+ if (exponent > 0) {
+ return isOdd ? -Infinity : Infinity;
+ }
+ return isOdd ? -0 : 0;
+ }
+ if (exponent > 0) {
+ return isNegativeZero(base) ? Infinity : 0;
+ }
+ if (isNegativeZero(base)) {
+ if (exponent > 0) {
+ return isOdd ? -0 : 0;
+ }
+ return isOdd ? -Infinity : Infinity;
+ }
+ if (base < 0 && isFinite(base) && isFinite(exponent) && !IsInteger(exponent)) {
+ return NaN;
+ }
+ */
+};
diff --git a/node_modules/es-abstract/2020/Number/index.js b/node_modules/es-abstract/2020/Number/index.js
new file mode 100644
index 0000000..63ec52d
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/index.js
@@ -0,0 +1,43 @@
+'use strict';
+
+var add = require('./add');
+var bitwiseAND = require('./bitwiseAND');
+var bitwiseNOT = require('./bitwiseNOT');
+var bitwiseOR = require('./bitwiseOR');
+var bitwiseXOR = require('./bitwiseXOR');
+var divide = require('./divide');
+var equal = require('./equal');
+var exponentiate = require('./exponentiate');
+var leftShift = require('./leftShift');
+var lessThan = require('./lessThan');
+var multiply = require('./multiply');
+var remainder = require('./remainder');
+var sameValue = require('./sameValue');
+var sameValueZero = require('./sameValueZero');
+var signedRightShift = require('./signedRightShift');
+var subtract = require('./subtract');
+var toString = require('./toString');
+var unaryMinus = require('./unaryMinus');
+var unsignedRightShift = require('./unsignedRightShift');
+
+module.exports = {
+ add: add,
+ bitwiseAND: bitwiseAND,
+ bitwiseNOT: bitwiseNOT,
+ bitwiseOR: bitwiseOR,
+ bitwiseXOR: bitwiseXOR,
+ divide: divide,
+ equal: equal,
+ exponentiate: exponentiate,
+ leftShift: leftShift,
+ lessThan: lessThan,
+ multiply: multiply,
+ remainder: remainder,
+ sameValue: sameValue,
+ sameValueZero: sameValueZero,
+ signedRightShift: signedRightShift,
+ subtract: subtract,
+ toString: toString,
+ unaryMinus: unaryMinus,
+ unsignedRightShift: unsignedRightShift
+};
diff --git a/node_modules/es-abstract/2020/Number/leftShift.js b/node_modules/es-abstract/2020/Number/leftShift.js
new file mode 100644
index 0000000..804fde4
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/leftShift.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var ToInt32 = require('../ToInt32');
+var ToUint32 = require('../ToUint32');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-leftShift
+
+module.exports = function NumberLeftShift(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+
+ var lnum = ToInt32(x);
+ var rnum = ToUint32(y);
+
+ var shiftCount = rnum & 0x1F;
+
+ return lnum << shiftCount;
+};
diff --git a/node_modules/es-abstract/2020/Number/lessThan.js b/node_modules/es-abstract/2020/Number/lessThan.js
new file mode 100644
index 0000000..5fcac24
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/lessThan.js
@@ -0,0 +1,26 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isNaN = require('../../helpers/isNaN');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-lessThan
+
+module.exports = function NumberLessThan(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+
+ // If x is NaN, return undefined.
+ // If y is NaN, return undefined.
+ if (isNaN(x) || isNaN(y)) {
+ return void undefined;
+ }
+
+ // shortcut for the actual spec mechanics
+ return x < y;
+};
diff --git a/node_modules/es-abstract/2020/Number/multiply.js b/node_modules/es-abstract/2020/Number/multiply.js
new file mode 100644
index 0000000..2a6c478
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/multiply.js
@@ -0,0 +1,33 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isNaN = require('../../helpers/isNaN');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-multiply
+
+module.exports = function NumberMultiply(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+
+ if (isNaN(x) || isNaN(y) || (x === 0 && !isFinite(y)) || (!isFinite(x) && y === 0)) {
+ return NaN;
+ }
+ if (!isFinite(x) && !isFinite(y)) {
+ return x === y ? Infinity : -Infinity;
+ }
+ if (!isFinite(x) && y !== 0) {
+ return x > 0 ? Infinity : -Infinity;
+ }
+ if (!isFinite(y) && x !== 0) {
+ return y > 0 ? Infinity : -Infinity;
+ }
+
+ // shortcut for the actual spec mechanics
+ return x * y;
+};
diff --git a/node_modules/es-abstract/2020/Number/remainder.js b/node_modules/es-abstract/2020/Number/remainder.js
new file mode 100644
index 0000000..bc61064
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/remainder.js
@@ -0,0 +1,32 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isNaN = require('../../helpers/isNaN');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-remainder
+
+module.exports = function NumberRemainder(n, d) {
+ if (Type(n) !== 'Number' || Type(d) !== 'Number') {
+ throw new $TypeError('Assertion failed: `n` and `d` arguments must be Numbers');
+ }
+
+ // If either operand is NaN, the result is NaN.
+ // If the dividend is an infinity, or the divisor is a zero, or both, the result is NaN.
+ if (isNaN(n) || isNaN(d) || !isFinite(n) || d === 0) {
+ return NaN;
+ }
+
+ // If the dividend is finite and the divisor is an infinity, the result equals the dividend.
+ // If the dividend is a zero and the divisor is nonzero and finite, the result is the same as the dividend.
+ if (!isFinite(d) || (n === 0 && d !== 0)) {
+ return n;
+ }
+
+ // In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved…
+ return n % d;
+};
diff --git a/node_modules/es-abstract/2020/Number/sameValue.js b/node_modules/es-abstract/2020/Number/sameValue.js
new file mode 100644
index 0000000..19efc37
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/sameValue.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var isNegativeZero = require('is-negative-zero');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+var NumberSameValueZero = require('./sameValueZero');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-sameValue
+
+module.exports = function NumberSameValue(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+ if (x === 0 && y === 0) {
+ return !(isNegativeZero(x) ^ isNegativeZero(y));
+ }
+ return NumberSameValueZero(x, y);
+};
diff --git a/node_modules/es-abstract/2020/Number/sameValueZero.js b/node_modules/es-abstract/2020/Number/sameValueZero.js
new file mode 100644
index 0000000..5688198
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/sameValueZero.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isNaN = require('../../helpers/isNaN');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-sameValueZero
+
+module.exports = function NumberSameValueZero(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+
+ var xNaN = isNaN(x);
+ var yNaN = isNaN(y);
+ if (xNaN || yNaN) {
+ return xNaN === yNaN;
+ }
+ return x === y;
+};
diff --git a/node_modules/es-abstract/2020/Number/signedRightShift.js b/node_modules/es-abstract/2020/Number/signedRightShift.js
new file mode 100644
index 0000000..043ca89
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/signedRightShift.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var ToInt32 = require('../ToInt32');
+var ToUint32 = require('../ToUint32');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-signedRightShift
+
+module.exports = function NumberSignedRightShift(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+
+ var lnum = ToInt32(x);
+ var rnum = ToUint32(y);
+
+ var shiftCount = rnum & 0x1F;
+
+ return lnum >> shiftCount;
+};
diff --git a/node_modules/es-abstract/2020/Number/subtract.js b/node_modules/es-abstract/2020/Number/subtract.js
new file mode 100644
index 0000000..3ff2dd2
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/subtract.js
@@ -0,0 +1,16 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-subtract
+
+module.exports = function NumberSubtract(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+ return x - y;
+};
diff --git a/node_modules/es-abstract/2020/Number/toString.js b/node_modules/es-abstract/2020/Number/toString.js
new file mode 100644
index 0000000..4f13316
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/toString.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-tostring
+
+module.exports = function NumberToString(x) {
+ if (Type(x) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` must be a Number');
+ }
+
+ return $String(x);
+};
diff --git a/node_modules/es-abstract/2020/Number/unaryMinus.js b/node_modules/es-abstract/2020/Number/unaryMinus.js
new file mode 100644
index 0000000..794582a
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/unaryMinus.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isNaN = require('../../helpers/isNaN');
+
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-unaryMinus
+
+module.exports = function NumberUnaryMinus(x) {
+ if (Type(x) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` argument must be a Number');
+ }
+ if (isNaN(x)) {
+ return NaN;
+ }
+ return -x;
+};
diff --git a/node_modules/es-abstract/2020/Number/unsignedRightShift.js b/node_modules/es-abstract/2020/Number/unsignedRightShift.js
new file mode 100644
index 0000000..874439e
--- /dev/null
+++ b/node_modules/es-abstract/2020/Number/unsignedRightShift.js
@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var ToInt32 = require('../ToInt32');
+var ToUint32 = require('../ToUint32');
+var Type = require('../Type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-unsignedRightShift
+
+module.exports = function NumberUnsignedRightShift(x, y) {
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+
+ var lnum = ToInt32(x);
+ var rnum = ToUint32(y);
+
+ var shiftCount = rnum & 0x1F;
+
+ return lnum >>> shiftCount;
+};
diff --git a/node_modules/es-abstract/2020/NumberBitwiseOp.js b/node_modules/es-abstract/2020/NumberBitwiseOp.js
new file mode 100644
index 0000000..11425ff
--- /dev/null
+++ b/node_modules/es-abstract/2020/NumberBitwiseOp.js
@@ -0,0 +1,29 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var ToInt32 = require('./ToInt32');
+var ToUint32 = require('./ToUint32');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-numberbitwiseop
+
+module.exports = function NumberBitwiseOp(op, x, y) {
+ if (op !== '&' && op !== '|' && op !== '^') {
+ throw new $TypeError('Assertion failed: `op` must be `&`, `|`, or `^`');
+ }
+ if (Type(x) !== 'Number' || Type(y) !== 'Number') {
+ throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+ }
+ var lnum = ToInt32(x);
+ var rnum = ToUint32(y);
+ if (op === '&') {
+ return lnum & rnum;
+ }
+ if (op === '|') {
+ return lnum | rnum;
+ }
+ return lnum ^ rnum;
+};
diff --git a/node_modules/es-abstract/2020/NumberToBigInt.js b/node_modules/es-abstract/2020/NumberToBigInt.js
new file mode 100644
index 0000000..a186988
--- /dev/null
+++ b/node_modules/es-abstract/2020/NumberToBigInt.js
@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $RangeError = GetIntrinsic('%RangeError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsInteger = require('./IsInteger');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-numbertobigint
+
+module.exports = function NumberToBigInt(number) {
+ if (Type(number) !== 'Number') {
+ throw new $TypeError('Assertion failed: `number` must be a String');
+ }
+ if (!IsInteger(number)) {
+ throw new $RangeError('The number ' + number + ' cannot be converted to a BigInt because it is not an integer');
+ }
+ return $BigInt(number);
+};
diff --git a/node_modules/es-abstract/2020/OrdinaryCreateFromConstructor.js b/node_modules/es-abstract/2020/OrdinaryCreateFromConstructor.js
new file mode 100644
index 0000000..8f3bb82
--- /dev/null
+++ b/node_modules/es-abstract/2020/OrdinaryCreateFromConstructor.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var GetPrototypeFromConstructor = require('./GetPrototypeFromConstructor');
+var IsArray = require('./IsArray');
+var OrdinaryObjectCreate = require('./OrdinaryObjectCreate');
+
+// https://262.ecma-international.org/6.0/#sec-ordinarycreatefromconstructor
+
+module.exports = function OrdinaryCreateFromConstructor(constructor, intrinsicDefaultProto) {
+ GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic
+ var proto = GetPrototypeFromConstructor(constructor, intrinsicDefaultProto);
+ var slots = arguments.length < 3 ? [] : arguments[2];
+ if (!IsArray(slots)) {
+ throw new $TypeError('Assertion failed: if provided, `internalSlotsList` must be a List');
+ }
+ return OrdinaryObjectCreate(proto, slots);
+};
diff --git a/node_modules/es-abstract/2020/OrdinaryDefineOwnProperty.js b/node_modules/es-abstract/2020/OrdinaryDefineOwnProperty.js
new file mode 100644
index 0000000..5d33aa6
--- /dev/null
+++ b/node_modules/es-abstract/2020/OrdinaryDefineOwnProperty.js
@@ -0,0 +1,61 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $gOPD = require('../helpers/getOwnPropertyDescriptor');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsExtensible = require('./IsExtensible');
+var IsPropertyKey = require('./IsPropertyKey');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+var ValidateAndApplyPropertyDescriptor = require('./ValidateAndApplyPropertyDescriptor');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ordinarydefineownproperty
+
+module.exports = function OrdinaryDefineOwnProperty(O, P, Desc) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: O must be an Object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: P must be a Property Key');
+ }
+ if (!isPropertyDescriptor({
+ Type: Type,
+ IsDataDescriptor: IsDataDescriptor,
+ IsAccessorDescriptor: IsAccessorDescriptor
+ }, Desc)) {
+ throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
+ }
+ if (!$gOPD) {
+ // ES3/IE 8 fallback
+ if (IsAccessorDescriptor(Desc)) {
+ throw new $SyntaxError('This environment does not support accessor property descriptors.');
+ }
+ var creatingNormalDataProperty = !(P in O)
+ && Desc['[[Writable]]']
+ && Desc['[[Enumerable]]']
+ && Desc['[[Configurable]]']
+ && '[[Value]]' in Desc;
+ var settingExistingDataProperty = (P in O)
+ && (!('[[Configurable]]' in Desc) || Desc['[[Configurable]]'])
+ && (!('[[Enumerable]]' in Desc) || Desc['[[Enumerable]]'])
+ && (!('[[Writable]]' in Desc) || Desc['[[Writable]]'])
+ && '[[Value]]' in Desc;
+ if (creatingNormalDataProperty || settingExistingDataProperty) {
+ O[P] = Desc['[[Value]]']; // eslint-disable-line no-param-reassign
+ return SameValue(O[P], Desc['[[Value]]']);
+ }
+ throw new $SyntaxError('This environment does not support defining non-writable, non-enumerable, or non-configurable properties');
+ }
+ var desc = $gOPD(O, P);
+ var current = desc && ToPropertyDescriptor(desc);
+ var extensible = IsExtensible(O);
+ return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current);
+};
diff --git a/node_modules/es-abstract/2020/OrdinaryGetOwnProperty.js b/node_modules/es-abstract/2020/OrdinaryGetOwnProperty.js
new file mode 100644
index 0000000..3d11e9f
--- /dev/null
+++ b/node_modules/es-abstract/2020/OrdinaryGetOwnProperty.js
@@ -0,0 +1,44 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $gOPD = require('../helpers/getOwnPropertyDescriptor');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+var has = require('has');
+
+var IsArray = require('./IsArray');
+var IsPropertyKey = require('./IsPropertyKey');
+var IsRegExp = require('./IsRegExp');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty
+
+module.exports = function OrdinaryGetOwnProperty(O, P) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: O must be an Object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: P must be a Property Key');
+ }
+ if (!has(O, P)) {
+ return void 0;
+ }
+ if (!$gOPD) {
+ // ES3 / IE 8 fallback
+ var arrayLength = IsArray(O) && P === 'length';
+ var regexLastIndex = IsRegExp(O) && P === 'lastIndex';
+ return {
+ '[[Configurable]]': !(arrayLength || regexLastIndex),
+ '[[Enumerable]]': $isEnumerable(O, P),
+ '[[Value]]': O[P],
+ '[[Writable]]': true
+ };
+ }
+ return ToPropertyDescriptor($gOPD(O, P));
+};
diff --git a/node_modules/es-abstract/2020/OrdinaryGetPrototypeOf.js b/node_modules/es-abstract/2020/OrdinaryGetPrototypeOf.js
new file mode 100644
index 0000000..ba17b98
--- /dev/null
+++ b/node_modules/es-abstract/2020/OrdinaryGetPrototypeOf.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $getProto = require('../helpers/getProto');
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/7.0/#sec-ordinarygetprototypeof
+
+module.exports = function OrdinaryGetPrototypeOf(O) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: O must be an Object');
+ }
+ if (!$getProto) {
+ throw new $TypeError('This environment does not support fetching prototypes.');
+ }
+ return $getProto(O);
+};
diff --git a/node_modules/es-abstract/2020/OrdinaryHasInstance.js b/node_modules/es-abstract/2020/OrdinaryHasInstance.js
new file mode 100644
index 0000000..85a240c
--- /dev/null
+++ b/node_modules/es-abstract/2020/OrdinaryHasInstance.js
@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var IsCallable = require('./IsCallable');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ordinaryhasinstance
+
+module.exports = function OrdinaryHasInstance(C, O) {
+ if (IsCallable(C) === false) {
+ return false;
+ }
+ if (Type(O) !== 'Object') {
+ return false;
+ }
+ var P = Get(C, 'prototype');
+ if (Type(P) !== 'Object') {
+ throw new $TypeError('OrdinaryHasInstance called on an object with an invalid prototype property.');
+ }
+ return O instanceof C;
+};
diff --git a/node_modules/es-abstract/2020/OrdinaryHasProperty.js b/node_modules/es-abstract/2020/OrdinaryHasProperty.js
new file mode 100644
index 0000000..dd09ca3
--- /dev/null
+++ b/node_modules/es-abstract/2020/OrdinaryHasProperty.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ordinaryhasproperty
+
+module.exports = function OrdinaryHasProperty(O, P) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: P must be a Property Key');
+ }
+ return P in O;
+};
diff --git a/node_modules/es-abstract/2020/OrdinaryObjectCreate.js b/node_modules/es-abstract/2020/OrdinaryObjectCreate.js
new file mode 100644
index 0000000..34810cd
--- /dev/null
+++ b/node_modules/es-abstract/2020/OrdinaryObjectCreate.js
@@ -0,0 +1,46 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+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);
+
+// https://262.ecma-international.org/6.0/#sec-objectcreate
+
+module.exports = function OrdinaryObjectCreate(proto) {
+ if (proto !== null && Type(proto) !== 'Object') {
+ throw new $TypeError('Assertion failed: `proto` must be null or an object');
+ }
+ var additionalInternalSlotsList = arguments.length < 2 ? [] : arguments[1];
+ if (!IsArray(additionalInternalSlotsList)) {
+ throw new $TypeError('Assertion failed: `additionalInternalSlotsList` must be an Array');
+ }
+ // var internalSlotsList = ['[[Prototype]]', '[[Extensible]]'];
+ if (additionalInternalSlotsList.length > 0) {
+ throw new $SyntaxError('es-abstract does not yet support internal slots');
+ // internalSlotsList.push(...additionalInternalSlotsList);
+ }
+ // var O = MakeBasicObject(internalSlotsList);
+ // setProto(O, proto);
+ // return O;
+
+ if ($ObjectCreate) {
+ return $ObjectCreate(proto);
+ }
+ if (hasProto) {
+ return { __proto__: proto };
+ }
+
+ if (proto === null) {
+ throw new $SyntaxError('native Object.create support is required to create null objects');
+ }
+ var T = function T() {};
+ T.prototype = proto;
+ return new T();
+};
diff --git a/node_modules/es-abstract/2020/OrdinarySetPrototypeOf.js b/node_modules/es-abstract/2020/OrdinarySetPrototypeOf.js
new file mode 100644
index 0000000..d0ff7a7
--- /dev/null
+++ b/node_modules/es-abstract/2020/OrdinarySetPrototypeOf.js
@@ -0,0 +1,53 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $setProto = require('../helpers/setProto');
+
+var OrdinaryGetPrototypeOf = require('./OrdinaryGetPrototypeOf');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/7.0/#sec-ordinarysetprototypeof
+
+module.exports = function OrdinarySetPrototypeOf(O, V) {
+ if (Type(V) !== 'Object' && Type(V) !== 'Null') {
+ 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;
+ }
+ */
+ try {
+ $setProto(O, V);
+ } catch (e) {
+ return false;
+ }
+ 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;
+ */
+};
diff --git a/node_modules/es-abstract/2020/PromiseResolve.js b/node_modules/es-abstract/2020/PromiseResolve.js
new file mode 100644
index 0000000..6474b79
--- /dev/null
+++ b/node_modules/es-abstract/2020/PromiseResolve.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBind = require('call-bind');
+
+var $resolve = GetIntrinsic('%Promise.resolve%', true);
+var $PromiseResolve = $resolve && callBind($resolve);
+
+// https://262.ecma-international.org/9.0/#sec-promise-resolve
+
+module.exports = function PromiseResolve(C, x) {
+ if (!$PromiseResolve) {
+ throw new SyntaxError('This environment does not support Promises.');
+ }
+ return $PromiseResolve(C, x);
+};
+
diff --git a/node_modules/es-abstract/2020/QuoteJSONString.js b/node_modules/es-abstract/2020/QuoteJSONString.js
new file mode 100644
index 0000000..c7ac054
--- /dev/null
+++ b/node_modules/es-abstract/2020/QuoteJSONString.js
@@ -0,0 +1,54 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+var forEach = require('../helpers/forEach');
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+
+var Type = require('./Type');
+var UnicodeEscape = require('./UnicodeEscape');
+var UTF16Encoding = require('./UTF16Encoding');
+var UTF16DecodeString = require('./UTF16DecodeString');
+
+var has = require('has');
+
+// https://262.ecma-international.org/11.0/#sec-quotejsonstring
+
+var escapes = {
+ '\u0008': '\\b',
+ '\u0009': '\\t',
+ '\u000A': '\\n',
+ '\u000C': '\\f',
+ '\u000D': '\\r',
+ '\u0022': '\\"',
+ '\u005c': '\\\\'
+};
+
+module.exports = function QuoteJSONString(value) {
+ if (Type(value) !== 'String') {
+ throw new $TypeError('Assertion failed: `value` must be a String');
+ }
+ var product = '"';
+ if (value) {
+ forEach(UTF16DecodeString(value), function (C) {
+ if (has(escapes, C)) {
+ product += escapes[C];
+ } else {
+ var cCharCode = $charCodeAt(C, 0);
+ if (cCharCode < 0x20 || isLeadingSurrogate(C) || isTrailingSurrogate(C)) {
+ product += UnicodeEscape(C);
+ } else {
+ product += UTF16Encoding(cCharCode);
+ }
+ }
+ });
+ }
+ product += '"';
+ return product;
+};
diff --git a/node_modules/es-abstract/2020/RegExpCreate.js b/node_modules/es-abstract/2020/RegExpCreate.js
new file mode 100644
index 0000000..68e3160
--- /dev/null
+++ b/node_modules/es-abstract/2020/RegExpCreate.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $RegExp = GetIntrinsic('%RegExp%');
+
+// var RegExpAlloc = require('./RegExpAlloc');
+// var RegExpInitialize = require('./RegExpInitialize');
+var ToString = require('./ToString');
+
+// https://262.ecma-international.org/6.0/#sec-regexpcreate
+
+module.exports = function RegExpCreate(P, F) {
+ // var obj = RegExpAlloc($RegExp);
+ // return RegExpInitialize(obj, P, F);
+
+ // covers spec mechanics; bypass regex brand checking
+ var pattern = typeof P === 'undefined' ? '' : ToString(P);
+ var flags = typeof F === 'undefined' ? '' : ToString(F);
+ return new $RegExp(pattern, flags);
+};
diff --git a/node_modules/es-abstract/2020/RegExpExec.js b/node_modules/es-abstract/2020/RegExpExec.js
new file mode 100644
index 0000000..29fee17
--- /dev/null
+++ b/node_modules/es-abstract/2020/RegExpExec.js
@@ -0,0 +1,32 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var regexExec = require('call-bind/callBound')('RegExp.prototype.exec');
+
+var Call = require('./Call');
+var Get = require('./Get');
+var IsCallable = require('./IsCallable');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-regexpexec
+
+module.exports = function RegExpExec(R, S) {
+ if (Type(R) !== 'Object') {
+ throw new $TypeError('Assertion failed: `R` must be an Object');
+ }
+ if (Type(S) !== 'String') {
+ throw new $TypeError('Assertion failed: `S` must be a String');
+ }
+ var exec = Get(R, 'exec');
+ if (IsCallable(exec)) {
+ var result = Call(exec, R, [S]);
+ if (result === null || Type(result) === 'Object') {
+ return result;
+ }
+ throw new $TypeError('"exec" method must return `null` or an Object');
+ }
+ return regexExec(R, S);
+};
diff --git a/node_modules/es-abstract/2020/RequireObjectCoercible.js b/node_modules/es-abstract/2020/RequireObjectCoercible.js
new file mode 100644
index 0000000..9008359
--- /dev/null
+++ b/node_modules/es-abstract/2020/RequireObjectCoercible.js
@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../5/CheckObjectCoercible');
diff --git a/node_modules/es-abstract/2020/SameValue.js b/node_modules/es-abstract/2020/SameValue.js
new file mode 100644
index 0000000..b73939b
--- /dev/null
+++ b/node_modules/es-abstract/2020/SameValue.js
@@ -0,0 +1,13 @@
+'use strict';
+
+var $isNaN = require('../helpers/isNaN');
+
+// http://262.ecma-international.org/5.1/#sec-9.12
+
+module.exports = function SameValue(x, y) {
+ if (x === y) { // 0 === -0, but they are not identical.
+ if (x === 0) { return 1 / x === 1 / y; }
+ return true;
+ }
+ return $isNaN(x) && $isNaN(y);
+};
diff --git a/node_modules/es-abstract/2020/SameValueNonNumeric.js b/node_modules/es-abstract/2020/SameValueNonNumeric.js
new file mode 100644
index 0000000..f7ef12c
--- /dev/null
+++ b/node_modules/es-abstract/2020/SameValueNonNumeric.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-samevaluenonnumeric
+
+module.exports = function SameValueNonNumeric(x, y) {
+ var xType = Type(x);
+ if (xType === 'Number' || xType === 'Bigint') {
+ throw new $TypeError('Assertion failed: SameValueNonNumeric does not accept Number or BigInt values');
+ }
+ if (xType !== Type(y)) {
+ throw new $TypeError('SameValueNonNumeric requires two non-numeric values of the same type.');
+ }
+ return SameValue(x, y);
+};
diff --git a/node_modules/es-abstract/2020/SameValueZero.js b/node_modules/es-abstract/2020/SameValueZero.js
new file mode 100644
index 0000000..bf1a148
--- /dev/null
+++ b/node_modules/es-abstract/2020/SameValueZero.js
@@ -0,0 +1,9 @@
+'use strict';
+
+var $isNaN = require('../helpers/isNaN');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-samevaluezero
+
+module.exports = function SameValueZero(x, y) {
+ return (x === y) || ($isNaN(x) && $isNaN(y));
+};
diff --git a/node_modules/es-abstract/2020/SecFromTime.js b/node_modules/es-abstract/2020/SecFromTime.js
new file mode 100644
index 0000000..fc2e445
--- /dev/null
+++ b/node_modules/es-abstract/2020/SecFromTime.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+var timeConstants = require('../helpers/timeConstants');
+var msPerSecond = timeConstants.msPerSecond;
+var SecondsPerMinute = timeConstants.SecondsPerMinute;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.10
+
+module.exports = function SecFromTime(t) {
+ return modulo(floor(t / msPerSecond), SecondsPerMinute);
+};
diff --git a/node_modules/es-abstract/2020/Set.js b/node_modules/es-abstract/2020/Set.js
new file mode 100644
index 0000000..ea49e81
--- /dev/null
+++ b/node_modules/es-abstract/2020/Set.js
@@ -0,0 +1,47 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// IE 9 does not throw in strict mode when writability/configurability/extensibility is violated
+var noThrowOnStrictViolation = (function () {
+ try {
+ delete [].length;
+ return true;
+ } catch (e) {
+ return false;
+ }
+}());
+
+// https://ecma-international.org/ecma-262/6.0/#sec-set-o-p-v-throw
+
+module.exports = function Set(O, P, V, Throw) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: `O` must be an Object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: `P` must be a Property Key');
+ }
+ if (Type(Throw) !== 'Boolean') {
+ throw new $TypeError('Assertion failed: `Throw` must be a Boolean');
+ }
+ if (Throw) {
+ O[P] = V; // eslint-disable-line no-param-reassign
+ if (noThrowOnStrictViolation && !SameValue(O[P], V)) {
+ 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;
+ }
+ }
+};
diff --git a/node_modules/es-abstract/2020/SetFunctionLength.js b/node_modules/es-abstract/2020/SetFunctionLength.js
new file mode 100644
index 0000000..a471b0c
--- /dev/null
+++ b/node_modules/es-abstract/2020/SetFunctionLength.js
@@ -0,0 +1,31 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var HasOwnProperty = require('./HasOwnProperty');
+var IsExtensible = require('./IsExtensible');
+var IsNonNegativeInteger = require('./IsNonNegativeInteger');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-setfunctionlength
+
+module.exports = function SetFunctionLength(F, length) {
+ if (typeof F !== 'function' || !IsExtensible(F) || HasOwnProperty(F, 'length')) {
+ throw new $TypeError('Assertion failed: `F` must be an extensible function and lack an own `length` property');
+ }
+ if (Type(length) !== 'Number') {
+ throw new $TypeError('Assertion failed: `length` must be a Number');
+ }
+ if (!IsNonNegativeInteger(length)) {
+ throw new $TypeError('Assertion failed: `length` must be an integer >= 0');
+ }
+ return DefinePropertyOrThrow(F, 'length', {
+ '[[Configurable]]': true,
+ '[[Enumerable]]': false,
+ '[[Value]]': length,
+ '[[Writable]]': false
+ });
+};
diff --git a/node_modules/es-abstract/2020/SetFunctionName.js b/node_modules/es-abstract/2020/SetFunctionName.js
new file mode 100644
index 0000000..f59cb7b
--- /dev/null
+++ b/node_modules/es-abstract/2020/SetFunctionName.js
@@ -0,0 +1,44 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var has = require('has');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var getSymbolDescription = require('../helpers/getSymbolDescription');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var IsExtensible = require('./IsExtensible');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-setfunctionname
+
+module.exports = function SetFunctionName(F, name) {
+ if (typeof F !== 'function') {
+ throw new $TypeError('Assertion failed: `F` must be a function');
+ }
+ if (!IsExtensible(F) || has(F, 'name')) {
+ throw new $TypeError('Assertion failed: `F` must be extensible, and must not have a `name` own property');
+ }
+ var nameType = Type(name);
+ if (nameType !== 'Symbol' && nameType !== 'String') {
+ throw new $TypeError('Assertion failed: `name` must be a Symbol or a String');
+ }
+ if (nameType === 'Symbol') {
+ var description = getSymbolDescription(name);
+ // eslint-disable-next-line no-param-reassign
+ name = typeof description === 'undefined' ? '' : '[' + description + ']';
+ }
+ if (arguments.length > 2) {
+ var prefix = arguments[2];
+ // eslint-disable-next-line no-param-reassign
+ name = prefix + ' ' + name;
+ }
+ return DefinePropertyOrThrow(F, 'name', {
+ '[[Value]]': name,
+ '[[Writable]]': false,
+ '[[Enumerable]]': false,
+ '[[Configurable]]': true
+ });
+};
diff --git a/node_modules/es-abstract/2020/SetIntegrityLevel.js b/node_modules/es-abstract/2020/SetIntegrityLevel.js
new file mode 100644
index 0000000..1ac7d61
--- /dev/null
+++ b/node_modules/es-abstract/2020/SetIntegrityLevel.js
@@ -0,0 +1,57 @@
+'use strict';
+
+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 forEach = require('../helpers/forEach');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-setintegritylevel
+
+module.exports = function SetIntegrityLevel(O, level) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ if (level !== 'sealed' && level !== 'frozen') {
+ throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`');
+ }
+ if (!$preventExtensions) {
+ throw new $SyntaxError('SetIntegrityLevel requires native `Object.preventExtensions` support');
+ }
+ var status = $preventExtensions(O);
+ if (!status) {
+ return false;
+ }
+ if (!$gOPN) {
+ throw new $SyntaxError('SetIntegrityLevel requires native `Object.getOwnPropertyNames` support');
+ }
+ var theKeys = $gOPN(O);
+ if (level === 'sealed') {
+ forEach(theKeys, function (k) {
+ DefinePropertyOrThrow(O, k, { configurable: false });
+ });
+ } else if (level === 'frozen') {
+ forEach(theKeys, function (k) {
+ var currentDesc = $gOPD(O, k);
+ if (typeof currentDesc !== 'undefined') {
+ var desc;
+ if (IsAccessorDescriptor(ToPropertyDescriptor(currentDesc))) {
+ desc = { configurable: false };
+ } else {
+ desc = { configurable: false, writable: false };
+ }
+ DefinePropertyOrThrow(O, k, desc);
+ }
+ });
+ }
+ return true;
+};
diff --git a/node_modules/es-abstract/2020/SpeciesConstructor.js b/node_modules/es-abstract/2020/SpeciesConstructor.js
new file mode 100644
index 0000000..491eb9b
--- /dev/null
+++ b/node_modules/es-abstract/2020/SpeciesConstructor.js
@@ -0,0 +1,32 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $species = GetIntrinsic('%Symbol.species%', true);
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsConstructor = require('./IsConstructor');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-speciesconstructor
+
+module.exports = function SpeciesConstructor(O, defaultConstructor) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ var C = O.constructor;
+ if (typeof C === 'undefined') {
+ return defaultConstructor;
+ }
+ if (Type(C) !== 'Object') {
+ throw new $TypeError('O.constructor is not an Object');
+ }
+ var S = $species ? C[$species] : void 0;
+ if (S == null) {
+ return defaultConstructor;
+ }
+ if (IsConstructor(S)) {
+ return S;
+ }
+ throw new $TypeError('no constructor found');
+};
diff --git a/node_modules/es-abstract/2020/SplitMatch.js b/node_modules/es-abstract/2020/SplitMatch.js
new file mode 100644
index 0000000..8ab0535
--- /dev/null
+++ b/node_modules/es-abstract/2020/SplitMatch.js
@@ -0,0 +1,38 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsInteger = require('./IsInteger');
+var Type = require('./Type');
+
+var $charAt = callBound('String.prototype.charAt');
+
+// https://262.ecma-international.org/6.0/#sec-splitmatch
+
+module.exports = function SplitMatch(S, q, R) {
+ if (Type(S) !== 'String') {
+ throw new $TypeError('Assertion failed: `S` must be a String');
+ }
+ if (!IsInteger(q)) {
+ throw new $TypeError('Assertion failed: `q` must be an integer');
+ }
+ if (Type(R) !== 'String') {
+ throw new $TypeError('Assertion failed: `R` must be a String');
+ }
+ var r = R.length;
+ var s = S.length;
+ if (q + r > s) {
+ return false;
+ }
+
+ for (var i = 0; i < r; i += 1) {
+ if ($charAt(S, q + i) !== $charAt(R, i)) {
+ return false;
+ }
+ }
+
+ return q + r;
+};
diff --git a/node_modules/es-abstract/2020/StrictEqualityComparison.js b/node_modules/es-abstract/2020/StrictEqualityComparison.js
new file mode 100644
index 0000000..f3435ba
--- /dev/null
+++ b/node_modules/es-abstract/2020/StrictEqualityComparison.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/5.1/#sec-11.9.6
+
+module.exports = function StrictEqualityComparison(x, y) {
+ var xType = Type(x);
+ var yType = Type(y);
+ if (xType !== yType) {
+ return false;
+ }
+ if (xType === 'Undefined' || xType === 'Null') {
+ return true;
+ }
+ return x === y; // shortcut for steps 4-7
+};
diff --git a/node_modules/es-abstract/2020/StringCreate.js b/node_modules/es-abstract/2020/StringCreate.js
new file mode 100644
index 0000000..da0c0ea
--- /dev/null
+++ b/node_modules/es-abstract/2020/StringCreate.js
@@ -0,0 +1,40 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Object = GetIntrinsic('%Object%');
+var $StringPrototype = GetIntrinsic('%String.prototype%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var Type = require('./Type');
+
+var setProto = require('../helpers/setProto');
+
+// https://262.ecma-international.org/6.0/#sec-stringcreate
+
+module.exports = function StringCreate(value, prototype) {
+ if (Type(value) !== 'String') {
+ throw new $TypeError('Assertion failed: `S` must be a String');
+ }
+
+ var S = $Object(value);
+ if (S !== $StringPrototype) {
+ if (setProto) {
+ setProto(S, prototype);
+ } else {
+ throw new $SyntaxError('StringCreate: a `proto` argument that is not `String.prototype` is not supported in an environment that does not support setting the [[Prototype]]');
+ }
+ }
+
+ var length = value.length;
+ DefinePropertyOrThrow(S, 'length', {
+ '[[Configurable]]': false,
+ '[[Enumerable]]': false,
+ '[[Value]]': length,
+ '[[Writable]]': false
+ });
+
+ return S;
+};
diff --git a/node_modules/es-abstract/2020/StringGetOwnProperty.js b/node_modules/es-abstract/2020/StringGetOwnProperty.js
new file mode 100644
index 0000000..b6f904e
--- /dev/null
+++ b/node_modules/es-abstract/2020/StringGetOwnProperty.js
@@ -0,0 +1,48 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+var $charAt = callBound('String.prototype.charAt');
+var $stringToString = callBound('String.prototype.toString');
+
+var CanonicalNumericIndexString = require('./CanonicalNumericIndexString');
+var IsInteger = require('./IsInteger');
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+var isNegativeZero = require('is-negative-zero');
+
+// https://262.ecma-international.org/8.0/#sec-stringgetownproperty
+
+module.exports = function StringGetOwnProperty(S, P) {
+ var str;
+ if (Type(S) === 'Object') {
+ try {
+ str = $stringToString(S);
+ } catch (e) { /**/ }
+ }
+ if (Type(str) !== 'String') {
+ throw new $TypeError('Assertion failed: `S` must be a boxed string object');
+ }
+ if (!IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+ }
+ if (Type(P) !== 'String') {
+ return void undefined;
+ }
+ var index = CanonicalNumericIndexString(P);
+ var len = str.length;
+ if (typeof index === 'undefined' || !IsInteger(index) || isNegativeZero(index) || index < 0 || len <= index) {
+ return void undefined;
+ }
+ var resultStr = $charAt(S, index);
+ return {
+ '[[Configurable]]': false,
+ '[[Enumerable]]': true,
+ '[[Value]]': resultStr,
+ '[[Writable]]': false
+ };
+};
diff --git a/node_modules/es-abstract/2020/StringPad.js b/node_modules/es-abstract/2020/StringPad.js
new file mode 100644
index 0000000..cdf6900
--- /dev/null
+++ b/node_modules/es-abstract/2020/StringPad.js
@@ -0,0 +1,43 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var ToLength = require('./ToLength');
+var ToString = require('./ToString');
+
+var $strSlice = callBound('String.prototype.slice');
+
+// https://262.ecma-international.org/11.0/#sec-stringpad
+
+module.exports = function StringPad(O, maxLength, fillString, placement) {
+ if (placement !== 'start' && placement !== 'end') {
+ throw new $TypeError('Assertion failed: `placement` must be "start" or "end"');
+ }
+ var S = ToString(O);
+ var intMaxLength = ToLength(maxLength);
+ var stringLength = S.length;
+ if (intMaxLength <= stringLength) {
+ return S;
+ }
+ var filler = typeof fillString === 'undefined' ? ' ' : ToString(fillString);
+ if (filler === '') {
+ return S;
+ }
+ var fillLen = intMaxLength - stringLength;
+
+ // the String value consisting of repeated concatenations of filler truncated to length fillLen.
+ var truncatedStringFiller = '';
+ while (truncatedStringFiller.length < fillLen) {
+ truncatedStringFiller += filler;
+ }
+ truncatedStringFiller = $strSlice(truncatedStringFiller, 0, fillLen);
+
+ if (placement === 'start') {
+ return truncatedStringFiller + S;
+ }
+ return S + truncatedStringFiller;
+};
diff --git a/node_modules/es-abstract/2020/SymbolDescriptiveString.js b/node_modules/es-abstract/2020/SymbolDescriptiveString.js
new file mode 100644
index 0000000..1efd131
--- /dev/null
+++ b/node_modules/es-abstract/2020/SymbolDescriptiveString.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $SymbolToString = callBound('Symbol.prototype.toString', true);
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-symboldescriptivestring
+
+module.exports = function SymbolDescriptiveString(sym) {
+ if (Type(sym) !== 'Symbol') {
+ throw new $TypeError('Assertion failed: `sym` must be a Symbol');
+ }
+ return $SymbolToString(sym);
+};
diff --git a/node_modules/es-abstract/2020/TestIntegrityLevel.js b/node_modules/es-abstract/2020/TestIntegrityLevel.js
new file mode 100644
index 0000000..cf1649c
--- /dev/null
+++ b/node_modules/es-abstract/2020/TestIntegrityLevel.js
@@ -0,0 +1,42 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $gOPD = require('../helpers/getOwnPropertyDescriptor');
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var every = require('../helpers/every');
+
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsExtensible = require('./IsExtensible');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-testintegritylevel
+
+module.exports = function TestIntegrityLevel(O, level) {
+ if (Type(O) !== 'Object') {
+ throw new $TypeError('Assertion failed: Type(O) is not Object');
+ }
+ if (level !== 'sealed' && level !== 'frozen') {
+ throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`');
+ }
+ var status = IsExtensible(O);
+ if (status) {
+ return false;
+ }
+ var theKeys = $gOPN(O);
+ return theKeys.length === 0 || every(theKeys, function (k) {
+ var currentDesc = $gOPD(O, k);
+ if (typeof currentDesc !== 'undefined') {
+ if (currentDesc.configurable) {
+ return false;
+ }
+ if (level === 'frozen' && IsDataDescriptor(ToPropertyDescriptor(currentDesc)) && currentDesc.writable) {
+ return false;
+ }
+ }
+ return true;
+ });
+};
diff --git a/node_modules/es-abstract/2020/TimeClip.js b/node_modules/es-abstract/2020/TimeClip.js
new file mode 100644
index 0000000..e416cab
--- /dev/null
+++ b/node_modules/es-abstract/2020/TimeClip.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Date = GetIntrinsic('%Date%');
+var $Number = GetIntrinsic('%Number%');
+
+var $isFinite = require('../helpers/isFinite');
+
+var abs = require('./abs');
+var ToNumber = require('./ToNumber');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.14
+
+module.exports = function TimeClip(time) {
+ if (!$isFinite(time) || abs(time) > 8.64e15) {
+ return NaN;
+ }
+ return $Number(new $Date(ToNumber(time)));
+};
+
diff --git a/node_modules/es-abstract/2020/TimeFromYear.js b/node_modules/es-abstract/2020/TimeFromYear.js
new file mode 100644
index 0000000..f3518a4
--- /dev/null
+++ b/node_modules/es-abstract/2020/TimeFromYear.js
@@ -0,0 +1,11 @@
+'use strict';
+
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+var DayFromYear = require('./DayFromYear');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function TimeFromYear(y) {
+ return msPerDay * DayFromYear(y);
+};
diff --git a/node_modules/es-abstract/2020/TimeString.js b/node_modules/es-abstract/2020/TimeString.js
new file mode 100644
index 0000000..051c472
--- /dev/null
+++ b/node_modules/es-abstract/2020/TimeString.js
@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $isNaN = require('../helpers/isNaN');
+var padTimeComponent = require('../helpers/padTimeComponent');
+
+var HourFromTime = require('./HourFromTime');
+var MinFromTime = require('./MinFromTime');
+var SecFromTime = require('./SecFromTime');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/9.0/#sec-timestring
+
+module.exports = function TimeString(tv) {
+ if (Type(tv) !== 'Number' || $isNaN(tv)) {
+ throw new $TypeError('Assertion failed: `tv` must be a non-NaN Number');
+ }
+ var hour = HourFromTime(tv);
+ var minute = MinFromTime(tv);
+ var second = SecFromTime(tv);
+ return padTimeComponent(hour) + ':' + padTimeComponent(minute) + ':' + padTimeComponent(second) + '\x20GMT';
+};
diff --git a/node_modules/es-abstract/2020/TimeWithinDay.js b/node_modules/es-abstract/2020/TimeWithinDay.js
new file mode 100644
index 0000000..2bba833
--- /dev/null
+++ b/node_modules/es-abstract/2020/TimeWithinDay.js
@@ -0,0 +1,12 @@
+'use strict';
+
+var modulo = require('./modulo');
+
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.2
+
+module.exports = function TimeWithinDay(t) {
+ return modulo(t, msPerDay);
+};
+
diff --git a/node_modules/es-abstract/2020/ToBoolean.js b/node_modules/es-abstract/2020/ToBoolean.js
new file mode 100644
index 0000000..466404b
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToBoolean.js
@@ -0,0 +1,5 @@
+'use strict';
+
+// http://262.ecma-international.org/5.1/#sec-9.2
+
+module.exports = function ToBoolean(value) { return !!value; };
diff --git a/node_modules/es-abstract/2020/ToDateString.js b/node_modules/es-abstract/2020/ToDateString.js
new file mode 100644
index 0000000..e636a9b
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToDateString.js
@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $Date = GetIntrinsic('%Date%');
+
+var $isNaN = require('../helpers/isNaN');
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-todatestring
+
+module.exports = function ToDateString(tv) {
+ if (Type(tv) !== 'Number') {
+ throw new $TypeError('Assertion failed: `tv` must be a Number');
+ }
+ if ($isNaN(tv)) {
+ return 'Invalid Date';
+ }
+ return $Date(tv);
+};
diff --git a/node_modules/es-abstract/2020/ToIndex.js b/node_modules/es-abstract/2020/ToIndex.js
new file mode 100644
index 0000000..c0185d1
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToIndex.js
@@ -0,0 +1,26 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $RangeError = GetIntrinsic('%RangeError%');
+
+var ToInteger = require('./ToInteger');
+var ToLength = require('./ToLength');
+var SameValue = require('./SameValue');
+
+// https://262.ecma-international.org/12.0/#sec-toindex
+
+module.exports = function ToIndex(value) {
+ if (typeof value === 'undefined') {
+ return 0;
+ }
+ var integerIndex = ToInteger(value);
+ if (integerIndex < 0) {
+ throw new $RangeError('index must be >= 0');
+ }
+ var index = ToLength(integerIndex);
+ if (!SameValue(integerIndex, index)) {
+ throw new $RangeError('index must be >= 0 and < 2 ** 53 - 1');
+ }
+ return index;
+};
diff --git a/node_modules/es-abstract/2020/ToInt16.js b/node_modules/es-abstract/2020/ToInt16.js
new file mode 100644
index 0000000..cb8e793
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToInt16.js
@@ -0,0 +1,10 @@
+'use strict';
+
+var ToUint16 = require('./ToUint16');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toint16
+
+module.exports = function ToInt16(argument) {
+ var int16bit = ToUint16(argument);
+ return int16bit >= 0x8000 ? int16bit - 0x10000 : int16bit;
+};
diff --git a/node_modules/es-abstract/2020/ToInt32.js b/node_modules/es-abstract/2020/ToInt32.js
new file mode 100644
index 0000000..b879ccc
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToInt32.js
@@ -0,0 +1,9 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+// http://262.ecma-international.org/5.1/#sec-9.5
+
+module.exports = function ToInt32(x) {
+ return ToNumber(x) >> 0;
+};
diff --git a/node_modules/es-abstract/2020/ToInt8.js b/node_modules/es-abstract/2020/ToInt8.js
new file mode 100644
index 0000000..bc452d8
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToInt8.js
@@ -0,0 +1,10 @@
+'use strict';
+
+var ToUint8 = require('./ToUint8');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toint8
+
+module.exports = function ToInt8(argument) {
+ var int8bit = ToUint8(argument);
+ return int8bit >= 0x80 ? int8bit - 0x100 : int8bit;
+};
diff --git a/node_modules/es-abstract/2020/ToInteger.js b/node_modules/es-abstract/2020/ToInteger.js
new file mode 100644
index 0000000..9210af8
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToInteger.js
@@ -0,0 +1,15 @@
+'use strict';
+
+var ES5ToInteger = require('../5/ToInteger');
+
+var ToNumber = require('./ToNumber');
+
+// https://262.ecma-international.org/11.0/#sec-tointeger
+
+module.exports = function ToInteger(value) {
+ var number = ToNumber(value);
+ if (number !== 0) {
+ number = ES5ToInteger(number);
+ }
+ return number === 0 ? 0 : number;
+};
diff --git a/node_modules/es-abstract/2020/ToLength.js b/node_modules/es-abstract/2020/ToLength.js
new file mode 100644
index 0000000..1bef9be
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToLength.js
@@ -0,0 +1,12 @@
+'use strict';
+
+var MAX_SAFE_INTEGER = require('../helpers/maxSafeInteger');
+
+var ToInteger = require('./ToInteger');
+
+module.exports = function ToLength(argument) {
+ var len = ToInteger(argument);
+ if (len <= 0) { return 0; } // includes converting -0 to +0
+ if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; }
+ return len;
+};
diff --git a/node_modules/es-abstract/2020/ToNumber.js b/node_modules/es-abstract/2020/ToNumber.js
new file mode 100644
index 0000000..e776bb2
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToNumber.js
@@ -0,0 +1,59 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $Number = GetIntrinsic('%Number%');
+var $RegExp = GetIntrinsic('%RegExp%');
+var $parseInteger = GetIntrinsic('%parseInt%');
+
+var callBound = require('call-bind/callBound');
+var regexTester = require('../helpers/regexTester');
+var isPrimitive = require('../helpers/isPrimitive');
+
+var $strSlice = callBound('String.prototype.slice');
+var isBinary = regexTester(/^0b[01]+$/i);
+var isOctal = regexTester(/^0o[0-7]+$/i);
+var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
+var nonWS = ['\u0085', '\u200b', '\ufffe'].join('');
+var nonWSregex = new $RegExp('[' + nonWS + ']', 'g');
+var hasNonWS = regexTester(nonWSregex);
+
+// whitespace from: https://es5.github.io/#x15.5.4.20
+// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
+var ws = [
+ '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003',
+ '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028',
+ '\u2029\uFEFF'
+].join('');
+var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');
+var $replace = callBound('String.prototype.replace');
+var $trim = function (value) {
+ return $replace(value, trimRegex, '');
+};
+
+var ToPrimitive = require('./ToPrimitive');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-tonumber
+
+module.exports = function ToNumber(argument) {
+ var value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);
+ if (typeof value === 'symbol') {
+ throw new $TypeError('Cannot convert a Symbol value to a number');
+ }
+ if (typeof value === 'string') {
+ if (isBinary(value)) {
+ return ToNumber($parseInteger($strSlice(value, 2), 2));
+ } else if (isOctal(value)) {
+ 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);
+ }
+ }
+ }
+ return $Number(value);
+};
diff --git a/node_modules/es-abstract/2020/ToNumeric.js b/node_modules/es-abstract/2020/ToNumeric.js
new file mode 100644
index 0000000..c187760
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToNumeric.js
@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Number = GetIntrinsic('%Number%');
+
+var isPrimitive = require('../helpers/isPrimitive');
+
+var ToPrimitive = require('./ToPrimitive');
+var ToNumber = require('./ToNumber');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-tonumber
+
+module.exports = function ToNumeric(argument) {
+ var primValue = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);
+ if (Type(primValue) === 'BigInt') {
+ return primValue;
+ }
+ return ToNumber(primValue);
+};
diff --git a/node_modules/es-abstract/2020/ToObject.js b/node_modules/es-abstract/2020/ToObject.js
new file mode 100644
index 0000000..cb26bac
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToObject.js
@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Object = GetIntrinsic('%Object%');
+
+var RequireObjectCoercible = require('./RequireObjectCoercible');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toobject
+
+module.exports = function ToObject(value) {
+ RequireObjectCoercible(value);
+ return $Object(value);
+};
diff --git a/node_modules/es-abstract/2020/ToPrimitive.js b/node_modules/es-abstract/2020/ToPrimitive.js
new file mode 100644
index 0000000..0fbe9b8
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToPrimitive.js
@@ -0,0 +1,12 @@
+'use strict';
+
+var toPrimitive = require('es-to-primitive/es2015');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toprimitive
+
+module.exports = function ToPrimitive(input) {
+ if (arguments.length > 1) {
+ return toPrimitive(input, arguments[1]);
+ }
+ return toPrimitive(input);
+};
diff --git a/node_modules/es-abstract/2020/ToPropertyDescriptor.js b/node_modules/es-abstract/2020/ToPropertyDescriptor.js
new file mode 100644
index 0000000..53db874
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToPropertyDescriptor.js
@@ -0,0 +1,52 @@
+'use strict';
+
+var has = require('has');
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+var ToBoolean = require('./ToBoolean');
+var IsCallable = require('./IsCallable');
+
+// https://262.ecma-international.org/5.1/#sec-8.10.5
+
+module.exports = function ToPropertyDescriptor(Obj) {
+ if (Type(Obj) !== 'Object') {
+ throw new $TypeError('ToPropertyDescriptor requires an object');
+ }
+
+ var desc = {};
+ if (has(Obj, 'enumerable')) {
+ desc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);
+ }
+ if (has(Obj, 'configurable')) {
+ desc['[[Configurable]]'] = ToBoolean(Obj.configurable);
+ }
+ if (has(Obj, 'value')) {
+ desc['[[Value]]'] = Obj.value;
+ }
+ if (has(Obj, 'writable')) {
+ desc['[[Writable]]'] = ToBoolean(Obj.writable);
+ }
+ if (has(Obj, 'get')) {
+ var getter = Obj.get;
+ if (typeof getter !== 'undefined' && !IsCallable(getter)) {
+ throw new $TypeError('getter must be a function');
+ }
+ desc['[[Get]]'] = getter;
+ }
+ if (has(Obj, 'set')) {
+ var setter = Obj.set;
+ if (typeof setter !== 'undefined' && !IsCallable(setter)) {
+ throw new $TypeError('setter must be a function');
+ }
+ desc['[[Set]]'] = setter;
+ }
+
+ if ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) {
+ throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
+ }
+ return desc;
+};
diff --git a/node_modules/es-abstract/2020/ToPropertyKey.js b/node_modules/es-abstract/2020/ToPropertyKey.js
new file mode 100644
index 0000000..fc1bf7d
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToPropertyKey.js
@@ -0,0 +1,15 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+
+var ToPrimitive = require('./ToPrimitive');
+var ToString = require('./ToString');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-topropertykey
+
+module.exports = function ToPropertyKey(argument) {
+ var key = ToPrimitive(argument, $String);
+ return typeof key === 'symbol' ? key : ToString(key);
+};
diff --git a/node_modules/es-abstract/2020/ToString.js b/node_modules/es-abstract/2020/ToString.js
new file mode 100644
index 0000000..4d494e1
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToString.js
@@ -0,0 +1,15 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-tostring
+
+module.exports = function ToString(argument) {
+ if (typeof argument === 'symbol') {
+ throw new $TypeError('Cannot convert a Symbol value to a string');
+ }
+ return $String(argument);
+};
diff --git a/node_modules/es-abstract/2020/ToUint16.js b/node_modules/es-abstract/2020/ToUint16.js
new file mode 100644
index 0000000..633ca84
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToUint16.js
@@ -0,0 +1,19 @@
+'use strict';
+
+var abs = require('./abs');
+var floor = require('./floor');
+var modulo = require('./modulo');
+var ToNumber = require('./ToNumber');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var $sign = require('../helpers/sign');
+
+// http://262.ecma-international.org/5.1/#sec-9.7
+
+module.exports = function ToUint16(value) {
+ var number = ToNumber(value);
+ if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
+ var posInt = $sign(number) * floor(abs(number));
+ return modulo(posInt, 0x10000);
+};
diff --git a/node_modules/es-abstract/2020/ToUint32.js b/node_modules/es-abstract/2020/ToUint32.js
new file mode 100644
index 0000000..2a8e9dd
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToUint32.js
@@ -0,0 +1,9 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+// http://262.ecma-international.org/5.1/#sec-9.6
+
+module.exports = function ToUint32(x) {
+ return ToNumber(x) >>> 0;
+};
diff --git a/node_modules/es-abstract/2020/ToUint8.js b/node_modules/es-abstract/2020/ToUint8.js
new file mode 100644
index 0000000..2dfd97c
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToUint8.js
@@ -0,0 +1,20 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var $sign = require('../helpers/sign');
+
+var abs = require('./abs');
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-touint8
+
+module.exports = function ToUint8(argument) {
+ var number = ToNumber(argument);
+ if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
+ var posInt = $sign(number) * floor(abs(number));
+ return modulo(posInt, 0x100);
+};
diff --git a/node_modules/es-abstract/2020/ToUint8Clamp.js b/node_modules/es-abstract/2020/ToUint8Clamp.js
new file mode 100644
index 0000000..b0b8ce8
--- /dev/null
+++ b/node_modules/es-abstract/2020/ToUint8Clamp.js
@@ -0,0 +1,19 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+var floor = require('./floor');
+
+var $isNaN = require('../helpers/isNaN');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-touint8clamp
+
+module.exports = function ToUint8Clamp(argument) {
+ var number = ToNumber(argument);
+ if ($isNaN(number) || number <= 0) { return 0; }
+ if (number >= 0xFF) { return 0xFF; }
+ var f = floor(argument);
+ if (f + 0.5 < number) { return f + 1; }
+ if (number < f + 0.5) { return f; }
+ if (f % 2 !== 0) { return f + 1; }
+ return f;
+};
diff --git a/node_modules/es-abstract/2020/TrimString.js b/node_modules/es-abstract/2020/TrimString.js
new file mode 100644
index 0000000..113dcf8
--- /dev/null
+++ b/node_modules/es-abstract/2020/TrimString.js
@@ -0,0 +1,29 @@
+'use strict';
+
+var trimStart = require('string.prototype.trimstart');
+var trimEnd = require('string.prototype.trimend');
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var RequireObjectCoercible = require('./RequireObjectCoercible');
+var ToString = require('./ToString');
+
+// https://262.ecma-international.org/10.0/#sec-trimstring
+
+module.exports = function TrimString(string, where) {
+ var str = RequireObjectCoercible(string);
+ var S = ToString(str);
+ var T;
+ if (where === 'start') {
+ T = trimStart(S);
+ } else if (where === 'end') {
+ T = trimEnd(S);
+ } else if (where === 'start+end') {
+ T = trimStart(trimEnd(S));
+ } else {
+ throw new $TypeError('Assertion failed: invalid `where` value; must be "start", "end", or "start+end"');
+ }
+ return T;
+};
diff --git a/node_modules/es-abstract/2020/Type.js b/node_modules/es-abstract/2020/Type.js
new file mode 100644
index 0000000..555ca74
--- /dev/null
+++ b/node_modules/es-abstract/2020/Type.js
@@ -0,0 +1,15 @@
+'use strict';
+
+var ES5Type = require('../5/Type');
+
+// https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values
+
+module.exports = function Type(x) {
+ if (typeof x === 'symbol') {
+ return 'Symbol';
+ }
+ if (typeof x === 'bigint') {
+ return 'BigInt';
+ }
+ return ES5Type(x);
+};
diff --git a/node_modules/es-abstract/2020/UTF16DecodeString.js b/node_modules/es-abstract/2020/UTF16DecodeString.js
new file mode 100644
index 0000000..8e27a21
--- /dev/null
+++ b/node_modules/es-abstract/2020/UTF16DecodeString.js
@@ -0,0 +1,29 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $push = callBound('Array.prototype.push');
+
+var CodePointAt = require('./CodePointAt');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-utf16decodestring
+
+module.exports = function UTF16DecodeString(string) {
+ if (Type(string) !== 'String') {
+ throw new $TypeError('Assertion failed: `string` must be a String');
+ }
+ var codePoints = [];
+ var size = string.length;
+ var position = 0;
+ while (position < size) {
+ var cp = CodePointAt(string, position);
+ $push(codePoints, cp['[[CodePoint]]']);
+ position += cp['[[CodeUnitCount]]'];
+ }
+ return codePoints;
+};
diff --git a/node_modules/es-abstract/2020/UTF16DecodeSurrogatePair.js b/node_modules/es-abstract/2020/UTF16DecodeSurrogatePair.js
new file mode 100644
index 0000000..2632e65
--- /dev/null
+++ b/node_modules/es-abstract/2020/UTF16DecodeSurrogatePair.js
@@ -0,0 +1,19 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+// https://262.ecma-international.org/11.0/#sec-utf16decodesurrogatepair
+
+module.exports = function UTF16DecodeSurrogatePair(lead, trail) {
+ if (!isLeadingSurrogate(lead) || !isTrailingSurrogate(trail)) {
+ throw new $TypeError('Assertion failed: `lead` must be a leading surrogate char code, and `trail` must be a trailing surrogate char code');
+ }
+ // var cp = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+ return $fromCharCode(lead) + $fromCharCode(trail);
+};
diff --git a/node_modules/es-abstract/2020/UTF16Encoding.js b/node_modules/es-abstract/2020/UTF16Encoding.js
new file mode 100644
index 0000000..f381595
--- /dev/null
+++ b/node_modules/es-abstract/2020/UTF16Encoding.js
@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+var isCodePoint = require('../helpers/isCodePoint');
+
+// https://262.ecma-international.org/7.0/#sec-utf16encoding
+
+module.exports = function UTF16Encoding(cp) {
+ if (!isCodePoint(cp)) {
+ throw new $TypeError('Assertion failed: `cp` must be >= 0 and <= 0x10FFFF');
+ }
+ if (cp <= 65535) {
+ return $fromCharCode(cp);
+ }
+ var cu1 = floor((cp - 65536) / 1024) + 0xD800;
+ var cu2 = modulo(cp - 65536, 1024) + 0xDC00;
+ return $fromCharCode(cu1) + $fromCharCode(cu2);
+};
diff --git a/node_modules/es-abstract/2020/UnicodeEscape.js b/node_modules/es-abstract/2020/UnicodeEscape.js
new file mode 100644
index 0000000..b708c90
--- /dev/null
+++ b/node_modules/es-abstract/2020/UnicodeEscape.js
@@ -0,0 +1,27 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+var $numberToString = callBound('Number.prototype.toString');
+var $toLowerCase = callBound('String.prototype.toLowerCase');
+
+var StringPad = require('./StringPad');
+
+// https://262.ecma-international.org/11.0/#sec-unicodeescape
+
+module.exports = function UnicodeEscape(C) {
+ if (typeof C !== 'string' || C.length !== 1) {
+ throw new $TypeError('Assertion failed: `C` must be a single code unit');
+ }
+ var n = $charCodeAt(C, 0);
+ if (n > 0xFFFF) {
+ throw new $TypeError('`Assertion failed: numeric value of `C` must be <= 0xFFFF');
+ }
+
+ return '\\u' + StringPad($toLowerCase($numberToString(n, 16)), 4, '0', 'start');
+};
diff --git a/node_modules/es-abstract/2020/ValidateAndApplyPropertyDescriptor.js b/node_modules/es-abstract/2020/ValidateAndApplyPropertyDescriptor.js
new file mode 100644
index 0000000..a7fd218
--- /dev/null
+++ b/node_modules/es-abstract/2020/ValidateAndApplyPropertyDescriptor.js
@@ -0,0 +1,170 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+var isSamePropertyDescriptor = require('../helpers/isSamePropertyDescriptor');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsGenericDescriptor = require('./IsGenericDescriptor');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-validateandapplypropertydescriptor
+// https://ecma-international.org/ecma-262/8.0/#sec-validateandapplypropertydescriptor
+
+// eslint-disable-next-line max-lines-per-function, max-statements, max-params
+module.exports = function ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current) {
+ // this uses the ES2017+ logic, since it fixes a number of bugs in the ES2015 logic.
+ var oType = Type(O);
+ if (oType !== 'Undefined' && oType !== 'Object') {
+ throw new $TypeError('Assertion failed: O must be undefined or an Object');
+ }
+ if (Type(extensible) !== 'Boolean') {
+ throw new $TypeError('Assertion failed: extensible must be a Boolean');
+ }
+ if (!isPropertyDescriptor({
+ Type: Type,
+ IsDataDescriptor: IsDataDescriptor,
+ IsAccessorDescriptor: IsAccessorDescriptor
+ }, Desc)) {
+ throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
+ }
+ if (Type(current) !== 'Undefined' && !isPropertyDescriptor({
+ Type: Type,
+ IsDataDescriptor: IsDataDescriptor,
+ IsAccessorDescriptor: IsAccessorDescriptor
+ }, current)) {
+ throw new $TypeError('Assertion failed: current must be a Property Descriptor, or undefined');
+ }
+ if (oType !== 'Undefined' && !IsPropertyKey(P)) {
+ throw new $TypeError('Assertion failed: if O is not undefined, P must be a Property Key');
+ }
+ if (Type(current) === 'Undefined') {
+ if (!extensible) {
+ return false;
+ }
+ if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) {
+ if (oType !== 'Undefined') {
+ DefineOwnProperty(
+ IsDataDescriptor,
+ SameValue,
+ FromPropertyDescriptor,
+ O,
+ P,
+ {
+ '[[Configurable]]': Desc['[[Configurable]]'],
+ '[[Enumerable]]': Desc['[[Enumerable]]'],
+ '[[Value]]': Desc['[[Value]]'],
+ '[[Writable]]': Desc['[[Writable]]']
+ }
+ );
+ }
+ } else {
+ if (!IsAccessorDescriptor(Desc)) {
+ throw new $TypeError('Assertion failed: Desc is not an accessor descriptor');
+ }
+ if (oType !== 'Undefined') {
+ return DefineOwnProperty(
+ IsDataDescriptor,
+ SameValue,
+ FromPropertyDescriptor,
+ O,
+ P,
+ Desc
+ );
+ }
+ }
+ return true;
+ }
+ if (IsGenericDescriptor(Desc) && !('[[Configurable]]' in Desc) && !('[[Enumerable]]' in Desc)) {
+ return true;
+ }
+ if (isSamePropertyDescriptor({ SameValue: SameValue }, Desc, current)) {
+ return true; // removed by ES2017, but should still be correct
+ }
+ // "if every field in Desc is absent, return true" can't really match the assertion that it's a Property Descriptor
+ if (!current['[[Configurable]]']) {
+ if (Desc['[[Configurable]]']) {
+ return false;
+ }
+ if ('[[Enumerable]]' in Desc && !Desc['[[Enumerable]]'] === !!current['[[Enumerable]]']) {
+ return false;
+ }
+ }
+ if (IsGenericDescriptor(Desc)) {
+ // no further validation is required.
+ } else if (IsDataDescriptor(current) !== IsDataDescriptor(Desc)) {
+ if (!current['[[Configurable]]']) {
+ return false;
+ }
+ if (IsDataDescriptor(current)) {
+ if (oType !== 'Undefined') {
+ DefineOwnProperty(
+ IsDataDescriptor,
+ SameValue,
+ FromPropertyDescriptor,
+ O,
+ P,
+ {
+ '[[Configurable]]': current['[[Configurable]]'],
+ '[[Enumerable]]': current['[[Enumerable]]'],
+ '[[Get]]': undefined
+ }
+ );
+ }
+ } else if (oType !== 'Undefined') {
+ DefineOwnProperty(
+ IsDataDescriptor,
+ SameValue,
+ FromPropertyDescriptor,
+ O,
+ P,
+ {
+ '[[Configurable]]': current['[[Configurable]]'],
+ '[[Enumerable]]': current['[[Enumerable]]'],
+ '[[Value]]': undefined
+ }
+ );
+ }
+ } else if (IsDataDescriptor(current) && IsDataDescriptor(Desc)) {
+ if (!current['[[Configurable]]'] && !current['[[Writable]]']) {
+ if ('[[Writable]]' in Desc && Desc['[[Writable]]']) {
+ return false;
+ }
+ if ('[[Value]]' in Desc && !SameValue(Desc['[[Value]]'], current['[[Value]]'])) {
+ return false;
+ }
+ return true;
+ }
+ } else if (IsAccessorDescriptor(current) && IsAccessorDescriptor(Desc)) {
+ if (!current['[[Configurable]]']) {
+ if ('[[Set]]' in Desc && !SameValue(Desc['[[Set]]'], current['[[Set]]'])) {
+ return false;
+ }
+ if ('[[Get]]' in Desc && !SameValue(Desc['[[Get]]'], current['[[Get]]'])) {
+ return false;
+ }
+ return true;
+ }
+ } else {
+ throw new $TypeError('Assertion failed: current and Desc are not both data, both accessors, or one accessor and one data.');
+ }
+ if (oType !== 'Undefined') {
+ return DefineOwnProperty(
+ IsDataDescriptor,
+ SameValue,
+ FromPropertyDescriptor,
+ O,
+ P,
+ Desc
+ );
+ }
+ return true;
+};
diff --git a/node_modules/es-abstract/2020/WeekDay.js b/node_modules/es-abstract/2020/WeekDay.js
new file mode 100644
index 0000000..17cf94c
--- /dev/null
+++ b/node_modules/es-abstract/2020/WeekDay.js
@@ -0,0 +1,10 @@
+'use strict';
+
+var Day = require('./Day');
+var modulo = require('./modulo');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.6
+
+module.exports = function WeekDay(t) {
+ return modulo(Day(t) + 4, 7);
+};
diff --git a/node_modules/es-abstract/2020/YearFromTime.js b/node_modules/es-abstract/2020/YearFromTime.js
new file mode 100644
index 0000000..be06ecb
--- /dev/null
+++ b/node_modules/es-abstract/2020/YearFromTime.js
@@ -0,0 +1,16 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Date = GetIntrinsic('%Date%');
+
+var callBound = require('call-bind/callBound');
+
+var $getUTCFullYear = callBound('Date.prototype.getUTCFullYear');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function YearFromTime(t) {
+ // largest y such that this.TimeFromYear(y) <= t
+ return $getUTCFullYear(new $Date(t));
+};
diff --git a/node_modules/es-abstract/2020/abs.js b/node_modules/es-abstract/2020/abs.js
new file mode 100644
index 0000000..8bc4543
--- /dev/null
+++ b/node_modules/es-abstract/2020/abs.js
@@ -0,0 +1,11 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $abs = GetIntrinsic('%Math.abs%');
+
+// http://262.ecma-international.org/5.1/#sec-5.2
+
+module.exports = function abs(x) {
+ return $abs(x);
+};
diff --git a/node_modules/es-abstract/2020/floor.js b/node_modules/es-abstract/2020/floor.js
new file mode 100644
index 0000000..8439df0
--- /dev/null
+++ b/node_modules/es-abstract/2020/floor.js
@@ -0,0 +1,11 @@
+'use strict';
+
+// var modulo = require('./modulo');
+var $floor = Math.floor;
+
+// http://262.ecma-international.org/5.1/#sec-5.2
+
+module.exports = function floor(x) {
+ // return x - modulo(x, 1);
+ return $floor(x);
+};
diff --git a/node_modules/es-abstract/2020/modulo.js b/node_modules/es-abstract/2020/modulo.js
new file mode 100644
index 0000000..b94bb52
--- /dev/null
+++ b/node_modules/es-abstract/2020/modulo.js
@@ -0,0 +1,9 @@
+'use strict';
+
+var mod = require('../helpers/mod');
+
+// https://262.ecma-international.org/5.1/#sec-5.2
+
+module.exports = function modulo(x, y) {
+ return mod(x, y);
+};
diff --git a/node_modules/es-abstract/2020/msFromTime.js b/node_modules/es-abstract/2020/msFromTime.js
new file mode 100644
index 0000000..a6bae76
--- /dev/null
+++ b/node_modules/es-abstract/2020/msFromTime.js
@@ -0,0 +1,11 @@
+'use strict';
+
+var modulo = require('./modulo');
+
+var msPerSecond = require('../helpers/timeConstants').msPerSecond;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.10
+
+module.exports = function msFromTime(t) {
+ return modulo(t, msPerSecond);
+};
diff --git a/node_modules/es-abstract/2020/thisBigIntValue.js b/node_modules/es-abstract/2020/thisBigIntValue.js
new file mode 100644
index 0000000..1fd1298
--- /dev/null
+++ b/node_modules/es-abstract/2020/thisBigIntValue.js
@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $bigIntValueOf = callBound('BigInt.prototype.valueOf', true);
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-thisbigintvalue
+
+module.exports = function thisBigIntValue(value) {
+ var type = Type(value);
+ if (type === 'BigInt') {
+ return value;
+ }
+ if (!$bigIntValueOf) {
+ throw new $TypeError('BigInt is not supported');
+ }
+ return $bigIntValueOf(value);
+};
diff --git a/node_modules/es-abstract/2020/thisBooleanValue.js b/node_modules/es-abstract/2020/thisBooleanValue.js
new file mode 100644
index 0000000..27075b9
--- /dev/null
+++ b/node_modules/es-abstract/2020/thisBooleanValue.js
@@ -0,0 +1,15 @@
+'use strict';
+
+var $BooleanValueOf = require('call-bind/callBound')('Boolean.prototype.valueOf');
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-boolean-prototype-object
+
+module.exports = function thisBooleanValue(value) {
+ if (Type(value) === 'Boolean') {
+ return value;
+ }
+
+ return $BooleanValueOf(value);
+};
diff --git a/node_modules/es-abstract/2020/thisNumberValue.js b/node_modules/es-abstract/2020/thisNumberValue.js
new file mode 100644
index 0000000..92968dc
--- /dev/null
+++ b/node_modules/es-abstract/2020/thisNumberValue.js
@@ -0,0 +1,18 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+
+var Type = require('./Type');
+
+var $NumberValueOf = callBound('Number.prototype.valueOf');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-number-prototype-object
+
+module.exports = function thisNumberValue(value) {
+ if (Type(value) === 'Number') {
+ return value;
+ }
+
+ return $NumberValueOf(value);
+};
+
diff --git a/node_modules/es-abstract/2020/thisStringValue.js b/node_modules/es-abstract/2020/thisStringValue.js
new file mode 100644
index 0000000..8e4274d
--- /dev/null
+++ b/node_modules/es-abstract/2020/thisStringValue.js
@@ -0,0 +1,15 @@
+'use strict';
+
+var $StringValueOf = require('call-bind/callBound')('String.prototype.valueOf');
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-string-prototype-object
+
+module.exports = function thisStringValue(value) {
+ if (Type(value) === 'String') {
+ return value;
+ }
+
+ return $StringValueOf(value);
+};
diff --git a/node_modules/es-abstract/2020/thisSymbolValue.js b/node_modules/es-abstract/2020/thisSymbolValue.js
new file mode 100644
index 0000000..91a5525
--- /dev/null
+++ b/node_modules/es-abstract/2020/thisSymbolValue.js
@@ -0,0 +1,19 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+
+var $SymbolValueOf = callBound('Symbol.prototype.valueOf', true);
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/9.0/#sec-thissymbolvalue
+
+module.exports = function thisSymbolValue(value) {
+ if (!$SymbolValueOf) {
+ throw new SyntaxError('Symbols are not supported; thisSymbolValue requires that `value` be a Symbol or a Symbol object');
+ }
+ if (Type(value) === 'Symbol') {
+ return value;
+ }
+ return $SymbolValueOf(value);
+};
diff --git a/node_modules/es-abstract/2020/thisTimeValue.js b/node_modules/es-abstract/2020/thisTimeValue.js
new file mode 100644
index 0000000..a9a47ac
--- /dev/null
+++ b/node_modules/es-abstract/2020/thisTimeValue.js
@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../2018/thisTimeValue');