Add files using upload-large-folder tool

novas/novacore-zephyr/groq-code-cli/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);
+};

novas/novacore-zephyr/groq-code-cli/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);
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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);
+};

novas/novacore-zephyr/groq-code-cli/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);
+};

novas/novacore-zephyr/groq-code-cli/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);
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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);
+};

novas/novacore-zephyr/groq-code-cli/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;
+};

novas/novacore-zephyr/groq-code-cli/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');
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/add.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isFinite = require('math-intrinsics/isFinite');
+var isNaN = require('math-intrinsics/isNaN');
+
+// https://262.ecma-international.org/12.0/#sec-numeric-types-number-add
+
+module.exports = function NumberAdd(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+
+	if (isNaN(x) || isNaN(y) || (x === Infinity && y === -Infinity) || (x === -Infinity && y === Infinity)) {
+		return NaN;
+	}
+
+	if (!isFinite(x)) {
+		return x;
+	}
+	if (!isFinite(y)) {
+		return y;
+	}
+
+	if (x === y && x === 0) { // both zeroes
+		return Infinity / x === -Infinity && Infinity / y === -Infinity ? -0 : +0;
+	}
+
+	// shortcut for the actual spec mechanics
+	return x + y;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/bitwiseAND.js

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

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/bitwiseNOT.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var ToInt32 = require('../ToInt32');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-bitwiseNOT
+
+module.exports = function NumberBitwiseNOT(x) {
+	if (typeof x !== 'number') {
+		throw new $TypeError('Assertion failed: `x` argument must be a Number');
+	}
+	var oldValue = ToInt32(x);
+	// Return the result of applying the bitwise operator op to lnum and rnum. The result is a signed 32-bit integer.
+	return ~oldValue;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/bitwiseOR.js

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

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/bitwiseXOR.js

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

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/divide.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isFinite = require('math-intrinsics/isFinite');
+var isNaN = require('math-intrinsics/isNaN');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-divide
+
+module.exports = function NumberDivide(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+	if (isNaN(x) || isNaN(y) || (!isFinite(x) && !isFinite(y))) {
+		return NaN;
+	}
+	// shortcut for the actual spec mechanics
+	return x / y;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/equal.js

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

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/exponentiate.js

@@ -0,0 +1,74 @@
+'use strict';
+
+// var isNegativeZero = require('math-intrinsics/isNegativeZero');
+var $pow = require('math-intrinsics/pow');
+
+var $TypeError = require('es-errors/type');
+
+/*
+var abs = require('math-intrinsics/abs');
+var isFinite = require('math-intrinsics/isFinite');
+var isNaN = require('math-intrinsics/isNaN');
+
+var IsInteger = require('math-intrinsics/isInteger');
+*/
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-exponentiate
+
+/* eslint max-lines-per-function: 0, max-statements: 0 */
+
+module.exports = function NumberExponentiate(base, exponent) {
+	if (typeof base !== 'number' || typeof exponent !== 'number') {
+		throw new $TypeError('Assertion failed: `base` and `exponent` arguments must be Numbers');
+	}
+	return $pow(base, exponent);
+	/*
+	if (isNaN(exponent)) {
+		return NaN;
+	}
+	if (exponent === 0) {
+		return 1;
+	}
+	if (isNaN(base)) {
+		return NaN;
+	}
+	var aB = abs(base);
+	if (aB > 1 && exponent === Infinity) {
+		return Infinity;
+	}
+	if (aB > 1 && exponent === -Infinity) {
+		return 0;
+	}
+	if (aB === 1 && (exponent === Infinity || exponent === -Infinity)) {
+		return NaN;
+	}
+	if (aB < 1 && exponent === Infinity) {
+		return +0;
+	}
+	if (aB < 1 && exponent === -Infinity) {
+		return Infinity;
+	}
+	if (base === Infinity) {
+		return exponent > 0 ? Infinity : 0;
+	}
+	if (base === -Infinity) {
+		var isOdd = true;
+		if (exponent > 0) {
+			return isOdd ? -Infinity : Infinity;
+		}
+		return isOdd ? -0 : 0;
+	}
+	if (exponent > 0) {
+		return isNegativeZero(base) ? Infinity : 0;
+	}
+	if (isNegativeZero(base)) {
+		if (exponent > 0) {
+			return isOdd ? -0 : 0;
+		}
+		return isOdd ? -Infinity : Infinity;
+	}
+	if (base < 0 && isFinite(base) && isFinite(exponent) && !IsInteger(exponent)) {
+		return NaN;
+	}
+	*/
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var add = require('./add');
+var bitwiseAND = require('./bitwiseAND');
+var bitwiseNOT = require('./bitwiseNOT');
+var bitwiseOR = require('./bitwiseOR');
+var bitwiseXOR = require('./bitwiseXOR');
+var divide = require('./divide');
+var equal = require('./equal');
+var exponentiate = require('./exponentiate');
+var leftShift = require('./leftShift');
+var lessThan = require('./lessThan');
+var multiply = require('./multiply');
+var remainder = require('./remainder');
+var sameValue = require('./sameValue');
+var sameValueZero = require('./sameValueZero');
+var signedRightShift = require('./signedRightShift');
+var subtract = require('./subtract');
+var toString = require('./toString');
+var unaryMinus = require('./unaryMinus');
+var unsignedRightShift = require('./unsignedRightShift');
+
+module.exports = {
+	add: add,
+	bitwiseAND: bitwiseAND,
+	bitwiseNOT: bitwiseNOT,
+	bitwiseOR: bitwiseOR,
+	bitwiseXOR: bitwiseXOR,
+	divide: divide,
+	equal: equal,
+	exponentiate: exponentiate,
+	leftShift: leftShift,
+	lessThan: lessThan,
+	multiply: multiply,
+	remainder: remainder,
+	sameValue: sameValue,
+	sameValueZero: sameValueZero,
+	signedRightShift: signedRightShift,
+	subtract: subtract,
+	toString: toString,
+	unaryMinus: unaryMinus,
+	unsignedRightShift: unsignedRightShift
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/leftShift.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var ToInt32 = require('../ToInt32');
+var ToUint32 = require('../ToUint32');
+var modulo = require('../modulo');
+
+// https://262.ecma-international.org/12.0/#sec-numeric-types-number-leftShift
+
+module.exports = function NumberLeftShift(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+
+	var lnum = ToInt32(x);
+	var rnum = ToUint32(y);
+
+	var shiftCount = modulo(rnum, 32);
+
+	return lnum << shiftCount;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/lessThan.js

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

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/multiply.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var isNaN = require('../../helpers/isNaN');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-multiply
+
+module.exports = function NumberMultiply(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+
+	if (isNaN(x) || isNaN(y) || (x === 0 && !isFinite(y)) || (!isFinite(x) && y === 0)) {
+		return NaN;
+	}
+	if (!isFinite(x) && !isFinite(y)) {
+		return x === y ? Infinity : -Infinity;
+	}
+	if (!isFinite(x) && y !== 0) {
+		return x > 0 ? Infinity : -Infinity;
+	}
+	if (!isFinite(y) && x !== 0) {
+		return y > 0 ? Infinity : -Infinity;
+	}
+
+	// shortcut for the actual spec mechanics
+	return x * y;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/remainder.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var isNaN = require('../../helpers/isNaN');
+
+// https://262.ecma-international.org/12.0/#sec-numeric-types-number-remainder
+
+module.exports = function NumberRemainder(n, d) {
+	if (typeof n !== 'number' || typeof d !== 'number') {
+		throw new $TypeError('Assertion failed: `n` and `d` arguments must be Numbers');
+	}
+
+	// If either operand is NaN, the result is NaN.
+	// If the dividend is an infinity, or the divisor is a zero, or both, the result is NaN.
+	if (isNaN(n) || isNaN(d) || !isFinite(n) || d === 0) {
+		return NaN;
+	}
+
+	// If the dividend is finite and the divisor is an infinity, the result equals the dividend.
+	// If the dividend is a zero and the divisor is nonzero and finite, the result is the same as the dividend.
+	if (!isFinite(d) || n === 0) {
+		return n;
+	}
+
+	// In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved…
+	return n % d;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/sameValue.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var isNegativeZero = require('math-intrinsics/isNegativeZero');
+var $TypeError = require('es-errors/type');
+
+var NumberSameValueZero = require('./sameValueZero');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-sameValue
+
+module.exports = function NumberSameValue(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+	if (x === 0 && y === 0) {
+		return !(isNegativeZero(x) ^ isNegativeZero(y));
+	}
+	return NumberSameValueZero(x, y);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/sameValueZero.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var isNaN = require('../../helpers/isNaN');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-sameValueZero
+
+module.exports = function NumberSameValueZero(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+
+	var xNaN = isNaN(x);
+	var yNaN = isNaN(y);
+	if (xNaN || yNaN) {
+		return xNaN === yNaN;
+	}
+	return x === y;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/signedRightShift.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var ToInt32 = require('../ToInt32');
+var ToUint32 = require('../ToUint32');
+var modulo = require('../modulo');
+
+// https://262.ecma-international.org/12.0/#sec-numeric-types-number-signedRightShift
+
+module.exports = function NumberSignedRightShift(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+
+	var lnum = ToInt32(x);
+	var rnum = ToUint32(y);
+
+	var shiftCount = modulo(rnum, 32);
+
+	return lnum >> shiftCount;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/subtract.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var NumberAdd = require('./add');
+var NumberUnaryMinus = require('./unaryMinus');
+
+// https://262.ecma-international.org/12.0/#sec-numeric-types-number-subtract
+
+module.exports = function NumberSubtract(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+	return NumberAdd(x, NumberUnaryMinus(y));
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/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-number-tostring
+
+module.exports = function NumberToString(x) {
+	if (typeof x !== 'number') {
+		throw new $TypeError('Assertion failed: `x` must be a Number');
+	}
+
+	return $String(x);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/unaryMinus.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var isNaN = require('../../helpers/isNaN');
+
+// https://262.ecma-international.org/11.0/#sec-numeric-types-number-unaryMinus
+
+module.exports = function NumberUnaryMinus(x) {
+	if (typeof x !== 'number') {
+		throw new $TypeError('Assertion failed: `x` argument must be a Number');
+	}
+	if (isNaN(x)) {
+		return NaN;
+	}
+	return -x;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/Number/unsignedRightShift.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var ToInt32 = require('../ToInt32');
+var ToUint32 = require('../ToUint32');
+var modulo = require('../modulo');
+
+// https://262.ecma-international.org/12.0/#sec-numeric-types-number-unsignedRightShift
+
+module.exports = function NumberUnsignedRightShift(x, y) {
+	if (typeof x !== 'number' || typeof y !== 'number') {
+		throw new $TypeError('Assertion failed: `x` and `y` arguments must be Numbers');
+	}
+
+	var lnum = ToInt32(x);
+	var rnum = ToUint32(y);
+
+	var shiftCount = modulo(rnum, 32);
+
+	return lnum >>> shiftCount;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2021/tables/typed-array-objects.js

@@ -0,0 +1,36 @@
+'use strict';
+
+// https://262.ecma-international.org/11.0/#table-the-typedarray-constructors
+
+module.exports = {
+	__proto__: null,
+	name: {
+		__proto__: null,
+		$Int8Array: 'Int8',
+		$Uint8Array: 'Uint8',
+		$Uint8ClampedArray: 'Uint8C',
+		$Int16Array: 'Int16',
+		$Uint16Array: 'Uint16',
+		$Int32Array: 'Int32',
+		$Uint32Array: 'Uint32',
+		$BigInt64Array: 'BigInt64',
+		$BigUint64Array: 'BigUint64',
+		$Float32Array: 'Float32',
+		$Float64Array: 'Float64'
+	},
+	size: {
+		__proto__: null,
+		$Int8: 1,
+		$Uint8: 1,
+		$Uint8C: 1,
+		$Int16: 2,
+		$Uint16: 2,
+		$Int32: 4,
+		$Uint32: 4,
+		$BigInt64: 8,
+		$BigUint64: 8,
+		$Float32: 4,
+		$Float64: 8
+	},
+	choices: '"Int8", "Uint8", "Uint8C", "Int16", "Uint16", "Int32", "Uint32", "BigInt64", "BigUint64", "Float32", or "Float64"'
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2022/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;
+};