Upload folder using huggingface_hub (part 31)

tools/ui/node_modules/es-abstract/2019/thisSymbolValue.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var $SyntaxError = require('es-errors/syntax');
+var callBound = require('call-bound');
+
+var $SymbolValueOf = callBound('Symbol.prototype.valueOf', true);
+
+// https://262.ecma-international.org/9.0/#sec-thissymbolvalue
+
+module.exports = function thisSymbolValue(value) {
+	if (typeof value === 'symbol') {
+		return value;
+	}
+
+	if (!$SymbolValueOf) {
+		throw new $SyntaxError('Symbols are not supported; thisSymbolValue requires that `value` be a Symbol or a Symbol object');
+	}
+
+	return $SymbolValueOf(value);
+};

tools/ui/node_modules/es-abstract/2019/thisTimeValue.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var timeValue = require('../helpers/timeValue');
+
+// https://262.ecma-international.org/6.0/#sec-properties-of-the-date-prototype-object
+
+module.exports = function thisTimeValue(value) {
+	return timeValue(value);
+};

tools/ui/node_modules/es-abstract/2020/AbstractEqualityComparison.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var StrictEqualityComparison = require('./StrictEqualityComparison');
+var StringToBigInt = require('./StringToBigInt');
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+
+var isNaN = require('math-intrinsics/isNaN');
+var isObject = require('es-object-atoms/isObject');
+var isSameType = require('../helpers/isSameType');
+
+// https://262.ecma-international.org/11.0/#sec-abstract-equality-comparison
+
+module.exports = function AbstractEqualityComparison(x, y) {
+	if (isSameType(x, y)) {
+		return StrictEqualityComparison(x, y);
+	}
+	if (x == null && y == null) {
+		return true;
+	}
+	if (typeof x === 'number' && typeof y === 'string') {
+		return AbstractEqualityComparison(x, ToNumber(y));
+	}
+	if (typeof x === 'string' && typeof y === 'number') {
+		return AbstractEqualityComparison(ToNumber(x), y);
+	}
+	if (typeof x === 'bigint' && typeof y === 'string') {
+		var n = StringToBigInt(y);
+		if (isNaN(n)) {
+			return false;
+		}
+		return AbstractEqualityComparison(x, n);
+	}
+	if (typeof x === 'string' && typeof y === 'bigint') {
+		return AbstractEqualityComparison(y, x);
+	}
+	if (typeof x === 'boolean') {
+		return AbstractEqualityComparison(ToNumber(x), y);
+	}
+	if (typeof y === 'boolean') {
+		return AbstractEqualityComparison(x, ToNumber(y));
+	}
+	if ((typeof x === 'string' || typeof x === 'number' || typeof x === 'bigint' || typeof x === 'symbol') && isObject(y)) {
+		return AbstractEqualityComparison(x, ToPrimitive(y));
+	}
+	if (isObject(x) && (typeof y === 'string' || typeof y === 'number' || typeof y === 'bigint' || typeof y === 'symbol')) {
+		return AbstractEqualityComparison(ToPrimitive(x), y);
+	}
+	if ((typeof x === 'bigint' && typeof y === 'number') || (typeof x === 'number' && typeof y === 'bigint')) {
+		if (isNaN(x) || isNaN(y) || x === Infinity || y === Infinity || x === -Infinity || y === -Infinity) {
+			return false;
+		}
+		return x == y; // eslint-disable-line eqeqeq
+	}
+	return false;
+};

tools/ui/node_modules/es-abstract/2020/AbstractRelationalComparison.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Number = GetIntrinsic('%Number%');
+var $TypeError = require('es-errors/type');
+
+var $isNaN = require('math-intrinsics/isNaN');
+
+var IsStringPrefix = require('./IsStringPrefix');
+var StringToBigInt = require('./StringToBigInt');
+var ToNumeric = require('./ToNumeric');
+var ToPrimitive = require('./ToPrimitive');
+
+var BigIntLessThan = require('./BigInt/lessThan');
+var NumberLessThan = require('./Number/lessThan');
+
+var isSameType = require('../helpers/isSameType');
+
+// https://262.ecma-international.org/11.0/#sec-abstract-relational-comparison
+
+// eslint-disable-next-line max-statements, max-lines-per-function
+module.exports = function AbstractRelationalComparison(x, y, LeftFirst) {
+	if (typeof 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);
+	}
+	if (typeof px === 'string' && typeof py === 'string') {
+		if (IsStringPrefix(py, px)) {
+			return false;
+		}
+		if (IsStringPrefix(px, py)) {
+			return true;
+		}
+		return px < py; // both strings, neither a prefix of the other. shortcut for steps 3 c-f
+	}
+
+	var nx;
+	var ny;
+	if (typeof px === 'bigint' && typeof py === 'string') {
+		ny = StringToBigInt(py);
+		if ($isNaN(ny)) {
+			return void undefined;
+		}
+		return BigIntLessThan(px, ny);
+	}
+	if (typeof px === 'string' && typeof py === 'bigint') {
+		nx = StringToBigInt(px);
+		if ($isNaN(nx)) {
+			return void undefined;
+		}
+		return BigIntLessThan(nx, py);
+	}
+
+	nx = ToNumeric(px);
+	ny = ToNumeric(py);
+	if (isSameType(nx, ny)) {
+		return typeof nx === 'number' ? NumberLessThan(nx, ny) : BigIntLessThan(nx, ny);
+	}
+
+	if ($isNaN(nx) || $isNaN(ny)) {
+		return void undefined;
+	}
+	if (nx === -Infinity || ny === Infinity) {
+		return true;
+	}
+	if (nx === Infinity || ny === -Infinity) {
+		return false;
+	}
+
+	return nx < ny; // by now, these are both nonzero, finite, and not equal
+};

tools/ui/node_modules/es-abstract/2020/AddEntriesFromIterable.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+var inspect = require('object-inspect');
+
+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 ThrowCompletion = require('./ThrowCompletion');
+
+// 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) {
+		var next = IteratorStep(iteratorRecord);
+		if (!next) {
+			return target;
+		}
+		var nextItem = IteratorValue(next);
+		if (!isObject(nextItem)) {
+			var error = ThrowCompletion(new $TypeError('iterator next must return an Object, got ' + inspect(nextItem)));
+			return IteratorClose(iteratorRecord, error);
+		}
+		try {
+			var k = Get(nextItem, '0');
+			var v = Get(nextItem, '1');
+			Call(adder, target, [k, v]);
+		} catch (e) {
+			return IteratorClose(iteratorRecord, ThrowCompletion(e));
+		}
+	}
+};

tools/ui/node_modules/es-abstract/2020/AdvanceStringIndex.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var CodePointAt = require('./CodePointAt');
+
+var $TypeError = require('es-errors/type');
+var isInteger = require('math-intrinsics/isInteger');
+var MAX_SAFE_INTEGER = require('math-intrinsics/constants/maxSafeInteger');
+
+// https://262.ecma-international.org/11.0/#sec-advancestringindex
+
+module.exports = function AdvanceStringIndex(S, index, unicode) {
+	if (typeof 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 (typeof 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]]'];
+};

tools/ui/node_modules/es-abstract/2020/ArrayCreate.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $ArrayPrototype = GetIntrinsic('%Array.prototype%');
+var $RangeError = require('es-errors/range');
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var isInteger = require('math-intrinsics/isInteger');
+var MAX_ARRAY_LENGTH = require('math-intrinsics/constants/maxArrayLength');
+var $setProto = require('set-proto');
+
+// https://262.ecma-international.org/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;
+};

tools/ui/node_modules/es-abstract/2020/ArraySetLength.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var $RangeError = require('es-errors/range');
+var $TypeError = require('es-errors/type');
+
+var assign = require('object.assign');
+
+var isPropertyDescriptor = require('../helpers/records/property-descriptor');
+
+var IsArray = require('./IsArray');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty');
+var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty');
+var ToNumber = require('./ToNumber');
+var ToString = require('./ToString');
+var ToUint32 = require('./ToUint32');
+
+// https://262.ecma-international.org/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(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;
+};

tools/ui/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 = require('es-errors/type');
+var isInteger = require('math-intrinsics/isInteger');
+var isObject = require('es-object-atoms/isObject');
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var IsConstructor = require('./IsConstructor');
+
+// https://262.ecma-international.org/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 && isObject(C)) {
+			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);
+};
+

tools/ui/node_modules/es-abstract/2020/AsyncFromSyncIteratorContinuation.js

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

tools/ui/node_modules/es-abstract/2020/AsyncIteratorClose.js

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

tools/ui/node_modules/es-abstract/2020/BigInt/add.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-add
+
+module.exports = function BigIntAdd(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+
+	// shortcut for the actual spec mechanics
+	return x + y;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/bitwiseAND.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var BigIntBitwiseOp = require('../BigIntBitwiseOp');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseAND
+
+module.exports = function BigIntBitwiseAND(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+	return BigIntBitwiseOp('&', x, y);
+};

tools/ui/node_modules/es-abstract/2020/BigInt/bitwiseNOT.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseNOT
+
+module.exports = function BigIntBitwiseNOT(x) {
+	if (typeof x !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` argument must be a BigInt');
+	}
+	return -x - $BigInt(1);
+};

tools/ui/node_modules/es-abstract/2020/BigInt/bitwiseOR.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var BigIntBitwiseOp = require('../BigIntBitwiseOp');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseOR
+
+module.exports = function BigIntBitwiseOR(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+	return BigIntBitwiseOp('|', x, y);
+};

tools/ui/node_modules/es-abstract/2020/BigInt/bitwiseXOR.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var BigIntBitwiseOp = require('../BigIntBitwiseOp');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-bitwiseXOR
+
+module.exports = function BigIntBitwiseXOR(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+	return BigIntBitwiseOp('^', x, y);
+};

tools/ui/node_modules/es-abstract/2020/BigInt/divide.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $RangeError = require('es-errors/range');
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-divide
+
+module.exports = function BigIntDivide(x, y) {
+	if (typeof x !== 'bigint' || typeof 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;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/equal.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-equal
+
+module.exports = function BigIntEqual(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+	// shortcut for the actual spec mechanics
+	return x === y;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/exponentiate.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $RangeError = require('es-errors/range');
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-exponentiate
+
+module.exports = function BigIntExponentiate(base, exponent) {
+	if (typeof base !== 'bigint' || typeof 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;
+};

tools/ui/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
+};

tools/ui/node_modules/es-abstract/2020/BigInt/leftShift.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-leftShift
+
+module.exports = function BigIntLeftShift(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+
+	// shortcut for the actual spec mechanics
+	return x << y;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/lessThan.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-lessThan
+
+module.exports = function BigIntLessThan(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+
+	// shortcut for the actual spec mechanics
+	return x < y;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/multiply.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-multiply
+
+module.exports = function BigIntMultiply(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+
+	// shortcut for the actual spec mechanics
+	return x * y;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/remainder.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $RangeError = require('es-errors/range');
+var $TypeError = require('es-errors/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 (typeof n !== 'bigint' || typeof 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;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/sameValue.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var BigIntEqual = require('./equal');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-sameValue
+
+module.exports = function BigIntSameValue(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+
+	return BigIntEqual(x, y);
+};

tools/ui/node_modules/es-abstract/2020/BigInt/sameValueZero.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var BigIntEqual = require('./equal');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-sameValueZero
+
+module.exports = function BigIntSameValueZero(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+
+	return BigIntEqual(x, y);
+};

tools/ui/node_modules/es-abstract/2020/BigInt/signedRightShift.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var BigIntLeftShift = require('./leftShift');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-signedRightShift
+
+module.exports = function BigIntSignedRightShift(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+
+	return BigIntLeftShift(x, -y);
+};

tools/ui/node_modules/es-abstract/2020/BigInt/subtract.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-subtract
+
+module.exports = function BigIntSubtract(x, y) {
+	if (typeof x !== 'bigint' || typeof y !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be BigInts');
+	}
+
+	// shortcut for the actual spec mechanics
+	return x - y;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/toString.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-tostring
+
+module.exports = function BigIntToString(x) {
+	if (typeof x !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` must be a BigInt');
+	}
+
+	return $String(x);
+};

tools/ui/node_modules/es-abstract/2020/BigInt/unaryMinus.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $BigInt = GetIntrinsic('%BigInt%', true);
+var $TypeError = require('es-errors/type');
+
+var zero = $BigInt && $BigInt(0);
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-unaryMinus
+
+module.exports = function BigIntUnaryMinus(x) {
+	if (typeof x !== 'bigint') {
+		throw new $TypeError('Assertion failed: `x` argument must be a BigInt');
+	}
+
+	if (x === zero) {
+		return zero;
+	}
+
+	return -x;
+};

tools/ui/node_modules/es-abstract/2020/BigInt/unsignedRightShift.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-bigint-unsignedRightShift
+
+module.exports = function BigIntUnsignedRightShift(x, y) {
+	if (typeof x !== 'bigint' || typeof 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');
+};

tools/ui/node_modules/es-abstract/2020/BigIntBitwiseOp.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+// var $BigInt = GetIntrinsic('%BigInt%', true);
+// var $pow = require('math-intrinsics/pow');
+
+// var BinaryAnd = require('./BinaryAnd');
+// var BinaryOr = require('./BinaryOr');
+// var BinaryXor = require('./BinaryXor');
+// 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 (typeof x !== 'bigint' || typeof 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;
+	*/
+};

tools/ui/node_modules/es-abstract/2020/BinaryAnd.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// 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;
+};

tools/ui/node_modules/es-abstract/2020/BinaryOr.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// 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;
+};

tools/ui/node_modules/es-abstract/2020/BinaryXor.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// 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;
+};

tools/ui/node_modules/es-abstract/2020/Call.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bound');
+
+var $TypeError = require('es-errors/type');
+
+var IsArray = require('./IsArray');
+
+var $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('Function.prototype.apply');
+
+// https://262.ecma-international.org/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);
+};

tools/ui/node_modules/es-abstract/2020/CanonicalNumericIndexString.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var SameValue = require('./SameValue');
+var ToNumber = require('./ToNumber');
+var ToString = require('./ToString');
+
+// https://262.ecma-international.org/6.0/#sec-canonicalnumericindexstring
+
+module.exports = function CanonicalNumericIndexString(argument) {
+	if (typeof 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;
+};

tools/ui/node_modules/es-abstract/2020/Canonicalize.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var callBound = require('call-bound');
+var hasOwn = require('hasown');
+
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+var $toUpperCase = callBound('String.prototype.toUpperCase');
+
+var caseFolding = require('../helpers/caseFolding.json');
+
+// https://262.ecma-international.org/6.0/#sec-runtime-semantics-canonicalize-ch
+
+module.exports = function Canonicalize(ch, IgnoreCase, Unicode) {
+	if (typeof ch !== 'string') {
+		throw new $TypeError('Assertion failed: `ch` must be a character');
+	}
+
+	if (typeof IgnoreCase !== 'boolean' || typeof Unicode !== 'boolean') {
+		throw new $TypeError('Assertion failed: `IgnoreCase` and `Unicode` must be Booleans');
+	}
+
+	if (!IgnoreCase) {
+		return ch; // step 1
+	}
+
+	if (Unicode) { // step 2
+		if (hasOwn(caseFolding.C, ch)) {
+			return caseFolding.C[ch];
+		}
+		if (hasOwn(caseFolding.S, ch)) {
+			return caseFolding.S[ch];
+		}
+		return ch; // step 2.b
+	}
+
+	var u = $toUpperCase(ch); // step 2
+
+	if (u.length !== 1) {
+		return ch; // step 3
+	}
+
+	var cu = u; // step 4
+
+	if ($charCodeAt(ch, 0) >= 128 && $charCodeAt(cu, 0) < 128) {
+		return ch; // step 5
+	}
+
+	return cu;
+};

tools/ui/node_modules/es-abstract/2020/CharacterRange.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bound');
+
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+var $TypeError = require('es-errors/type');
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+
+var CharSet = require('../helpers/CharSet').CharSet;
+
+module.exports = function CharacterRange(A, B) {
+	var a;
+	var b;
+
+	if (A instanceof CharSet || B instanceof CharSet) {
+		if (!(A instanceof CharSet) || !(B instanceof CharSet)) {
+			throw new $TypeError('Assertion failed: CharSets A and B are not both CharSets');
+		}
+
+		A.yield(function (c) {
+			if (typeof a !== 'undefined') {
+				throw new $TypeError('Assertion failed: CharSet A has more than one character');
+			}
+			a = c;
+		});
+		B.yield(function (c) {
+			if (typeof b !== 'undefined') {
+				throw new $TypeError('Assertion failed: CharSet B has more than one character');
+			}
+			b = c;
+		});
+	} else {
+		if (A.length !== 1 || B.length !== 1) {
+			throw new $TypeError('Assertion failed: CharSets A and B contain exactly one character');
+		}
+		a = A[0];
+		b = B[0];
+	}
+
+	var i = $charCodeAt(a, 0);
+	var j = $charCodeAt(b, 0);
+
+	if (!(i <= j)) {
+		throw new $TypeError('Assertion failed: i is not <= j');
+	}
+
+	var arr = [];
+	for (var k = i; k <= j; k += 1) {
+		arr[arr.length] = $fromCharCode(k);
+	}
+	return arr;
+};

tools/ui/node_modules/es-abstract/2020/CodePointAt.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var callBound = require('call-bound');
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+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 (typeof 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
+	};
+};

tools/ui/node_modules/es-abstract/2020/CompletePropertyDescriptor.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var hasOwn = require('hasown');
+
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsGenericDescriptor = require('./IsGenericDescriptor');
+
+var isPropertyDescriptor = require('../helpers/records/property-descriptor');
+
+// https://262.ecma-international.org/6.0/#sec-completepropertydescriptor
+
+module.exports = function CompletePropertyDescriptor(Desc) {
+	if (!isPropertyDescriptor(Desc)) {
+		throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor');
+	}
+
+	/* eslint no-param-reassign: 0 */
+
+	if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) {
+		if (!hasOwn(Desc, '[[Value]]')) {
+			Desc['[[Value]]'] = void 0;
+		}
+		if (!hasOwn(Desc, '[[Writable]]')) {
+			Desc['[[Writable]]'] = false;
+		}
+	} else {
+		if (!hasOwn(Desc, '[[Get]]')) {
+			Desc['[[Get]]'] = void 0;
+		}
+		if (!hasOwn(Desc, '[[Set]]')) {
+			Desc['[[Set]]'] = void 0;
+		}
+	}
+	if (!hasOwn(Desc, '[[Enumerable]]')) {
+		Desc['[[Enumerable]]'] = false;
+	}
+	if (!hasOwn(Desc, '[[Configurable]]')) {
+		Desc['[[Configurable]]'] = false;
+	}
+	return Desc;
+};

tools/ui/node_modules/es-abstract/2020/CompletionRecord.js

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

tools/ui/node_modules/es-abstract/2020/CopyDataProperties.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+var callBound = require('call-bound');
+var OwnPropertyKeys = require('own-keys');
+
+var every = require('../helpers/every');
+var forEach = require('../helpers/forEach');
+
+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('../helpers/isPropertyKey');
+var SameValue = require('./SameValue');
+var ToNumber = require('./ToNumber');
+var ToObject = require('./ToObject');
+
+// https://262.ecma-international.org/11.0/#sec-copydataproperties
+
+module.exports = function CopyDataProperties(target, source, excludedItems) {
+	if (!isObject(target)) {
+		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;
+};

tools/ui/node_modules/es-abstract/2020/CreateAsyncFromSyncIterator.js

@@ -0,0 +1,137 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+var $Promise = GetIntrinsic('%Promise%', true);
+
+var AsyncFromSyncIteratorContinuation = require('./AsyncFromSyncIteratorContinuation');
+var Call = require('./Call');
+var CreateIterResultObject = require('./CreateIterResultObject');
+var Get = require('./Get');
+var GetMethod = require('./GetMethod');
+var IteratorNext = require('./IteratorNext');
+var OrdinaryObjectCreate = require('./OrdinaryObjectCreate');
+
+var isIteratorRecord = require('../helpers/records/iterator-record-2023');
+
+var SLOT = require('internal-slot');
+
+var $AsyncFromSyncIteratorPrototype = GetIntrinsic('%AsyncFromSyncIteratorPrototype%', true) || {
+	next: function next(value) {
+		if (!$Promise) {
+			throw new $SyntaxError('This environment does not support Promises.');
+		}
+
+		var O = this; // step 1
+
+		SLOT.assert(O, '[[SyncIteratorRecord]]'); // step 2
+
+		var argsLength = arguments.length;
+
+		return new $Promise(function (resolve) { // step 3
+			var syncIteratorRecord = SLOT.get(O, '[[SyncIteratorRecord]]'); // step 4
+			var result;
+			if (argsLength > 0) {
+				result = IteratorNext(syncIteratorRecord['[[Iterator]]'], value); // step 5.a
+			} else { // step 6
+				result = IteratorNext(syncIteratorRecord['[[Iterator]]']);// step 6.a
+			}
+			resolve(AsyncFromSyncIteratorContinuation(result)); // step 8
+		});
+	},
+	'return': function () {
+		if (!$Promise) {
+			throw new $SyntaxError('This environment does not support Promises.');
+		}
+
+		var O = this; // step 1
+
+		SLOT.assert(O, '[[SyncIteratorRecord]]'); // step 2
+
+		var valueIsPresent = arguments.length > 0;
+		var value = valueIsPresent ? arguments[0] : void undefined;
+
+		return new $Promise(function (resolve, reject) { // step 3
+			var syncIterator = SLOT.get(O, '[[SyncIteratorRecord]]')['[[Iterator]]']; // step 4
+			var iteratorReturn = GetMethod(syncIterator, 'return'); // step 5
+
+			if (typeof iteratorReturn === 'undefined') { // step 7
+				var iterResult = CreateIterResultObject(value, true); // step 7.a
+				Call(resolve, void undefined, [iterResult]); // step 7.b
+				return;
+			}
+			var result;
+			if (valueIsPresent) { // step 8
+				result = Call(iteratorReturn, syncIterator, [value]); // step 8.a
+			} else { // step 9
+				result = Call(iteratorReturn, syncIterator); // step 9.a
+			}
+			if (!isObject(result)) { // step 11
+				Call(reject, void undefined, [new $TypeError('Iterator `return` method returned a non-object value.')]); // step 11.a
+				return;
+			}
+
+			resolve(AsyncFromSyncIteratorContinuation(result)); // step 12
+		});
+	},
+	'throw': function () {
+		if (!$Promise) {
+			throw new $SyntaxError('This environment does not support Promises.');
+		}
+
+		var O = this; // step 1
+
+		SLOT.assert(O, '[[SyncIteratorRecord]]'); // step 2
+
+		var valueIsPresent = arguments.length > 0;
+		var value = valueIsPresent ? arguments[0] : void undefined;
+
+		return new $Promise(function (resolve, reject) { // step 3
+			var syncIterator = SLOT.get(O, '[[SyncIteratorRecord]]')['[[Iterator]]']; // step 4
+
+			var throwMethod = GetMethod(syncIterator, 'throw'); // step 5
+
+			if (typeof throwMethod === 'undefined') { // step 7
+				Call(reject, void undefined, [value]); // step 7.a
+				return;
+			}
+
+			var result;
+			if (valueIsPresent) { // step 8
+				result = Call(throwMethod, syncIterator, [value]); // step 8.a
+			} else { // step 9
+				result = Call(throwMethod, syncIterator); // step 9.a
+			}
+			if (!isObject(result)) { // step 11
+				Call(reject, void undefined, [new $TypeError('Iterator `throw` method returned a non-object value.')]); // step 11.a
+				return;
+			}
+
+			resolve(AsyncFromSyncIteratorContinuation(result/* , promiseCapability */)); // step 12
+		});
+	}
+};
+
+// https://262.ecma-international.org/11.0/#sec-createasyncfromsynciterator
+
+module.exports = function CreateAsyncFromSyncIterator(syncIteratorRecord) {
+	if (!isIteratorRecord(syncIteratorRecord)) {
+		throw new $TypeError('Assertion failed: `syncIteratorRecord` must be an Iterator Record');
+	}
+
+	// var asyncIterator = OrdinaryObjectCreate(%AsyncFromSyncIteratorPrototype%, « [[SyncIteratorRecord]] »); // step 1
+	var asyncIterator = OrdinaryObjectCreate($AsyncFromSyncIteratorPrototype);
+
+	SLOT.set(asyncIterator, '[[SyncIteratorRecord]]', syncIteratorRecord); // step 2
+
+	var nextMethod = Get(asyncIterator, 'next'); // step 3
+
+	return { // steps 3-4
+		'[[Iterator]]': asyncIterator,
+		'[[NextMethod]]': nextMethod,
+		'[[Done]]': false
+	};
+};

tools/ui/node_modules/es-abstract/2020/CreateDataProperty.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var isPropertyKey = require('../helpers/isPropertyKey');
+var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty');
+
+// https://262.ecma-international.org/6.0/#sec-createdataproperty
+
+module.exports = function CreateDataProperty(O, P, V) {
+	if (!isObject(O)) {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (!isPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: P is not a Property Key');
+	}
+	var newDesc = {
+		'[[Configurable]]': true,
+		'[[Enumerable]]': true,
+		'[[Value]]': V,
+		'[[Writable]]': true
+	};
+	return OrdinaryDefineOwnProperty(O, P, newDesc);
+};

tools/ui/node_modules/es-abstract/2020/CreateDataPropertyOrThrow.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var CreateDataProperty = require('./CreateDataProperty');
+
+var isPropertyKey = require('../helpers/isPropertyKey');
+
+// // https://262.ecma-international.org/6.0/#sec-createdatapropertyorthrow
+
+module.exports = function CreateDataPropertyOrThrow(O, P, V) {
+	if (!isObject(O)) {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (!isPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: P is not a Property Key');
+	}
+	var success = CreateDataProperty(O, P, V);
+	if (!success) {
+		throw new $TypeError('unable to create data property');
+	}
+	return success;
+};

tools/ui/node_modules/es-abstract/2020/CreateHTML.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var callBound = require('call-bound');
+
+var $replace = callBound('String.prototype.replace');
+
+var RequireObjectCoercible = require('./RequireObjectCoercible');
+var ToString = require('./ToString');
+
+// https://262.ecma-international.org/6.0/#sec-createhtml
+
+module.exports = function CreateHTML(string, tag, attribute, value) {
+	if (typeof tag !== 'string' || typeof 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, '&quot;');
+		p1 += '\x20' + attribute + '\x3D\x22' + escapedV + '\x22';
+	}
+	return p1 + '>' + S + '</' + tag + '>';
+};

tools/ui/node_modules/es-abstract/2020/CreateIterResultObject.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/6.0/#sec-createiterresultobject
+
+module.exports = function CreateIterResultObject(value, done) {
+	if (typeof done !== 'boolean') {
+		throw new $TypeError('Assertion failed: Type(done) is not Boolean');
+	}
+	return {
+		value: value,
+		done: done
+	};
+};

tools/ui/node_modules/es-abstract/2020/CreateListFromArrayLike.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var callBound = require('call-bound');
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+var $indexOf = callBound('Array.prototype.indexOf', true) || callBound('String.prototype.indexOf');
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var LengthOfArrayLike = require('./LengthOfArrayLike');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+var defaultElementTypes = ['Undefined', 'Null', 'Boolean', 'String', 'Symbol', 'Number', 'BigInt', 'Object'];
+
+// https://262.ecma-international.org/11.0/#sec-createlistfromarraylike
+
+/** @type {(obj: object, elementTypes?: typeof defaultElementTypes) => unknown[]} */
+module.exports = function CreateListFromArrayLike(obj) {
+	var elementTypes = arguments.length > 1
+		? arguments[1]
+		: defaultElementTypes;
+
+	if (!isObject(obj)) {
+		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);
+	/** @type {(typeof elementTypes)[]} */
+	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');
+		}
+		list[list.length] = next;
+		index += 1;
+	}
+	return list;
+};

tools/ui/node_modules/es-abstract/2020/CreateMethodProperty.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var isPropertyKey = require('../helpers/isPropertyKey');
+var SameValue = require('./SameValue');
+
+// https://262.ecma-international.org/6.0/#sec-createmethodproperty
+
+module.exports = function CreateMethodProperty(O, P, V) {
+	if (!isObject(O)) {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+
+	if (!isPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: P is not a Property Key');
+	}
+
+	var newDesc = {
+		'[[Configurable]]': true,
+		'[[Enumerable]]': false,
+		'[[Value]]': V,
+		'[[Writable]]': true
+	};
+	return DefineOwnProperty(
+		IsDataDescriptor,
+		SameValue,
+		FromPropertyDescriptor,
+		O,
+		P,
+		newDesc
+	);
+};