Bump the npm group with 2 updates (#1819)

* Bump the npm group with 2 updates

Bumps the npm group with 2 updates: [eslint](https://github.com/eslint/eslint) and [eslint-plugin-import](https://github.com/import-js/eslint-plugin-import).


Updates `eslint` from 8.45.0 to 8.46.0
- [Release notes](https://github.com/eslint/eslint/releases)
- [Changelog](https://github.com/eslint/eslint/blob/main/CHANGELOG.md)
- [Commits](https://github.com/eslint/eslint/compare/v8.45.0...v8.46.0)

Updates `eslint-plugin-import` from 2.27.5 to 2.28.0
- [Release notes](https://github.com/import-js/eslint-plugin-import/releases)
- [Changelog](https://github.com/import-js/eslint-plugin-import/blob/main/CHANGELOG.md)
- [Commits](https://github.com/import-js/eslint-plugin-import/compare/v2.27.5...v2.28.0)

---
updated-dependencies:
- dependency-name: eslint
  dependency-type: direct:development
  update-type: version-update:semver-minor
  dependency-group: npm
- dependency-name: eslint-plugin-import
  dependency-type: direct:development
  update-type: version-update:semver-minor
  dependency-group: npm
...

Signed-off-by: dependabot[bot] <support@github.com>

* Update checked-in dependencies

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

node_modules/object.groupby/aos/AddValueToKeyedGroup.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+var GetIntrinsic = require('get-intrinsic');
+var SameValue = require('es-abstract/2022/SameValue');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $filter = callBound('Array.prototype.filter');
+var $push = callBound('Array.prototype.push');
+
+module.exports = function AddValueToKeyedGroup(groups, key, value) {
+	var found = $filter(groups, function (group) {
+		return SameValue(group['[[Key]]'], key); // eslint-disable-line new-cap
+	});
+	if (found.length > 0) {
+		var g = found[0];
+		if (found.length !== 1) {
+			throw new $TypeError('Assertion failed: more than 1 Record inside `groups` has a `[[Key]]` that is SameValue to `key`');
+		}
+		$push(g['[[Elements]]'], value); // step 1.a.ii
+	} else {
+		var group = { '[[Key]]': key, '[[Elements]]': [value] }; // eslint-disable-line sort-keys
+		$push(groups, group); // step 3
+	}
+};

node_modules/object.groupby/aos/GroupBy.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var AddValueToKeyedGroup = require('./AddValueToKeyedGroup');
+var Call = require('es-abstract/2022/Call');
+var GetIterator = require('es-abstract/2022/GetIterator');
+var IsCallable = require('es-abstract/2022/IsCallable');
+var IteratorClose = require('./IteratorClose');
+var IteratorStep = require('./IteratorStep');
+var IteratorValue = require('es-abstract/2022/IteratorValue');
+var maxSafeInteger = require('es-abstract/helpers/maxSafeInteger');
+var RequireObjectCoercible = require('es-abstract/2022/RequireObjectCoercible');
+var ThrowCompletion = require('es-abstract/2022/ThrowCompletion');
+var ToPropertyKey = require('es-abstract/2022/ToPropertyKey');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+module.exports = function GroupBy(items, callbackfn, coercion) {
+	if (coercion !== 'property' && coercion !== 'zero') {
+		throw new $TypeError('Assertion failed: `coercion` must be `"property"` or `"zero"`');
+	}
+
+	RequireObjectCoercible(items); // step 1
+
+	if (!IsCallable(callbackfn)) { // step 2
+		throw new $TypeError('`callbackfn` must be callable');
+	}
+
+	var groups = []; // step 3
+
+	var iterator = GetIterator(items); // step 4
+	var iteratorRecord = { // TODO: remove this once GetIterator is on ES2023+
+		'[[Iterator]]': iterator,
+		'[[NextMethod]]': iterator.next,
+		'[[Done]]': false // eslint-disable-line sort-keys
+	};
+
+	var k = 0; // step 5
+
+	// eslint-disable-next-line no-constant-condition
+	while (true) { // step 6
+		if (k >= maxSafeInteger) { // step 6.a
+			var error = ThrowCompletion(new $TypeError('Iteration count exceeds the max safe integer value')); // step 6.a.i
+			return IteratorClose(iteratorRecord, error); // step 6.a.ii
+		}
+
+		var next = IteratorStep(iteratorRecord); // step 6.b
+		if (!next) { // step 6.c
+			return groups; // step 6.c.i
+		}
+
+		var value = IteratorValue(next); // step 6.d
+
+		var key;
+		try {
+			key = Call(callbackfn, undefined, [value, k]); // step 6.e
+		} catch (e) {
+			IteratorClose(iteratorRecord, ThrowCompletion(e)); // step 6.f
+		}
+
+		if (coercion === 'property') { // step 6.g
+			try {
+				key = ToPropertyKey(key); // step 6.g.i
+			} catch (e) {
+				IteratorClose(iteratorRecord, ThrowCompletion(e)); // step 6.g.ii
+			}
+		} else {
+			if (coercion !== 'zero') {
+				throw new $TypeError('Assertion failed: `coercion` should be `"zero"` here'); // step 6.h.i
+			}
+			if (key === 0) { // step 6.h.ii
+				key = 0; // handle negative zero
+			}
+		}
+
+		AddValueToKeyedGroup(groups, key, value); // step 6.i
+
+		k += 1; // step 6.j
+	}
+};

node_modules/object.groupby/aos/IteratorClose.js

@@ -0,0 +1,67 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Call = require('es-abstract/2022/Call');
+var CompletionRecord = require('es-abstract/2022/CompletionRecord');
+var GetMethod = require('es-abstract/2022/GetMethod');
+var Type = require('es-abstract/2022/Type');
+
+var assertRecord = require('es-abstract/helpers/assertRecord');
+
+// https://262.ecma-international.org/14.0/#sec-iteratorclose
+
+module.exports = function IteratorClose(iteratorRecord, completion) {
+	assertRecord(Type, 'Iterator Record', 'iteratorRecord', iteratorRecord);
+	if (Type(iteratorRecord['[[Iterator]]']) !== 'Object') {
+		throw new $TypeError('Assertion failed: iteratorRecord.[[Iterator]] must be an Object'); // step 1
+	}
+
+	if (!(completion instanceof CompletionRecord)) { // step 2
+		throw new $TypeError('Assertion failed: completion is not a Completion Record instance');
+	}
+	var completionThunk = function () {
+		var value = completion.value();
+		if (completion.type() === 'throw') {
+			throw value;
+		}
+		return value;
+	};
+
+	var iterator = iteratorRecord['[[Iterator]]']; // step 3
+
+	var iteratorReturn;
+	try {
+		iteratorReturn = GetMethod(iterator, 'return'); // step 4
+	} catch (e) {
+		completionThunk(); // throws if `completion` is a throw completion // step 6
+		completionThunk = null; // ensure it's not called twice.
+		throw e; // step 7
+	}
+	if (typeof iteratorReturn === 'undefined') {
+		return completionThunk(); // step 5.a - 5.b
+	}
+
+	var innerResult;
+	try {
+		innerResult = Call(iteratorReturn, iterator, []);
+	} catch (e) {
+		// if we hit here, then "e" is the innerResult completion that needs re-throwing
+
+		completionThunk(); // throws if `completion` is a throw completion // step 6
+		completionThunk = null; // ensure it's not called twice.
+
+		// if not, then return the innerResult completion
+		throw e; // step 7
+	}
+	var completionRecord = completionThunk(); // if innerResult worked, then throw if the completion does
+	completionThunk = null; // ensure it's not called twice.
+
+	if (Type(innerResult) !== 'Object') {
+		throw new $TypeError('iterator .return must return an object');
+	}
+
+	return completionRecord;
+};

node_modules/object.groupby/aos/IteratorNext.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Call = require('es-abstract/2022/Call');
+var Type = require('es-abstract/2022/Type');
+
+var assertRecord = require('es-abstract/helpers/assertRecord');
+
+// https://262.ecma-international.org/14.0/#sec-iteratornext
+
+module.exports = function IteratorNext(iteratorRecord) {
+	assertRecord(Type, 'Iterator Record', 'iteratorRecord', iteratorRecord);
+
+	var result;
+	if (arguments.length < 2) { // step 1
+		result = Call(iteratorRecord['[[NextMethod]]'], iteratorRecord['[[Iterator]]']); // step 1.a
+	} else { // step 2
+		result = Call(iteratorRecord['[[NextMethod]]'], iteratorRecord['[[Iterator]]'], [arguments[1]]); // step 2.a
+	}
+
+	if (Type(result) !== 'Object') {
+		throw new $TypeError('iterator next must return an object'); // step 3
+	}
+	return result; // step 4
+};

node_modules/object.groupby/aos/IteratorStep.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var IteratorComplete = require('es-abstract/2022/IteratorComplete');
+var IteratorNext = require('./IteratorNext');
+var Type = require('es-abstract/2022/Type');
+
+var assertRecord = require('es-abstract/helpers/assertRecord');
+
+// https://262.ecma-international.org/14.0/#sec-iteratorstep
+
+module.exports = function IteratorStep(iteratorRecord) {
+	assertRecord(Type, 'Iterator Record', 'iteratorRecord', iteratorRecord);
+
+	var result = IteratorNext(iteratorRecord); // step 1
+	var done = IteratorComplete(result); // step 2
+	return done === true ? false : result; // steps 3-4
+};
+