Add files using upload-large-folder tool

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/StringCreate.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Object = require('es-object-atoms');
+var $StringPrototype = GetIntrinsic('%String.prototype%');
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var setProto = require('set-proto');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+
+// https://262.ecma-international.org/6.0/#sec-stringcreate
+
+module.exports = function StringCreate(value, prototype) {
+	if (typeof value !== 'string') {
+		throw new $TypeError('Assertion failed: `S` must be a String');
+	}
+
+	var S = $Object(value);
+	if (prototype !== $StringPrototype) {
+		if (setProto) {
+			setProto(S, prototype);
+		} else {
+			throw new $SyntaxError('StringCreate: a `proto` argument that is not `String.prototype` is not supported in an environment that does not support setting the [[Prototype]]');
+		}
+	}
+
+	var length = value.length;
+	DefinePropertyOrThrow(S, 'length', {
+		'[[Configurable]]': false,
+		'[[Enumerable]]': false,
+		'[[Value]]': length,
+		'[[Writable]]': false
+	});
+
+	return S;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/SymbolDescriptiveString.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var callBound = require('call-bound');
+
+var $SymbolToString = callBound('Symbol.prototype.toString', true);
+
+// https://262.ecma-international.org/6.0/#sec-symboldescriptivestring
+
+module.exports = function SymbolDescriptiveString(sym) {
+	if (typeof sym !== 'symbol') {
+		throw new $TypeError('Assertion failed: `sym` must be a Symbol');
+	}
+	return $SymbolToString(sym);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/TestIntegrityLevel.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var $gOPD = require('gopd');
+var $TypeError = require('es-errors/type');
+
+var every = require('../helpers/every');
+var OwnPropertyKeys = require('own-keys');
+var isObject = require('es-object-atoms/isObject');
+
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsExtensible = require('./IsExtensible');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-testintegritylevel
+
+module.exports = function TestIntegrityLevel(O, level) {
+	if (!isObject(O)) {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (level !== 'sealed' && level !== 'frozen') {
+		throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`');
+	}
+	var status = IsExtensible(O);
+	if (status || !$gOPD) {
+		return false;
+	}
+	var theKeys = OwnPropertyKeys(O);
+	return theKeys.length === 0 || every(theKeys, function (k) {
+		var currentDesc = $gOPD(O, k);
+		if (typeof currentDesc !== 'undefined') {
+			if (currentDesc.configurable) {
+				return false;
+			}
+			if (level === 'frozen' && IsDataDescriptor(ToPropertyDescriptor(currentDesc)) && currentDesc.writable) {
+				return false;
+			}
+		}
+		return true;
+	});
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/TimeClip.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Date = GetIntrinsic('%Date%');
+
+var $isFinite = require('math-intrinsics/isFinite');
+var abs = require('math-intrinsics/abs');
+
+var ToNumber = require('./ToNumber');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.14
+
+module.exports = function TimeClip(time) {
+	if (!$isFinite(time) || abs(time) > 8.64e15) {
+		return NaN;
+	}
+	return +new $Date(ToNumber(time));
+};
+

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/TimeFromYear.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+var DayFromYear = require('./DayFromYear');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function TimeFromYear(y) {
+	return msPerDay * DayFromYear(y);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/TimeWithinDay.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var modulo = require('./modulo');
+
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.2
+
+module.exports = function TimeWithinDay(t) {
+	return modulo(t, msPerDay);
+};
+

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToBoolean.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// http://262.ecma-international.org/5.1/#sec-9.2
+
+module.exports = function ToBoolean(value) { return !!value; };

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToDateString.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = require('es-errors/type');
+var $Date = GetIntrinsic('%Date%');
+var $String = GetIntrinsic('%String%');
+
+var $isNaN = require('math-intrinsics/isNaN');
+
+// https://262.ecma-international.org/6.0/#sec-todatestring
+
+module.exports = function ToDateString(tv) {
+	if (typeof tv !== 'number') {
+		throw new $TypeError('Assertion failed: `tv` must be a Number');
+	}
+	if ($isNaN(tv)) {
+		return 'Invalid Date';
+	}
+	return $String(new $Date(tv));
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToInt16.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var ToUint16 = require('./ToUint16');
+
+// https://262.ecma-international.org/6.0/#sec-toint16
+
+module.exports = function ToInt16(argument) {
+	var int16bit = ToUint16(argument);
+	return int16bit >= 0x8000 ? int16bit - 0x10000 : int16bit;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToInt32.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+// http://262.ecma-international.org/5.1/#sec-9.5
+
+module.exports = function ToInt32(x) {
+	return ToNumber(x) >> 0;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToInt8.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var ToUint8 = require('./ToUint8');
+
+// https://262.ecma-international.org/6.0/#sec-toint8
+
+module.exports = function ToInt8(argument) {
+	var int8bit = ToUint8(argument);
+	return int8bit >= 0x80 ? int8bit - 0x100 : int8bit;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToInteger.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var ES5ToInteger = require('../5/ToInteger');
+
+var ToNumber = require('./ToNumber');
+
+// https://262.ecma-international.org/6.0/#sec-tointeger
+
+module.exports = function ToInteger(value) {
+	var number = ToNumber(value);
+	return ES5ToInteger(number);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToLength.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var MAX_SAFE_INTEGER = require('math-intrinsics/constants/maxSafeInteger');
+
+var ToInteger = require('./ToInteger');
+
+// https://262.ecma-international.org/6.0/#sec-tolength
+
+module.exports = function ToLength(argument) {
+	var len = ToInteger(argument);
+	if (len <= 0) { return 0; } // includes converting -0 to +0
+	if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; }
+	return len;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToNumber.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = require('es-errors/type');
+var $Number = GetIntrinsic('%Number%');
+var $RegExp = GetIntrinsic('%RegExp%');
+var $parseInteger = GetIntrinsic('%parseInt%');
+
+var callBound = require('call-bound');
+var regexTester = require('safe-regex-test');
+var isPrimitive = require('../helpers/isPrimitive');
+
+var $strSlice = callBound('String.prototype.slice');
+var isBinary = regexTester(/^0b[01]+$/i);
+var isOctal = regexTester(/^0o[0-7]+$/i);
+var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
+var nonWS = ['\u0085', '\u200b', '\ufffe'].join('');
+var nonWSregex = new $RegExp('[' + nonWS + ']', 'g');
+var hasNonWS = regexTester(nonWSregex);
+
+var $trim = require('string.prototype.trim');
+
+var ToPrimitive = require('./ToPrimitive');
+
+// https://262.ecma-international.org/6.0/#sec-tonumber
+
+module.exports = function ToNumber(argument) {
+	var value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);
+	if (typeof value === 'symbol') {
+		throw new $TypeError('Cannot convert a Symbol value to a number');
+	}
+	if (typeof value === 'string') {
+		if (isBinary(value)) {
+			return ToNumber($parseInteger($strSlice(value, 2), 2));
+		} else if (isOctal(value)) {
+			return ToNumber($parseInteger($strSlice(value, 2), 8));
+		} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {
+			return NaN;
+		}
+		var trimmed = $trim(value);
+		if (trimmed !== value) {
+			return ToNumber(trimmed);
+		}
+
+	}
+	return +value;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToObject.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// https://262.ecma-international.org/6.0/#sec-toobject
+
+module.exports = require('es-object-atoms/ToObject');

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToPrimitive.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var toPrimitive = require('es-to-primitive/es2015');
+
+// https://262.ecma-international.org/6.0/#sec-toprimitive
+
+module.exports = function ToPrimitive(input) {
+	if (arguments.length > 1) {
+		return toPrimitive(input, arguments[1]);
+	}
+	return toPrimitive(input);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToPropertyDescriptor.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var hasOwn = require('hasown');
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var IsCallable = require('./IsCallable');
+var ToBoolean = require('./ToBoolean');
+
+// https://262.ecma-international.org/5.1/#sec-8.10.5
+
+module.exports = function ToPropertyDescriptor(Obj) {
+	if (!isObject(Obj)) {
+		throw new $TypeError('ToPropertyDescriptor requires an object');
+	}
+
+	var desc = {};
+	if (hasOwn(Obj, 'enumerable')) {
+		desc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);
+	}
+	if (hasOwn(Obj, 'configurable')) {
+		desc['[[Configurable]]'] = ToBoolean(Obj.configurable);
+	}
+	if (hasOwn(Obj, 'value')) {
+		desc['[[Value]]'] = Obj.value;
+	}
+	if (hasOwn(Obj, 'writable')) {
+		desc['[[Writable]]'] = ToBoolean(Obj.writable);
+	}
+	if (hasOwn(Obj, 'get')) {
+		var getter = Obj.get;
+		if (typeof getter !== 'undefined' && !IsCallable(getter)) {
+			throw new $TypeError('getter must be a function');
+		}
+		desc['[[Get]]'] = getter;
+	}
+	if (hasOwn(Obj, 'set')) {
+		var setter = Obj.set;
+		if (typeof setter !== 'undefined' && !IsCallable(setter)) {
+			throw new $TypeError('setter must be a function');
+		}
+		desc['[[Set]]'] = setter;
+	}
+
+	if ((hasOwn(desc, '[[Get]]') || hasOwn(desc, '[[Set]]')) && (hasOwn(desc, '[[Value]]') || hasOwn(desc, '[[Writable]]'))) {
+		throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
+	}
+	return desc;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToPropertyKey.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+
+var ToPrimitive = require('./ToPrimitive');
+var ToString = require('./ToString');
+
+// https://262.ecma-international.org/6.0/#sec-topropertykey
+
+module.exports = function ToPropertyKey(argument) {
+	var key = ToPrimitive(argument, $String);
+	return typeof key === 'symbol' ? key : ToString(key);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToString.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+var $TypeError = require('es-errors/type');
+
+// https://262.ecma-international.org/6.0/#sec-tostring
+
+module.exports = function ToString(argument) {
+	if (typeof argument === 'symbol') {
+		throw new $TypeError('Cannot convert a Symbol value to a string');
+	}
+	return $String(argument);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToUint16.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var modulo = require('./modulo');
+var ToNumber = require('./ToNumber');
+
+var abs = require('math-intrinsics/abs');
+var floor = require('math-intrinsics/floor');
+var $isNaN = require('math-intrinsics/isNaN');
+var $isFinite = require('math-intrinsics/isFinite');
+var $sign = require('math-intrinsics/sign');
+
+// http://262.ecma-international.org/5.1/#sec-9.7
+
+module.exports = function ToUint16(value) {
+	var number = ToNumber(value);
+	if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
+	var posInt = $sign(number) * floor(abs(number));
+	return modulo(posInt, 0x10000);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToUint32.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+// http://262.ecma-international.org/5.1/#sec-9.6
+
+module.exports = function ToUint32(x) {
+	return ToNumber(x) >>> 0;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToUint8.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+var $isNaN = require('math-intrinsics/isNaN');
+var $isFinite = require('math-intrinsics/isFinite');
+var $sign = require('math-intrinsics/sign');
+var abs = require('math-intrinsics/abs');
+var floor = require('math-intrinsics/floor');
+var modulo = require('math-intrinsics/mod');
+
+// https://262.ecma-international.org/6.0/#sec-touint8
+
+module.exports = function ToUint8(argument) {
+	var number = ToNumber(argument);
+	if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
+	var posInt = $sign(number) * floor(abs(number));
+	return modulo(posInt, 0x100);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ToUint8Clamp.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+var floor = require('./floor');
+
+var $isNaN = require('math-intrinsics/isNaN');
+
+// https://262.ecma-international.org/6.0/#sec-touint8clamp
+
+module.exports = function ToUint8Clamp(argument) {
+	var number = ToNumber(argument);
+	if ($isNaN(number) || number <= 0) { return 0; }
+	if (number >= 0xFF) { return 0xFF; }
+	var f = floor(number);
+	if (f + 0.5 < number) { return f + 1; }
+	if (number < f + 0.5) { return f; }
+	if (f % 2 !== 0) { return f + 1; }
+	return f;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/Type.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var ES5Type = require('../5/Type');
+
+// https://262.ecma-international.org/6.0/#sec-ecmascript-data-types-and-values
+
+module.exports = function Type(x) {
+	if (typeof x === 'symbol') {
+		return 'Symbol';
+	}
+	return ES5Type(x);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/TypedArrayCreate.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+
+var IsArray = require('./IsArray');
+var IsConstructor = require('./IsConstructor');
+var ValidateTypedArray = require('./ValidateTypedArray');
+
+var availableTypedArrays = require('available-typed-arrays')();
+var typedArrayLength = require('typed-array-length');
+
+// https://262.ecma-international.org/7.0/#typedarray-create
+
+module.exports = function TypedArrayCreate(constructor, argumentList) {
+	if (!IsConstructor(constructor)) {
+		throw new $TypeError('Assertion failed: `constructor` must be a constructor');
+	}
+	if (!IsArray(argumentList)) {
+		throw new $TypeError('Assertion failed: `argumentList` must be a List');
+	}
+	if (availableTypedArrays.length === 0) {
+		throw new $SyntaxError('Assertion failed: Typed Arrays are not supported in this environment');
+	}
+
+	// var newTypedArray = Construct(constructor, argumentList); // step 1
+	var newTypedArray;
+	if (argumentList.length === 0) {
+		newTypedArray = new constructor();
+	} else if (argumentList.length === 1) {
+		newTypedArray = new constructor(argumentList[0]);
+	} else if (argumentList.length === 2) {
+		newTypedArray = new constructor(argumentList[0], argumentList[1]);
+	} else {
+		newTypedArray = new constructor(argumentList[0], argumentList[1], argumentList[2]);
+	}
+
+	ValidateTypedArray(newTypedArray); // step 2
+
+	if (argumentList.length === 1 && typeof argumentList[0] === 'number') { // step 3
+		if (typedArrayLength(newTypedArray) < argumentList[0]) {
+			throw new $TypeError('Assertion failed: `argumentList[0]` must be <= `newTypedArray.length`'); // step 3.a
+		}
+	}
+
+	return newTypedArray; // step 4
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/TypedArraySpeciesCreate.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+
+var whichTypedArray = require('which-typed-array');
+var availableTypedArrays = require('available-typed-arrays')();
+
+var IsArray = require('./IsArray');
+var SpeciesConstructor = require('./SpeciesConstructor');
+var TypedArrayCreate = require('./TypedArrayCreate');
+
+var getConstructor = require('../helpers/typedArrayConstructors');
+
+// https://262.ecma-international.org/7.0/#typedarray-species-create
+
+module.exports = function TypedArraySpeciesCreate(exemplar, argumentList) {
+	if (availableTypedArrays.length === 0) {
+		throw new $SyntaxError('Assertion failed: Typed Arrays are not supported in this environment');
+	}
+
+	var kind = whichTypedArray(exemplar);
+	if (!kind) {
+		throw new $TypeError('Assertion failed: exemplar must be a TypedArray'); // step 1
+	}
+	if (!IsArray(argumentList)) {
+		throw new $TypeError('Assertion failed: `argumentList` must be a List'); // step 1
+	}
+
+	var defaultConstructor = getConstructor(kind); // step 2
+	if (typeof defaultConstructor !== 'function') {
+		throw new $SyntaxError('Assertion failed: `constructor` of `exemplar` (' + kind + ') must exist. Please report this!');
+	}
+	var constructor = SpeciesConstructor(exemplar, defaultConstructor); // step 3
+
+	return TypedArrayCreate(constructor, argumentList); // step 4
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/UTF16Decode.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = require('es-errors/type');
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+
+// https://262.ecma-international.org/7.0/#sec-utf16decode
+
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+// https://262.ecma-international.org/11.0/#sec-utf16decodesurrogatepair
+
+module.exports = function UTF16Decode(lead, trail) {
+	if (!isLeadingSurrogate(lead) || !isTrailingSurrogate(trail)) {
+		throw new $TypeError('Assertion failed: `lead` must be a leading surrogate char code, and `trail` must be a trailing surrogate char code');
+	}
+	// var cp = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+	return $fromCharCode(lead) + $fromCharCode(trail);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/UTF16Encoding.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = require('es-errors/type');
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+var isCodePoint = require('../helpers/isCodePoint');
+
+// https://262.ecma-international.org/7.0/#sec-utf16encoding
+
+module.exports = function UTF16Encoding(cp) {
+	if (!isCodePoint(cp)) {
+		throw new $TypeError('Assertion failed: `cp` must be >= 0 and <= 0x10FFFF');
+	}
+	if (cp <= 65535) {
+		return $fromCharCode(cp);
+	}
+	var cu1 = $fromCharCode(floor((cp - 65536) / 1024) + 0xD800);
+	var cu2 = $fromCharCode(modulo(cp - 65536, 1024) + 0xDC00);
+	return cu1 + cu2;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ValidateAndApplyPropertyDescriptor.js

@@ -0,0 +1,159 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+var isPropertyDescriptor = require('../helpers/records/property-descriptor');
+var isSamePropertyDescriptor = require('../helpers/isSamePropertyDescriptor');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsGenericDescriptor = require('./IsGenericDescriptor');
+var isPropertyKey = require('../helpers/isPropertyKey');
+var SameValue = require('./SameValue');
+
+// https://262.ecma-international.org/6.0/#sec-validateandapplypropertydescriptor
+// https://262.ecma-international.org/8.0/#sec-validateandapplypropertydescriptor
+
+// eslint-disable-next-line max-lines-per-function, max-statements
+module.exports = function ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current) {
+	// this uses the ES2017+ logic, since it fixes a number of bugs in the ES2015 logic.
+	if (typeof O !== 'undefined' && !isObject(O)) {
+		throw new $TypeError('Assertion failed: O must be undefined or an Object');
+	}
+	if (typeof extensible !== 'boolean') {
+		throw new $TypeError('Assertion failed: extensible must be a Boolean');
+	}
+	if (!isPropertyDescriptor(Desc)) {
+		throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
+	}
+	if (typeof current !== 'undefined' && !isPropertyDescriptor(current)) {
+		throw new $TypeError('Assertion failed: current must be a Property Descriptor, or undefined');
+	}
+	if (typeof O !== 'undefined' && !isPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: if O is not undefined, P must be a Property Key');
+	}
+	if (typeof current === 'undefined') {
+		if (!extensible) {
+			return false;
+		}
+		if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) {
+			if (typeof O !== 'undefined') {
+				DefineOwnProperty(
+					IsDataDescriptor,
+					SameValue,
+					FromPropertyDescriptor,
+					O,
+					P,
+					{
+						'[[Configurable]]': Desc['[[Configurable]]'],
+						'[[Enumerable]]': Desc['[[Enumerable]]'],
+						'[[Value]]': Desc['[[Value]]'],
+						'[[Writable]]': Desc['[[Writable]]']
+					}
+				);
+			}
+		} else {
+			if (!IsAccessorDescriptor(Desc)) {
+				throw new $TypeError('Assertion failed: Desc is not an accessor descriptor');
+			}
+			if (typeof O !== 'undefined') {
+				return DefineOwnProperty(
+					IsDataDescriptor,
+					SameValue,
+					FromPropertyDescriptor,
+					O,
+					P,
+					Desc
+				);
+			}
+		}
+		return true;
+	}
+	if (IsGenericDescriptor(Desc) && !('[[Configurable]]' in Desc) && !('[[Enumerable]]' in Desc)) {
+		return true;
+	}
+	if (isSamePropertyDescriptor({ SameValue: SameValue }, Desc, current)) {
+		return true; // removed by ES2017, but should still be correct
+	}
+	// "if every field in Desc is absent, return true" can't really match the assertion that it's a Property Descriptor
+	if (!current['[[Configurable]]']) {
+		if (Desc['[[Configurable]]']) {
+			return false;
+		}
+		if ('[[Enumerable]]' in Desc && !Desc['[[Enumerable]]'] === !!current['[[Enumerable]]']) {
+			return false;
+		}
+	}
+	if (IsGenericDescriptor(Desc)) {
+		// no further validation is required.
+	} else if (IsDataDescriptor(current) !== IsDataDescriptor(Desc)) {
+		if (!current['[[Configurable]]']) {
+			return false;
+		}
+		if (IsDataDescriptor(current)) {
+			if (typeof O !== 'undefined') {
+				DefineOwnProperty(
+					IsDataDescriptor,
+					SameValue,
+					FromPropertyDescriptor,
+					O,
+					P,
+					{
+						'[[Configurable]]': current['[[Configurable]]'],
+						'[[Enumerable]]': current['[[Enumerable]]'],
+						'[[Get]]': undefined
+					}
+				);
+			}
+		} else if (typeof O !== 'undefined') {
+			DefineOwnProperty(
+				IsDataDescriptor,
+				SameValue,
+				FromPropertyDescriptor,
+				O,
+				P,
+				{
+					'[[Configurable]]': current['[[Configurable]]'],
+					'[[Enumerable]]': current['[[Enumerable]]'],
+					'[[Value]]': undefined
+				}
+			);
+		}
+	} else if (IsDataDescriptor(current) && IsDataDescriptor(Desc)) {
+		if (!current['[[Configurable]]'] && !current['[[Writable]]']) {
+			if ('[[Writable]]' in Desc && Desc['[[Writable]]']) {
+				return false;
+			}
+			if ('[[Value]]' in Desc && !SameValue(Desc['[[Value]]'], current['[[Value]]'])) {
+				return false;
+			}
+			return true;
+		}
+	} else if (IsAccessorDescriptor(current) && IsAccessorDescriptor(Desc)) {
+		if (!current['[[Configurable]]']) {
+			if ('[[Set]]' in Desc && !SameValue(Desc['[[Set]]'], current['[[Set]]'])) {
+				return false;
+			}
+			if ('[[Get]]' in Desc && !SameValue(Desc['[[Get]]'], current['[[Get]]'])) {
+				return false;
+			}
+			return true;
+		}
+	} else {
+		throw new $TypeError('Assertion failed: current and Desc are not both data, both accessors, or one accessor and one data.');
+	}
+	if (typeof O !== 'undefined') {
+		return DefineOwnProperty(
+			IsDataDescriptor,
+			SameValue,
+			FromPropertyDescriptor,
+			O,
+			P,
+			Desc
+		);
+	}
+	return true;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/ValidateTypedArray.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var IsDetachedBuffer = require('./IsDetachedBuffer');
+
+var isTypedArray = require('is-typed-array');
+var typedArrayBuffer = require('typed-array-buffer');
+
+// https://262.ecma-international.org/6.0/#sec-validatetypedarray
+
+module.exports = function ValidateTypedArray(O) {
+	if (!isObject(O)) {
+		throw new $TypeError('Assertion failed: `O` must be an Object'); // step 1
+	}
+	if (!isTypedArray(O)) {
+		throw new $TypeError('Assertion failed: `O` must be a Typed Array'); // steps 2 - 3
+	}
+
+	var buffer = typedArrayBuffer(O); // step 4
+
+	if (IsDetachedBuffer(buffer)) {
+		throw new $TypeError('`O` must be backed by a non-detached buffer'); // step 5
+	}
+
+	return buffer; // step 6
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/WeekDay.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var Day = require('./Day');
+var modulo = require('./modulo');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.6
+
+module.exports = function WeekDay(t) {
+	return modulo(Day(t) + 4, 7);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/YearFromTime.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Date = GetIntrinsic('%Date%');
+
+var callBound = require('call-bound');
+
+var $getUTCFullYear = callBound('Date.prototype.getUTCFullYear');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function YearFromTime(t) {
+	// largest y such that this.TimeFromYear(y) <= t
+	return $getUTCFullYear(new $Date(t));
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/thisBooleanValue.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $BooleanValueOf = require('call-bound')('Boolean.prototype.valueOf');
+
+// https://262.ecma-international.org/6.0/#sec-properties-of-the-boolean-prototype-object
+
+module.exports = function thisBooleanValue(value) {
+	if (typeof value === 'boolean') {
+		return value;
+	}
+
+	return $BooleanValueOf(value);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/thisNumberValue.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var callBound = require('call-bound');
+
+var $NumberValueOf = callBound('Number.prototype.valueOf');
+
+// https://262.ecma-international.org/6.0/#sec-properties-of-the-number-prototype-object
+
+module.exports = function thisNumberValue(value) {
+	if (typeof value === 'number') {
+		return value;
+	}
+
+	return $NumberValueOf(value);
+};
+

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/thisStringValue.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $StringValueOf = require('call-bound')('String.prototype.valueOf');
+
+// https://262.ecma-international.org/6.0/#sec-properties-of-the-string-prototype-object
+
+module.exports = function thisStringValue(value) {
+	if (typeof value === 'string') {
+		return value;
+	}
+
+	return $StringValueOf(value);
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2016/thisTimeValue.js

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

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2017/AbstractEqualityComparison.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+
+var isSameType = require('../helpers/isSameType');
+
+var isObject = require('es-object-atoms/isObject');
+
+// https://262.ecma-international.org/6.0/#sec-abstract-equality-comparison
+
+module.exports = function AbstractEqualityComparison(x, y) {
+	if (isSameType(x, y)) {
+		return x === y; // ES6+ specified this shortcut anyways.
+	}
+	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 === 'boolean') {
+		return AbstractEqualityComparison(ToNumber(x), y);
+	}
+	if (typeof y === 'boolean') {
+		return AbstractEqualityComparison(x, ToNumber(y));
+	}
+	if ((typeof x === 'string' || typeof x === 'number' || typeof x === 'symbol') && isObject(y)) {
+		return AbstractEqualityComparison(x, ToPrimitive(y));
+	}
+	if (isObject(x) && (typeof y === 'string' || typeof y === 'number' || typeof y === 'symbol')) {
+		return AbstractEqualityComparison(ToPrimitive(x), y);
+	}
+	return false;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2017/AbstractRelationalComparison.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Number = GetIntrinsic('%Number%');
+var $TypeError = require('es-errors/type');
+var $isNaN = require('math-intrinsics/isNaN');
+var $isFinite = require('math-intrinsics/isFinite');
+
+var isPrefixOf = require('../helpers/isPrefixOf');
+
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+
+// https://262.ecma-international.org/5.1/#sec-11.8.5
+
+// eslint-disable-next-line max-statements
+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);
+	}
+	var bothStrings = typeof px === 'string' && typeof py === 'string';
+	if (!bothStrings) {
+		var nx = ToNumber(px);
+		var ny = ToNumber(py);
+		if ($isNaN(nx) || $isNaN(ny)) {
+			return undefined;
+		}
+		if ($isFinite(nx) && $isFinite(ny) && nx === ny) {
+			return false;
+		}
+		if (nx === Infinity) {
+			return false;
+		}
+		if (ny === Infinity) {
+			return true;
+		}
+		if (ny === -Infinity) {
+			return false;
+		}
+		if (nx === -Infinity) {
+			return true;
+		}
+		return nx < ny; // by now, these are both nonzero, finite, and not equal
+	}
+	if (isPrefixOf(py, px)) {
+		return false;
+	}
+	if (isPrefixOf(px, py)) {
+		return true;
+	}
+	return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2017/AdvanceStringIndex.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var isInteger = require('math-intrinsics/isInteger');
+var MAX_SAFE_INTEGER = require('math-intrinsics/constants/maxSafeInteger');
+
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+var $TypeError = require('es-errors/type');
+
+var $charCodeAt = require('call-bound')('String.prototype.charCodeAt');
+
+// https://262.ecma-international.org/6.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 first = $charCodeAt(S, index);
+	if (!isLeadingSurrogate(first)) {
+		return index + 1;
+	}
+
+	var second = $charCodeAt(S, index + 1);
+	if (!isTrailingSurrogate(second)) {
+		return index + 1;
+	}
+
+	return index + 2;
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2017/ArrayCreate.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $ArrayPrototype = GetIntrinsic('%Array.prototype%');
+var $RangeError = require('es-errors/range');
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var isInteger = require('math-intrinsics/isInteger');
+var MAX_ARRAY_LENGTH = require('math-intrinsics/constants/maxArrayLength');
+var $setProto = require('set-proto');
+
+// https://262.ecma-international.org/6.0/#sec-arraycreate
+
+module.exports = function ArrayCreate(length) {
+	if (!isInteger(length) || length < 0) {
+		throw new $TypeError('Assertion failed: `length` must be an integer Number >= 0');
+	}
+	if (length > MAX_ARRAY_LENGTH) {
+		throw new $RangeError('length is greater than (2**32 - 1)');
+	}
+	var proto = arguments.length > 1 ? arguments[1] : $ArrayPrototype;
+	var A = []; // steps 5 - 7, and 9
+	if (proto !== $ArrayPrototype) { // step 8
+		if (!$setProto) {
+			throw new $SyntaxError('ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]');
+		}
+		$setProto(A, proto);
+	}
+	if (length !== 0) { // bypasses the need for step 2
+		A.length = length;
+	}
+	/* step 10, the above as a shortcut for the below
+	OrdinaryDefineOwnProperty(A, 'length', {
+		'[[Configurable]]': false,
+		'[[Enumerable]]': false,
+		'[[Value]]': length,
+		'[[Writable]]': true
+	});
+	*/
+	return A;
+};

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

novas/novacore-zephyr/groq-code-cli/node_modules/es-abstract/2017/ArraySpeciesCreate.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Array = GetIntrinsic('%Array%');
+var $species = GetIntrinsic('%Symbol.species%', true);
+var $TypeError = require('es-errors/type');
+var isInteger = require('math-intrinsics/isInteger');
+var isObject = require('es-object-atoms/isObject');
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var IsConstructor = require('./IsConstructor');
+
+// https://262.ecma-international.org/6.0/#sec-arrayspeciescreate
+
+module.exports = function ArraySpeciesCreate(originalArray, length) {
+	if (!isInteger(length) || length < 0) {
+		throw new $TypeError('Assertion failed: length must be an integer >= 0');
+	}
+	var len = length === 0 ? 0 : length;
+	var C;
+	var isArray = IsArray(originalArray);
+	if (isArray) {
+		C = Get(originalArray, 'constructor');
+		// TODO: figure out how to make a cross-realm normal Array, a same-realm Array
+		// if (IsConstructor(C)) {
+		// 	if C is another realm's Array, C = undefined
+		// 	Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ?
+		// }
+		if ($species && isObject(C)) {
+			C = Get(C, $species);
+			if (C === null) {
+				C = void 0;
+			}
+		}
+	}
+	if (typeof C === 'undefined') {
+		return $Array(len);
+	}
+	if (!IsConstructor(C)) {
+		throw new $TypeError('C must be a constructor');
+	}
+	return new C(len); // Construct(C, len);
+};
+

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

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

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

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

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

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

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

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