robojerk/codeql-action

Bump the npm group with 2 updates (#1819)

Browse source 
* 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>
This commit is contained in:
dependabot[bot] 2023-08-01 03:35:02 -07:00 • committed by GitHub
parent a6b0ced86b
commit e7e35baaf0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1408 changed files with 27215 additions and 9910 deletions
Download patch file Download diff file Expand all files Collapse all files

86
node_modules/es-abstract/2022/RawBytesToNumeric.js generated vendored
View file

@ -3,7 +3,6 @@
var GetIntrinsic = require('get-intrinsic');
var callBound = require('call-bind/callBound');
var $pow = GetIntrinsic('%Math.pow%');
var $RangeError = GetIntrinsic('%RangeError%');
var $SyntaxError = GetIntrinsic('%SyntaxError%');
var $TypeError = GetIntrinsic('%TypeError%');
@ -15,6 +14,9 @@ var IsBigIntElementType = require('./IsBigIntElementType');
var IsUnsignedElementType = require('./IsUnsignedElementType');
var Type = require('./Type');
var bytesAsFloat32 = require('../helpers/bytesAsFloat32');
var bytesAsFloat64 = require('../helpers/bytesAsFloat64');
var bytesAsInteger = require('../helpers/bytesAsInteger');
var every = require('../helpers/every');
var isByteValue = require('../helpers/isByteValue');
@ -67,90 +69,16 @@ module.exports = function RawBytesToNumeric(type, rawBytes, isLittleEndian) {
// eslint-disable-next-line no-param-reassign
rawBytes = $slice(rawBytes, 0, elementSize);
if (!isLittleEndian) {
// eslint-disable-next-line no-param-reassign
rawBytes = $reverse(rawBytes); // step 2
$reverse(rawBytes); // step 2
}
/* eslint no-redeclare: 1 */
if (type === 'Float32') { // step 3
/*
Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2008 binary32 value.
If value is an IEEE 754-2008 binary32 NaN value, return the NaN Number value.
Return the Number value that corresponds to value.
*/
var sign = (rawBytes[3] & 0x80) >> 7; // first bit
var exponent = ((rawBytes[3] & 0x7F) << 1) // 7 bits from index 3
| ((rawBytes[2] & 0x80) >> 7); // 1 bit from index 2
var mantissa = ((rawBytes[2] & 0x7F) << 16) // 7 bits from index 2
| (rawBytes[1] << 8) // 8 bits from index 1
| rawBytes[0]; // 8 bits from index 0
if (exponent === 0 && mantissa === 0) {
return sign === 0 ? 0 : -0;
}
if (exponent === 0xFF && mantissa === 0) {
return sign === 0 ? Infinity : -Infinity;
}
if (exponent === 0xFF && mantissa !== 0) {
return NaN;
}
exponent -= 127; // subtract the bias
// return $pow(-1, sign) * mantissa / $pow(2, 23) * $pow(2, exponent);
// return $pow(-1, sign) * (mantissa + 0x1000000) * $pow(2, exponent - 23);
return $pow(-1, sign) * (1 + (mantissa / $pow(2, 23))) * $pow(2, exponent);
return bytesAsFloat32(rawBytes);
}
if (type === 'Float64') { // step 4
/*
Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2008 binary64 value.
If value is an IEEE 754-2008 binary64 NaN value, return the NaN Number value.
Return the Number value that corresponds to value.
*/
var sign = rawBytes[7] & 0x80 ? -1 : 1; // first bit
var exponent = ((rawBytes[7] & 0x7F) << 4) // 7 bits from index 7
| ((rawBytes[6] & 0xF0) >> 4); // 4 bits from index 6
var mantissa = ((rawBytes[6] & 0x0F) * 0x1000000000000) // 4 bits from index 6
+ (rawBytes[5] * 0x10000000000) // 8 bits from index 5
+ (rawBytes[4] * 0x100000000) // 8 bits from index 4
+ (rawBytes[3] * 0x1000000) // 8 bits from index 3
+ (rawBytes[2] * 0x10000) // 8 bits from index 2
+ (rawBytes[1] * 0x100) // 8 bits from index 1
+ rawBytes[0]; // 8 bits from index 0
if (exponent === 0 && mantissa === 0) {
return sign * 0;
}
if (exponent === 0x7FF && mantissa !== 0) {
return NaN;
}
if (exponent === 0x7FF && mantissa === 0) {
return sign * Infinity;
}
exponent -= 1023; // subtract the bias
return sign * (mantissa + 0x10000000000000) * $pow(2, exponent - 52);
return bytesAsFloat64(rawBytes);
}
// this is common to both branches
var intValue = isBigInt ? $BigInt(0) : 0;
for (var i = 0; i < rawBytes.length; i++) {
intValue |= isBigInt ? $BigInt(rawBytes[i]) << $BigInt(8 * i) : rawBytes[i] << (8 * i);
}
/*
Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of an unsigned little-endian binary number.
*/
if (!IsUnsignedElementType(type)) { // steps 5-6
// Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of a binary little-endian 2's complement number of bit length elementSize × 8.
var bitLength = elementSize * 8;
if (bitLength < 32) {
var x = isBigInt ? $BigInt(32 - bitLength) : 32 - bitLength;
intValue = (intValue << x) >> x;
}
}
return intValue; // step 7
return bytesAsInteger(rawBytes, elementSize, IsUnsignedElementType(type), isBigInt);
};