Save current BZZZ config-ui state before CHORUS branding update

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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
+};

install/config-ui/node_modules/es-abstract/2021/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) { // eslint-disable-line no-constant-condition
+		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));
+		}
+	}
+};

install/config-ui/node_modules/es-abstract/2021/AddToKeptObjects.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var SLOT = require('internal-slot');
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var ClearKeptObjects = require('./ClearKeptObjects');
+
+// https://262.ecma-international.org/12.0/#sec-addtokeptobjects
+
+module.exports = function AddToKeptObjects(object) {
+	if (!isObject(object)) {
+		throw new $TypeError('Assertion failed: `object` must be an Object');
+	}
+	var arr = SLOT.get(ClearKeptObjects, '[[es-abstract internal: KeptAlive]]');
+	arr[arr.length] = object;
+};

install/config-ui/node_modules/es-abstract/2021/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/12.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]]'];
+};

install/config-ui/node_modules/es-abstract/2021/ApplyStringOrNumericBinaryOperator.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var HasOwnProperty = require('./HasOwnProperty');
+var ToNumeric = require('./ToNumeric');
+var ToPrimitive = require('./ToPrimitive');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+var NumberAdd = require('./Number/add');
+var NumberBitwiseAND = require('./Number/bitwiseAND');
+var NumberBitwiseOR = require('./Number/bitwiseOR');
+var NumberBitwiseXOR = require('./Number/bitwiseXOR');
+var NumberDivide = require('./Number/divide');
+var NumberExponentiate = require('./Number/exponentiate');
+var NumberLeftShift = require('./Number/leftShift');
+var NumberMultiply = require('./Number/multiply');
+var NumberRemainder = require('./Number/remainder');
+var NumberSignedRightShift = require('./Number/signedRightShift');
+var NumberSubtract = require('./Number/subtract');
+var NumberUnsignedRightShift = require('./Number/unsignedRightShift');
+var BigIntAdd = require('./BigInt/add');
+var BigIntBitwiseAND = require('./BigInt/bitwiseAND');
+var BigIntBitwiseOR = require('./BigInt/bitwiseOR');
+var BigIntBitwiseXOR = require('./BigInt/bitwiseXOR');
+var BigIntDivide = require('./BigInt/divide');
+var BigIntExponentiate = require('./BigInt/exponentiate');
+var BigIntLeftShift = require('./BigInt/leftShift');
+var BigIntMultiply = require('./BigInt/multiply');
+var BigIntRemainder = require('./BigInt/remainder');
+var BigIntSignedRightShift = require('./BigInt/signedRightShift');
+var BigIntSubtract = require('./BigInt/subtract');
+var BigIntUnsignedRightShift = require('./BigInt/unsignedRightShift');
+
+// https://262.ecma-international.org/12.0/#sec-applystringornumericbinaryoperator
+
+// https://262.ecma-international.org/12.0/#step-applystringornumericbinaryoperator-operations-table
+var table = {
+	'**': [NumberExponentiate, BigIntExponentiate],
+	'*': [NumberMultiply, BigIntMultiply],
+	'/': [NumberDivide, BigIntDivide],
+	'%': [NumberRemainder, BigIntRemainder],
+	'+': [NumberAdd, BigIntAdd],
+	'-': [NumberSubtract, BigIntSubtract],
+	'<<': [NumberLeftShift, BigIntLeftShift],
+	'>>': [NumberSignedRightShift, BigIntSignedRightShift],
+	'>>>': [NumberUnsignedRightShift, BigIntUnsignedRightShift],
+	'&': [NumberBitwiseAND, BigIntBitwiseAND],
+	'^': [NumberBitwiseXOR, BigIntBitwiseXOR],
+	'|': [NumberBitwiseOR, BigIntBitwiseOR]
+};
+
+module.exports = function ApplyStringOrNumericBinaryOperator(lval, opText, rval) {
+	if (typeof opText !== 'string' || !HasOwnProperty(table, opText)) {
+		throw new $TypeError('Assertion failed: `opText` must be a valid operation string');
+	}
+	if (opText === '+') {
+		var lprim = ToPrimitive(lval);
+		var rprim = ToPrimitive(rval);
+		if (typeof lprim === 'string' || typeof rprim === 'string') {
+			var lstr = ToString(lprim);
+			var rstr = ToString(rprim);
+			return lstr + rstr;
+		}
+		/* eslint no-param-reassign: 1 */
+		lval = lprim;
+		rval = rprim;
+	}
+	var lnum = ToNumeric(lval);
+	var rnum = ToNumeric(rval);
+	if (Type(lnum) !== Type(rnum)) {
+		throw new $TypeError('types of ' + lnum + ' and ' + rnum + ' differ');
+	}
+	var Operation = table[opText][typeof lnum === 'bigint' ? 1 : 0];
+	return Operation(lnum, rnum);
+};

install/config-ui/node_modules/es-abstract/2021/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/12.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 3, 5
+	if (proto !== $ArrayPrototype) { // step 4
+		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 6
+		A.length = length;
+	}
+	/* step 6, the above as a shortcut for the below
+	OrdinaryDefineOwnProperty(A, 'length', {
+		'[[Configurable]]': false,
+		'[[Enumerable]]': false,
+		'[[Value]]': length,
+		'[[Writable]]': true
+	});
+	*/
+	return A;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/ArraySpeciesCreate.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+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 ArrayCreate = require('./ArrayCreate');
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var IsConstructor = require('./IsConstructor');
+
+// https://262.ecma-international.org/12.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 isArray = IsArray(originalArray);
+	if (!isArray) {
+		return ArrayCreate(length);
+	}
+
+	var 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 ArrayCreate(length);
+	}
+	if (!IsConstructor(C)) {
+		throw new $TypeError('C must be a constructor');
+	}
+	return new C(length); // Construct(C, length);
+};
+

install/config-ui/node_modules/es-abstract/2021/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
+};

install/config-ui/node_modules/es-abstract/2021/AsyncIteratorClose.js

@@ -0,0 +1,70 @@
+'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/12.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 $then(
+		$then(
+			$then(
+				new $Promise(function (resolve) {
+					resolve(GetMethod(iterator, 'return')); // step 4
+					// resolve(Call(ret, iterator, [])); // step 6
+				}),
+				function (returnV) { // step 5.a
+					if (typeof returnV === 'undefined') {
+						return completion; // step 5.b
+					}
+					return Call(returnV, iterator); // step 5.c, 5.d.
+				}
+			),
+			null,
+			function (e) {
+				if (completion.type() === 'throw') {
+					completion['?'](); // step 6
+				} else {
+					throw e; // step 7
+				}
+			}
+		),
+		function (innerResult) { // step 8
+			if (completion.type() === 'throw') {
+				completion['?'](); // step 6
+			}
+			if (!isObject(innerResult)) {
+				throw new $TypeError('`innerResult` must be an Object'); // step 10
+			}
+			return completion;
+		}
+	);
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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');
+};

install/config-ui/node_modules/es-abstract/2021/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;
+	*/
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/ByteListBitwiseOp.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var IsArray = require('./IsArray');
+
+var isByteValue = require('../helpers/isByteValue');
+
+// https://262.ecma-international.org/12.0/#sec-bytelistbitwiseop
+
+module.exports = function ByteListBitwiseOp(op, xBytes, yBytes) {
+	if (op !== '&' && op !== '^' && op !== '|') {
+		throw new $TypeError('Assertion failed: `op` must be `&`, `^`, or `|`');
+	}
+	if (!IsArray(xBytes) || !IsArray(yBytes) || xBytes.length !== yBytes.length) {
+		throw new $TypeError('Assertion failed: `xBytes` and `yBytes` must be same-length sequences of byte values (an integer 0-255, inclusive)');
+	}
+
+	var result = [];
+
+	for (var i = 0; i < xBytes.length; i += 1) {
+		var xByte = xBytes[i];
+		var yByte = yBytes[i];
+		if (!isByteValue(xByte) || !isByteValue(yByte)) {
+			throw new $TypeError('Assertion failed: `xBytes` and `yBytes` must be same-length sequences of byte values (an integer 0-255, inclusive)');
+		}
+		var resultByte;
+		if (op === '&') {
+			resultByte = xByte & yByte;
+		} else if (op === '^') {
+			resultByte = xByte ^ yByte;
+		} else {
+			resultByte = xByte | yByte;
+		}
+		result[result.length] = resultByte;
+	}
+
+	return result;
+};

install/config-ui/node_modules/es-abstract/2021/ByteListEqual.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var IsArray = require('./IsArray');
+
+var isByteValue = require('../helpers/isByteValue');
+
+// https://262.ecma-international.org/12.0/#sec-bytelistequal
+
+module.exports = function ByteListEqual(xBytes, yBytes) {
+	if (!IsArray(xBytes) || !IsArray(yBytes)) {
+		throw new $TypeError('Assertion failed: `xBytes` and `yBytes` must be sequences of byte values (an integer 0-255, inclusive)');
+	}
+
+	if (xBytes.length !== yBytes.length) {
+		return false;
+	}
+
+	for (var i = 0; i < xBytes.length; i += 1) {
+		var xByte = xBytes[i];
+		var yByte = yBytes[i];
+		if (!isByteValue(xByte) || !isByteValue(yByte)) {
+			throw new $TypeError('Assertion failed: `xBytes` and `yBytes` must be sequences of byte values (an integer 0-255, inclusive)');
+		}
+		if (xByte !== yByte) {
+			return false;
+		}
+	}
+	return true;
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/ClearKeptObjects.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var SLOT = require('internal-slot');
+var keptObjects = [];
+
+// https://262.ecma-international.org/12.0/#sec-clear-kept-objects
+
+module.exports = function ClearKeptObjects() {
+	keptObjects.length = 0;
+};
+
+SLOT.set(module.exports, '[[es-abstract internal: KeptAlive]]', keptObjects);

install/config-ui/node_modules/es-abstract/2021/CloneArrayBuffer.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var GetPrototypeFromConstructor = require('./GetPrototypeFromConstructor');
+var IsConstructor = require('./IsConstructor');
+var IsDetachedBuffer = require('./IsDetachedBuffer');
+var OrdinarySetPrototypeOf = require('./OrdinarySetPrototypeOf');
+
+var isInteger = require('math-intrinsics/isInteger');
+var isArrayBuffer = require('is-array-buffer');
+var arrayBufferSlice = require('arraybuffer.prototype.slice');
+
+// https://262.ecma-international.org/12.0/#sec-clonearraybuffer
+
+module.exports = function CloneArrayBuffer(srcBuffer, srcByteOffset, srcLength, cloneConstructor) {
+	if (!isArrayBuffer(srcBuffer)) {
+		throw new $TypeError('Assertion failed: `srcBuffer` must be an ArrayBuffer instance');
+	}
+	if (!isInteger(srcByteOffset) || srcByteOffset < 0) {
+		throw new $TypeError('Assertion failed: `srcByteOffset` must be a non-negative integer');
+	}
+	if (!isInteger(srcLength) || srcLength < 0) {
+		throw new $TypeError('Assertion failed: `srcLength` must be a non-negative integer');
+	}
+	if (!IsConstructor(cloneConstructor)) {
+		throw new $TypeError('Assertion failed: `cloneConstructor` must be a constructor');
+	}
+
+	// 3. Let targetBuffer be ? AllocateArrayBuffer(cloneConstructor, srcLength).
+	var proto = GetPrototypeFromConstructor(cloneConstructor, '%ArrayBufferPrototype%'); // step 3, kinda
+
+	if (IsDetachedBuffer(srcBuffer)) {
+		throw new $TypeError('`srcBuffer` must not be a detached ArrayBuffer'); // step 4
+	}
+
+	/*
+    5. Let srcBlock be srcBuffer.[[ArrayBufferData]].
+    6. Let targetBlock be targetBuffer.[[ArrayBufferData]].
+    7. Perform CopyDataBlockBytes(targetBlock, 0, srcBlock, srcByteOffset, srcLength).
+    */
+	var targetBuffer = arrayBufferSlice(srcBuffer, srcByteOffset, srcByteOffset + srcLength); // steps 5-7
+	OrdinarySetPrototypeOf(targetBuffer, proto); // step 3
+
+	return targetBuffer; // step 8
+};

install/config-ui/node_modules/es-abstract/2021/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 UTF16SurrogatePairToCodePoint = require('./UTF16SurrogatePairToCodePoint');
+
+var $charAt = callBound('String.prototype.charAt');
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+
+// https://262.ecma-international.org/12.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]]': UTF16SurrogatePairToCodePoint(first, second),
+		'[[CodeUnitCount]]': 2,
+		'[[IsUnpairedSurrogate]]': false
+	};
+};

install/config-ui/node_modules/es-abstract/2021/CodePointsToString.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var UTF16EncodeCodePoint = require('./UTF16EncodeCodePoint');
+var IsArray = require('./IsArray');
+
+var forEach = require('../helpers/forEach');
+var isCodePoint = require('../helpers/isCodePoint');
+
+// https://262.ecma-international.org/12.0/#sec-codepointstostring
+
+module.exports = function CodePointsToString(text) {
+	if (!IsArray(text)) {
+		throw new $TypeError('Assertion failed: `text` must be a sequence of Unicode Code Points');
+	}
+	var result = '';
+	forEach(text, function (cp) {
+		if (!isCodePoint(cp)) {
+			throw new $TypeError('Assertion failed: `text` must be a sequence of Unicode Code Points');
+		}
+		result += UTF16EncodeCodePoint(cp);
+	});
+	return result;
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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;

install/config-ui/node_modules/es-abstract/2021/CopyDataProperties.js

@@ -0,0 +1,69 @@
+'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 forEach = require('../helpers/forEach');
+var every = require('../helpers/every');
+var some = require('../helpers/some');
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+var CreateDataPropertyOrThrow = require('./CreateDataPropertyOrThrow');
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var isPropertyKey = require('../helpers/isPropertyKey');
+var SameValue = require('./SameValue');
+var ToNumber = require('./ToNumber');
+var ToObject = require('./ToObject');
+
+var isInteger = require('math-intrinsics/isInteger');
+
+// https://262.ecma-international.org/12.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 keys = OwnPropertyKeys(from);
+	forEach(keys, function (nextKey) {
+		var excluded = some(excludedItems, function (e) {
+			return SameValue(e, nextKey) === true;
+		});
+		/*
+		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;
+};

install/config-ui/node_modules/es-abstract/2021/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, 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, 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, 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, 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
+	};
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/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 + '>';
+};

install/config-ui/node_modules/es-abstract/2021/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
+	};
+};

install/config-ui/node_modules/es-abstract/2021/CreateListFromArrayLike.js

@@ -0,0 +1,44 @@
+'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
+
+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);
+	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;
+};

install/config-ui/node_modules/es-abstract/2021/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
+	);
+};

install/config-ui/node_modules/es-abstract/2021/CreateRegExpStringIterator.js

@@ -0,0 +1,100 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var hasSymbols = require('has-symbols')();
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+var IteratorPrototype = GetIntrinsic('%IteratorPrototype%', true);
+
+var AdvanceStringIndex = require('./AdvanceStringIndex');
+var CreateIterResultObject = require('./CreateIterResultObject');
+var CreateMethodProperty = require('./CreateMethodProperty');
+var Get = require('./Get');
+var OrdinaryObjectCreate = require('./OrdinaryObjectCreate');
+var RegExpExec = require('./RegExpExec');
+var Set = require('./Set');
+var ToLength = require('./ToLength');
+var ToString = require('./ToString');
+
+var SLOT = require('internal-slot');
+var setToStringTag = require('es-set-tostringtag');
+
+var RegExpStringIterator = function RegExpStringIterator(R, S, global, fullUnicode) {
+	if (typeof S !== 'string') {
+		throw new $TypeError('`S` must be a string');
+	}
+	if (typeof global !== 'boolean') {
+		throw new $TypeError('`global` must be a boolean');
+	}
+	if (typeof fullUnicode !== 'boolean') {
+		throw new $TypeError('`fullUnicode` must be a boolean');
+	}
+	SLOT.set(this, '[[IteratingRegExp]]', R);
+	SLOT.set(this, '[[IteratedString]]', S);
+	SLOT.set(this, '[[Global]]', global);
+	SLOT.set(this, '[[Unicode]]', fullUnicode);
+	SLOT.set(this, '[[Done]]', false);
+};
+
+if (IteratorPrototype) {
+	RegExpStringIterator.prototype = OrdinaryObjectCreate(IteratorPrototype);
+}
+
+var RegExpStringIteratorNext = function next() {
+	var O = this; // eslint-disable-line no-invalid-this
+	if (!isObject(O)) {
+		throw new $TypeError('receiver must be an object');
+	}
+	if (
+		!(O instanceof RegExpStringIterator)
+		|| !SLOT.has(O, '[[IteratingRegExp]]')
+		|| !SLOT.has(O, '[[IteratedString]]')
+		|| !SLOT.has(O, '[[Global]]')
+		|| !SLOT.has(O, '[[Unicode]]')
+		|| !SLOT.has(O, '[[Done]]')
+	) {
+		throw new $TypeError('"this" value must be a RegExpStringIterator instance');
+	}
+	if (SLOT.get(O, '[[Done]]')) {
+		return CreateIterResultObject(undefined, true);
+	}
+	var R = SLOT.get(O, '[[IteratingRegExp]]');
+	var S = SLOT.get(O, '[[IteratedString]]');
+	var global = SLOT.get(O, '[[Global]]');
+	var fullUnicode = SLOT.get(O, '[[Unicode]]');
+	var match = RegExpExec(R, S);
+	if (match === null) {
+		SLOT.set(O, '[[Done]]', true);
+		return CreateIterResultObject(undefined, true);
+	}
+	if (global) {
+		var matchStr = ToString(Get(match, '0'));
+		if (matchStr === '') {
+			var thisIndex = ToLength(Get(R, 'lastIndex'));
+			var nextIndex = AdvanceStringIndex(S, thisIndex, fullUnicode);
+			Set(R, 'lastIndex', nextIndex, true);
+		}
+		return CreateIterResultObject(match, false);
+	}
+	SLOT.set(O, '[[Done]]', true);
+	return CreateIterResultObject(match, false);
+};
+CreateMethodProperty(RegExpStringIterator.prototype, 'next', RegExpStringIteratorNext);
+
+if (hasSymbols) {
+	setToStringTag(RegExpStringIterator.prototype, 'RegExp String Iterator');
+
+	if (Symbol.iterator && typeof RegExpStringIterator.prototype[Symbol.iterator] !== 'function') {
+		var iteratorFn = function SymbolIterator() {
+			return this;
+		};
+		CreateMethodProperty(RegExpStringIterator.prototype, Symbol.iterator, iteratorFn);
+	}
+}
+
+// https://262.ecma-international.org/11.0/#sec-createregexpstringiterator
+module.exports = function CreateRegExpStringIterator(R, S, global, fullUnicode) {
+	// assert R.global === global && R.unicode === fullUnicode?
+	return new RegExpStringIterator(R, S, global, fullUnicode);
+};

install/config-ui/node_modules/es-abstract/2021/DateFromTime.js

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

install/config-ui/node_modules/es-abstract/2021/DateString.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+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('math-intrinsics/isNaN');
+var padTimeComponent = require('../helpers/padTimeComponent');
+
+var DateFromTime = require('./DateFromTime');
+var MonthFromTime = require('./MonthFromTime');
+var WeekDay = require('./WeekDay');
+var YearFromTime = require('./YearFromTime');
+
+// https://262.ecma-international.org/9.0/#sec-datestring
+
+module.exports = function DateString(tv) {
+	if (typeof 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;
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};
+

install/config-ui/node_modules/es-abstract/2021/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));
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};

install/config-ui/node_modules/es-abstract/2021/DefinePropertyOrThrow.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var isPropertyDescriptor = require('../helpers/records/property-descriptor');
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var isPropertyKey = require('../helpers/isPropertyKey');
+var SameValue = require('./SameValue');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-definepropertyorthrow
+
+module.exports = function DefinePropertyOrThrow(O, P, desc) {
+	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 Desc = isPropertyDescriptor(desc) ? desc : ToPropertyDescriptor(desc);
+	if (!isPropertyDescriptor(Desc)) {
+		throw new $TypeError('Assertion failed: Desc is not a valid Property Descriptor');
+	}
+
+	return DefineOwnProperty(
+		IsDataDescriptor,
+		SameValue,
+		FromPropertyDescriptor,
+		O,
+		P,
+		Desc
+	);
+};

install/config-ui/node_modules/es-abstract/2021/DeletePropertyOrThrow.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');
+
+// https://262.ecma-international.org/6.0/#sec-deletepropertyorthrow
+
+module.exports = function DeletePropertyOrThrow(O, P) {
+	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');
+	}
+
+	// eslint-disable-next-line no-param-reassign
+	var success = delete O[P];
+	if (!success) {
+		throw new $TypeError('Attempt to delete property failed.');
+	}
+	return success;
+};

install/config-ui/node_modules/es-abstract/2021/DetachArrayBuffer.js

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

install/config-ui/node_modules/es-abstract/2021/EnumerableOwnPropertyNames.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var objectKeys = require('object-keys');
+var safePushApply = require('safe-push-apply');
+var callBound = require('call-bound');
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+var forEach = require('../helpers/forEach');
+
+// https://262.ecma-international.org/8.0/#sec-enumerableownproperties
+
+module.exports = function EnumerableOwnPropertyNames(O, kind) {
+	if (!isObject(O)) {
+		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)) {
+				safePushApply(results, [
+					kind === 'value' ? O[key] : [key, O[key]]
+				]);
+			}
+		});
+		return results;
+	}
+	throw new $TypeError('Assertion failed: "kind" is not "key", "value", or "key+value": ' + kind);
+};

install/config-ui/node_modules/es-abstract/2021/FlattenIntoArray.js

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

install/config-ui/node_modules/es-abstract/2021/FromPropertyDescriptor.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var isPropertyDescriptor = require('../helpers/records/property-descriptor');
+var fromPropertyDescriptor = require('../helpers/fromPropertyDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-frompropertydescriptor
+
+module.exports = function FromPropertyDescriptor(Desc) {
+	if (typeof Desc !== 'undefined' && !isPropertyDescriptor(Desc)) {
+		throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor');
+	}
+
+	return fromPropertyDescriptor(Desc);
+};

install/config-ui/node_modules/es-abstract/2021/Get.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var inspect = require('object-inspect');
+
+var isPropertyKey = require('../helpers/isPropertyKey');
+
+var isObject = require('es-object-atoms/isObject');
+
+// https://262.ecma-international.org/6.0/#sec-get-o-p
+
+module.exports = function Get(O, P) {
+	// 7.3.1.1
+	if (!isObject(O)) {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	// 7.3.1.2
+	if (!isPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: P is not a Property Key, got ' + inspect(P));
+	}
+	// 7.3.1.3
+	return O[P];
+};

install/config-ui/node_modules/es-abstract/2021/GetGlobalObject.js

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

install/config-ui/node_modules/es-abstract/2021/GetIterator.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = require('es-errors/type');
+var $SyntaxError = require('es-errors/syntax');
+var isObject = require('es-object-atoms/isObject');
+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 ES = {
+	AdvanceStringIndex: AdvanceStringIndex,
+	GetMethod: GetMethod
+};
+
+// 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 $SyntaxError("async from sync iterators aren't currently supported");
+			}
+		} else {
+			actualMethod = getIteratorMethod(ES, obj);
+		}
+	}
+	var iterator = Call(actualMethod, obj);
+	if (!isObject(iterator)) {
+		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
+	};
+	*/
+};

install/config-ui/node_modules/es-abstract/2021/GetMethod.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var GetV = require('./GetV');
+var IsCallable = require('./IsCallable');
+var isPropertyKey = require('../helpers/isPropertyKey');
+
+var inspect = require('object-inspect');
+
+// https://262.ecma-international.org/6.0/#sec-getmethod
+
+module.exports = function GetMethod(O, P) {
+	// 7.3.9.1
+	if (!isPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: P is not a Property Key');
+	}
+
+	// 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(inspect(P) + ' is not a function: ' + inspect(func));
+	}
+
+	// 7.3.9.6
+	return func;
+};

install/config-ui/node_modules/es-abstract/2021/GetOwnPropertyKeys.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var hasSymbols = require('has-symbols')();
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true);
+var $gOPS = hasSymbols && GetIntrinsic('%Object.getOwnPropertySymbols%', true);
+var keys = require('object-keys');
+
+// https://262.ecma-international.org/6.0/#sec-getownpropertykeys
+
+module.exports = function GetOwnPropertyKeys(O, Type) {
+	if (!isObject(O)) {
+		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"`');
+};

install/config-ui/node_modules/es-abstract/2021/GetPromiseResolve.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var Get = require('./Get');
+var IsCallable = require('./IsCallable');
+var IsConstructor = require('./IsConstructor');
+
+// https://262.ecma-international.org/12.0/#sec-getpromiseresolve
+
+module.exports = function GetPromiseResolve(promiseConstructor) {
+	if (!IsConstructor(promiseConstructor)) {
+		throw new $TypeError('Assertion failed: `promiseConstructor` must be a constructor');
+	}
+	var promiseResolve = Get(promiseConstructor, 'resolve');
+	if (IsCallable(promiseResolve) === false) {
+		throw new $TypeError('`resolve` method is not callable');
+	}
+	return promiseResolve;
+};

install/config-ui/node_modules/es-abstract/2021/GetPrototypeFromConstructor.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Function = GetIntrinsic('%Function%');
+var $TypeError = require('es-errors/type');
+var $SyntaxError = require('es-errors/syntax');
+
+var Get = require('./Get');
+var IsConstructor = require('./IsConstructor');
+
+var isObject = require('es-object-atoms/isObject');
+
+// https://262.ecma-international.org/6.0/#sec-getprototypefromconstructor
+
+module.exports = function GetPrototypeFromConstructor(constructor, intrinsicDefaultProto) {
+	var intrinsic = GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic
+	if (!isObject(intrinsic)) {
+		throw new $TypeError('intrinsicDefaultProto must be an object');
+	}
+	if (!IsConstructor(constructor)) {
+		throw new $TypeError('Assertion failed: `constructor` must be a constructor');
+	}
+	var proto = Get(constructor, 'prototype');
+	if (!isObject(proto)) {
+		if (!(constructor instanceof $Function)) {
+			// ignore other realms, for now
+			throw new $SyntaxError('cross-realm constructors not currently supported');
+		}
+		proto = intrinsic;
+	}
+	return proto;
+};

install/config-ui/node_modules/es-abstract/2021/GetSubstitution.js

@@ -0,0 +1,119 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var callBound = require('call-bound');
+var regexTester = require('safe-regex-test');
+var isInteger = require('math-intrinsics/isInteger');
+
+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 ToObject = require('./ToObject');
+var ToString = require('./ToString');
+
+var every = require('../helpers/every');
+var isStringOrUndefined = require('../helpers/isStringOrUndefined');
+
+// http://www.ecma-international.org/ecma-262/12.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 (typeof matched !== 'string') {
+		throw new $TypeError('Assertion failed: `matched` must be a String');
+	}
+	var matchLength = matched.length;
+
+	if (typeof 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, isStringOrUndefined)) {
+		throw new $TypeError('Assertion failed: `captures` must be a possibly-empty List of Strings or `undefined`, got ' + inspect(captures));
+	}
+
+	if (typeof replacement !== 'string') {
+		throw new $TypeError('Assertion failed: `replacement` must be a String');
+	}
+
+	var tailPos = position + matchLength;
+	var m = captures.length;
+	if (typeof 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 && typeof 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 && typeof captures[nnI] === 'undefined' ? '' : captures[nnI];
+					i += 2;
+				} else if (next === '<') {
+					if (typeof namedCaptures === 'undefined') {
+						result += '$<';
+						i += 2;
+					} else {
+						var endIndex = $indexOf(replacement, '>', i);
+						if (endIndex > -1) {
+							var groupName = $strSlice(replacement, i + '$<'.length, endIndex);
+							var capture = Get(namedCaptures, groupName);
+
+							if (typeof capture !== 'undefined') {
+								result += ToString(capture);
+							}
+							i += ('<' + groupName + '>').length;
+						}
+					}
+				} else {
+					result += '$';
+				}
+			}
+		} else {
+			// the final $, or else not a $
+			result += $charAt(replacement, i);
+		}
+	}
+	return result;
+};

install/config-ui/node_modules/es-abstract/2021/GetV.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var inspect = require('object-inspect');
+
+var isPropertyKey = require('../helpers/isPropertyKey');
+// var ToObject = require('./ToObject');
+
+// https://262.ecma-international.org/6.0/#sec-getv
+
+module.exports = function GetV(V, P) {
+	// 7.3.2.1
+	if (!isPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: P is not a Property Key, got ' + inspect(P));
+	}
+
+	// 7.3.2.2-3
+	// var O = ToObject(V);
+
+	// 7.3.2.4
+	return V[P];
+};

install/config-ui/node_modules/es-abstract/2021/GetValueFromBuffer.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var $Uint8Array = GetIntrinsic('%Uint8Array%', true);
+var isInteger = require('math-intrinsics/isInteger');
+
+var callBound = require('call-bound');
+
+var $slice = callBound('Array.prototype.slice');
+
+var IsDetachedBuffer = require('./IsDetachedBuffer');
+var RawBytesToNumeric = require('./RawBytesToNumeric');
+
+var isArrayBuffer = require('is-array-buffer');
+var isSharedArrayBuffer = require('is-shared-array-buffer');
+var safeConcat = require('safe-array-concat');
+
+var tableTAO = require('./tables/typed-array-objects');
+
+var defaultEndianness = require('../helpers/defaultEndianness');
+
+// https://262.ecma-international.org/11.0/#sec-getvaluefrombuffer
+
+module.exports = function GetValueFromBuffer(arrayBuffer, byteIndex, type, isTypedArray, order) {
+	var isSAB = isSharedArrayBuffer(arrayBuffer);
+	if (!isArrayBuffer(arrayBuffer) && !isSAB) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` must be an ArrayBuffer or a SharedArrayBuffer');
+	}
+
+	if (!isInteger(byteIndex)) {
+		throw new $TypeError('Assertion failed: `byteIndex` must be an integer');
+	}
+
+	if (typeof type !== 'string' || typeof tableTAO.size['$' + type] !== 'number') {
+		throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices);
+	}
+
+	if (typeof isTypedArray !== 'boolean') {
+		throw new $TypeError('Assertion failed: `isTypedArray` must be a boolean');
+	}
+
+	if (order !== 'SeqCst' && order !== 'Unordered') {
+		throw new $TypeError('Assertion failed: `order` must be either `SeqCst` or `Unordered`');
+	}
+
+	if (arguments.length > 5 && typeof arguments[5] !== 'boolean') {
+		throw new $TypeError('Assertion failed: `isLittleEndian` must be a boolean, if present');
+	}
+
+	if (IsDetachedBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` is detached'); // step 1
+	}
+
+	// 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
+
+	if (byteIndex < 0) {
+		throw new $TypeError('Assertion failed: `byteIndex` must be non-negative'); // step 3
+	}
+
+	// 4. Let block be arrayBuffer.[[ArrayBufferData]].
+
+	var elementSize = tableTAO.size['$' + type]; // step 5
+	if (!elementSize) {
+		throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices);
+	}
+
+	var rawValue;
+	if (isSAB) { // step 6
+		/*
+		a. Let execution be the [[CandidateExecution]] field of the surrounding agent's Agent Record.
+		b. Let eventList be the [[EventList]] field of the element in execution.[[EventLists]] whose [[AgentSignifier]] is AgentSignifier().
+		c. If isTypedArray is true and type is "Int8", "Uint8", "Int16", "Uint16", "Int32", or "Uint32", let noTear be true; otherwise let noTear be false.
+		d. Let rawValue be a List of length elementSize of nondeterministically chosen byte values.
+		e. NOTE: In implementations, rawValue is the result of a non-atomic or atomic read instruction on the underlying hardware. The nondeterminism is a semantic prescription of the memory model to describe observable behaviour of hardware with weak consistency.
+		f. Let readEvent be ReadSharedMemory{ [[Order]]: order, [[NoTear]]: noTear, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize }.
+		g. Append readEvent to eventList.
+		h. Append Chosen Value Record { [[Event]]: readEvent, [[ChosenValue]]: rawValue } to execution.[[ChosenValues]].
+		*/
+		throw new $SyntaxError('SharedArrayBuffer is not supported by this implementation');
+	} else {
+		// 7. Let rawValue be a List of elementSize containing, in order, the elementSize sequence of bytes starting with block[byteIndex].
+		rawValue = $slice(new $Uint8Array(arrayBuffer, byteIndex), 0, elementSize); // step 6
+	}
+
+	// 8. If isLittleEndian is not present, set isLittleEndian to either true or false. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the SetValueInBuffer abstract operation.
+	var isLittleEndian = arguments.length > 5 ? arguments[5] : defaultEndianness === 'little'; // step 8
+
+	var bytes = isLittleEndian
+		? $slice(safeConcat([0, 0, 0, 0, 0, 0, 0, 0], rawValue), -elementSize)
+		: $slice(safeConcat(rawValue, [0, 0, 0, 0, 0, 0, 0, 0]), 0, elementSize);
+
+	return RawBytesToNumeric(type, bytes, isLittleEndian);
+};

install/config-ui/node_modules/es-abstract/2021/HasOwnProperty.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var hasOwn = require('hasown');
+var isObject = require('es-object-atoms/isObject');
+
+var isPropertyKey = require('../helpers/isPropertyKey');
+
+// https://262.ecma-international.org/6.0/#sec-hasownproperty
+
+module.exports = function HasOwnProperty(O, P) {
+	if (!isObject(O)) {
+		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 hasOwn(O, P);
+};

install/config-ui/node_modules/es-abstract/2021/HasProperty.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var isPropertyKey = require('../helpers/isPropertyKey');
+
+// https://262.ecma-international.org/6.0/#sec-hasproperty
+
+module.exports = function HasProperty(O, P) {
+	if (!isObject(O)) {
+		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;
+};

install/config-ui/node_modules/es-abstract/2021/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);
+};

install/config-ui/node_modules/es-abstract/2021/InLeapYear.js

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

install/config-ui/node_modules/es-abstract/2021/InstanceofOperator.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+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');
+
+// https://262.ecma-international.org/6.0/#sec-instanceofoperator
+
+module.exports = function InstanceofOperator(O, C) {
+	if (!isObject(O)) {
+		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);
+};

install/config-ui/node_modules/es-abstract/2021/IntegerIndexedElementGet.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var GetValueFromBuffer = require('./GetValueFromBuffer');
+var IsValidIntegerIndex = require('./IsValidIntegerIndex');
+
+var typedArrayBuffer = require('typed-array-buffer');
+var typedArrayByteOffset = require('typed-array-byte-offset');
+var whichTypedArray = require('which-typed-array');
+
+var tableTAO = require('./tables/typed-array-objects');
+
+// https://262.ecma-international.org/12.0/#sec-integerindexedelementget
+
+module.exports = function IntegerIndexedElementGet(O, index) {
+	var arrayTypeName = whichTypedArray(O); // step 4
+	if (!arrayTypeName) {
+		throw new $TypeError('Assertion failed: `O` must be a TypedArray'); // step 1
+	}
+
+	if (typeof index !== 'number') {
+		throw new $TypeError('Assertion failed: `index` must be a Number');
+	}
+
+	if (!IsValidIntegerIndex(O, index)) {
+		return void undefined; // step 2
+	}
+
+	var offset = typedArrayByteOffset(O); // step 3
+
+	var elementType = tableTAO.name['$' + arrayTypeName]; // step 7
+
+	var elementSize = tableTAO.size['$' + elementType]; // step 5
+
+	var indexedPosition = (index * elementSize) + offset; // step 6
+
+	return GetValueFromBuffer(typedArrayBuffer(O), indexedPosition, elementType, true, 'Unordered'); // step 11
+};

install/config-ui/node_modules/es-abstract/2021/IntegerIndexedElementSet.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var IsValidIntegerIndex = require('./IsValidIntegerIndex');
+var SetValueInBuffer = require('./SetValueInBuffer');
+var ToBigInt = require('./ToBigInt');
+var ToNumber = require('./ToNumber');
+
+var typedArrayBuffer = require('typed-array-buffer');
+var typedArrayByteOffset = require('typed-array-byte-offset');
+var whichTypedArray = require('which-typed-array');
+
+var tableTAO = require('./tables/typed-array-objects');
+
+// https://262.ecma-international.org/12.0/#sec-integerindexedelementset
+
+module.exports = function IntegerIndexedElementSet(O, index, value) {
+	if (typeof index !== 'number') {
+		throw new $TypeError('Assertion failed: `index` must be a Number');
+	}
+
+	var arrayTypeName = whichTypedArray(O); // step 4.b
+	if (!arrayTypeName) {
+		throw new $TypeError('Assertion failed: `O` must be a TypedArray'); // step 1
+	}
+
+	var contentType = arrayTypeName === 'BigInt64Array' || arrayTypeName === 'BigUint64Array' ? 'BigInt' : 'Number';
+	var numValue = contentType === 'BigInt' ? ToBigInt(value) : ToNumber(value); // steps 2 - 3
+
+	if (IsValidIntegerIndex(O, index)) { // step 4
+		var offset = typedArrayByteOffset(O); // step 4.a
+
+		var elementType = tableTAO.name['$' + arrayTypeName]; // step 4.e
+
+		var elementSize = tableTAO.size['$' + elementType]; // step 4.c
+
+		var indexedPosition = (index * elementSize) + offset; // step 4.d
+
+		SetValueInBuffer(typedArrayBuffer(O), indexedPosition, elementType, numValue, true, 'Unordered'); // step 4.e
+	}
+
+	// 5. Return NormalCompletion(undefined)
+};

install/config-ui/node_modules/es-abstract/2021/InternalizeJSONProperty.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var Call = require('./Call');
+var CreateDataProperty = require('./CreateDataProperty');
+var EnumerableOwnPropertyNames = require('./EnumerableOwnPropertyNames');
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var LengthOfArrayLike = require('./LengthOfArrayLike');
+var ToString = require('./ToString');
+
+var forEach = require('../helpers/forEach');
+
+// https://262.ecma-international.org/11.0/#sec-internalizejsonproperty
+
+module.exports = function InternalizeJSONProperty(holder, name, reviver) {
+	if (!isObject(holder)) {
+		throw new $TypeError('Assertion failed: `holder` is not an Object');
+	}
+	if (typeof name !== 'string') {
+		throw new $TypeError('Assertion failed: `name` is not a String');
+	}
+	if (typeof reviver !== 'function') {
+		throw new $TypeError('Assertion failed: `reviver` is not a Function');
+	}
+
+	var val = Get(holder, name); // step 1
+
+	if (isObject(val)) { // step 2
+		var isArray = IsArray(val); // step 2.a
+		if (isArray) { // step 2.b
+			var I = 0; // step 2.b.i
+
+			var len = LengthOfArrayLike(val, 'length'); // step 2.b.ii
+
+			while (I < len) { // step 2.b.iii
+				var newElement = InternalizeJSONProperty(val, ToString(I), reviver); // step 2.b.iv.1
+
+				if (typeof newElement === 'undefined') { // step 2.b.iii.2
+					delete val[ToString(I)]; // step 2.b.iii.2.a
+				} else { // step 2.b.iii.3
+					CreateDataProperty(val, ToString(I), newElement); // step 2.b.iii.3.a
+				}
+
+				I += 1; // step 2.b.iii.4
+			}
+		} else { // step 2.c
+			var keys = EnumerableOwnPropertyNames(val, 'key'); // step 2.c.i
+
+			forEach(keys, function (P) { // step 2.c.ii
+				// eslint-disable-next-line no-shadow
+				var newElement = InternalizeJSONProperty(val, P, reviver); // step 2.c.ii.1
+
+				if (typeof newElement === 'undefined') { // step 2.c.ii.2
+					delete val[P]; // step 2.c.ii.2.a
+				} else { // step 2.c.ii.3
+					CreateDataProperty(val, P, newElement); // step 2.c.ii.3.a
+				}
+			});
+		}
+	}
+
+	return Call(reviver, holder, [name, val]); // step 3
+};

install/config-ui/node_modules/es-abstract/2021/Invoke.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var Call = require('./Call');
+var IsArray = require('./IsArray');
+var GetV = require('./GetV');
+var isPropertyKey = require('../helpers/isPropertyKey');
+
+// https://262.ecma-international.org/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);
+};

install/config-ui/node_modules/es-abstract/2021/IsAccessorDescriptor.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var hasOwn = require('hasown');
+
+var isPropertyDescriptor = require('../helpers/records/property-descriptor');
+
+// https://262.ecma-international.org/5.1/#sec-8.10.1
+
+module.exports = function IsAccessorDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	if (!isPropertyDescriptor(Desc)) {
+		throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor');
+	}
+
+	if (!hasOwn(Desc, '[[Get]]') && !hasOwn(Desc, '[[Set]]')) {
+		return false;
+	}
+
+	return true;
+};

install/config-ui/node_modules/es-abstract/2021/IsArray.js

@@ -0,0 +1,4 @@
+'use strict';
+
+// https://262.ecma-international.org/6.0/#sec-isarray
+module.exports = require('../helpers/IsArray');

install/config-ui/node_modules/es-abstract/2021/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';
+};

install/config-ui/node_modules/es-abstract/2021/IsCallable.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// http://262.ecma-international.org/5.1/#sec-9.11
+
+module.exports = require('is-callable');

install/config-ui/node_modules/es-abstract/2021/IsCompatiblePropertyDescriptor.js

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

install/config-ui/node_modules/es-abstract/2021/IsConcatSpreadable.js

@@ -0,0 +1,26 @@
+'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 isObject = require('es-object-atoms/isObject');
+
+// https://262.ecma-international.org/6.0/#sec-isconcatspreadable
+
+module.exports = function IsConcatSpreadable(O) {
+	if (!isObject(O)) {
+		return false;
+	}
+	if ($isConcatSpreadable) {
+		var spreadable = Get(O, $isConcatSpreadable);
+		if (typeof spreadable !== 'undefined') {
+			return ToBoolean(spreadable);
+		}
+	}
+	return IsArray(O);
+};

install/config-ui/node_modules/es-abstract/2021/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://262.ecma-international.org/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;
+	};
+}

install/config-ui/node_modules/es-abstract/2021/IsDataDescriptor.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var hasOwn = require('hasown');
+
+var isPropertyDescriptor = require('../helpers/records/property-descriptor');
+
+// https://262.ecma-international.org/5.1/#sec-8.10.2
+
+module.exports = function IsDataDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	if (!isPropertyDescriptor(Desc)) {
+		throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor');
+	}
+
+	if (!hasOwn(Desc, '[[Value]]') && !hasOwn(Desc, '[[Writable]]')) {
+		return false;
+	}
+
+	return true;
+};

install/config-ui/node_modules/es-abstract/2021/IsDetachedBuffer.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var $byteLength = require('array-buffer-byte-length');
+var availableTypedArrays = require('available-typed-arrays')();
+var callBound = require('call-bound');
+var isArrayBuffer = require('is-array-buffer');
+var isSharedArrayBuffer = require('is-shared-array-buffer');
+
+var $sabByteLength = callBound('SharedArrayBuffer.prototype.byteLength', true);
+
+// https://262.ecma-international.org/8.0/#sec-isdetachedbuffer
+
+module.exports = function IsDetachedBuffer(arrayBuffer) {
+	var isSAB = isSharedArrayBuffer(arrayBuffer);
+	if (!isArrayBuffer(arrayBuffer) && !isSAB) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot');
+	}
+	if ((isSAB ? $sabByteLength : $byteLength)(arrayBuffer) === 0) {
+		try {
+			new global[availableTypedArrays[0]](arrayBuffer); // eslint-disable-line no-new
+		} catch (error) {
+			return !!error && error.name === 'TypeError';
+		}
+	}
+	return false;
+};

install/config-ui/node_modules/es-abstract/2021/IsExtensible.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true);
+var $isExtensible = GetIntrinsic('%Object.isExtensible%', true);
+
+var isPrimitive = require('../helpers/isPrimitive');
+
+// https://262.ecma-international.org/6.0/#sec-isextensible-o
+
+module.exports = $preventExtensions
+	? function IsExtensible(obj) {
+		return !isPrimitive(obj) && $isExtensible(obj);
+	}
+	: function IsExtensible(obj) {
+		return !isPrimitive(obj);
+	};

install/config-ui/node_modules/es-abstract/2021/IsGenericDescriptor.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+
+var isPropertyDescriptor = require('../helpers/records/property-descriptor');
+
+// https://262.ecma-international.org/6.0/#sec-isgenericdescriptor
+
+module.exports = function IsGenericDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	if (!isPropertyDescriptor(Desc)) {
+		throw new $TypeError('Assertion failed: `Desc` must be a Property Descriptor');
+	}
+
+	if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) {
+		return true;
+	}
+
+	return false;
+};

install/config-ui/node_modules/es-abstract/2021/IsIntegralNumber.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var isInteger = require('math-intrinsics/isInteger');
+
+// https://262.ecma-international.org/12.0/#sec-isinteger
+
+module.exports = function IsIntegralNumber(argument) {
+	return isInteger(argument);
+};

install/config-ui/node_modules/es-abstract/2021/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;
+};