Add files using upload-large-folder tool

novas/novacore-zephyr/groq-code-cli/node_modules/es-set-tostringtag/test/index.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var test = require('tape');
+var hasToStringTag = require('has-tostringtag/shams')();
+var hasOwn = require('hasown');
+
+var setToStringTag = require('../');
+
+test('setToStringTag', function (t) {
+	t.equal(typeof setToStringTag, 'function', 'is a function');
+
+	/** @type {{ [Symbol.toStringTag]?: typeof sentinel }} */
+	var obj = {};
+	var sentinel = {};
+
+	setToStringTag(obj, sentinel);
+
+	t['throws'](
+		// @ts-expect-error
+		function () { setToStringTag(obj, sentinel, { force: 'yes' }); },
+		TypeError,
+		'throws if options is not an object'
+	);
+
+	t.test('has Symbol.toStringTag', { skip: !hasToStringTag }, function (st) {
+		st.ok(hasOwn(obj, Symbol.toStringTag), 'has toStringTag property');
+
+		st.equal(obj[Symbol.toStringTag], sentinel, 'toStringTag property is as expected');
+
+		st.equal(String(obj), '[object Object]', 'toStringTag works');
+
+		/** @type {{ [Symbol.toStringTag]?: string }} */
+		var tagged = {};
+		tagged[Symbol.toStringTag] = 'already tagged';
+		st.equal(String(tagged), '[object already tagged]', 'toStringTag works');
+
+		setToStringTag(tagged, 'new tag');
+		st.equal(String(tagged), '[object already tagged]', 'toStringTag is unchanged');
+
+		setToStringTag(tagged, 'new tag', { force: true });
+		st.equal(String(tagged), '[object new tag]', 'toStringTag is changed with force: true');
+
+		st.deepEqual(
+			Object.getOwnPropertyDescriptor(tagged, Symbol.toStringTag),
+			{
+				configurable: true,
+				enumerable: false,
+				value: 'new tag',
+				writable: false
+			},
+			'has expected property descriptor'
+		);
+
+		setToStringTag(tagged, 'new tag', { force: true, nonConfigurable: true });
+		st.deepEqual(
+			Object.getOwnPropertyDescriptor(tagged, Symbol.toStringTag),
+			{
+				configurable: false,
+				enumerable: false,
+				value: 'new tag',
+				writable: false
+			},
+			'is nonconfigurable'
+		);
+
+		st.end();
+	});
+
+	t.test('does not have Symbol.toStringTag', { skip: hasToStringTag }, function (st) {
+		var passed = true;
+		for (var key in obj) { // eslint-disable-line no-restricted-syntax
+			if (hasOwn(obj, key)) {
+				st.fail('object has own key ' + key);
+				passed = false;
+			}
+		}
+		if (passed) {
+			st.ok(true, 'object has no enumerable own keys');
+		}
+
+		st.end();
+	});
+
+	t.end();
+});

novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/es-to-primitive
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/helpers/isPrimitive.js

@@ -0,0 +1,6 @@
+'use strict';
+
+/** @type {(value: unknown) => value is null | undefined | string | symbol | number | boolean | bigint} */
+module.exports = function isPrimitive(value) {
+	return value === null || (typeof value !== 'function' && typeof value !== 'object');
+};

novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es2015.js

@@ -0,0 +1,140 @@
+'use strict';
+
+var test = require('tape');
+var toPrimitive = require('../es2015');
+var is = require('object-is');
+var forEach = require('for-each');
+var functionName = require('function.prototype.name');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+
+/** @typedef {{ toString?: unknown, valueOf?: unknown, [Symbol.toPrimitive]?: unknown }} Coercible */
+
+test('function properties', function (t) {
+	t.equal(toPrimitive.length, 1, 'length is 1');
+	t.equal(functionName(toPrimitive), 'ToPrimitive', 'name is ToPrimitive');
+
+	t.end();
+});
+
+test('primitives', function (t) {
+	forEach(v.primitives, function (i) {
+		t.ok(is(toPrimitive(i), i), 'toPrimitive(' + debug(i) + ') returns the same value');
+		t.ok(is(toPrimitive(i, String), i), 'toPrimitive(' + debug(i) + ', String) returns the same value');
+		t.ok(is(toPrimitive(i, Number), i), 'toPrimitive(' + debug(i) + ', Number) returns the same value');
+	});
+	t.end();
+});
+
+test('Symbols', { skip: !v.hasSymbols }, function (t) {
+	forEach(v.symbols, function (sym) {
+		t.equal(toPrimitive(sym), sym, 'toPrimitive(' + debug(sym) + ') returns the same value');
+		t.equal(toPrimitive(sym, String), sym, 'toPrimitive(' + debug(sym) + ', String) returns the same value');
+		t.equal(toPrimitive(sym, Number), sym, 'toPrimitive(' + debug(sym) + ', Number) returns the same value');
+	});
+
+	var primitiveSym = Symbol('primitiveSym');
+	var objectSym = Object(primitiveSym);
+	t.equal(toPrimitive(objectSym), primitiveSym, 'toPrimitive(' + debug(objectSym) + ') returns ' + debug(primitiveSym));
+	t.equal(toPrimitive(objectSym, String), primitiveSym, 'toPrimitive(' + debug(objectSym) + ', String) returns ' + debug(primitiveSym));
+	t.equal(toPrimitive(objectSym, Number), primitiveSym, 'toPrimitive(' + debug(objectSym) + ', Number) returns ' + debug(primitiveSym));
+	t.end();
+});
+
+test('Arrays', function (t) {
+	var arrays = [[], ['a', 'b'], [1, 2]];
+	forEach(arrays, function (arr) {
+		t.equal(toPrimitive(arr), String(arr), 'toPrimitive(' + debug(arr) + ') returns the string version of the array');
+		t.equal(toPrimitive(arr, String), String(arr), 'toPrimitive(' + debug(arr) + ') returns the string version of the array');
+		t.equal(toPrimitive(arr, Number), String(arr), 'toPrimitive(' + debug(arr) + ') returns the string version of the array');
+	});
+	t.end();
+});
+
+test('Dates', function (t) {
+	var dates = [new Date(), new Date(0), new Date(NaN)];
+	forEach(dates, function (date) {
+		t.equal(toPrimitive(date), String(date), 'toPrimitive(' + debug(date) + ') returns the string version of the date');
+		t.equal(toPrimitive(date, String), String(date), 'toPrimitive(' + debug(date) + ') returns the string version of the date');
+		t.ok(is(toPrimitive(date, Number), Number(date)), 'toPrimitive(' + debug(date) + ') returns the number version of the date');
+	});
+	t.end();
+});
+
+test('Objects', function (t) {
+	t.equal(toPrimitive(v.coercibleObject), v.coercibleObject.valueOf(), 'coercibleObject with no hint coerces to valueOf');
+	t.equal(toPrimitive(v.coercibleObject, Number), v.coercibleObject.valueOf(), 'coercibleObject with hint Number coerces to valueOf');
+	t.equal(toPrimitive(v.coercibleObject, String), v.coercibleObject.toString(), 'coercibleObject with hint String coerces to non-stringified toString');
+
+	t.equal(toPrimitive(v.coercibleFnObject), v.coercibleFnObject.toString(), 'coercibleFnObject coerces to non-stringified toString');
+	t.equal(toPrimitive(v.coercibleFnObject, Number), v.coercibleFnObject.toString(), 'coercibleFnObject with hint Number coerces to non-stringified toString');
+	t.equal(toPrimitive(v.coercibleFnObject, String), v.coercibleFnObject.toString(), 'coercibleFnObject with hint String coerces to non-stringified toString');
+
+	t.equal(toPrimitive({}), '[object Object]', '{} with no hint coerces to Object#toString');
+	t.equal(toPrimitive({}, Number), '[object Object]', '{} with hint Number coerces to Object#toString');
+	t.equal(toPrimitive({}, String), '[object Object]', '{} with hint String coerces to Object#toString');
+
+	t.equal(toPrimitive(v.toStringOnlyObject), v.toStringOnlyObject.toString(), 'toStringOnlyObject returns non-stringified toString');
+	t.equal(toPrimitive(v.toStringOnlyObject, Number), v.toStringOnlyObject.toString(), 'toStringOnlyObject with hint Number returns non-stringified toString');
+	t.equal(toPrimitive(v.toStringOnlyObject, String), v.toStringOnlyObject.toString(), 'toStringOnlyObject with hint String returns non-stringified toString');
+
+	t.equal(toPrimitive(v.valueOfOnlyObject), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject returns valueOf');
+	t.equal(toPrimitive(v.valueOfOnlyObject, Number), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject with hint Number returns valueOf');
+	t.equal(toPrimitive(v.valueOfOnlyObject, String), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject with hint String returns non-stringified valueOf');
+
+	t.test('Symbol.toPrimitive', { skip: !v.hasSymbols || !Symbol.toPrimitive }, function (st) {
+		/** @type {Coercible} */
+		var overriddenObject = { toString: st.fail, valueOf: st.fail };
+		overriddenObject[Symbol.toPrimitive] = /** @type {(hint: string) => unknown} */ function (hint) {
+			return String(hint);
+		};
+
+		st.equal(toPrimitive(overriddenObject), 'default', 'object with Symbol.toPrimitive + no hint invokes that');
+		st.equal(toPrimitive(overriddenObject, Number), 'number', 'object with Symbol.toPrimitive + hint Number invokes that');
+		st.equal(toPrimitive(overriddenObject, String), 'string', 'object with Symbol.toPrimitive + hint String invokes that');
+
+		/** @type {Coercible} */
+		var nullToPrimitive = { toString: v.coercibleObject.toString, valueOf: v.coercibleObject.valueOf };
+		nullToPrimitive[Symbol.toPrimitive] = null;
+		st.equal(toPrimitive(nullToPrimitive), toPrimitive(v.coercibleObject), 'object with no hint + null Symbol.toPrimitive ignores it');
+		st.equal(toPrimitive(nullToPrimitive, Number), toPrimitive(v.coercibleObject, Number), 'object with hint Number + null Symbol.toPrimitive ignores it');
+		st.equal(toPrimitive(nullToPrimitive, String), toPrimitive(v.coercibleObject, String), 'object with hint String + null Symbol.toPrimitive ignores it');
+
+		st.test('exceptions', function (sst) {
+			/** @type {Coercible} */
+			var nonFunctionToPrimitive = { toString: sst.fail, valueOf: sst.fail };
+			nonFunctionToPrimitive[Symbol.toPrimitive] = {};
+			sst['throws'](toPrimitive.bind(null, nonFunctionToPrimitive), TypeError, 'Symbol.toPrimitive returning a non-function throws');
+
+			/** @type {Coercible} */
+			var uncoercibleToPrimitive = { toString: sst.fail, valueOf: sst.fail };
+			uncoercibleToPrimitive[Symbol.toPrimitive] = /** @type {(hint: string) => unknown} */ function (hint) {
+				return { toString: function () { return hint; } };
+			};
+			sst['throws'](toPrimitive.bind(null, uncoercibleToPrimitive), TypeError, 'Symbol.toPrimitive returning an object throws');
+
+			/** @type {Coercible} */
+			var throwingToPrimitive = { toString: sst.fail, valueOf: sst.fail };
+			throwingToPrimitive[Symbol.toPrimitive] = /** @type {(hint: string) => unknown} */ function (hint) {
+				throw new RangeError(hint);
+			};
+			sst['throws'](toPrimitive.bind(null, throwingToPrimitive), RangeError, 'Symbol.toPrimitive throwing throws');
+
+			sst.end();
+		});
+
+		st.end();
+	});
+
+	t.test('exceptions', function (st) {
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject), TypeError, 'uncoercibleObject throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject, Number), TypeError, 'uncoercibleObject with hint Number throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject, String), TypeError, 'uncoercibleObject with hint String throws a TypeError');
+
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject), TypeError, 'uncoercibleFnObject throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject, Number), TypeError, 'uncoercibleFnObject with hint Number throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject, String), TypeError, 'uncoercibleFnObject with hint String throws a TypeError');
+		st.end();
+	});
+	t.end();
+});

novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es5.js

@@ -0,0 +1,98 @@
+'use strict';
+
+var test = require('tape');
+var toPrimitive = require('../es5');
+var is = require('object-is');
+var forEach = require('for-each');
+var functionName = require('function.prototype.name');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+
+test('function properties', function (t) {
+	t.equal(toPrimitive.length, 1, 'length is 1');
+	t.equal(functionName(toPrimitive), 'ToPrimitive', 'name is ToPrimitive');
+
+	t.end();
+});
+
+test('primitives', function (t) {
+	forEach(v.primitives, function (i) {
+		t.ok(is(toPrimitive(i), i), 'toPrimitive(' + debug(i) + ') returns the same value');
+		t.ok(is(toPrimitive(i, String), i), 'toPrimitive(' + debug(i) + ', String) returns the same value');
+		t.ok(is(toPrimitive(i, Number), i), 'toPrimitive(' + debug(i) + ', Number) returns the same value');
+	});
+	t.end();
+});
+
+test('Symbols', { skip: !v.hasSymbols }, function (t) {
+	forEach(v.symbols, function (sym) {
+		t.equal(toPrimitive(sym), sym, 'toPrimitive(' + debug(sym) + ') returns the same value');
+		t.equal(toPrimitive(sym, String), sym, 'toPrimitive(' + debug(sym) + ', String) returns the same value');
+		t.equal(toPrimitive(sym, Number), sym, 'toPrimitive(' + debug(sym) + ', Number) returns the same value');
+	});
+
+	var primitiveSym = Symbol('primitiveSym');
+	var stringSym = Symbol.prototype.toString.call(primitiveSym);
+	var objectSym = Object(primitiveSym);
+	t.equal(toPrimitive(objectSym), primitiveSym, 'toPrimitive(' + debug(objectSym) + ') returns ' + debug(primitiveSym));
+
+	// This is different from ES2015, as the ES5 algorithm doesn't account for the existence of Symbols:
+	t.equal(toPrimitive(objectSym, String), stringSym, 'toPrimitive(' + debug(objectSym) + ', String) returns ' + debug(stringSym));
+	t.equal(toPrimitive(objectSym, Number), primitiveSym, 'toPrimitive(' + debug(objectSym) + ', Number) returns ' + debug(primitiveSym));
+	t.end();
+});
+
+test('Arrays', function (t) {
+	var arrays = [[], ['a', 'b'], [1, 2]];
+	forEach(arrays, function (arr) {
+		t.ok(is(toPrimitive(arr), arr.toString()), 'toPrimitive(' + debug(arr) + ') returns toString of the array');
+		t.equal(toPrimitive(arr, String), arr.toString(), 'toPrimitive(' + debug(arr) + ') returns toString of the array');
+		t.ok(is(toPrimitive(arr, Number), arr.toString()), 'toPrimitive(' + debug(arr) + ') returns toString of the array');
+	});
+	t.end();
+});
+
+test('Dates', function (t) {
+	var dates = [new Date(), new Date(0), new Date(NaN)];
+	forEach(dates, function (date) {
+		t.equal(toPrimitive(date), date.toString(), 'toPrimitive(' + debug(date) + ') returns toString of the date');
+		t.equal(toPrimitive(date, String), date.toString(), 'toPrimitive(' + debug(date) + ') returns toString of the date');
+		t.ok(is(toPrimitive(date, Number), date.valueOf()), 'toPrimitive(' + debug(date) + ') returns valueOf of the date');
+	});
+	t.end();
+});
+
+test('Objects', function (t) {
+	t.equal(toPrimitive(v.coercibleObject), v.coercibleObject.valueOf(), 'coercibleObject with no hint coerces to valueOf');
+	t.equal(toPrimitive(v.coercibleObject, String), v.coercibleObject.toString(), 'coercibleObject with hint String coerces to toString');
+	t.equal(toPrimitive(v.coercibleObject, Number), v.coercibleObject.valueOf(), 'coercibleObject with hint Number coerces to valueOf');
+
+	t.equal(toPrimitive(v.coercibleFnObject), v.coercibleFnObject.toString(), 'coercibleFnObject coerces to toString');
+	t.equal(toPrimitive(v.coercibleFnObject, String), v.coercibleFnObject.toString(), 'coercibleFnObject with hint String coerces to toString');
+	t.equal(toPrimitive(v.coercibleFnObject, Number), v.coercibleFnObject.toString(), 'coercibleFnObject with hint Number coerces to toString');
+
+	t.ok(is(toPrimitive({}), '[object Object]'), '{} with no hint coerces to Object#toString');
+	t.equal(toPrimitive({}, String), '[object Object]', '{} with hint String coerces to Object#toString');
+	t.ok(is(toPrimitive({}, Number), '[object Object]'), '{} with hint Number coerces to Object#toString');
+
+	t.equal(toPrimitive(v.toStringOnlyObject), v.toStringOnlyObject.toString(), 'toStringOnlyObject returns toString');
+	t.equal(toPrimitive(v.toStringOnlyObject, String), v.toStringOnlyObject.toString(), 'toStringOnlyObject with hint String returns toString');
+	t.equal(toPrimitive(v.toStringOnlyObject, Number), v.toStringOnlyObject.toString(), 'toStringOnlyObject with hint Number returns toString');
+
+	t.equal(toPrimitive(v.valueOfOnlyObject), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject returns valueOf');
+	t.equal(toPrimitive(v.valueOfOnlyObject, String), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject with hint String returns valueOf');
+	t.equal(toPrimitive(v.valueOfOnlyObject, Number), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject with hint Number returns valueOf');
+
+	t.test('exceptions', function (st) {
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject), TypeError, 'uncoercibleObject throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject, String), TypeError, 'uncoercibleObject with hint String throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject, Number), TypeError, 'uncoercibleObject with hint Number throws a TypeError');
+
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject), TypeError, 'uncoercibleFnObject throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject, String), TypeError, 'uncoercibleFnObject with hint String throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject, Number), TypeError, 'uncoercibleFnObject with hint Number throws a TypeError');
+		st.end();
+	});
+
+	t.end();
+});

novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es6.js

@@ -0,0 +1,140 @@
+'use strict';
+
+var test = require('tape');
+var toPrimitive = require('../es6');
+var is = require('object-is');
+var forEach = require('for-each');
+var functionName = require('function.prototype.name');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+
+/** @typedef {{ toString?: unknown, valueOf?: unknown, [Symbol.toPrimitive]?: unknown }} Coercible */
+
+test('function properties', function (t) {
+	t.equal(toPrimitive.length, 1, 'length is 1');
+	t.equal(functionName(toPrimitive), 'ToPrimitive', 'name is ToPrimitive');
+
+	t.end();
+});
+
+test('primitives', function (t) {
+	forEach(v.primitives, function (i) {
+		t.ok(is(toPrimitive(i), i), 'toPrimitive(' + debug(i) + ') returns the same value');
+		t.ok(is(toPrimitive(i, String), i), 'toPrimitive(' + debug(i) + ', String) returns the same value');
+		t.ok(is(toPrimitive(i, Number), i), 'toPrimitive(' + debug(i) + ', Number) returns the same value');
+	});
+	t.end();
+});
+
+test('Symbols', { skip: !v.hasSymbols }, function (t) {
+	forEach(v.symbols, function (sym) {
+		t.equal(toPrimitive(sym), sym, 'toPrimitive(' + debug(sym) + ') returns the same value');
+		t.equal(toPrimitive(sym, String), sym, 'toPrimitive(' + debug(sym) + ', String) returns the same value');
+		t.equal(toPrimitive(sym, Number), sym, 'toPrimitive(' + debug(sym) + ', Number) returns the same value');
+	});
+
+	var primitiveSym = Symbol('primitiveSym');
+	var objectSym = Object(primitiveSym);
+	t.equal(toPrimitive(objectSym), primitiveSym, 'toPrimitive(' + debug(objectSym) + ') returns ' + debug(primitiveSym));
+	t.equal(toPrimitive(objectSym, String), primitiveSym, 'toPrimitive(' + debug(objectSym) + ', String) returns ' + debug(primitiveSym));
+	t.equal(toPrimitive(objectSym, Number), primitiveSym, 'toPrimitive(' + debug(objectSym) + ', Number) returns ' + debug(primitiveSym));
+	t.end();
+});
+
+test('Arrays', function (t) {
+	var arrays = [[], ['a', 'b'], [1, 2]];
+	forEach(arrays, function (arr) {
+		t.equal(toPrimitive(arr), String(arr), 'toPrimitive(' + debug(arr) + ') returns the string version of the array');
+		t.equal(toPrimitive(arr, String), String(arr), 'toPrimitive(' + debug(arr) + ') returns the string version of the array');
+		t.equal(toPrimitive(arr, Number), String(arr), 'toPrimitive(' + debug(arr) + ') returns the string version of the array');
+	});
+	t.end();
+});
+
+test('Dates', function (t) {
+	var dates = [new Date(), new Date(0), new Date(NaN)];
+	forEach(dates, function (date) {
+		t.equal(toPrimitive(date), String(date), 'toPrimitive(' + debug(date) + ') returns the string version of the date');
+		t.equal(toPrimitive(date, String), String(date), 'toPrimitive(' + debug(date) + ') returns the string version of the date');
+		t.ok(is(toPrimitive(date, Number), Number(date)), 'toPrimitive(' + debug(date) + ') returns the number version of the date');
+	});
+	t.end();
+});
+
+test('Objects', function (t) {
+	t.equal(toPrimitive(v.coercibleObject), v.coercibleObject.valueOf(), 'coercibleObject with no hint coerces to valueOf');
+	t.equal(toPrimitive(v.coercibleObject, Number), v.coercibleObject.valueOf(), 'coercibleObject with hint Number coerces to valueOf');
+	t.equal(toPrimitive(v.coercibleObject, String), v.coercibleObject.toString(), 'coercibleObject with hint String coerces to non-stringified toString');
+
+	t.equal(toPrimitive(v.coercibleFnObject), v.coercibleFnObject.toString(), 'coercibleFnObject coerces to non-stringified toString');
+	t.equal(toPrimitive(v.coercibleFnObject, Number), v.coercibleFnObject.toString(), 'coercibleFnObject with hint Number coerces to non-stringified toString');
+	t.equal(toPrimitive(v.coercibleFnObject, String), v.coercibleFnObject.toString(), 'coercibleFnObject with hint String coerces to non-stringified toString');
+
+	t.equal(toPrimitive({}), '[object Object]', '{} with no hint coerces to Object#toString');
+	t.equal(toPrimitive({}, Number), '[object Object]', '{} with hint Number coerces to Object#toString');
+	t.equal(toPrimitive({}, String), '[object Object]', '{} with hint String coerces to Object#toString');
+
+	t.equal(toPrimitive(v.toStringOnlyObject), v.toStringOnlyObject.toString(), 'toStringOnlyObject returns non-stringified toString');
+	t.equal(toPrimitive(v.toStringOnlyObject, Number), v.toStringOnlyObject.toString(), 'toStringOnlyObject with hint Number returns non-stringified toString');
+	t.equal(toPrimitive(v.toStringOnlyObject, String), v.toStringOnlyObject.toString(), 'toStringOnlyObject with hint String returns non-stringified toString');
+
+	t.equal(toPrimitive(v.valueOfOnlyObject), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject returns valueOf');
+	t.equal(toPrimitive(v.valueOfOnlyObject, Number), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject with hint Number returns valueOf');
+	t.equal(toPrimitive(v.valueOfOnlyObject, String), v.valueOfOnlyObject.valueOf(), 'valueOfOnlyObject with hint String returns non-stringified valueOf');
+
+	t.test('Symbol.toPrimitive', { skip: !v.hasSymbols || !Symbol.toPrimitive }, function (st) {
+		/** @type {Coercible} */
+		var overriddenObject = { toString: st.fail, valueOf: st.fail };
+		overriddenObject[Symbol.toPrimitive] = /** @type {(hint: string) => unknown} */ function (hint) {
+			return String(hint);
+		};
+
+		st.equal(toPrimitive(overriddenObject), 'default', 'object with Symbol.toPrimitive + no hint invokes that');
+		st.equal(toPrimitive(overriddenObject, Number), 'number', 'object with Symbol.toPrimitive + hint Number invokes that');
+		st.equal(toPrimitive(overriddenObject, String), 'string', 'object with Symbol.toPrimitive + hint String invokes that');
+
+		/** @type {Coercible} */
+		var nullToPrimitive = { toString: v.coercibleObject.toString, valueOf: v.coercibleObject.valueOf };
+		nullToPrimitive[Symbol.toPrimitive] = null;
+		st.equal(toPrimitive(nullToPrimitive), toPrimitive(v.coercibleObject), 'object with no hint + null Symbol.toPrimitive ignores it');
+		st.equal(toPrimitive(nullToPrimitive, Number), toPrimitive(v.coercibleObject, Number), 'object with hint Number + null Symbol.toPrimitive ignores it');
+		st.equal(toPrimitive(nullToPrimitive, String), toPrimitive(v.coercibleObject, String), 'object with hint String + null Symbol.toPrimitive ignores it');
+
+		st.test('exceptions', function (sst) {
+			/** @type {Coercible} */
+			var nonFunctionToPrimitive = { toString: sst.fail, valueOf: sst.fail };
+			nonFunctionToPrimitive[Symbol.toPrimitive] = {};
+			sst['throws'](toPrimitive.bind(null, nonFunctionToPrimitive), TypeError, 'Symbol.toPrimitive returning a non-function throws');
+
+			/** @type {Coercible} */
+			var uncoercibleToPrimitive = { toString: sst.fail, valueOf: sst.fail };
+			uncoercibleToPrimitive[Symbol.toPrimitive] = /** @type {(hint: string) => unknown} */ function (hint) {
+				return { toString: function () { return hint; } };
+			};
+			sst['throws'](toPrimitive.bind(null, uncoercibleToPrimitive), TypeError, 'Symbol.toPrimitive returning an object throws');
+
+			/** @type {Coercible} */
+			var throwingToPrimitive = { toString: sst.fail, valueOf: sst.fail };
+			throwingToPrimitive[Symbol.toPrimitive] = /** @type {(hint: string) => unknown} */ function (hint) {
+				throw new RangeError(hint);
+			};
+			sst['throws'](toPrimitive.bind(null, throwingToPrimitive), RangeError, 'Symbol.toPrimitive throwing throws');
+
+			sst.end();
+		});
+
+		st.end();
+	});
+
+	t.test('exceptions', function (st) {
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject), TypeError, 'uncoercibleObject throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject, Number), TypeError, 'uncoercibleObject with hint Number throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleObject, String), TypeError, 'uncoercibleObject with hint String throws a TypeError');
+
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject), TypeError, 'uncoercibleFnObject throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject, Number), TypeError, 'uncoercibleFnObject with hint Number throws a TypeError');
+		st['throws'](toPrimitive.bind(null, v.uncoercibleFnObject, String), TypeError, 'uncoercibleFnObject with hint String throws a TypeError');
+		st.end();
+	});
+	t.end();
+});

novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var toPrimitive = require('../');
+var ES5 = require('../es5');
+var ES6 = require('../es6');
+var ES2015 = require('../es2015');
+
+var test = require('tape');
+
+test('default export', function (t) {
+	t.equal(toPrimitive, ES2015, 'default export is ES2015');
+	t.equal(toPrimitive.ES5, ES5, 'ES5 property has ES5 method');
+	t.equal(toPrimitive.ES6, ES6, 'ES6 property has ES6 method');
+	t.equal(toPrimitive.ES2015, ES2015, 'ES2015 property has ES2015 method');
+	t.end();
+});
+
+require('./es5');
+require('./es6');
+require('./es2015');

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.d.mts

@@ -0,0 +1,22 @@
+/**
+ * Randomizes the order of elements in an `array` using the Fisher-Yates algorithm.
+ *
+ * This function takes an `array` and returns a new `array` with its elements shuffled in a random order.
+ *
+ * @template T - The type of elements in the `array`.
+ * @param {T[]} array - The `array` to shuffle.
+ * @returns {T[]} A new `array` with its elements shuffled in random order.
+ */
+declare function shuffle<T>(array: ArrayLike<T> | null | undefined): T[];
+/**
+ * Randomizes the order of elements in an `object` using the Fisher-Yates algorithm.
+ *
+ * This function takes an `object` and returns a new `object` with its values shuffled in a random order.
+ *
+ * @template T - The type of elements in the `object`.
+ * @param {T} object - The `object` to shuffle.
+ * @returns {T[]} A new `Array` with the values of the `object` shuffled in a random order.
+ */
+declare function shuffle<T extends object>(object: T | null | undefined): Array<T[keyof T]>;
+
+export { shuffle };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Randomizes the order of elements in an `array` using the Fisher-Yates algorithm.
+ *
+ * This function takes an `array` and returns a new `array` with its elements shuffled in a random order.
+ *
+ * @template T - The type of elements in the `array`.
+ * @param {T[]} array - The `array` to shuffle.
+ * @returns {T[]} A new `array` with its elements shuffled in random order.
+ */
+declare function shuffle<T>(array: ArrayLike<T> | null | undefined): T[];
+/**
+ * Randomizes the order of elements in an `object` using the Fisher-Yates algorithm.
+ *
+ * This function takes an `object` and returns a new `object` with its values shuffled in a random order.
+ *
+ * @template T - The type of elements in the `object`.
+ * @param {T} object - The `object` to shuffle.
+ * @returns {T[]} A new `Array` with the values of the `object` shuffled in a random order.
+ */
+declare function shuffle<T extends object>(object: T | null | undefined): Array<T[keyof T]>;
+
+export { shuffle };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const shuffle$1 = require('../../array/shuffle.js');
+const values = require('../object/values.js');
+const isArray = require('../predicate/isArray.js');
+const isArrayLike = require('../predicate/isArrayLike.js');
+const isNil = require('../predicate/isNil.js');
+const isObjectLike = require('../predicate/isObjectLike.js');
+
+function shuffle(collection) {
+    if (isNil.isNil(collection)) {
+        return [];
+    }
+    if (isArray.isArray(collection)) {
+        return shuffle$1.shuffle(collection);
+    }
+    if (isArrayLike.isArrayLike(collection)) {
+        return shuffle$1.shuffle(Array.from(collection));
+    }
+    if (isObjectLike.isObjectLike(collection)) {
+        return shuffle$1.shuffle(values.values(collection));
+    }
+    return [];
+}
+
+exports.shuffle = shuffle;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.mjs

@@ -0,0 +1,24 @@
+import { shuffle as shuffle$1 } from '../../array/shuffle.mjs';
+import { values } from '../object/values.mjs';
+import { isArray } from '../predicate/isArray.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { isNil } from '../predicate/isNil.mjs';
+import { isObjectLike } from '../predicate/isObjectLike.mjs';
+
+function shuffle(collection) {
+    if (isNil(collection)) {
+        return [];
+    }
+    if (isArray(collection)) {
+        return shuffle$1(collection);
+    }
+    if (isArrayLike(collection)) {
+        return shuffle$1(Array.from(collection));
+    }
+    if (isObjectLike(collection)) {
+        return shuffle$1(values(collection));
+    }
+    return [];
+}
+
+export { shuffle };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.d.mts

@@ -0,0 +1,39 @@
+/**
+ * Returns the length of an array, string, or object.
+ *
+ * This function takes an array, string, or object and returns its length.
+ * For arrays and strings, it returns the number of elements or characters, respectively.
+ * For objects, it returns the number of enumerable properties.
+ *
+ * @template T - The type of the input value.
+ * @param {T[] | object | string | Map<unknown, T> | Set<T> | null | undefined } target - The value whose size is to be determined. It can be an array, string, or object.
+ * @returns {number} The size of the input value.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * const arrSize = size(arr);
+ * // arrSize will be 3
+ *
+ * const str = 'hello';
+ * const strSize = size(str);
+ * // strSize will be 5
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const objSize = size(obj);
+ * // objSize will be 3
+ *
+ * const emptyArr = [];
+ * const emptyArrSize = size(emptyArr);
+ * // emptyArrSize will be 0
+ *
+ * const emptyStr = '';
+ * const emptyStrSize = size(emptyStr);
+ * // emptyStrSize will be 0
+ *
+ * const emptyObj = {};
+ * const emptyObjSize = size(emptyObj);
+ * // emptyObjSize will be 0
+ */
+declare function size(collection: object | string | null | undefined): number;
+
+export { size };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Returns the length of an array, string, or object.
+ *
+ * This function takes an array, string, or object and returns its length.
+ * For arrays and strings, it returns the number of elements or characters, respectively.
+ * For objects, it returns the number of enumerable properties.
+ *
+ * @template T - The type of the input value.
+ * @param {T[] | object | string | Map<unknown, T> | Set<T> | null | undefined } target - The value whose size is to be determined. It can be an array, string, or object.
+ * @returns {number} The size of the input value.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * const arrSize = size(arr);
+ * // arrSize will be 3
+ *
+ * const str = 'hello';
+ * const strSize = size(str);
+ * // strSize will be 5
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const objSize = size(obj);
+ * // objSize will be 3
+ *
+ * const emptyArr = [];
+ * const emptyArrSize = size(emptyArr);
+ * // emptyArrSize will be 0
+ *
+ * const emptyStr = '';
+ * const emptyStrSize = size(emptyStr);
+ * // emptyStrSize will be 0
+ *
+ * const emptyObj = {};
+ * const emptyObjSize = size(emptyObj);
+ * // emptyObjSize will be 0
+ */
+declare function size(collection: object | string | null | undefined): number;
+
+export { size };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const isNil = require('../../predicate/isNil.js');
+
+function size(target) {
+    if (isNil.isNil(target)) {
+        return 0;
+    }
+    if (target instanceof Map || target instanceof Set) {
+        return target.size;
+    }
+    return Object.keys(target).length;
+}
+
+exports.size = size;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.mjs

@@ -0,0 +1,13 @@
+import { isNil } from '../../predicate/isNil.mjs';
+
+function size(target) {
+    if (isNil(target)) {
+        return 0;
+    }
+    if (target instanceof Map || target instanceof Set) {
+        return target.size;
+    }
+    return Object.keys(target).length;
+}
+
+export { size };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Create a slice of `array` from `start` up to, but not including, `end`.
+ *
+ * It does not return a dense array for sparse arrays unlike the native `Array.prototype.slice`.
+ *
+ * @template T - The type of the array elements.
+ * @param {ArrayLike<T> | null | undefined} array - The array to slice.
+ * @param {number} [start=0] - The start position.
+ * @param {number} [end=array.length] - The end position.
+ * @returns {T[]} - Returns the slice of `array`.
+ *
+ * @example
+ * slice([1, 2, 3], 1, 2); // => [2]
+ * slice(new Array(3)); // => [undefined, undefined, undefined]
+ */
+declare function slice<T>(array: ArrayLike<T> | null | undefined, start?: number, end?: number): T[];
+
+export { slice };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create a slice of `array` from `start` up to, but not including, `end`.
+ *
+ * It does not return a dense array for sparse arrays unlike the native `Array.prototype.slice`.
+ *
+ * @template T - The type of the array elements.
+ * @param {ArrayLike<T> | null | undefined} array - The array to slice.
+ * @param {number} [start=0] - The start position.
+ * @param {number} [end=array.length] - The end position.
+ * @returns {T[]} - Returns the slice of `array`.
+ *
+ * @example
+ * slice([1, 2, 3], 1, 2); // => [2]
+ * slice(new Array(3)); // => [undefined, undefined, undefined]
+ */
+declare function slice<T>(array: ArrayLike<T> | null | undefined, start?: number, end?: number): T[];
+
+export { slice };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const isIterateeCall = require('../_internal/isIterateeCall.js');
+const isArrayLike = require('../predicate/isArrayLike.js');
+const toInteger = require('../util/toInteger.js');
+
+function slice(array, start, end) {
+    if (!isArrayLike.isArrayLike(array)) {
+        return [];
+    }
+    const length = array.length;
+    if (end === undefined) {
+        end = length;
+    }
+    else if (typeof end !== 'number' && isIterateeCall.isIterateeCall(array, start, end)) {
+        start = 0;
+        end = length;
+    }
+    start = toInteger.toInteger(start);
+    end = toInteger.toInteger(end);
+    if (start < 0) {
+        start = Math.max(length + start, 0);
+    }
+    else {
+        start = Math.min(start, length);
+    }
+    if (end < 0) {
+        end = Math.max(length + end, 0);
+    }
+    else {
+        end = Math.min(end, length);
+    }
+    const resultLength = Math.max(end - start, 0);
+    const result = new Array(resultLength);
+    for (let i = 0; i < resultLength; ++i) {
+        result[i] = array[start + i];
+    }
+    return result;
+}
+
+exports.slice = slice;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.mjs

@@ -0,0 +1,39 @@
+import { isIterateeCall } from '../_internal/isIterateeCall.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { toInteger } from '../util/toInteger.mjs';
+
+function slice(array, start, end) {
+    if (!isArrayLike(array)) {
+        return [];
+    }
+    const length = array.length;
+    if (end === undefined) {
+        end = length;
+    }
+    else if (typeof end !== 'number' && isIterateeCall(array, start, end)) {
+        start = 0;
+        end = length;
+    }
+    start = toInteger(start);
+    end = toInteger(end);
+    if (start < 0) {
+        start = Math.max(length + start, 0);
+    }
+    else {
+        start = Math.min(start, length);
+    }
+    if (end < 0) {
+        end = Math.max(length + end, 0);
+    }
+    else {
+        end = Math.min(end, length);
+    }
+    const resultLength = Math.max(end - start, 0);
+    const result = new Array(resultLength);
+    for (let i = 0; i < resultLength; ++i) {
+        result[i] = array[start + i];
+    }
+    return result;
+}
+
+export { slice };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.d.mts

@@ -0,0 +1,31 @@
+import { ListIterateeCustom } from '../_internal/ListIterateeCustom.mjs';
+import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.mjs';
+
+/**
+ * Checks if predicate returns truthy for any element of collection.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection - The collection to iterate over.
+ * @param {ListIterateeCustom<T, boolean>} [predicate] - The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * some([null, 0, 'yes', false], Boolean);
+ * // => true
+ */
+declare function some<T>(collection: ArrayLike<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>): boolean;
+/**
+ * Checks if predicate returns truthy for any element of collection.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The object to iterate over.
+ * @param {ObjectIterateeCustom<T, boolean>} [predicate] - The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * some({ 'a': 0, 'b': 1, 'c': 0 }, function(n) { return n > 0; });
+ * // => true
+ */
+declare function some<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>): boolean;
+
+export { some };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.d.ts

@@ -0,0 +1,31 @@
+import { ListIterateeCustom } from '../_internal/ListIterateeCustom.js';
+import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.js';
+
+/**
+ * Checks if predicate returns truthy for any element of collection.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection - The collection to iterate over.
+ * @param {ListIterateeCustom<T, boolean>} [predicate] - The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * some([null, 0, 'yes', false], Boolean);
+ * // => true
+ */
+declare function some<T>(collection: ArrayLike<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>): boolean;
+/**
+ * Checks if predicate returns truthy for any element of collection.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The object to iterate over.
+ * @param {ObjectIterateeCustom<T, boolean>} [predicate] - The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * some({ 'a': 0, 'b': 1, 'c': 0 }, function(n) { return n > 0; });
+ * // => true
+ */
+declare function some<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>): boolean;
+
+export { some };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.js

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const identity = require('../../function/identity.js');
+const property = require('../object/property.js');
+const matches = require('../predicate/matches.js');
+const matchesProperty = require('../predicate/matchesProperty.js');
+
+function some(source, predicate, guard) {
+    if (!source) {
+        return false;
+    }
+    if (guard != null) {
+        predicate = undefined;
+    }
+    if (!predicate) {
+        predicate = identity.identity;
+    }
+    const values = Array.isArray(source) ? source : Object.values(source);
+    switch (typeof predicate) {
+        case 'function': {
+            if (!Array.isArray(source)) {
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
+                    if (predicate(value, key, source)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            for (let i = 0; i < source.length; i++) {
+                if (predicate(source[i], i, source)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        case 'object': {
+            if (Array.isArray(predicate) && predicate.length === 2) {
+                const key = predicate[0];
+                const value = predicate[1];
+                const matchFunc = matchesProperty.matchesProperty(key, value);
+                if (Array.isArray(source)) {
+                    for (let i = 0; i < source.length; i++) {
+                        if (matchFunc(source[i])) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                return values.some(matchFunc);
+            }
+            else {
+                const matchFunc = matches.matches(predicate);
+                if (Array.isArray(source)) {
+                    for (let i = 0; i < source.length; i++) {
+                        if (matchFunc(source[i])) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                return values.some(matchFunc);
+            }
+        }
+        case 'number':
+        case 'symbol':
+        case 'string': {
+            const propFunc = property.property(predicate);
+            if (Array.isArray(source)) {
+                for (let i = 0; i < source.length; i++) {
+                    if (propFunc(source[i])) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            return values.some(propFunc);
+        }
+    }
+}
+
+exports.some = some;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.mjs

@@ -0,0 +1,82 @@
+import { identity } from '../../function/identity.mjs';
+import { property } from '../object/property.mjs';
+import { matches } from '../predicate/matches.mjs';
+import { matchesProperty } from '../predicate/matchesProperty.mjs';
+
+function some(source, predicate, guard) {
+    if (!source) {
+        return false;
+    }
+    if (guard != null) {
+        predicate = undefined;
+    }
+    if (!predicate) {
+        predicate = identity;
+    }
+    const values = Array.isArray(source) ? source : Object.values(source);
+    switch (typeof predicate) {
+        case 'function': {
+            if (!Array.isArray(source)) {
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
+                    if (predicate(value, key, source)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            for (let i = 0; i < source.length; i++) {
+                if (predicate(source[i], i, source)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        case 'object': {
+            if (Array.isArray(predicate) && predicate.length === 2) {
+                const key = predicate[0];
+                const value = predicate[1];
+                const matchFunc = matchesProperty(key, value);
+                if (Array.isArray(source)) {
+                    for (let i = 0; i < source.length; i++) {
+                        if (matchFunc(source[i])) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                return values.some(matchFunc);
+            }
+            else {
+                const matchFunc = matches(predicate);
+                if (Array.isArray(source)) {
+                    for (let i = 0; i < source.length; i++) {
+                        if (matchFunc(source[i])) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+                return values.some(matchFunc);
+            }
+        }
+        case 'number':
+        case 'symbol':
+        case 'string': {
+            const propFunc = property(predicate);
+            if (Array.isArray(source)) {
+                for (let i = 0; i < source.length; i++) {
+                    if (propFunc(source[i])) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            return values.some(propFunc);
+        }
+    }
+}
+
+export { some };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.d.mts

@@ -0,0 +1,73 @@
+import { ListIteratee } from '../_internal/ListIteratee.mjs';
+import { Many } from '../_internal/Many.mjs';
+import { ObjectIteratee } from '../_internal/ObjectIteratee.mjs';
+
+/**
+ * Sorts an array of objects based on multiple properties and their corresponding order directions.
+ *
+ * This function takes an array of objects, an array of criteria to sort by.
+ * It returns the ascending sorted array, ordering by each key.
+ * If values for a key are equal, it moves to the next key to determine the order.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | object | null | undefined} collection - The array of objects to be sorted.
+ * @param {Array<Array<Criterion<T> | Criterion<T>>>} criteria - An array of criteria (property names or property paths or custom key functions) to sort by.
+ * @returns {T[]} - The ascending sorted array.
+ *
+ * @example
+ * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
+ * const users = [
+ *   { user: 'fred', age: 48 },
+ *   { user: 'barney', age: 34 },
+ *   { user: 'fred', age: 40 },
+ *   { user: 'barney', age: 36 },
+ * ];
+ * const result = sortBy(users, ['user', (item) => item.age])
+ * // result will be:
+ * // [
+ * //   { user: 'barney', age: 34 },
+ * //   { user: 'barney', age: 36 },
+ * //   { user: 'fred', age: 40 },
+ * //   { user: 'fred', age: 48 },
+ * // ]
+ */
+/**
+ * Creates an array of elements, sorted in ascending order by the results of running each element in a collection thru each iteratee.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection - The collection to iterate over.
+ * @param {...Array<T | readonly T[] | ListIteratee<T>>} iteratees - The iteratees to sort by.
+ * @returns {T[]} Returns the new sorted array.
+ *
+ * @example
+ * const users = [
+ *   { 'user': 'fred',   'age': 48 },
+ *   { 'user': 'barney', 'age': 36 },
+ *   { 'user': 'fred',   'age': 42 },
+ *   { 'user': 'barney', 'age': 34 }
+ * ];
+ *
+ * sortBy(users, [function(o) { return o.user; }]);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
+ */
+declare function sortBy<T>(collection: ArrayLike<T> | null | undefined, ...iteratees: Array<Many<ListIteratee<T>>>): T[];
+/**
+ * Creates an array of elements, sorted in ascending order by the results of running each element in a collection thru each iteratee.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The object to iterate over.
+ * @param {...Array<T[keyof T] | readonly Array<T[keyof T]> | ObjectIteratee<T>>} iteratees - The iteratees to sort by.
+ * @returns {Array<T[keyof T]>} Returns the new sorted array.
+ *
+ * @example
+ * const users = {
+ *   'a': { 'user': 'fred',   'age': 48 },
+ *   'b': { 'user': 'barney', 'age': 36 }
+ * };
+ *
+ * sortBy(users, [function(o) { return o.user; }]);
+ * // => [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 48 }]
+ */
+declare function sortBy<T extends object>(collection: T | null | undefined, ...iteratees: Array<Many<ObjectIteratee<T>>>): Array<T[keyof T]>;
+
+export { sortBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.d.ts

@@ -0,0 +1,73 @@
+import { ListIteratee } from '../_internal/ListIteratee.js';
+import { Many } from '../_internal/Many.js';
+import { ObjectIteratee } from '../_internal/ObjectIteratee.js';
+
+/**
+ * Sorts an array of objects based on multiple properties and their corresponding order directions.
+ *
+ * This function takes an array of objects, an array of criteria to sort by.
+ * It returns the ascending sorted array, ordering by each key.
+ * If values for a key are equal, it moves to the next key to determine the order.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | object | null | undefined} collection - The array of objects to be sorted.
+ * @param {Array<Array<Criterion<T> | Criterion<T>>>} criteria - An array of criteria (property names or property paths or custom key functions) to sort by.
+ * @returns {T[]} - The ascending sorted array.
+ *
+ * @example
+ * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
+ * const users = [
+ *   { user: 'fred', age: 48 },
+ *   { user: 'barney', age: 34 },
+ *   { user: 'fred', age: 40 },
+ *   { user: 'barney', age: 36 },
+ * ];
+ * const result = sortBy(users, ['user', (item) => item.age])
+ * // result will be:
+ * // [
+ * //   { user: 'barney', age: 34 },
+ * //   { user: 'barney', age: 36 },
+ * //   { user: 'fred', age: 40 },
+ * //   { user: 'fred', age: 48 },
+ * // ]
+ */
+/**
+ * Creates an array of elements, sorted in ascending order by the results of running each element in a collection thru each iteratee.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection - The collection to iterate over.
+ * @param {...Array<T | readonly T[] | ListIteratee<T>>} iteratees - The iteratees to sort by.
+ * @returns {T[]} Returns the new sorted array.
+ *
+ * @example
+ * const users = [
+ *   { 'user': 'fred',   'age': 48 },
+ *   { 'user': 'barney', 'age': 36 },
+ *   { 'user': 'fred',   'age': 42 },
+ *   { 'user': 'barney', 'age': 34 }
+ * ];
+ *
+ * sortBy(users, [function(o) { return o.user; }]);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
+ */
+declare function sortBy<T>(collection: ArrayLike<T> | null | undefined, ...iteratees: Array<Many<ListIteratee<T>>>): T[];
+/**
+ * Creates an array of elements, sorted in ascending order by the results of running each element in a collection thru each iteratee.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The object to iterate over.
+ * @param {...Array<T[keyof T] | readonly Array<T[keyof T]> | ObjectIteratee<T>>} iteratees - The iteratees to sort by.
+ * @returns {Array<T[keyof T]>} Returns the new sorted array.
+ *
+ * @example
+ * const users = {
+ *   'a': { 'user': 'fred',   'age': 48 },
+ *   'b': { 'user': 'barney', 'age': 36 }
+ * };
+ *
+ * sortBy(users, [function(o) { return o.user; }]);
+ * // => [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 48 }]
+ */
+declare function sortBy<T extends object>(collection: T | null | undefined, ...iteratees: Array<Many<ObjectIteratee<T>>>): Array<T[keyof T]>;
+
+export { sortBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const orderBy = require('./orderBy.js');
+const flatten = require('../../array/flatten.js');
+const isIterateeCall = require('../_internal/isIterateeCall.js');
+
+function sortBy(collection, ...criteria) {
+    const length = criteria.length;
+    if (length > 1 && isIterateeCall.isIterateeCall(collection, criteria[0], criteria[1])) {
+        criteria = [];
+    }
+    else if (length > 2 && isIterateeCall.isIterateeCall(criteria[0], criteria[1], criteria[2])) {
+        criteria = [criteria[0]];
+    }
+    return orderBy.orderBy(collection, flatten.flatten(criteria), ['asc']);
+}
+
+exports.sortBy = sortBy;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.mjs

@@ -0,0 +1,16 @@
+import { orderBy } from './orderBy.mjs';
+import { flatten } from '../../array/flatten.mjs';
+import { isIterateeCall } from '../_internal/isIterateeCall.mjs';
+
+function sortBy(collection, ...criteria) {
+    const length = criteria.length;
+    if (length > 1 && isIterateeCall(collection, criteria[0], criteria[1])) {
+        criteria = [];
+    }
+    else if (length > 2 && isIterateeCall(criteria[0], criteria[1], criteria[2])) {
+        criteria = [criteria[0]];
+    }
+    return orderBy(collection, flatten(criteria), ['asc']);
+}
+
+export { sortBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.d.mts

@@ -0,0 +1,30 @@
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([30, 50], 40)
+ * // => 1
+ */
+declare function sortedIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([30, 50], 40)
+ * // => 1
+ */
+declare function sortedIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndex };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([30, 50], 40)
+ * // => 1
+ */
+declare function sortedIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+/**
+ * Uses a binary search to determine the lowest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([30, 50], 40)
+ * // => 1
+ */
+declare function sortedIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndex };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const sortedIndexBy = require('./sortedIndexBy.js');
+const isNil = require('../../predicate/isNil.js');
+const isNull = require('../../predicate/isNull.js');
+const isSymbol = require('../../predicate/isSymbol.js');
+const isNumber = require('../predicate/isNumber.js');
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+function sortedIndex(array, value) {
+    if (isNil.isNil(array)) {
+        return 0;
+    }
+    let low = 0, high = isNil.isNil(array) ? low : array.length;
+    if (isNumber.isNumber(value) && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            const compute = array[mid];
+            if (!isNull.isNull(compute) && !isSymbol.isSymbol(compute) && compute < value) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return high;
+    }
+    return sortedIndexBy.sortedIndexBy(array, value, value => value);
+}
+
+exports.sortedIndex = sortedIndex;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.mjs

@@ -0,0 +1,30 @@
+import { sortedIndexBy } from './sortedIndexBy.mjs';
+import { isNil } from '../../predicate/isNil.mjs';
+import { isNull } from '../../predicate/isNull.mjs';
+import { isSymbol } from '../../predicate/isSymbol.mjs';
+import { isNumber } from '../predicate/isNumber.mjs';
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+function sortedIndex(array, value) {
+    if (isNil(array)) {
+        return 0;
+    }
+    let low = 0, high = isNil(array) ? low : array.length;
+    if (isNumber(value) && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            const compute = array[mid];
+            if (!isNull(compute) && !isSymbol(compute) && compute < value) {
+                low = mid + 1;
+            }
+            else {
+                high = mid;
+            }
+        }
+        return high;
+    }
+    return sortedIndexBy(array, value, value => value);
+}
+
+export { sortedIndex };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.d.mts

@@ -0,0 +1,25 @@
+import { ValueIteratee } from '../_internal/ValueIteratee.mjs';
+
+/**
+ * This method is like `sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The sorted array to inspect.
+ * @param {T} value - The value to evaluate.
+ * @param {ValueIteratee<T>} [iteratee] - The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted into `array`.
+ *
+ * @example
+ * const dict = { 'thirty': 30, 'forty': 40, 'fifty': 50 };
+ * sortedIndexBy(['thirty', 'fifty'], 'forty', _.propertyOf(dict));
+ * // => 1
+ *
+ * @example
+ * sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
+ * // => 0
+ */
+declare function sortedIndexBy<T>(array: ArrayLike<T> | null | undefined, value: T, iteratee?: ValueIteratee<T>): number;
+
+export { sortedIndexBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.d.ts

@@ -0,0 +1,25 @@
+import { ValueIteratee } from '../_internal/ValueIteratee.js';
+
+/**
+ * This method is like `sortedIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The sorted array to inspect.
+ * @param {T} value - The value to evaluate.
+ * @param {ValueIteratee<T>} [iteratee] - The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted into `array`.
+ *
+ * @example
+ * const dict = { 'thirty': 30, 'forty': 40, 'fifty': 50 };
+ * sortedIndexBy(['thirty', 'fifty'], 'forty', _.propertyOf(dict));
+ * // => 1
+ *
+ * @example
+ * sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
+ * // => 0
+ */
+declare function sortedIndexBy<T>(array: ArrayLike<T> | null | undefined, value: T, iteratee?: ValueIteratee<T>): number;
+
+export { sortedIndexBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const isNull = require('../../predicate/isNull.js');
+const isUndefined = require('../../predicate/isUndefined.js');
+const isNaN = require('../predicate/isNaN.js');
+const isNil = require('../predicate/isNil.js');
+const isSymbol = require('../predicate/isSymbol.js');
+const iteratee = require('../util/iteratee.js');
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
+function sortedIndexBy(array, value, iteratee$1 = iteratee.iteratee, retHighest) {
+    let low = 0;
+    let high = array == null ? 0 : array.length;
+    if (high === 0 || isNil.isNil(array)) {
+        return 0;
+    }
+    const iterateeFunction = iteratee.iteratee(iteratee$1);
+    const transformedValue = iterateeFunction(value);
+    const valIsNaN = isNaN.isNaN(transformedValue);
+    const valIsNull = isNull.isNull(transformedValue);
+    const valIsSymbol = isSymbol.isSymbol(transformedValue);
+    const valIsUndefined = isUndefined.isUndefined(transformedValue);
+    while (low < high) {
+        let setLow;
+        const mid = Math.floor((low + high) / 2);
+        const computed = iterateeFunction(array[mid]);
+        const othIsDefined = !isUndefined.isUndefined(computed);
+        const othIsNull = isNull.isNull(computed);
+        const othIsReflexive = !isNaN.isNaN(computed);
+        const othIsSymbol = isSymbol.isSymbol(computed);
+        if (valIsNaN) {
+            setLow = retHighest || othIsReflexive;
+        }
+        else if (valIsUndefined) {
+            setLow = othIsReflexive && (retHighest || othIsDefined);
+        }
+        else if (valIsNull) {
+            setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+        }
+        else if (valIsSymbol) {
+            setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+        }
+        else if (othIsNull || othIsSymbol) {
+            setLow = false;
+        }
+        else {
+            setLow = retHighest ? computed <= transformedValue : computed < transformedValue;
+        }
+        if (setLow) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return Math.min(high, MAX_ARRAY_INDEX);
+}
+
+exports.sortedIndexBy = sortedIndexBy;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.mjs

@@ -0,0 +1,58 @@
+import { isNull } from '../../predicate/isNull.mjs';
+import { isUndefined } from '../../predicate/isUndefined.mjs';
+import { isNaN } from '../predicate/isNaN.mjs';
+import { isNil } from '../predicate/isNil.mjs';
+import { isSymbol } from '../predicate/isSymbol.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1;
+function sortedIndexBy(array, value, iteratee$1 = iteratee, retHighest) {
+    let low = 0;
+    let high = array == null ? 0 : array.length;
+    if (high === 0 || isNil(array)) {
+        return 0;
+    }
+    const iterateeFunction = iteratee(iteratee$1);
+    const transformedValue = iterateeFunction(value);
+    const valIsNaN = isNaN(transformedValue);
+    const valIsNull = isNull(transformedValue);
+    const valIsSymbol = isSymbol(transformedValue);
+    const valIsUndefined = isUndefined(transformedValue);
+    while (low < high) {
+        let setLow;
+        const mid = Math.floor((low + high) / 2);
+        const computed = iterateeFunction(array[mid]);
+        const othIsDefined = !isUndefined(computed);
+        const othIsNull = isNull(computed);
+        const othIsReflexive = !isNaN(computed);
+        const othIsSymbol = isSymbol(computed);
+        if (valIsNaN) {
+            setLow = retHighest || othIsReflexive;
+        }
+        else if (valIsUndefined) {
+            setLow = othIsReflexive && (retHighest || othIsDefined);
+        }
+        else if (valIsNull) {
+            setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
+        }
+        else if (valIsSymbol) {
+            setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
+        }
+        else if (othIsNull || othIsSymbol) {
+            setLow = false;
+        }
+        else {
+            setLow = retHighest ? computed <= transformedValue : computed < transformedValue;
+        }
+        if (setLow) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return Math.min(high, MAX_ARRAY_INDEX);
+}
+
+export { sortedIndexBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Finds the index of the first occurrence of a value in a sorted array, similar to how `Array#indexOf` works, but specifically for sorted arrays.
+ *
+ * Make sure to provide a sorted array to this function, as it uses a binary search to quickly find the index.
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else -1.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * sortedIndexOf(numbers, 11); // Return value: 0
+ * sortedIndexOf(numbers, 30); // Return value: -1
+ *
+ * // If the value is duplicated, it returns the first index of the value.
+ * const duplicateNumbers = [1, 2, 2, 3, 3, 3, 4];
+ * sortedIndexOf(duplicateNumbers, 3); // Return value: 3
+ *
+ * // If the array is unsorted, it can return the wrong index.
+ * const unSortedArray = [55, 33, 22, 11, 44];
+ * sortedIndexOf(unSortedArray, 11); // Return value: -1
+ *
+ * // -0 and 0 are treated the same
+ * const mixedZeroArray = [-0, 0];
+ * sortedIndexOf(mixedZeroArray, 0); // Return value: 0
+ * sortedIndexOf(mixedZeroArray, -0); // Return value: 0
+ *
+ * // It works with array-like objects
+ * const arrayLike = { length: 3, 0: 10, 1: 20, 2: 30 };
+ * sortedIndexOf(arrayLike, 20); // Return value: 1
+ */
+declare function sortedIndexOf<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndexOf };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Finds the index of the first occurrence of a value in a sorted array, similar to how `Array#indexOf` works, but specifically for sorted arrays.
+ *
+ * Make sure to provide a sorted array to this function, as it uses a binary search to quickly find the index.
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else -1.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * sortedIndexOf(numbers, 11); // Return value: 0
+ * sortedIndexOf(numbers, 30); // Return value: -1
+ *
+ * // If the value is duplicated, it returns the first index of the value.
+ * const duplicateNumbers = [1, 2, 2, 3, 3, 3, 4];
+ * sortedIndexOf(duplicateNumbers, 3); // Return value: 3
+ *
+ * // If the array is unsorted, it can return the wrong index.
+ * const unSortedArray = [55, 33, 22, 11, 44];
+ * sortedIndexOf(unSortedArray, 11); // Return value: -1
+ *
+ * // -0 and 0 are treated the same
+ * const mixedZeroArray = [-0, 0];
+ * sortedIndexOf(mixedZeroArray, 0); // Return value: 0
+ * sortedIndexOf(mixedZeroArray, -0); // Return value: 0
+ *
+ * // It works with array-like objects
+ * const arrayLike = { length: 3, 0: 10, 1: 20, 2: 30 };
+ * sortedIndexOf(arrayLike, 20); // Return value: 1
+ */
+declare function sortedIndexOf<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndexOf };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const sortedIndex = require('./sortedIndex.js');
+const eq = require('../util/eq.js');
+
+function sortedIndexOf(array, value) {
+    if (!array?.length) {
+        return -1;
+    }
+    const index = sortedIndex.sortedIndex(array, value);
+    if (index < array.length && eq.eq(array[index], value)) {
+        return index;
+    }
+    return -1;
+}
+
+exports.sortedIndexOf = sortedIndexOf;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.mjs

@@ -0,0 +1,15 @@
+import { sortedIndex } from './sortedIndex.mjs';
+import { eq } from '../util/eq.mjs';
+
+function sortedIndexOf(array, value) {
+    if (!array?.length) {
+        return -1;
+    }
+    const index = sortedIndex(array, value);
+    if (index < array.length && eq(array[index], value)) {
+        return index;
+    }
+    return -1;
+}
+
+export { sortedIndexOf };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Uses a binary search to determine the highest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([4, 5, 5, 5, 6], 5)
+ * // => 4
+ */
+declare function sortedLastIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedLastIndex };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Uses a binary search to determine the highest index at which `value`
+ * should be inserted into `array` in order to maintain its sort order.
+ *
+ * @category Array
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to evaluate.
+ * @returns {number} Returns the index at which `value` should be inserted
+ *  into `array`.
+ * @example
+ * sortedIndex([4, 5, 5, 5, 6], 5)
+ * // => 4
+ */
+declare function sortedLastIndex<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedLastIndex };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const sortedLastIndexBy = require('./sortedLastIndexBy.js');
+const isNil = require('../../predicate/isNil.js');
+const isNull = require('../../predicate/isNull.js');
+const isSymbol = require('../../predicate/isSymbol.js');
+const isNumber = require('../predicate/isNumber.js');
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+function sortedLastIndex(array, value) {
+    if (isNil.isNil(array)) {
+        return 0;
+    }
+    let high = array.length;
+    if (!isNumber.isNumber(value) || Number.isNaN(value) || high > HALF_MAX_ARRAY_LENGTH) {
+        return sortedLastIndexBy.sortedLastIndexBy(array, value, value => value);
+    }
+    let low = 0;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        const compute = array[mid];
+        if (!isNull.isNull(compute) && !isSymbol.isSymbol(compute) && compute <= value) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return high;
+}
+
+exports.sortedLastIndex = sortedLastIndex;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.mjs

@@ -0,0 +1,31 @@
+import { sortedLastIndexBy } from './sortedLastIndexBy.mjs';
+import { isNil } from '../../predicate/isNil.mjs';
+import { isNull } from '../../predicate/isNull.mjs';
+import { isSymbol } from '../../predicate/isSymbol.mjs';
+import { isNumber } from '../predicate/isNumber.mjs';
+
+const MAX_ARRAY_LENGTH = 4294967295;
+const HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
+function sortedLastIndex(array, value) {
+    if (isNil(array)) {
+        return 0;
+    }
+    let high = array.length;
+    if (!isNumber(value) || Number.isNaN(value) || high > HALF_MAX_ARRAY_LENGTH) {
+        return sortedLastIndexBy(array, value, value => value);
+    }
+    let low = 0;
+    while (low < high) {
+        const mid = (low + high) >>> 1;
+        const compute = array[mid];
+        if (!isNull(compute) && !isSymbol(compute) && compute <= value) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return high;
+}
+
+export { sortedLastIndex };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.d.mts

@@ -0,0 +1,20 @@
+import { ValueIteratee } from '../_internal/ValueIteratee.mjs';
+
+/**
+ * This method is like `sortedLastIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The sorted array to inspect.
+ * @param {T} value - The value to evaluate.
+ * @param {ValueIteratee<T>} iteratee - The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted into `array`.
+ *
+ * @example
+ * sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
+ * // => 1
+ */
+declare function sortedLastIndexBy<T>(array: ArrayLike<T> | null | undefined, value: T, iteratee: ValueIteratee<T>): number;
+
+export { sortedLastIndexBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.d.ts

@@ -0,0 +1,20 @@
+import { ValueIteratee } from '../_internal/ValueIteratee.js';
+
+/**
+ * This method is like `sortedLastIndex` except that it accepts `iteratee`
+ * which is invoked for `value` and each element of `array` to compute their
+ * sort ranking. The iteratee is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} array - The sorted array to inspect.
+ * @param {T} value - The value to evaluate.
+ * @param {ValueIteratee<T>} iteratee - The iteratee invoked per element.
+ * @returns {number} Returns the index at which `value` should be inserted into `array`.
+ *
+ * @example
+ * sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
+ * // => 1
+ */
+declare function sortedLastIndexBy<T>(array: ArrayLike<T> | null | undefined, value: T, iteratee: ValueIteratee<T>): number;
+
+export { sortedLastIndexBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const sortedIndexBy = require('./sortedIndexBy.js');
+
+function sortedLastIndexBy(array, value, iteratee) {
+    return sortedIndexBy.sortedIndexBy(array, value, iteratee, true);
+}
+
+exports.sortedLastIndexBy = sortedLastIndexBy;

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.mjs

@@ -0,0 +1,7 @@
+import { sortedIndexBy } from './sortedIndexBy.mjs';
+
+function sortedLastIndexBy(array, value, iteratee) {
+    return sortedIndexBy(array, value, iteratee, true);
+}
+
+export { sortedLastIndexBy };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.d.mts

@@ -0,0 +1,35 @@
+/**
+ * Finds the index of the last occurrence of a value in a sorted array.
+ * This function is similar to `Array#lastIndexOf` but is specifically designed for sorted arrays.
+ *
+ * Make sure to provide a sorted array to this function, as it uses a binary search to quickly find the index.
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to search for.
+ * @returns {number} Returns the index of the last matched value, else -1.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * sortedLastIndexOf(numbers, 3); // Return value: 2
+ * sortedLastIndexOf(numbers, 6); // Return value: -1
+ *
+ * // If the value is duplicated, it returns the last index of the value.
+ * const duplicateNumbers = [1, 2, 2, 3, 3, 3, 4];
+ * sortedLastIndexOf(duplicateNumbers, 3); // Return value: 5
+ *
+ * // If the array is unsorted, it can return the wrong index.
+ * const unSortedArray = [55, 33, 22, 11, 44];
+ * sortedLastIndexOf(unSortedArray, 11); // Return value: -1
+ *
+ * // -0 and 0 are treated the same
+ * const mixedZeroArray = [-0, 0];
+ * sortedLastIndexOf(mixedZeroArray, 0); // Return value: 1
+ * sortedLastIndexOf(mixedZeroArray, -0); // Return value: 1
+ *
+ * // It works with array-like objects
+ * const arrayLike = { length: 3, 0: 10, 1: 20, 2: 20 };
+ * sortedLastIndexOf(arrayLike, 20); // Return value: 2
+ */
+declare function sortedLastIndexOf<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedLastIndexOf };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Finds the index of the last occurrence of a value in a sorted array.
+ * This function is similar to `Array#lastIndexOf` but is specifically designed for sorted arrays.
+ *
+ * Make sure to provide a sorted array to this function, as it uses a binary search to quickly find the index.
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to search for.
+ * @returns {number} Returns the index of the last matched value, else -1.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * sortedLastIndexOf(numbers, 3); // Return value: 2
+ * sortedLastIndexOf(numbers, 6); // Return value: -1
+ *
+ * // If the value is duplicated, it returns the last index of the value.
+ * const duplicateNumbers = [1, 2, 2, 3, 3, 3, 4];
+ * sortedLastIndexOf(duplicateNumbers, 3); // Return value: 5
+ *
+ * // If the array is unsorted, it can return the wrong index.
+ * const unSortedArray = [55, 33, 22, 11, 44];
+ * sortedLastIndexOf(unSortedArray, 11); // Return value: -1
+ *
+ * // -0 and 0 are treated the same
+ * const mixedZeroArray = [-0, 0];
+ * sortedLastIndexOf(mixedZeroArray, 0); // Return value: 1
+ * sortedLastIndexOf(mixedZeroArray, -0); // Return value: 1
+ *
+ * // It works with array-like objects
+ * const arrayLike = { length: 3, 0: 10, 1: 20, 2: 20 };
+ * sortedLastIndexOf(arrayLike, 20); // Return value: 2
+ */
+declare function sortedLastIndexOf<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedLastIndexOf };

novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const sortedLastIndex = require('./sortedLastIndex.js');
+const eq = require('../util/eq.js');
+
+function sortedLastIndexOf(array, value) {
+    if (!array?.length) {
+        return -1;
+    }
+    const index = sortedLastIndex.sortedLastIndex(array, value) - 1;
+    if (index >= 0 && eq.eq(array[index], value)) {
+        return index;
+    }
+    return -1;
+}
+
+exports.sortedLastIndexOf = sortedLastIndexOf;