diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-set-tostringtag/test/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-set-tostringtag/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..f1757b3a803db86e4f41186a4ff2b7411724d39a --- /dev/null +++ b/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(); +}); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/.github/FUNDING.yml b/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..9f928ae809d50c18aa9d24bea66f7dea85da323c --- /dev/null +++ b/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'] diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/helpers/isPrimitive.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/helpers/isPrimitive.js new file mode 100644 index 0000000000000000000000000000000000000000..401b5a47bf2b0681e281e2e77e3f2b07964e1d89 --- /dev/null +++ b/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'); +}; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es2015.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es2015.js new file mode 100644 index 0000000000000000000000000000000000000000..7b8458fbdab703bbc23d11cf0fef8937d76bad84 --- /dev/null +++ b/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(); +}); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es5.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es5.js new file mode 100644 index 0000000000000000000000000000000000000000..c17f6022aa36ebfb27ed31bbe6786868db669207 --- /dev/null +++ b/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(); +}); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es6.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/es6.js new file mode 100644 index 0000000000000000000000000000000000000000..b7a3515988982a7ef287046904bafd0b65cc9948 --- /dev/null +++ b/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(); +}); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-to-primitive/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ad71f39e2581e72e94435c3bbf8086fbaa29e8a6 --- /dev/null +++ b/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'); diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b4ab5e72b78e44020aaf8995cdc226bc559d9d0d --- /dev/null +++ b/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(array: ArrayLike | 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(object: T | null | undefined): Array; + +export { shuffle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b4ab5e72b78e44020aaf8995cdc226bc559d9d0d --- /dev/null +++ b/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(array: ArrayLike | 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(object: T | null | undefined): Array; + +export { shuffle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.js new file mode 100644 index 0000000000000000000000000000000000000000..fcf1724d2d074df654360a433c10046ed20a9c65 --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/shuffle.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7f4104349e037e79b95a11444b54ff33e7c62bb5 --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9e7b776c53efb11792c555f6ed9be4fd9e2492f3 --- /dev/null +++ b/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 | Set | 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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9e7b776c53efb11792c555f6ed9be4fd9e2492f3 --- /dev/null +++ b/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 | Set | 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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.js new file mode 100644 index 0000000000000000000000000000000000000000..ec91ddf46656ff1ff653fdd7b90a2215d2e599d9 --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/size.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0392cf8ed607cec2fd4405cb54d1a5aa70767061 --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f9c2e53b9e39d27a0c00a09b28c3d4c27cb4a2f7 --- /dev/null +++ b/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 | 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(array: ArrayLike | null | undefined, start?: number, end?: number): T[]; + +export { slice }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9c2e53b9e39d27a0c00a09b28c3d4c27cb4a2f7 --- /dev/null +++ b/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 | 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(array: ArrayLike | null | undefined, start?: number, end?: number): T[]; + +export { slice }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.js new file mode 100644 index 0000000000000000000000000000000000000000..5c1fa4aa26aec9f2d9de62a68054fc8bf1be8332 --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/slice.mjs new file mode 100644 index 0000000000000000000000000000000000000000..026bec4878c2bfb52518928379040810c1d5c285 --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8a5ab16f86fd2885321e1c2700c7007829c4a8cc --- /dev/null +++ b/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 | null | undefined} collection - The collection to iterate over. + * @param {ListIterateeCustom} [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(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom): 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} [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(collection: T | null | undefined, predicate?: ObjectIterateeCustom): boolean; + +export { some }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cf44fbc58bc4fd501b40c66f2ffa62837cb2b58a --- /dev/null +++ b/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 | null | undefined} collection - The collection to iterate over. + * @param {ListIterateeCustom} [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(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom): 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} [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(collection: T | null | undefined, predicate?: ObjectIterateeCustom): boolean; + +export { some }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.js new file mode 100644 index 0000000000000000000000000000000000000000..9d5f47957490a989d88a4700ee2fa3454baf1440 --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/some.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f6c05ecd8381eede9f42ba6fcbef4520a3276fd5 --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8aecc4cc46755256f8c26b11ca1f63c39fa9c5b3 --- /dev/null +++ b/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 | object | null | undefined} collection - The array of objects to be sorted. + * @param {Array | Criterion>>} 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 | null | undefined} collection - The collection to iterate over. + * @param {...Array>} 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(collection: ArrayLike | null | undefined, ...iteratees: Array>>): 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 | ObjectIteratee>} iteratees - The iteratees to sort by. + * @returns {Array} 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(collection: T | null | undefined, ...iteratees: Array>>): Array; + +export { sortBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..eccafb087a529ef834439f91bcedd4115d10cedb --- /dev/null +++ b/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 | object | null | undefined} collection - The array of objects to be sorted. + * @param {Array | Criterion>>} 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 | null | undefined} collection - The collection to iterate over. + * @param {...Array>} 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(collection: ArrayLike | null | undefined, ...iteratees: Array>>): 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 | ObjectIteratee>} iteratees - The iteratees to sort by. + * @returns {Array} 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(collection: T | null | undefined, ...iteratees: Array>>): Array; + +export { sortBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.js new file mode 100644 index 0000000000000000000000000000000000000000..f786b5e14c334735fd4c288e3810e629dbe3bf4e --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fddfbe6ab54aae4a0dfa934d1d9eac8a9de91d3b --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d5e2f7327dba8ea97fa59ea0f095ca8ace953cc1 --- /dev/null +++ b/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 | 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(array: ArrayLike | 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 | 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(array: ArrayLike | null | undefined, value: T): number; + +export { sortedIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d5e2f7327dba8ea97fa59ea0f095ca8ace953cc1 --- /dev/null +++ b/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 | 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(array: ArrayLike | 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 | 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(array: ArrayLike | null | undefined, value: T): number; + +export { sortedIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.js new file mode 100644 index 0000000000000000000000000000000000000000..8de6dcee2463b521e7ce3e5fd64026fbfd11becc --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndex.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6ac2e02e3bbbbc010eb0d05ca8368ce6b28f3357 --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..edbca67f25ef5bb361201915dd231a8844488c6c --- /dev/null +++ b/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 | null | undefined} array - The sorted array to inspect. + * @param {T} value - The value to evaluate. + * @param {ValueIteratee} [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(array: ArrayLike | null | undefined, value: T, iteratee?: ValueIteratee): number; + +export { sortedIndexBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6c81f1ac6ad6b48138f63bf8f34f545aaa8f3eef --- /dev/null +++ b/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 | null | undefined} array - The sorted array to inspect. + * @param {T} value - The value to evaluate. + * @param {ValueIteratee} [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(array: ArrayLike | null | undefined, value: T, iteratee?: ValueIteratee): number; + +export { sortedIndexBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.js new file mode 100644 index 0000000000000000000000000000000000000000..ed4dc512f5de15c01e060c4c8b214ac4d3f22803 --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..eb44b81750a69e7927e59acdaa1517110c74c50c --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ee3a4f971bb690df4339dfb5f7e800c730d913b6 --- /dev/null +++ b/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 | 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(array: ArrayLike | null | undefined, value: T): number; + +export { sortedIndexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee3a4f971bb690df4339dfb5f7e800c730d913b6 --- /dev/null +++ b/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 | 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(array: ArrayLike | null | undefined, value: T): number; + +export { sortedIndexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.js new file mode 100644 index 0000000000000000000000000000000000000000..b5aea7a35402af8790971327ceda691fac477317 --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedIndexOf.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c3e9988331b7ebde6a5291400e3cdb9f8f9bf4d7 --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d42a443aea95cfbbb5a766fa2c406b26f8fb918e --- /dev/null +++ b/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 | 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(array: ArrayLike | null | undefined, value: T): number; + +export { sortedLastIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d42a443aea95cfbbb5a766fa2c406b26f8fb918e --- /dev/null +++ b/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 | 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(array: ArrayLike | null | undefined, value: T): number; + +export { sortedLastIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.js new file mode 100644 index 0000000000000000000000000000000000000000..40455292c2f3527be55aa1e9be86869ad13e3ed4 --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndex.mjs new file mode 100644 index 0000000000000000000000000000000000000000..50dc40bb78e2ffeffd5b8daaae056c095307af6f --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..43ef9a764ab7be6005268c930d44d0e0db660f7c --- /dev/null +++ b/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 | null | undefined} array - The sorted array to inspect. + * @param {T} value - The value to evaluate. + * @param {ValueIteratee} 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(array: ArrayLike | null | undefined, value: T, iteratee: ValueIteratee): number; + +export { sortedLastIndexBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c2cc5404862ca11bbca3c71fcb30ef8fc023704e --- /dev/null +++ b/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 | null | undefined} array - The sorted array to inspect. + * @param {T} value - The value to evaluate. + * @param {ValueIteratee} 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(array: ArrayLike | null | undefined, value: T, iteratee: ValueIteratee): number; + +export { sortedLastIndexBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.js new file mode 100644 index 0000000000000000000000000000000000000000..b4616aaaf722d0c13f3694679cdf43a83795b985 --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..510bc016c15024c644c5ffe07010bd133af5ef7e --- /dev/null +++ b/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 }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e227d8dad12560dc5b85b32d80f6f1bccfea7571 --- /dev/null +++ b/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 | 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(array: ArrayLike | null | undefined, value: T): number; + +export { sortedLastIndexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e227d8dad12560dc5b85b32d80f6f1bccfea7571 --- /dev/null +++ b/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 | 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(array: ArrayLike | null | undefined, value: T): number; + +export { sortedLastIndexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.js new file mode 100644 index 0000000000000000000000000000000000000000..bb9a3e62fcfd408fa989bf673da7f19b8c4d098d --- /dev/null +++ b/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; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c2e3caa396a50379b0b17d9b87c7ba17753c127f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sortedLastIndexOf.mjs @@ -0,0 +1,15 @@ +import { sortedLastIndex } from './sortedLastIndex.mjs'; +import { eq } from '../util/eq.mjs'; + +function sortedLastIndexOf(array, value) { + if (!array?.length) { + return -1; + } + const index = sortedLastIndex(array, value) - 1; + if (index >= 0 && eq(array[index], value)) { + return index; + } + return -1; +} + +export { sortedLastIndexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cd4714cbf56e708016345cbe8c420f2e5e662ead --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.d.mts @@ -0,0 +1,26 @@ +/** + * Gets all but the first element of array. + * + * @template T + * @param {readonly [unknown, ...T]} array - The array to query. + * @returns {T} Returns the slice of array. + * + * @example + * tail([1, 2, 3]); + * // => [2, 3] + */ +declare function tail(array: readonly [unknown, ...T]): T; +/** + * Gets all but the first element of array. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @returns {T[]} Returns the slice of array. + * + * @example + * tail([1, 2, 3]); + * // => [2, 3] + */ +declare function tail(array: ArrayLike | null | undefined): T[]; + +export { tail }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cd4714cbf56e708016345cbe8c420f2e5e662ead --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.d.ts @@ -0,0 +1,26 @@ +/** + * Gets all but the first element of array. + * + * @template T + * @param {readonly [unknown, ...T]} array - The array to query. + * @returns {T} Returns the slice of array. + * + * @example + * tail([1, 2, 3]); + * // => [2, 3] + */ +declare function tail(array: readonly [unknown, ...T]): T; +/** + * Gets all but the first element of array. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @returns {T[]} Returns the slice of array. + * + * @example + * tail([1, 2, 3]); + * // => [2, 3] + */ +declare function tail(array: ArrayLike | null | undefined): T[]; + +export { tail }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.js new file mode 100644 index 0000000000000000000000000000000000000000..e564188edb56960db1843104fa75a0a0ea8c4fd9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const tail$1 = require('../../array/tail.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function tail(arr) { + if (!isArrayLike.isArrayLike(arr)) { + return []; + } + return tail$1.tail(toArray.toArray(arr)); +} + +exports.tail = tail; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fbbb7104ed8f20d9c11f7f50606f9c6b64d3c89f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/tail.mjs @@ -0,0 +1,12 @@ +import { tail as tail$1 } from '../../array/tail.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function tail(arr) { + if (!isArrayLike(arr)) { + return []; + } + return tail$1(toArray(arr)); +} + +export { tail }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..582ab7027afb2141d6f24aea1cd04cedc0d852c9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.d.mts @@ -0,0 +1,27 @@ +/** + * Creates a slice of array with n elements taken from the beginning. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {number} [n=1] - The number of elements to take. + * @returns {T[]} Returns the slice of array. + * + * @example + * take([1, 2, 3]); + * // => [1] + * + * @example + * take([1, 2, 3], 2); + * // => [1, 2] + * + * @example + * take([1, 2, 3], 5); + * // => [1, 2, 3] + * + * @example + * take([1, 2, 3], 0); + * // => [] + */ +declare function take(array: ArrayLike | null | undefined, n?: number): T[]; + +export { take }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..582ab7027afb2141d6f24aea1cd04cedc0d852c9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.d.ts @@ -0,0 +1,27 @@ +/** + * Creates a slice of array with n elements taken from the beginning. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {number} [n=1] - The number of elements to take. + * @returns {T[]} Returns the slice of array. + * + * @example + * take([1, 2, 3]); + * // => [1] + * + * @example + * take([1, 2, 3], 2); + * // => [1, 2] + * + * @example + * take([1, 2, 3], 5); + * // => [1, 2, 3] + * + * @example + * take([1, 2, 3], 0); + * // => [] + */ +declare function take(array: ArrayLike | null | undefined, n?: number): T[]; + +export { take }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.js new file mode 100644 index 0000000000000000000000000000000000000000..7860480ed50800a844245985d20e74637431c521 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const take$1 = require('../../array/take.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const toInteger = require('../util/toInteger.js'); + +function take(arr, count = 1, guard) { + count = guard ? 1 : toInteger.toInteger(count); + if (count < 1 || !isArrayLike.isArrayLike(arr)) { + return []; + } + return take$1.take(toArray.toArray(arr), count); +} + +exports.take = take; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c1b4ed3a6bd6ac1f1d3ec5f2ada9421aa89c041a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/take.mjs @@ -0,0 +1,14 @@ +import { take as take$1 } from '../../array/take.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { toInteger } from '../util/toInteger.mjs'; + +function take(arr, count = 1, guard) { + count = guard ? 1 : toInteger(count); + if (count < 1 || !isArrayLike(arr)) { + return []; + } + return take$1(toArray(arr), count); +} + +export { take }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..31df7e7a5a84de3ce013e6171b3ca723ac37f1fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.d.mts @@ -0,0 +1,27 @@ +/** + * Creates a slice of array with n elements taken from the end. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {number} [n=1] - The number of elements to take. + * @returns {T[]} Returns the slice of array. + * + * @example + * takeRight([1, 2, 3]); + * // => [3] + * + * @example + * takeRight([1, 2, 3], 2); + * // => [2, 3] + * + * @example + * takeRight([1, 2, 3], 5); + * // => [1, 2, 3] + * + * @example + * takeRight([1, 2, 3], 0); + * // => [] + */ +declare function takeRight(array: ArrayLike | null | undefined, n?: number): T[]; + +export { takeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..31df7e7a5a84de3ce013e6171b3ca723ac37f1fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.d.ts @@ -0,0 +1,27 @@ +/** + * Creates a slice of array with n elements taken from the end. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {number} [n=1] - The number of elements to take. + * @returns {T[]} Returns the slice of array. + * + * @example + * takeRight([1, 2, 3]); + * // => [3] + * + * @example + * takeRight([1, 2, 3], 2); + * // => [2, 3] + * + * @example + * takeRight([1, 2, 3], 5); + * // => [1, 2, 3] + * + * @example + * takeRight([1, 2, 3], 0); + * // => [] + */ +declare function takeRight(array: ArrayLike | null | undefined, n?: number): T[]; + +export { takeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.js new file mode 100644 index 0000000000000000000000000000000000000000..fece14d91c7ba5171a836f5c2328503cb7c05b89 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const takeRight$1 = require('../../array/takeRight.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const toInteger = require('../util/toInteger.js'); + +function takeRight(arr, count = 1, guard) { + count = guard ? 1 : toInteger.toInteger(count); + if (count <= 0 || !isArrayLike.isArrayLike(arr)) { + return []; + } + return takeRight$1.takeRight(toArray.toArray(arr), count); +} + +exports.takeRight = takeRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2d6cf86218e8925c064023871d03fe6a9f2d2a0a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRight.mjs @@ -0,0 +1,14 @@ +import { takeRight as takeRight$1 } from '../../array/takeRight.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { toInteger } from '../util/toInteger.mjs'; + +function takeRight(arr, count = 1, guard) { + count = guard ? 1 : toInteger(count); + if (count <= 0 || !isArrayLike(arr)) { + return []; + } + return takeRight$1(toArray(arr), count); +} + +export { takeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5243bc4756de855b445a900c673467db5d9d46ad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.d.mts @@ -0,0 +1,36 @@ +import { ListIteratee } from '../_internal/ListIteratee.mjs'; + +/** + * Creates a slice of array with elements taken from the end. Elements are taken until predicate + * returns falsey. The predicate is invoked with three arguments: (value, index, array). + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {ListIteratee} [predicate] - The function invoked per iteration. + * @returns {T[]} Returns the slice of array. + * + * @example + * const users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * takeRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['fred', 'pebbles'] + * + * @example + * takeRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['pebbles'] + * + * @example + * takeRightWhile(users, ['active', false]); + * // => objects for ['fred', 'pebbles'] + * + * @example + * takeRightWhile(users, 'active'); + * // => [] + */ +declare function takeRightWhile(array: ArrayLike | null | undefined, predicate?: ListIteratee): T[]; + +export { takeRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..afc53aa32f69a4c820ff0e3db5bdc22b883f2d42 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.d.ts @@ -0,0 +1,36 @@ +import { ListIteratee } from '../_internal/ListIteratee.js'; + +/** + * Creates a slice of array with elements taken from the end. Elements are taken until predicate + * returns falsey. The predicate is invoked with three arguments: (value, index, array). + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {ListIteratee} [predicate] - The function invoked per iteration. + * @returns {T[]} Returns the slice of array. + * + * @example + * const users = [ + * { 'user': 'barney', 'active': true }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': false } + * ]; + * + * takeRightWhile(users, function(o) { return !o.active; }); + * // => objects for ['fred', 'pebbles'] + * + * @example + * takeRightWhile(users, { 'user': 'pebbles', 'active': false }); + * // => objects for ['pebbles'] + * + * @example + * takeRightWhile(users, ['active', false]); + * // => objects for ['fred', 'pebbles'] + * + * @example + * takeRightWhile(users, 'active'); + * // => [] + */ +declare function takeRightWhile(array: ArrayLike | null | undefined, predicate?: ListIteratee): T[]; + +export { takeRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.js new file mode 100644 index 0000000000000000000000000000000000000000..310fce36866766051032c87403f6c562a2d3d744 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const negate = require('../../function/negate.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); +const iteratee = require('../util/iteratee.js'); + +function takeRightWhile(_array, predicate) { + if (!isArrayLikeObject.isArrayLikeObject(_array)) { + return []; + } + const array = toArray.toArray(_array); + const index = array.findLastIndex(negate.negate(iteratee.iteratee(predicate ?? identity.identity))); + return array.slice(index + 1); +} + +exports.takeRightWhile = takeRightWhile; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c7ef177ccd9aaadaf64d61d2e923c3cfdf3a18d8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeRightWhile.mjs @@ -0,0 +1,16 @@ +import { identity } from '../../function/identity.mjs'; +import { negate } from '../../function/negate.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function takeRightWhile(_array, predicate) { + if (!isArrayLikeObject(_array)) { + return []; + } + const array = toArray(_array); + const index = array.findLastIndex(negate(iteratee(predicate ?? identity))); + return array.slice(index + 1); +} + +export { takeRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..32565bb14c9c386d9fc8e492a8138774acff9d8b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.d.mts @@ -0,0 +1,36 @@ +import { ListIteratee } from '../_internal/ListIteratee.mjs'; + +/** + * Creates a slice of array with elements taken from the beginning. Elements are taken until predicate + * returns falsey. The predicate is invoked with three arguments: (value, index, array). + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {ListIteratee} [predicate] - The function invoked per iteration. + * @returns {T[]} Returns the slice of array. + * + * @example + * const users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * takeWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney', 'fred'] + * + * @example + * takeWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['barney'] + * + * @example + * takeWhile(users, ['active', false]); + * // => objects for ['barney', 'fred'] + * + * @example + * takeWhile(users, 'active'); + * // => [] + */ +declare function takeWhile(array: ArrayLike | null | undefined, predicate?: ListIteratee): T[]; + +export { takeWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ded714589c006c68aa391a9636d5f4c7ee84437f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.d.ts @@ -0,0 +1,36 @@ +import { ListIteratee } from '../_internal/ListIteratee.js'; + +/** + * Creates a slice of array with elements taken from the beginning. Elements are taken until predicate + * returns falsey. The predicate is invoked with three arguments: (value, index, array). + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {ListIteratee} [predicate] - The function invoked per iteration. + * @returns {T[]} Returns the slice of array. + * + * @example + * const users = [ + * { 'user': 'barney', 'active': false }, + * { 'user': 'fred', 'active': false }, + * { 'user': 'pebbles', 'active': true } + * ]; + * + * takeWhile(users, function(o) { return !o.active; }); + * // => objects for ['barney', 'fred'] + * + * @example + * takeWhile(users, { 'user': 'barney', 'active': false }); + * // => objects for ['barney'] + * + * @example + * takeWhile(users, ['active', false]); + * // => objects for ['barney', 'fred'] + * + * @example + * takeWhile(users, 'active'); + * // => [] + */ +declare function takeWhile(array: ArrayLike | null | undefined, predicate?: ListIteratee): T[]; + +export { takeWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.js new file mode 100644 index 0000000000000000000000000000000000000000..48fae13d14ce2d19a1d9a9b22177b367b10bdf5c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toArray = require('../_internal/toArray.js'); +const identity = require('../function/identity.js'); +const negate = require('../function/negate.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); +const iteratee = require('../util/iteratee.js'); + +function takeWhile(array, predicate) { + if (!isArrayLikeObject.isArrayLikeObject(array)) { + return []; + } + const _array = toArray.toArray(array); + const index = _array.findIndex(negate.negate(iteratee.iteratee(predicate ?? identity.identity))); + return index === -1 ? _array : _array.slice(0, index); +} + +exports.takeWhile = takeWhile; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d6a80ff00bc4028d8e5c4e8f01dcdb38a6c2bdc5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/takeWhile.mjs @@ -0,0 +1,16 @@ +import { toArray } from '../_internal/toArray.mjs'; +import { identity } from '../function/identity.mjs'; +import { negate } from '../function/negate.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function takeWhile(array, predicate) { + if (!isArrayLikeObject(array)) { + return []; + } + const _array = toArray(array); + const index = _array.findIndex(negate(iteratee(predicate ?? identity))); + return index === -1 ? _array : _array.slice(0, index); +} + +export { takeWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f9cc7655b3dd77c8b74353354f865ac3da34a849 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.d.mts @@ -0,0 +1,30 @@ +/** + * This function takes multiple arrays and returns a new array containing only the unique values + * from all input arrays, preserving the order of their first occurrence. + * + * @template T - The type of elements in the arrays. + * @param {Array | null | undefined>} arrays - The arrays to inspect. + * @returns {T[]} Returns the new array of combined unique values. + * + * @example + * // Returns [2, 1] + * union([2], [1, 2]); + * + * @example + * // Returns [2, 1, 3] + * union([2], [1, 2], [2, 3]); + * + * @example + * // Returns [1, 3, 2, [5], [4]] (does not deeply flatten nested arrays) + * union([1, 3, 2], [1, [5]], [2, [4]]); + * + * @example + * // Returns [0, 2, 1] (ignores non-array values like 3 and { '0': 1 }) + * union([0], 3, { '0': 1 }, null, [2, 1]); + * @example + * // Returns [0, 'a', 2, 1] (treats array-like object { 0: 'a', length: 1 } as a valid array) + * union([0], { 0: 'a', length: 1 }, [2, 1]); + */ +declare function union(...arrays: Array | null | undefined>): T[]; + +export { union }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9cc7655b3dd77c8b74353354f865ac3da34a849 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.d.ts @@ -0,0 +1,30 @@ +/** + * This function takes multiple arrays and returns a new array containing only the unique values + * from all input arrays, preserving the order of their first occurrence. + * + * @template T - The type of elements in the arrays. + * @param {Array | null | undefined>} arrays - The arrays to inspect. + * @returns {T[]} Returns the new array of combined unique values. + * + * @example + * // Returns [2, 1] + * union([2], [1, 2]); + * + * @example + * // Returns [2, 1, 3] + * union([2], [1, 2], [2, 3]); + * + * @example + * // Returns [1, 3, 2, [5], [4]] (does not deeply flatten nested arrays) + * union([1, 3, 2], [1, [5]], [2, [4]]); + * + * @example + * // Returns [0, 2, 1] (ignores non-array values like 3 and { '0': 1 }) + * union([0], 3, { '0': 1 }, null, [2, 1]); + * @example + * // Returns [0, 'a', 2, 1] (treats array-like object { 0: 'a', length: 1 } as a valid array) + * union([0], { 0: 'a', length: 1 }, [2, 1]); + */ +declare function union(...arrays: Array | null | undefined>): T[]; + +export { union }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.js new file mode 100644 index 0000000000000000000000000000000000000000..087bcab717eb1dfa701e64f02e4e473ea56c92c8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flattenDepth = require('./flattenDepth.js'); +const uniq = require('../../array/uniq.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function union(...arrays) { + const validArrays = arrays.filter(isArrayLikeObject.isArrayLikeObject); + const flattened = flattenDepth.flattenDepth(validArrays, 1); + return uniq.uniq(flattened); +} + +exports.union = union; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.mjs new file mode 100644 index 0000000000000000000000000000000000000000..28481c43f2966962fb125c6d4a3e4c2d37ef978c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/union.mjs @@ -0,0 +1,11 @@ +import { flattenDepth } from './flattenDepth.mjs'; +import { uniq } from '../../array/uniq.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function union(...arrays) { + const validArrays = arrays.filter(isArrayLikeObject); + const flattened = flattenDepth(validArrays, 1); + return uniq(flattened); +} + +export { union }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..766a940bcbf896b308ac51d32ae69a37c81f453d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.d.mts @@ -0,0 +1,93 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The arrays to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * @example + * unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ +declare function unionBy(arrays: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays1 - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + */ +declare function unionBy(arrays1: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays1 - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], [3.4], Math.floor); + * // => [2.1, 1.2, 3.4] + */ +declare function unionBy(arrays1: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays1 - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {ArrayLike | null | undefined} arrays4 - The fourth array to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], [3.4], [4.5], Math.floor); + * // => [2.1, 1.2, 3.4, 4.5] + */ +declare function unionBy(arrays1: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, arrays4: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays1 - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {ArrayLike | null | undefined} arrays4 - The fourth array to inspect. + * @param {ArrayLike | null | undefined} arrays5 - The fifth array to inspect. + * @param {...Array | ArrayLike | null | undefined>} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], [3.4], [4.5], [5.6], Math.floor); + * // => [2.1, 1.2, 3.4, 4.5, 5.6] + */ +declare function unionBy(arrays1: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, arrays4: ArrayLike | null | undefined, arrays5: ArrayLike | null | undefined, ...iteratee: Array | ArrayLike | null | undefined>): T[]; + +export { unionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..88ea6aeebfe0fd2e9969be10e77e29062dbd7954 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.d.ts @@ -0,0 +1,93 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The arrays to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + * + * @example + * unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 1 }, { 'x': 2 }] + */ +declare function unionBy(arrays: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays1 - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + */ +declare function unionBy(arrays1: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays1 - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], [3.4], Math.floor); + * // => [2.1, 1.2, 3.4] + */ +declare function unionBy(arrays1: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays1 - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {ArrayLike | null | undefined} arrays4 - The fourth array to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], [3.4], [4.5], Math.floor); + * // => [2.1, 1.2, 3.4, 4.5] + */ +declare function unionBy(arrays1: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, arrays4: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `union` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays1 - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {ArrayLike | null | undefined} arrays4 - The fourth array to inspect. + * @param {ArrayLike | null | undefined} arrays5 - The fifth array to inspect. + * @param {...Array | ArrayLike | null | undefined>} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionBy([2.1], [1.2, 2.3], [3.4], [4.5], [5.6], Math.floor); + * // => [2.1, 1.2, 3.4, 4.5, 5.6] + */ +declare function unionBy(arrays1: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, arrays4: ArrayLike | null | undefined, arrays5: ArrayLike | null | undefined, ...iteratee: Array | ArrayLike | null | undefined>): T[]; + +export { unionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.js new file mode 100644 index 0000000000000000000000000000000000000000..96fdfcf2855b9a366eae30214982d2e24d86fc21 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.js @@ -0,0 +1,21 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const last = require('../../array/last.js'); +const uniq = require('../../array/uniq.js'); +const uniqBy = require('../../array/uniqBy.js'); +const flattenArrayLike = require('../_internal/flattenArrayLike.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); +const iteratee = require('../util/iteratee.js'); + +function unionBy(...values) { + const lastValue = last.last(values); + const flattened = flattenArrayLike.flattenArrayLike(values); + if (isArrayLikeObject.isArrayLikeObject(lastValue) || lastValue == null) { + return uniq.uniq(flattened); + } + return uniqBy.uniqBy(flattened, iteratee.iteratee(lastValue)); +} + +exports.unionBy = unionBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..92905c99b8196d9f4c1957743fd31eb24836ece9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionBy.mjs @@ -0,0 +1,17 @@ +import { last } from '../../array/last.mjs'; +import { uniq } from '../../array/uniq.mjs'; +import { uniqBy } from '../../array/uniqBy.mjs'; +import { flattenArrayLike } from '../_internal/flattenArrayLike.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function unionBy(...values) { + const lastValue = last(values); + const flattened = flattenArrayLike(values); + if (isArrayLikeObject(lastValue) || lastValue == null) { + return uniq(flattened); + } + return uniqBy(flattened, iteratee(lastValue)); +} + +export { unionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..39bf36948af0923a3095428c1aa4be935d46dfbd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.d.mts @@ -0,0 +1,52 @@ +/** + * This method is like `union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The arrays to inspect. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * unionWith(objects, others, isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ +declare function unionWith(arrays: ArrayLike | null | undefined, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionWith([1, 2], [2, 3], (a, b) => a === b); + * // => [1, 2, 3] + */ +declare function unionWith(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {...Array<(a: T, b: T) => boolean | ArrayLike | null | undefined>} comparator - The comparator invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionWith([1], [2], [3], (a, b) => a === b); + * // => [1, 2, 3] + */ +declare function unionWith(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, ...comparator: Array<((a: T, b: T) => boolean) | ArrayLike | null | undefined>): T[]; + +export { unionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..39bf36948af0923a3095428c1aa4be935d46dfbd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.d.ts @@ -0,0 +1,52 @@ +/** + * This method is like `union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The arrays to inspect. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * unionWith(objects, others, isEqual); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ +declare function unionWith(arrays: ArrayLike | null | undefined, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionWith([1, 2], [2, 3], (a, b) => a === b); + * // => [1, 2, 3] + */ +declare function unionWith(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `union` except that it accepts `comparator` which + * is invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {...Array<(a: T, b: T) => boolean | ArrayLike | null | undefined>} comparator - The comparator invoked per element. + * @returns {T[]} Returns the new array of combined values. + * + * @example + * unionWith([1], [2], [3], (a, b) => a === b); + * // => [1, 2, 3] + */ +declare function unionWith(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, ...comparator: Array<((a: T, b: T) => boolean) | ArrayLike | null | undefined>): T[]; + +export { unionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.js new file mode 100644 index 0000000000000000000000000000000000000000..2ad77f99e00d63fd5797b9f92cabe55759364720 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const last = require('../../array/last.js'); +const uniq = require('../../array/uniq.js'); +const uniqWith = require('../../array/uniqWith.js'); +const flattenArrayLike = require('../_internal/flattenArrayLike.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function unionWith(...values) { + const lastValue = last.last(values); + const flattened = flattenArrayLike.flattenArrayLike(values); + if (isArrayLikeObject.isArrayLikeObject(lastValue) || lastValue == null) { + return uniq.uniq(flattened); + } + return uniqWith.uniqWith(flattened, lastValue); +} + +exports.unionWith = unionWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9e1f27e474d8f8c01923f1037bd34ed493391a7c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unionWith.mjs @@ -0,0 +1,16 @@ +import { last } from '../../array/last.mjs'; +import { uniq } from '../../array/uniq.mjs'; +import { uniqWith } from '../../array/uniqWith.mjs'; +import { flattenArrayLike } from '../_internal/flattenArrayLike.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function unionWith(...values) { + const lastValue = last(values); + const flattened = flattenArrayLike(values); + if (isArrayLikeObject(lastValue) || lastValue == null) { + return uniq(flattened); + } + return uniqWith(flattened, lastValue); +} + +export { unionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d08236ea46ce39765524448c38da2acd36d9a6a6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.d.mts @@ -0,0 +1,18 @@ +/** + * Creates a duplicate-free version of an array. + * + * This function takes an array and returns a new array containing only the unique values + * from the original array, preserving the order of first occurrence. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The array to process. + * @returns {T[]} A new array with only unique values from the original array. + * + * @example + * const array = [1, 2, 2, 3, 4, 4, 5]; + * const result = uniq(array); + * // result will be [1, 2, 3, 4, 5] + */ +declare function uniq(arr: ArrayLike | null | undefined): T[]; + +export { uniq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d08236ea46ce39765524448c38da2acd36d9a6a6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.d.ts @@ -0,0 +1,18 @@ +/** + * Creates a duplicate-free version of an array. + * + * This function takes an array and returns a new array containing only the unique values + * from the original array, preserving the order of first occurrence. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The array to process. + * @returns {T[]} A new array with only unique values from the original array. + * + * @example + * const array = [1, 2, 2, 3, 4, 4, 5]; + * const result = uniq(array); + * // result will be [1, 2, 3, 4, 5] + */ +declare function uniq(arr: ArrayLike | null | undefined): T[]; + +export { uniq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.js new file mode 100644 index 0000000000000000000000000000000000000000..5c98d488999f1fb3f2772658b06a2e8afd399760 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const uniq$1 = require('../../array/uniq.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function uniq(arr) { + if (!isArrayLike.isArrayLike(arr)) { + return []; + } + return uniq$1.uniq(Array.from(arr)); +} + +exports.uniq = uniq; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.mjs new file mode 100644 index 0000000000000000000000000000000000000000..028f89427a90058bcf4b06a7d679fc5ffcb1b465 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniq.mjs @@ -0,0 +1,11 @@ +import { uniq as uniq$1 } from '../../array/uniq.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function uniq(arr) { + if (!isArrayLike(arr)) { + return []; + } + return uniq$1(Array.from(arr)); +} + +export { uniq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..92a7ac79f263a78e590454aa138a446d5fb6ad82 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.d.mts @@ -0,0 +1,17 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Creates a duplicate-free version of an array, using an optional transform function. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ValueIteratee} iteratee - The transform function or property name to get values from. + * @returns {T[]} Returns the new duplicate-free array. + * + * @example + * uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + */ +declare function uniqBy(array: ArrayLike | null | undefined, iteratee: ValueIteratee): T[]; + +export { uniqBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dd6a23de5bcef6e68012faf54da1fffcb1ada9e7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.d.ts @@ -0,0 +1,17 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Creates a duplicate-free version of an array, using an optional transform function. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ValueIteratee} iteratee - The transform function or property name to get values from. + * @returns {T[]} Returns the new duplicate-free array. + * + * @example + * uniqBy([2.1, 1.2, 2.3], Math.floor); + * // => [2.1, 1.2] + */ +declare function uniqBy(array: ArrayLike | null | undefined, iteratee: ValueIteratee): T[]; + +export { uniqBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.js new file mode 100644 index 0000000000000000000000000000000000000000..a247981179f15509c229aa6fbd403c46fcd8822a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const uniqBy$1 = require('../../array/uniqBy.js'); +const identity = require('../../function/identity.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); +const iteratee = require('../util/iteratee.js'); + +function uniqBy(array, iteratee$1 = identity.identity) { + if (!isArrayLikeObject.isArrayLikeObject(array)) { + return []; + } + return uniqBy$1.uniqBy(Array.from(array), iteratee.iteratee(iteratee$1)); +} + +exports.uniqBy = uniqBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0a8677f89ec922d66832f1ddbeee633442bdbf3a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqBy.mjs @@ -0,0 +1,13 @@ +import { uniqBy as uniqBy$1 } from '../../array/uniqBy.mjs'; +import { identity } from '../../function/identity.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function uniqBy(array, iteratee$1 = identity) { + if (!isArrayLikeObject(array)) { + return []; + } + return uniqBy$1(Array.from(array), iteratee(iteratee$1)); +} + +export { uniqBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d1e266c7dd22a9810efb08822f4c923dad2feb13 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.d.mts @@ -0,0 +1,27 @@ +type Comparator = (a: T, b: T) => boolean; +/** + * This method is like `uniq`, except that it accepts a `comparator` which is used to determine the equality of elements. + * + * It creates a duplicate-free version of an array, in which only the first occurrence of each element is kept. + * If a `comparator` is provided, it will be invoked with two arguments: `(arrVal, othVal)` to compare elements. + * If no comparator is provided, shallow equality is used. + * + * The order of result values is determined by the order they appear in the input array. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The array to process. + * @param {Comparator} [comparator] - Optional function to compare elements for equality. + * @returns {T[]} A new array with only unique values based on the comparator. + * + * @example + * const array = [1, 2, 2, 3]; + * const result = uniqWith(array); + * // result will be [1, 2, 3] + * + * const array = [1, 2, 3]; + * const result = uniqWith(array, (a, b) => a % 2 === b % 2) + * // result will be [1, 2] + */ +declare function uniqWith(arr: ArrayLike | null | undefined, comparator?: Comparator): T[]; + +export { uniqWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d1e266c7dd22a9810efb08822f4c923dad2feb13 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.d.ts @@ -0,0 +1,27 @@ +type Comparator = (a: T, b: T) => boolean; +/** + * This method is like `uniq`, except that it accepts a `comparator` which is used to determine the equality of elements. + * + * It creates a duplicate-free version of an array, in which only the first occurrence of each element is kept. + * If a `comparator` is provided, it will be invoked with two arguments: `(arrVal, othVal)` to compare elements. + * If no comparator is provided, shallow equality is used. + * + * The order of result values is determined by the order they appear in the input array. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The array to process. + * @param {Comparator} [comparator] - Optional function to compare elements for equality. + * @returns {T[]} A new array with only unique values based on the comparator. + * + * @example + * const array = [1, 2, 2, 3]; + * const result = uniqWith(array); + * // result will be [1, 2, 3] + * + * const array = [1, 2, 3]; + * const result = uniqWith(array, (a, b) => a % 2 === b % 2) + * // result will be [1, 2] + */ +declare function uniqWith(arr: ArrayLike | null | undefined, comparator?: Comparator): T[]; + +export { uniqWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.js new file mode 100644 index 0000000000000000000000000000000000000000..66fa121b27dde8dae1024aa1e5a19131ead072dd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const uniqWith$1 = require('../../array/uniqWith.js'); +const uniq = require('./uniq.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function uniqWith(arr, comparator) { + if (!isArrayLike.isArrayLike(arr)) { + return []; + } + return typeof comparator === 'function' ? uniqWith$1.uniqWith(Array.from(arr), comparator) : uniq.uniq(Array.from(arr)); +} + +exports.uniqWith = uniqWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0ab3f53dcbcecc55eb5430f60baad5a2142ec48f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/uniqWith.mjs @@ -0,0 +1,12 @@ +import { uniqWith as uniqWith$1 } from '../../array/uniqWith.mjs'; +import { uniq } from './uniq.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function uniqWith(arr, comparator) { + if (!isArrayLike(arr)) { + return []; + } + return typeof comparator === 'function' ? uniqWith$1(Array.from(arr), comparator) : uniq(Array.from(arr)); +} + +export { uniqWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b444aefdf1064d72dc38af4977ae52684a761994 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.d.mts @@ -0,0 +1,16 @@ +/** + * Gathers elements in the same position in an internal array + * from a grouped array of elements and returns them as a new array. + * + * @template T - The type of elements in the nested array. + * @param {T[][] | ArrayLike> | null | undefined} array - The nested array to unzip. + * @returns {T[][]} A new array of unzipped elements. + * + * @example + * const zipped = [['a', true, 1],['b', false, 2]]; + * const result = unzip(zipped); + * // result will be [['a', 'b'], [true, false], [1, 2]] + */ +declare function unzip(array: T[][] | ArrayLike> | null | undefined): T[][]; + +export { unzip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b444aefdf1064d72dc38af4977ae52684a761994 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.d.ts @@ -0,0 +1,16 @@ +/** + * Gathers elements in the same position in an internal array + * from a grouped array of elements and returns them as a new array. + * + * @template T - The type of elements in the nested array. + * @param {T[][] | ArrayLike> | null | undefined} array - The nested array to unzip. + * @returns {T[][]} A new array of unzipped elements. + * + * @example + * const zipped = [['a', true, 1],['b', false, 2]]; + * const result = unzip(zipped); + * // result will be [['a', 'b'], [true, false], [1, 2]] + */ +declare function unzip(array: T[][] | ArrayLike> | null | undefined): T[][]; + +export { unzip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.js new file mode 100644 index 0000000000000000000000000000000000000000..4110eadc4d6bc1703b923dadcfd4b8dfe0705f83 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const unzip$1 = require('../../array/unzip.js'); +const isArray = require('../predicate/isArray.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function unzip(array) { + if (!isArrayLikeObject.isArrayLikeObject(array) || !array.length) { + return []; + } + array = isArray.isArray(array) ? array : Array.from(array); + array = array.filter(item => isArrayLikeObject.isArrayLikeObject(item)); + return unzip$1.unzip(array); +} + +exports.unzip = unzip; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.mjs new file mode 100644 index 0000000000000000000000000000000000000000..631df333bbf5280d6a49796d2fb3a7a9057dd1e8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzip.mjs @@ -0,0 +1,14 @@ +import { unzip as unzip$1 } from '../../array/unzip.mjs'; +import { isArray } from '../predicate/isArray.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function unzip(array) { + if (!isArrayLikeObject(array) || !array.length) { + return []; + } + array = isArray(array) ? array : Array.from(array); + array = array.filter(item => isArrayLikeObject(item)); + return unzip$1(array); +} + +export { unzip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ed501dc0171561419f782adacd55282e4db07afe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.d.mts @@ -0,0 +1,30 @@ +/** + * This method is like `unzip` except that it accepts an iteratee to specify + * how regrouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @template T, R + * @param {ArrayLike> | null | undefined} array - The array of grouped elements to process. + * @param {(...values: T[]) => R} iteratee - The function to combine regrouped values. + * @returns {R[]} Returns the new array of regrouped elements. + * + * @example + * unzipWith([[1, 10, 100], [2, 20, 200]], (a, b) => a + b); + * // => [3, 30, 300] + */ +declare function unzipWith(array: ArrayLike> | null | undefined, iteratee: (...values: T[]) => R): R[]; +/** + * This method is like `unzip` except that it accepts an iteratee to specify + * how regrouped values should be combined. + * + * @template T + * @param {ArrayLike> | null | undefined} array - The array of grouped elements to process. + * @returns {T[][]} Returns the new array of regrouped elements. + * + * @example + * unzipWith([[1, 10, 100], [2, 20, 200]]); + * // => [[1, 2], [10, 20], [100, 200]] + */ +declare function unzipWith(array: ArrayLike> | null | undefined): T[][]; + +export { unzipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ed501dc0171561419f782adacd55282e4db07afe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.d.ts @@ -0,0 +1,30 @@ +/** + * This method is like `unzip` except that it accepts an iteratee to specify + * how regrouped values should be combined. The iteratee is invoked with the + * elements of each group: (...group). + * + * @template T, R + * @param {ArrayLike> | null | undefined} array - The array of grouped elements to process. + * @param {(...values: T[]) => R} iteratee - The function to combine regrouped values. + * @returns {R[]} Returns the new array of regrouped elements. + * + * @example + * unzipWith([[1, 10, 100], [2, 20, 200]], (a, b) => a + b); + * // => [3, 30, 300] + */ +declare function unzipWith(array: ArrayLike> | null | undefined, iteratee: (...values: T[]) => R): R[]; +/** + * This method is like `unzip` except that it accepts an iteratee to specify + * how regrouped values should be combined. + * + * @template T + * @param {ArrayLike> | null | undefined} array - The array of grouped elements to process. + * @returns {T[][]} Returns the new array of regrouped elements. + * + * @example + * unzipWith([[1, 10, 100], [2, 20, 200]]); + * // => [[1, 2], [10, 20], [100, 200]] + */ +declare function unzipWith(array: ArrayLike> | null | undefined): T[][]; + +export { unzipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.js new file mode 100644 index 0000000000000000000000000000000000000000..d9911e542e1eef626e0378fc750df3828f562504 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const unzip = require('../../array/unzip.js'); +const isArray = require('../predicate/isArray.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function unzipWith(array, iteratee) { + if (!isArrayLikeObject.isArrayLikeObject(array) || !array.length) { + return []; + } + const unziped = isArray.isArray(array) ? unzip.unzip(array) : unzip.unzip(Array.from(array, value => Array.from(value))); + if (!iteratee) { + return unziped; + } + const result = new Array(unziped.length); + for (let i = 0; i < unziped.length; i++) { + const value = unziped[i]; + result[i] = iteratee(...value); + } + return result; +} + +exports.unzipWith = unzipWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0b707ae70c8130e25e7710273bebe32643b5f77e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/unzipWith.mjs @@ -0,0 +1,21 @@ +import { unzip } from '../../array/unzip.mjs'; +import { isArray } from '../predicate/isArray.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function unzipWith(array, iteratee) { + if (!isArrayLikeObject(array) || !array.length) { + return []; + } + const unziped = isArray(array) ? unzip(array) : unzip(Array.from(array, value => Array.from(value))); + if (!iteratee) { + return unziped; + } + const result = new Array(unziped.length); + for (let i = 0; i < unziped.length; i++) { + const value = unziped[i]; + result[i] = iteratee(...value); + } + return result; +} + +export { unzipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c27e9fcf8cef3910a984ca95c5feca938c8cf063 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.d.mts @@ -0,0 +1,23 @@ +/** + * Creates an array that excludes all specified values. + * + * It correctly excludes `NaN`, as it compares values using [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero). + * + * @template T The type of elements in the array. + * @param {ArrayLike | null | undefined} array - The array to filter. + * @param {...T[]} values - The values to exclude. + * @returns {T[]} A new array without the specified values. + * + * @example + * // Removes the specified values from the array + * without([1, 2, 3, 4, 5], 2, 4); + * // Returns: [1, 3, 5] + * + * @example + * // Removes specified string values from the array + * without(['a', 'b', 'c', 'a'], 'a'); + * // Returns: ['b', 'c'] + */ +declare function without(array: ArrayLike | null | undefined, ...values: T[]): T[]; + +export { without }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c27e9fcf8cef3910a984ca95c5feca938c8cf063 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.d.ts @@ -0,0 +1,23 @@ +/** + * Creates an array that excludes all specified values. + * + * It correctly excludes `NaN`, as it compares values using [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero). + * + * @template T The type of elements in the array. + * @param {ArrayLike | null | undefined} array - The array to filter. + * @param {...T[]} values - The values to exclude. + * @returns {T[]} A new array without the specified values. + * + * @example + * // Removes the specified values from the array + * without([1, 2, 3, 4, 5], 2, 4); + * // Returns: [1, 3, 5] + * + * @example + * // Removes specified string values from the array + * without(['a', 'b', 'c', 'a'], 'a'); + * // Returns: ['b', 'c'] + */ +declare function without(array: ArrayLike | null | undefined, ...values: T[]): T[]; + +export { without }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.js new file mode 100644 index 0000000000000000000000000000000000000000..3ec02b077d936105bbfeb3c228cd2695cf311575 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const without$1 = require('../../array/without.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function without(array, ...values) { + if (!isArrayLikeObject.isArrayLikeObject(array)) { + return []; + } + return without$1.without(Array.from(array), ...values); +} + +exports.without = without; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6fd25d571aad1a584ddbe1a8acc8cf9b4206474a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/without.mjs @@ -0,0 +1,11 @@ +import { without as without$1 } from '../../array/without.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function without(array, ...values) { + if (!isArrayLikeObject(array)) { + return []; + } + return without$1(Array.from(array), ...values); +} + +export { without }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b10a08c6ab070813021b9f19ddb607247d343282 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.d.mts @@ -0,0 +1,23 @@ +/** + * Computes the symmetric difference of the provided arrays, returning an array of elements + * that exist in only one of the arrays. + * + * @template T - The type of elements in the arrays. + * @param {...(ArrayLike | null | undefined)} arrays - The arrays to compare. + * @returns {T[]} An array containing the elements that are present in only one of the provided `arrays`. + * + * @example + * // Returns [1, 2, 5, 6] + * xor([1, 2, 3, 4], [3, 4, 5, 6]); + * + * @example + * // Returns ['a', 'c'] + * xor(['a', 'b'], ['b', 'c']); + * + * @example + * // Returns [1, 3, 5] + * xor([1, 2], [2, 3], [4, 5]); + */ +declare function xor(...arrays: Array | null | undefined>): T[]; + +export { xor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b10a08c6ab070813021b9f19ddb607247d343282 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.d.ts @@ -0,0 +1,23 @@ +/** + * Computes the symmetric difference of the provided arrays, returning an array of elements + * that exist in only one of the arrays. + * + * @template T - The type of elements in the arrays. + * @param {...(ArrayLike | null | undefined)} arrays - The arrays to compare. + * @returns {T[]} An array containing the elements that are present in only one of the provided `arrays`. + * + * @example + * // Returns [1, 2, 5, 6] + * xor([1, 2, 3, 4], [3, 4, 5, 6]); + * + * @example + * // Returns ['a', 'c'] + * xor(['a', 'b'], ['b', 'c']); + * + * @example + * // Returns [1, 3, 5] + * xor([1, 2], [2, 3], [4, 5]); + */ +declare function xor(...arrays: Array | null | undefined>): T[]; + +export { xor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.js new file mode 100644 index 0000000000000000000000000000000000000000..c8cda1736c037ea1efbaafbc2e3843fdb0926ee0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); +const toArray = require('../util/toArray.js'); + +function xor(...arrays) { + const itemCounts = new Map(); + for (let i = 0; i < arrays.length; i++) { + const array = arrays[i]; + if (!isArrayLikeObject.isArrayLikeObject(array)) { + continue; + } + const itemSet = new Set(toArray.toArray(array)); + for (const item of itemSet) { + if (!itemCounts.has(item)) { + itemCounts.set(item, 1); + } + else { + itemCounts.set(item, itemCounts.get(item) + 1); + } + } + } + const result = []; + for (const [item, count] of itemCounts) { + if (count === 1) { + result.push(item); + } + } + return result; +} + +exports.xor = xor; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6ac3e40f3c48e508c4b5947d75cb78b9a05267c1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xor.mjs @@ -0,0 +1,30 @@ +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; +import { toArray } from '../util/toArray.mjs'; + +function xor(...arrays) { + const itemCounts = new Map(); + for (let i = 0; i < arrays.length; i++) { + const array = arrays[i]; + if (!isArrayLikeObject(array)) { + continue; + } + const itemSet = new Set(toArray(array)); + for (const item of itemSet) { + if (!itemCounts.has(item)) { + itemCounts.set(item, 1); + } + else { + itemCounts.set(item, itemCounts.get(item) + 1); + } + } + } + const result = []; + for (const [item, count] of itemCounts) { + if (count === 1) { + result.push(item); + } + } + return result; +} + +export { xor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..50ea2c71a19730164ddce94361a0b5def9b1a6e2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.d.mts @@ -0,0 +1,56 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * This method is like `xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The arrays to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorBy([2.1, 1.2], [4.3, 2.4], Math.floor); + * // => [1.2, 4.3] + * + * @example + * xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ +declare function xorBy(arrays: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorBy([2.1, 1.2], [4.3, 2.4], Math.floor); + * // => [1.2, 4.3] + */ +declare function xorBy(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {...Array | ArrayLike | null | undefined>} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorBy([1.2, 2.3], [3.4, 4.5], [5.6, 6.7], Math.floor); + * // => [1.2, 3.4, 5.6] + */ +declare function xorBy(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, ...iteratee: Array | ArrayLike | null | undefined>): T[]; + +export { xorBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3ffd371a41e39718411116d1427b839afd6442c8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.d.ts @@ -0,0 +1,56 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * This method is like `xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The arrays to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorBy([2.1, 1.2], [4.3, 2.4], Math.floor); + * // => [1.2, 4.3] + * + * @example + * xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); + * // => [{ 'x': 2 }] + */ +declare function xorBy(arrays: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ValueIteratee} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorBy([2.1, 1.2], [4.3, 2.4], Math.floor); + * // => [1.2, 4.3] + */ +declare function xorBy(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, iteratee?: ValueIteratee): T[]; +/** + * This method is like `xor` except that it accepts `iteratee` which is + * invoked for each element of each `arrays` to generate the criterion by which + * uniqueness is computed. The iteratee is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {...Array | ArrayLike | null | undefined>} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorBy([1.2, 2.3], [3.4, 4.5], [5.6, 6.7], Math.floor); + * // => [1.2, 3.4, 5.6] + */ +declare function xorBy(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, ...iteratee: Array | ArrayLike | null | undefined>): T[]; + +export { xorBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.js new file mode 100644 index 0000000000000000000000000000000000000000..85c7049b18cf35cd6e53e6f4cd0498f58cebfe50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const differenceBy = require('./differenceBy.js'); +const intersectionBy = require('./intersectionBy.js'); +const last = require('./last.js'); +const unionBy = require('./unionBy.js'); +const windowed = require('../../array/windowed.js'); +const identity = require('../../function/identity.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); +const iteratee = require('../util/iteratee.js'); + +function xorBy(...values) { + const lastValue = last.last(values); + let mapper = identity.identity; + if (!isArrayLikeObject.isArrayLikeObject(lastValue) && lastValue != null) { + mapper = iteratee.iteratee(lastValue); + values = values.slice(0, -1); + } + const arrays = values.filter(isArrayLikeObject.isArrayLikeObject); + const union = unionBy.unionBy(...arrays, mapper); + const intersections = windowed.windowed(arrays, 2).map(([arr1, arr2]) => intersectionBy.intersectionBy(arr1, arr2, mapper)); + return differenceBy.differenceBy(union, unionBy.unionBy(...intersections, mapper), mapper); +} + +exports.xorBy = xorBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e51cdcfbbe7b4e9aaa8a1a5fee482cbd5e5b1632 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorBy.mjs @@ -0,0 +1,23 @@ +import { differenceBy } from './differenceBy.mjs'; +import { intersectionBy } from './intersectionBy.mjs'; +import { last } from './last.mjs'; +import { unionBy } from './unionBy.mjs'; +import { windowed } from '../../array/windowed.mjs'; +import { identity } from '../../function/identity.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function xorBy(...values) { + const lastValue = last(values); + let mapper = identity; + if (!isArrayLikeObject(lastValue) && lastValue != null) { + mapper = iteratee(lastValue); + values = values.slice(0, -1); + } + const arrays = values.filter(isArrayLikeObject); + const union = unionBy(...arrays, mapper); + const intersections = windowed(arrays, 2).map(([arr1, arr2]) => intersectionBy(arr1, arr2, mapper)); + return differenceBy(union, unionBy(...intersections, mapper), mapper); +} + +export { xorBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f29c717d5f2e161fda182d90a807b6abe4ae3004 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.d.mts @@ -0,0 +1,52 @@ +/** + * This method is like `xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The arrays to inspect. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * xorWith(objects, others, isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ +declare function xorWith(arrays: ArrayLike | null | undefined, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorWith([1, 2], [2, 3], (a, b) => a === b); + * // => [1, 3] + */ +declare function xorWith(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {...Array<(a: T, b: T) => boolean | ArrayLike | null | undefined>} comparator - The comparator invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorWith([1], [2], [3], (a, b) => a === b); + * // => [1, 2, 3] + */ +declare function xorWith(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, ...comparator: Array<((a: T, b: T) => boolean) | ArrayLike | null | undefined>): T[]; + +export { xorWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f29c717d5f2e161fda182d90a807b6abe4ae3004 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.d.ts @@ -0,0 +1,52 @@ +/** + * This method is like `xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The arrays to inspect. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * xorWith(objects, others, isEqual); + * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] + */ +declare function xorWith(arrays: ArrayLike | null | undefined, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorWith([1, 2], [2, 3], (a, b) => a === b); + * // => [1, 3] + */ +declare function xorWith(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `xor` except that it accepts `comparator` which is + * invoked to compare elements of `arrays`. The comparator is invoked + * with two arguments: (arrVal, othVal). + * + * @template T + * @param {ArrayLike | null | undefined} arrays - The first array to inspect. + * @param {ArrayLike | null | undefined} arrays2 - The second array to inspect. + * @param {ArrayLike | null | undefined} arrays3 - The third array to inspect. + * @param {...Array<(a: T, b: T) => boolean | ArrayLike | null | undefined>} comparator - The comparator invoked per element. + * @returns {T[]} Returns the new array of values. + * + * @example + * xorWith([1], [2], [3], (a, b) => a === b); + * // => [1, 2, 3] + */ +declare function xorWith(arrays: ArrayLike | null | undefined, arrays2: ArrayLike | null | undefined, arrays3: ArrayLike | null | undefined, ...comparator: Array<((a: T, b: T) => boolean) | ArrayLike | null | undefined>): T[]; + +export { xorWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.js new file mode 100644 index 0000000000000000000000000000000000000000..5cdbb90a33f0ba142227f5f1afe08a5046dd4624 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const differenceWith = require('./differenceWith.js'); +const intersectionWith = require('./intersectionWith.js'); +const last = require('./last.js'); +const unionWith = require('./unionWith.js'); +const windowed = require('../../array/windowed.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function xorWith(...values) { + const lastValue = last.last(values); + let comparator = (a, b) => a === b; + if (typeof lastValue === 'function') { + comparator = lastValue; + values = values.slice(0, -1); + } + const arrays = values.filter(isArrayLikeObject.isArrayLikeObject); + const union = unionWith.unionWith(...arrays, comparator); + const intersections = windowed.windowed(arrays, 2).map(([arr1, arr2]) => intersectionWith.intersectionWith(arr1, arr2, comparator)); + return differenceWith.differenceWith(union, unionWith.unionWith(...intersections, comparator), comparator); +} + +exports.xorWith = xorWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a4e16c6813fe5f565e45873aa61d0c2f10859ba1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/xorWith.mjs @@ -0,0 +1,21 @@ +import { differenceWith } from './differenceWith.mjs'; +import { intersectionWith } from './intersectionWith.mjs'; +import { last } from './last.mjs'; +import { unionWith } from './unionWith.mjs'; +import { windowed } from '../../array/windowed.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function xorWith(...values) { + const lastValue = last(values); + let comparator = (a, b) => a === b; + if (typeof lastValue === 'function') { + comparator = lastValue; + values = values.slice(0, -1); + } + const arrays = values.filter(isArrayLikeObject); + const union = unionWith(...arrays, comparator); + const intersections = windowed(arrays, 2).map(([arr1, arr2]) => intersectionWith(arr1, arr2, comparator)); + return differenceWith(union, unionWith(...intersections, comparator), comparator); +} + +export { xorWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6e50b6f585503bfcb6e3ed71e7efb78aea50b2ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.d.mts @@ -0,0 +1,186 @@ +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T, U + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @returns {Array<[T | undefined, U | undefined]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const result = zip(arr1, arr2); + * // result will be [[1, 'a'], [2, 'b'], [3, 'c']] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T, U + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @returns {Array<[T | undefined, U | undefined]>} Returns the new array of grouped elements. + * + * @example + * zip([1, 2], ['a', 'b']); + * // => [[1, 'a'], [2, 'b']] + */ +declare function zip(arr1: ArrayLike, arr2: ArrayLike): Array<[T | undefined, U | undefined]>; +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T, U, V + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const arr3 = [true, false]; + * const result = zip(arr1, arr2, arr3); + * // result will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T, U, V + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined]>} Returns the new array of grouped elements. + * + * @example + * zip([1, 2], ['a', 'b'], [true, false]); + * // => [[1, 'a', true], [2, 'b', false]] + */ +declare function zip(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike): Array<[T | undefined, U | undefined, V | undefined]>; +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T, U, V, W + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const arr3 = [true, false]; + * const arr4 = [null, null, null]; + * const result = zip(arr1, arr2, arr3, arr4); + * // result will be [[1, 'a', true, null], [2, 'b', false, null], [3, 'c', undefined, null]] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T, U, V, W + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined]>} Returns the new array of grouped elements. + * + * @example + * zip([1], ['a'], [true], [null]); + * // => [[1, 'a', true, null]] + */ +declare function zip(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, arr4: ArrayLike): Array<[T | undefined, U | undefined, V | undefined, W | undefined]>; +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T, U, V, W + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @param {ArrayLike} arr5 - The fifth array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const arr3 = [true, false]; + * const arr4 = [null, null, null]; + * const arr5 = [undefined, undefined, undefined]; + * const result = zip(arr1, arr2, arr3, arr4, arr5); + * // result will be [[1, 'a', true, null, undefined], [2, 'b', false, null, undefined], [3, 'c', undefined, null, undefined]] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T, U, V, W, X + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @param {ArrayLike} arr5 - The fifth array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>} Returns the new array of grouped elements. + * + * @example + * zip([1], ['a'], [true], [null], [undefined]); + * // => [[1, 'a', true, null, undefined]] + */ +declare function zip(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, arr4: ArrayLike, arr5: ArrayLike): Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>; +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T + * @param {Array | null | undefined>} arrays - The arrays to zip. + * @returns {Array>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const arr3 = [true, false]; + * const arr4 = [null, null, null]; + * const arr5 = [undefined, undefined, undefined]; + * const result = zip(arr1, arr2, arr3, arr4, arr5); + * // result will be [[1, 'a', true, null, undefined], [2, 'b', false, null, undefined], [3, 'c', undefined, null, undefined]] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T + * @param {...Array | null | undefined>} arrays - The arrays to process. + * @returns {Array>} Returns the new array of grouped elements. + * + * @example + * zip([1, 2], ['a', 'b'], [true, false]); + * // => [[1, 'a', true], [2, 'b', false]] + */ +declare function zip(...arrays: Array | null | undefined>): Array>; + +export { zip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6e50b6f585503bfcb6e3ed71e7efb78aea50b2ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.d.ts @@ -0,0 +1,186 @@ +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T, U + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @returns {Array<[T | undefined, U | undefined]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const result = zip(arr1, arr2); + * // result will be [[1, 'a'], [2, 'b'], [3, 'c']] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T, U + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @returns {Array<[T | undefined, U | undefined]>} Returns the new array of grouped elements. + * + * @example + * zip([1, 2], ['a', 'b']); + * // => [[1, 'a'], [2, 'b']] + */ +declare function zip(arr1: ArrayLike, arr2: ArrayLike): Array<[T | undefined, U | undefined]>; +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T, U, V + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const arr3 = [true, false]; + * const result = zip(arr1, arr2, arr3); + * // result will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T, U, V + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined]>} Returns the new array of grouped elements. + * + * @example + * zip([1, 2], ['a', 'b'], [true, false]); + * // => [[1, 'a', true], [2, 'b', false]] + */ +declare function zip(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike): Array<[T | undefined, U | undefined, V | undefined]>; +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T, U, V, W + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const arr3 = [true, false]; + * const arr4 = [null, null, null]; + * const result = zip(arr1, arr2, arr3, arr4); + * // result will be [[1, 'a', true, null], [2, 'b', false, null], [3, 'c', undefined, null]] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T, U, V, W + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined]>} Returns the new array of grouped elements. + * + * @example + * zip([1], ['a'], [true], [null]); + * // => [[1, 'a', true, null]] + */ +declare function zip(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, arr4: ArrayLike): Array<[T | undefined, U | undefined, V | undefined, W | undefined]>; +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T, U, V, W + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @param {ArrayLike} arr5 - The fifth array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const arr3 = [true, false]; + * const arr4 = [null, null, null]; + * const arr5 = [undefined, undefined, undefined]; + * const result = zip(arr1, arr2, arr3, arr4, arr5); + * // result will be [[1, 'a', true, null, undefined], [2, 'b', false, null, undefined], [3, 'c', undefined, null, undefined]] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T, U, V, W, X + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @param {ArrayLike} arr5 - The fifth array to zip. + * @returns {Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>} Returns the new array of grouped elements. + * + * @example + * zip([1], ['a'], [true], [null], [undefined]); + * // => [[1, 'a', true, null, undefined]] + */ +declare function zip(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, arr4: ArrayLike, arr5: ArrayLike): Array<[T | undefined, U | undefined, V | undefined, W | undefined, X | undefined]>; +/** + * Combines multiple arrays into a single array of tuples. + * + * This function takes multiple arrays and returns a new array where each element is a tuple + * containing the corresponding elements from the input arrays. If the input arrays are of + * different lengths, the resulting array will have the length of the longest input array, + * with undefined values for missing elements. + * + * @template T + * @param {Array | null | undefined>} arrays - The arrays to zip. + * @returns {Array>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const arr3 = [true, false]; + * const arr4 = [null, null, null]; + * const arr5 = [undefined, undefined, undefined]; + * const result = zip(arr1, arr2, arr3, arr4, arr5); + * // result will be [[1, 'a', true, null, undefined], [2, 'b', false, null, undefined], [3, 'c', undefined, null, undefined]] + */ +/** + * Creates an array of grouped elements, the first of which contains the first elements of the given arrays, + * the second of which contains the second elements of the given arrays, and so on. + * + * @template T + * @param {...Array | null | undefined>} arrays - The arrays to process. + * @returns {Array>} Returns the new array of grouped elements. + * + * @example + * zip([1, 2], ['a', 'b'], [true, false]); + * // => [[1, 'a', true], [2, 'b', false]] + */ +declare function zip(...arrays: Array | null | undefined>): Array>; + +export { zip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.js new file mode 100644 index 0000000000000000000000000000000000000000..971a9e756153f6cd8d91855069ac51f656dbea92 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const zip$1 = require('../../array/zip.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function zip(...arrays) { + if (!arrays.length) { + return []; + } + return zip$1.zip(...arrays.filter(group => isArrayLikeObject.isArrayLikeObject(group))); +} + +exports.zip = zip; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.mjs new file mode 100644 index 0000000000000000000000000000000000000000..efdd4b032e69719e72fa5d605bf52e0348bb1b8a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zip.mjs @@ -0,0 +1,11 @@ +import { zip as zip$1 } from '../../array/zip.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function zip(...arrays) { + if (!arrays.length) { + return []; + } + return zip$1(...arrays.filter(group => isArrayLikeObject(group))); +} + +export { zip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b265b5c892dbed1c32f0c16d47566f3f5f08d476 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.d.mts @@ -0,0 +1,29 @@ +/** + * Combines two arrays, one of property names and one of corresponding values, into a single object. + * + * @template T - The type of values in the values array + * @param {ArrayLike} props - An array of property names + * @param {ArrayLike} values - An array of values corresponding to the property names + * @returns {Record} A new object composed of the given property names and values + * + * @example + * const props = ['a', 'b', 'c']; + * const values = [1, 2, 3]; + * zipObject(props, values); + * // => { a: 1, b: 2, c: 3 } + */ +declare function zipObject(props: ArrayLike, values: ArrayLike): Record; +/** + * Creates an object from an array of property names, with undefined values. + * + * @param {ArrayLike} [props] - An array of property names + * @returns {Record} A new object with the given property names and undefined values + * + * @example + * const props = ['a', 'b', 'c']; + * zipObject(props); + * // => { a: undefined, b: undefined, c: undefined } + */ +declare function zipObject(props?: ArrayLike): Record; + +export { zipObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b265b5c892dbed1c32f0c16d47566f3f5f08d476 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.d.ts @@ -0,0 +1,29 @@ +/** + * Combines two arrays, one of property names and one of corresponding values, into a single object. + * + * @template T - The type of values in the values array + * @param {ArrayLike} props - An array of property names + * @param {ArrayLike} values - An array of values corresponding to the property names + * @returns {Record} A new object composed of the given property names and values + * + * @example + * const props = ['a', 'b', 'c']; + * const values = [1, 2, 3]; + * zipObject(props, values); + * // => { a: 1, b: 2, c: 3 } + */ +declare function zipObject(props: ArrayLike, values: ArrayLike): Record; +/** + * Creates an object from an array of property names, with undefined values. + * + * @param {ArrayLike} [props] - An array of property names + * @returns {Record} A new object with the given property names and undefined values + * + * @example + * const props = ['a', 'b', 'c']; + * zipObject(props); + * // => { a: undefined, b: undefined, c: undefined } + */ +declare function zipObject(props?: ArrayLike): Record; + +export { zipObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.js new file mode 100644 index 0000000000000000000000000000000000000000..6bc6c9101c8cd478e16c5b0e9146fa874dc08416 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const assignValue = require('../_internal/assignValue.js'); + +function zipObject(keys = [], values = []) { + const result = {}; + for (let i = 0; i < keys.length; i++) { + assignValue.assignValue(result, keys[i], values[i]); + } + return result; +} + +exports.zipObject = zipObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3b4025096d1220979b35546195f2f3ef5ac0845b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObject.mjs @@ -0,0 +1,11 @@ +import { assignValue } from '../_internal/assignValue.mjs'; + +function zipObject(keys = [], values = []) { + const result = {}; + for (let i = 0; i < keys.length; i++) { + assignValue(result, keys[i], values[i]); + } + return result; +} + +export { zipObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fb63cfe4ad2f374bc91a441a5a24cf16d9c7f821 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.d.mts @@ -0,0 +1,38 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Creates a deeply nested object given arrays of paths and values. + * + * This function takes two arrays: one containing arrays of property paths, and the other containing corresponding values. + * It returns a new object where paths from the first array are used as key paths to set values, with corresponding elements from the second array as values. + * Paths can be dot-separated strings or arrays of property names. + * + * If the `keys` array is longer than the `values` array, the remaining keys will have `undefined` as their values. + * + * @template P - The type of property paths. + * @template V - The type of values corresponding to the property paths. + * @param {ArrayLike

} keys - An array of property paths, each path can be a dot-separated string or an array of property names. + * @param {ArrayLike} values - An array of values corresponding to the property paths. + * @returns {Record} A new object composed of the given property paths and values. + * + * @example + * const paths = ['a.b.c', 'd.e.f']; + * const values = [1, 2]; + * const result = zipObjectDeep(paths, values); + * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } } + * + * @example + * const paths = [['a', 'b', 'c'], ['d', 'e', 'f']]; + * const values = [1, 2]; + * const result = zipObjectDeep(paths, values); + * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } } + * + * @example + * const paths = ['a.b[0].c', 'a.b[1].d']; + * const values = [1, 2]; + * const result = zipObjectDeep(paths, values); + * // result will be { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } + */ +declare function zipObjectDeep(keys?: ArrayLike, values?: ArrayLike): object; + +export { zipObjectDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2ed39d8b202a79194192946b075a2d496921168c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.d.ts @@ -0,0 +1,38 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Creates a deeply nested object given arrays of paths and values. + * + * This function takes two arrays: one containing arrays of property paths, and the other containing corresponding values. + * It returns a new object where paths from the first array are used as key paths to set values, with corresponding elements from the second array as values. + * Paths can be dot-separated strings or arrays of property names. + * + * If the `keys` array is longer than the `values` array, the remaining keys will have `undefined` as their values. + * + * @template P - The type of property paths. + * @template V - The type of values corresponding to the property paths. + * @param {ArrayLike

} keys - An array of property paths, each path can be a dot-separated string or an array of property names. + * @param {ArrayLike} values - An array of values corresponding to the property paths. + * @returns {Record} A new object composed of the given property paths and values. + * + * @example + * const paths = ['a.b.c', 'd.e.f']; + * const values = [1, 2]; + * const result = zipObjectDeep(paths, values); + * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } } + * + * @example + * const paths = [['a', 'b', 'c'], ['d', 'e', 'f']]; + * const values = [1, 2]; + * const result = zipObjectDeep(paths, values); + * // result will be { a: { b: { c: 1 } }, d: { e: { f: 2 } } } + * + * @example + * const paths = ['a.b[0].c', 'a.b[1].d']; + * const values = [1, 2]; + * const result = zipObjectDeep(paths, values); + * // result will be { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } + */ +declare function zipObjectDeep(keys?: ArrayLike, values?: ArrayLike): object; + +export { zipObjectDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.js new file mode 100644 index 0000000000000000000000000000000000000000..76e7c212d0d62be25bab502446c8551ff88d3c55 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const zip = require('../../array/zip.js'); +const set = require('../object/set.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function zipObjectDeep(keys, values) { + const result = {}; + if (!isArrayLike.isArrayLike(keys)) { + return result; + } + if (!isArrayLike.isArrayLike(values)) { + values = []; + } + const zipped = zip.zip(Array.from(keys), Array.from(values)); + for (let i = 0; i < zipped.length; i++) { + const [key, value] = zipped[i]; + if (key != null) { + set.set(result, key, value); + } + } + return result; +} + +exports.zipObjectDeep = zipObjectDeep; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a6ffcb4aafc59e12a7d8c640bba9d46fddcdfcb9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipObjectDeep.mjs @@ -0,0 +1,23 @@ +import { zip } from '../../array/zip.mjs'; +import { set } from '../object/set.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function zipObjectDeep(keys, values) { + const result = {}; + if (!isArrayLike(keys)) { + return result; + } + if (!isArrayLike(values)) { + values = []; + } + const zipped = zip(Array.from(keys), Array.from(values)); + for (let i = 0; i < zipped.length; i++) { + const [key, value] = zipped[i]; + if (key != null) { + set(result, key, value); + } + } + return result; +} + +export { zipObjectDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e9766f54e1e64ee0804407414fcdad855e4daabb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.d.mts @@ -0,0 +1,92 @@ +/** + * Combines one array into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {(item: T) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, combine: (item: T) => R): R[]; +/** + * Combines two arrays into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {(item1: T, item2: U) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, arr2: ArrayLike, combine: (item1: T, item2: U) => R): R[]; +/** + * Combines three arrays into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @template V - The type of elements in the third array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {(item1: T, item2: U, item3: V) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, combine: (item1: T, item2: U, item3: V) => R): R[]; +/** + * Combines four arrays into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @template V - The type of elements in the third array. + * @template W - The type of elements in the fourth array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @param {(item1: T, item2: U, item3: V, item4: W) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, arr4: ArrayLike, combine: (item1: T, item2: U, item3: V, item4: W) => R): R[]; +/** + * Combines five arrays into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @template V - The type of elements in the third array. + * @template W - The type of elements in the fourth array. + * @template X - The type of elements in the fifth array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @param {ArrayLike} arr5 - The fifth array to zip. + * @param {(item1: T, item2: U, item3: V, item4: W, item5: X) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, arr4: ArrayLike, arr5: ArrayLike, combine: (item1: T, item2: U, item3: V, item4: W, item5: X) => R): R[]; +/** + * Combines multiple arrays into a single array using a custom combiner function. + * + * This function takes one array and a variable number of additional arrays, + * applying the provided combiner function to the corresponding elements of each array. + * If the input arrays are of different lengths, the resulting array will have the length + * of the longest input array, with undefined values for missing elements. + * + * @template T - The type of elements in the input arrays. + * @template R - The type of elements in the resulting array. + * @param {Array<((...group: T[]) => R) | ArrayLike | null | undefined>} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const result = zipWith(arr1, arr2, (num, char) => `${num}${char}`); + * // result will be ['1a', '2b', '3c'] + */ +declare function zipWith(...combine: Array<((...group: T[]) => R) | ArrayLike | null | undefined>): R[]; + +export { zipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e9766f54e1e64ee0804407414fcdad855e4daabb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.d.ts @@ -0,0 +1,92 @@ +/** + * Combines one array into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {(item: T) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, combine: (item: T) => R): R[]; +/** + * Combines two arrays into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {(item1: T, item2: U) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, arr2: ArrayLike, combine: (item1: T, item2: U) => R): R[]; +/** + * Combines three arrays into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @template V - The type of elements in the third array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {(item1: T, item2: U, item3: V) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, combine: (item1: T, item2: U, item3: V) => R): R[]; +/** + * Combines four arrays into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @template V - The type of elements in the third array. + * @template W - The type of elements in the fourth array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @param {(item1: T, item2: U, item3: V, item4: W) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, arr4: ArrayLike, combine: (item1: T, item2: U, item3: V, item4: W) => R): R[]; +/** + * Combines five arrays into a single array using a custom combiner function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @template V - The type of elements in the third array. + * @template W - The type of elements in the fourth array. + * @template X - The type of elements in the fifth array. + * @template R - The type of elements in the resulting array. + * @param {ArrayLike} arr1 - The first array to zip. + * @param {ArrayLike} arr2 - The second array to zip. + * @param {ArrayLike} arr3 - The third array to zip. + * @param {ArrayLike} arr4 - The fourth array to zip. + * @param {ArrayLike} arr5 - The fifth array to zip. + * @param {(item1: T, item2: U, item3: V, item4: W, item5: X) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + */ +declare function zipWith(arr1: ArrayLike, arr2: ArrayLike, arr3: ArrayLike, arr4: ArrayLike, arr5: ArrayLike, combine: (item1: T, item2: U, item3: V, item4: W, item5: X) => R): R[]; +/** + * Combines multiple arrays into a single array using a custom combiner function. + * + * This function takes one array and a variable number of additional arrays, + * applying the provided combiner function to the corresponding elements of each array. + * If the input arrays are of different lengths, the resulting array will have the length + * of the longest input array, with undefined values for missing elements. + * + * @template T - The type of elements in the input arrays. + * @template R - The type of elements in the resulting array. + * @param {Array<((...group: T[]) => R) | ArrayLike | null | undefined>} combine - The combiner function that takes corresponding elements from each array and returns a single value. + * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const arr2 = ['a', 'b', 'c']; + * const result = zipWith(arr1, arr2, (num, char) => `${num}${char}`); + * // result will be ['1a', '2b', '3c'] + */ +declare function zipWith(...combine: Array<((...group: T[]) => R) | ArrayLike | null | undefined>): R[]; + +export { zipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.js new file mode 100644 index 0000000000000000000000000000000000000000..007d98175461189dbd03fe61d8cce8eda1b847f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const unzip = require('./unzip.js'); +const isFunction = require('../../predicate/isFunction.js'); + +function zipWith(...combine) { + let iteratee = combine.pop(); + if (!isFunction.isFunction(iteratee)) { + combine.push(iteratee); + iteratee = undefined; + } + if (!combine?.length) { + return []; + } + const result = unzip.unzip(combine); + if (iteratee == null) { + return result; + } + return result.map(group => iteratee(...group)); +} + +exports.zipWith = zipWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..00da136d6a46f83c50f79c048d34bea632ed1f71 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/zipWith.mjs @@ -0,0 +1,20 @@ +import { unzip } from './unzip.mjs'; +import { isFunction } from '../../predicate/isFunction.mjs'; + +function zipWith(...combine) { + let iteratee = combine.pop(); + if (!isFunction(iteratee)) { + combine.push(iteratee); + iteratee = undefined; + } + if (!combine?.length) { + return []; + } + const result = unzip(combine); + if (iteratee == null) { + return result; + } + return result.map(group => iteratee(...group)); +} + +export { zipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..97ff596052c9541c20905f09a593bde93cde8a2e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.d.mts @@ -0,0 +1,24 @@ +/** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @template TFunc - The type of the function to be invoked. + * @param {number} n - The number of calls before `func` is invoked. + * @param {TFunc} func - The function to restrict. + * @returns {TFunc} Returns the new restricted function. + * @throws {TypeError} - If `func` is not a function. + * + * @example + * const saves = ['profile', 'settings']; + * const done = after(saves.length, () => { + * console.log('done saving!'); + * }); + * + * saves.forEach(type => { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */ +declare function after any>(n: number, func: TFunc): TFunc; + +export { after }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..97ff596052c9541c20905f09a593bde93cde8a2e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.d.ts @@ -0,0 +1,24 @@ +/** + * The opposite of `_.before`; this method creates a function that invokes + * `func` once it's called `n` or more times. + * + * @template TFunc - The type of the function to be invoked. + * @param {number} n - The number of calls before `func` is invoked. + * @param {TFunc} func - The function to restrict. + * @returns {TFunc} Returns the new restricted function. + * @throws {TypeError} - If `func` is not a function. + * + * @example + * const saves = ['profile', 'settings']; + * const done = after(saves.length, () => { + * console.log('done saving!'); + * }); + * + * saves.forEach(type => { + * asyncSave({ 'type': type, 'complete': done }); + * }); + * // => Logs 'done saving!' after the two async saves have completed. + */ +declare function after any>(n: number, func: TFunc): TFunc; + +export { after }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.js new file mode 100644 index 0000000000000000000000000000000000000000..3e22b85926aff466876d2a41e18d81305e03ce57 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('../util/toInteger.js'); + +function after(n, func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + n = toInteger.toInteger(n); + return function (...args) { + if (--n < 1) { + return func.apply(this, args); + } + }; +} + +exports.after = after; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.mjs new file mode 100644 index 0000000000000000000000000000000000000000..99c727b5f283a5ead2d3a8496e25699526c12085 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/after.mjs @@ -0,0 +1,15 @@ +import { toInteger } from '../util/toInteger.mjs'; + +function after(n, func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + n = toInteger(n); + return function (...args) { + if (--n < 1) { + return func.apply(this, args); + } + }; +} + +export { after }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f2b0e0952f2a801c3309b5728ab61d12077f108e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.d.mts @@ -0,0 +1,24 @@ +/** + * Creates a function that invokes func, with up to `n` arguments, ignoring any additional arguments. + * If `n` is not provided, it defaults to the function's length. + * + * @param {Function} func - The function to cap arguments for. + * @param {number} [n] - The arity cap. Defaults to func.length. + * @returns {Function} Returns the new capped function. + * + * @example + * function fn(a: number, b: number, c: number) { + * return Array.from(arguments); + * } + * + * // Cap at 2 arguments + * const capped = ary(fn, 2); + * capped(1, 2, 3); // [1, 2] + * + * // Default to function length + * const defaultCap = ary(fn); + * defaultCap(1, 2, 3); // [1, 2, 3] + */ +declare function ary(func: (...args: any[]) => any, n?: number): (...args: any[]) => any; + +export { ary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f2b0e0952f2a801c3309b5728ab61d12077f108e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.d.ts @@ -0,0 +1,24 @@ +/** + * Creates a function that invokes func, with up to `n` arguments, ignoring any additional arguments. + * If `n` is not provided, it defaults to the function's length. + * + * @param {Function} func - The function to cap arguments for. + * @param {number} [n] - The arity cap. Defaults to func.length. + * @returns {Function} Returns the new capped function. + * + * @example + * function fn(a: number, b: number, c: number) { + * return Array.from(arguments); + * } + * + * // Cap at 2 arguments + * const capped = ary(fn, 2); + * capped(1, 2, 3); // [1, 2] + * + * // Default to function length + * const defaultCap = ary(fn); + * defaultCap(1, 2, 3); // [1, 2, 3] + */ +declare function ary(func: (...args: any[]) => any, n?: number): (...args: any[]) => any; + +export { ary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.js new file mode 100644 index 0000000000000000000000000000000000000000..872a929bd2d329502fd01d9b30c88777e770b7f1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const ary$1 = require('../../function/ary.js'); + +function ary(func, n = func.length, guard) { + if (guard) { + n = func.length; + } + if (Number.isNaN(n) || n < 0) { + n = 0; + } + return ary$1.ary(func, n); +} + +exports.ary = ary; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.mjs new file mode 100644 index 0000000000000000000000000000000000000000..063dd15991eb29bb186278a02de0a30bdf916204 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/ary.mjs @@ -0,0 +1,13 @@ +import { ary as ary$1 } from '../../function/ary.mjs'; + +function ary(func, n = func.length, guard) { + if (guard) { + n = func.length; + } + if (Number.isNaN(n) || n < 0) { + n = 0; + } + return ary$1(func, n); +} + +export { ary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..759258e2ea00fef4f3314f1a2ff8248447a60373 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.d.mts @@ -0,0 +1,33 @@ +/** + * Attempts to execute a function with the provided arguments. + * If the function throws an error, it catches the error and returns it. + * If the caught error is not an instance of Error, it wraps it in a new Error. + * + * @param {F} func - The function to be executed. + * @param {...Parameters} args - The arguments to pass to the function. + * @returns {ReturnType | Error} The return value of the function if successful, or an Error if an exception is thrown. + * + * @template F - The type of the function being attempted. + * + * @example + * // Example 1: Successful execution + * const result = attempt((x, y) => x + y, 2, 3); + * console.log(result); // Output: 5 + * + * @example + * // Example 2: Function throws an error + * const errorResult = attempt(() => { + * throw new Error("Something went wrong"); + * }); + * console.log(errorResult); // Output: Error: Something went wrong + * + * @example + * // Example 3: Non-Error thrown + * const nonErrorResult = attempt(() => { + * throw "This is a string error"; + * }); + * console.log(nonErrorResult); // Output: Error: This is a string error + */ +declare function attempt(func: (...args: any[]) => R, ...args: any[]): R | Error; + +export { attempt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..759258e2ea00fef4f3314f1a2ff8248447a60373 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.d.ts @@ -0,0 +1,33 @@ +/** + * Attempts to execute a function with the provided arguments. + * If the function throws an error, it catches the error and returns it. + * If the caught error is not an instance of Error, it wraps it in a new Error. + * + * @param {F} func - The function to be executed. + * @param {...Parameters} args - The arguments to pass to the function. + * @returns {ReturnType | Error} The return value of the function if successful, or an Error if an exception is thrown. + * + * @template F - The type of the function being attempted. + * + * @example + * // Example 1: Successful execution + * const result = attempt((x, y) => x + y, 2, 3); + * console.log(result); // Output: 5 + * + * @example + * // Example 2: Function throws an error + * const errorResult = attempt(() => { + * throw new Error("Something went wrong"); + * }); + * console.log(errorResult); // Output: Error: Something went wrong + * + * @example + * // Example 3: Non-Error thrown + * const nonErrorResult = attempt(() => { + * throw "This is a string error"; + * }); + * console.log(nonErrorResult); // Output: Error: This is a string error + */ +declare function attempt(func: (...args: any[]) => R, ...args: any[]): R | Error; + +export { attempt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.js new file mode 100644 index 0000000000000000000000000000000000000000..2305479781156a93296d57cc15b92cdf708aaed1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function attempt(func, ...args) { + try { + return func(...args); + } + catch (e) { + return e instanceof Error ? e : new Error(e); + } +} + +exports.attempt = attempt; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.mjs new file mode 100644 index 0000000000000000000000000000000000000000..20d1a1d179c951aeae084652b9d23897caa9ae5a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/attempt.mjs @@ -0,0 +1,10 @@ +function attempt(func, ...args) { + try { + return func(...args); + } + catch (e) { + return e instanceof Error ? e : new Error(e); + } +} + +export { attempt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..144569f89673067025f7ef24d533a7cab2929545 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.d.mts @@ -0,0 +1,26 @@ +/** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @template F - The type of the function to be invoked. + * @param {number} n - The number of times the returned function is allowed to call `func` before stopping. + * - If `n` is 0, `func` will never be called. + * - If `n` is a positive integer, `func` will be called up to `n-1` times. + * @param {F} func - The function to be called with the limit applied. + * @returns {(...args: Parameters) => ReturnType } - A new function that: + * - Tracks the number of calls. + * - Invokes `func` until the `n-1`-th call. + * - Returns last result of `func`, if `n` is reached. + * @throws {TypeError} - If `func` is not a function. + * @example + * let count = 0; + * const before3 = before(3, () => ++count); + * + * before3(); // => 1 + * before3(); // => 2 + * before3(); // => 2 + */ +declare function before any>(n: number, func: F): F; + +export { before }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..144569f89673067025f7ef24d533a7cab2929545 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.d.ts @@ -0,0 +1,26 @@ +/** + * Creates a function that invokes `func`, with the `this` binding and arguments + * of the created function, while it's called less than `n` times. Subsequent + * calls to the created function return the result of the last `func` invocation. + * + * @template F - The type of the function to be invoked. + * @param {number} n - The number of times the returned function is allowed to call `func` before stopping. + * - If `n` is 0, `func` will never be called. + * - If `n` is a positive integer, `func` will be called up to `n-1` times. + * @param {F} func - The function to be called with the limit applied. + * @returns {(...args: Parameters) => ReturnType } - A new function that: + * - Tracks the number of calls. + * - Invokes `func` until the `n-1`-th call. + * - Returns last result of `func`, if `n` is reached. + * @throws {TypeError} - If `func` is not a function. + * @example + * let count = 0; + * const before3 = before(3, () => ++count); + * + * before3(); // => 1 + * before3(); // => 2 + * before3(); // => 2 + */ +declare function before any>(n: number, func: F): F; + +export { before }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.js new file mode 100644 index 0000000000000000000000000000000000000000..eccedfd6d378ad524ef17e823515a8b7d09479ff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('../util/toInteger.js'); + +function before(n, func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + let result; + n = toInteger.toInteger(n); + return function (...args) { + if (--n > 0) { + result = func.apply(this, args); + } + if (n <= 1 && func) { + func = undefined; + } + return result; + }; +} + +exports.before = before; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.mjs new file mode 100644 index 0000000000000000000000000000000000000000..54790159536716d4e01e631c8dfd49b8f271db27 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/before.mjs @@ -0,0 +1,20 @@ +import { toInteger } from '../util/toInteger.mjs'; + +function before(n, func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + let result; + n = toInteger(n); + return function (...args) { + if (--n > 0) { + result = func.apply(this, args); + } + if (n <= 1 && func) { + func = undefined; + } + return result; + }; +} + +export { before }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b5dd9a949712ad5c6d0b5e4dfb221656d4035ea8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.d.mts @@ -0,0 +1,33 @@ +/** + * Creates a function that invokes `func` with the `this` binding of `thisArg` and `partials` prepended to the arguments it receives. + * + * The `bind.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: Unlike native `Function#bind`, this method doesn't set the `length` property of bound functions. + * + * @template F - The type of the function to bind. + * @param {F} func - The function to bind. + * @param {unknown} thisObj - The `this` binding of `func`. + * @param {...any} partialArgs - The arguments to be partially applied. + * @returns {F} - Returns the new bound function. + * + * @example + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * const object = { user: 'fred' }; + * let bound = bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * bound = bind(greet, object, bind.placeholder, '!'); + * bound('hi'); + * // => 'hi fred!' + */ +declare function bind(func: (...args: any[]) => any, thisObj: any, ...partialArgs: any[]): (...args: any[]) => any; +declare namespace bind { + var placeholder: typeof bindPlaceholder; +} +declare const bindPlaceholder: unique symbol; + +export { bind }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b5dd9a949712ad5c6d0b5e4dfb221656d4035ea8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.d.ts @@ -0,0 +1,33 @@ +/** + * Creates a function that invokes `func` with the `this` binding of `thisArg` and `partials` prepended to the arguments it receives. + * + * The `bind.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: Unlike native `Function#bind`, this method doesn't set the `length` property of bound functions. + * + * @template F - The type of the function to bind. + * @param {F} func - The function to bind. + * @param {unknown} thisObj - The `this` binding of `func`. + * @param {...any} partialArgs - The arguments to be partially applied. + * @returns {F} - Returns the new bound function. + * + * @example + * function greet(greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * } + * const object = { user: 'fred' }; + * let bound = bind(greet, object, 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * bound = bind(greet, object, bind.placeholder, '!'); + * bound('hi'); + * // => 'hi fred!' + */ +declare function bind(func: (...args: any[]) => any, thisObj: any, ...partialArgs: any[]): (...args: any[]) => any; +declare namespace bind { + var placeholder: typeof bindPlaceholder; +} +declare const bindPlaceholder: unique symbol; + +export { bind }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.js new file mode 100644 index 0000000000000000000000000000000000000000..e2cce97114497896e1519eb435d0659aaa7ef25b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.js @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function bind(func, thisObj, ...partialArgs) { + const bound = function (...providedArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === bind.placeholder) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + if (this instanceof bound) { + return new func(...args); + } + return func.apply(thisObj, args); + }; + return bound; +} +const bindPlaceholder = Symbol('bind.placeholder'); +bind.placeholder = bindPlaceholder; + +exports.bind = bind; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4889a57c4a33b5c8b12cdd4d2acf4b3ba17dac80 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bind.mjs @@ -0,0 +1,27 @@ +function bind(func, thisObj, ...partialArgs) { + const bound = function (...providedArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === bind.placeholder) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + if (this instanceof bound) { + return new func(...args); + } + return func.apply(thisObj, args); + }; + return bound; +} +const bindPlaceholder = Symbol('bind.placeholder'); +bind.placeholder = bindPlaceholder; + +export { bind }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..437fe2c9c70d4eba290853525586f25fbdd3e019 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.d.mts @@ -0,0 +1,45 @@ +/** + * Creates a function that invokes the method at `object[key]` with `partialArgs` prepended to the arguments it receives. + * + * This method differs from `bind` by allowing bound functions to reference methods that may be redefined or don't yet exist. + * + * The `bindKey.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * @template T - The type of the object to bind. + * @template K - The type of the key to bind. + * @param {T} object - The object to invoke the method on. + * @param {K} key - The key of the method. + * @param {...any} partialArgs - The arguments to be partially applied. + * @returns {T[K] extends (...args: any[]) => any ? (...args: any[]) => ReturnType : never} - Returns the new bound function. + * + * @example + * const object = { + * user: 'fred', + * greet: function (greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * }, + * }; + * + * let bound = bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function (greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * bound = bindKey(object, 'greet', bindKey.placeholder, '!'); + * bound('hi'); + * // => 'hiya fred!' + */ +declare function bindKey(object: object, key: string, ...partialArgs: any[]): (...args: any[]) => any; +declare namespace bindKey { + var placeholder: typeof bindKeyPlaceholder; +} +declare const bindKeyPlaceholder: unique symbol; + +export { bindKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..437fe2c9c70d4eba290853525586f25fbdd3e019 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.d.ts @@ -0,0 +1,45 @@ +/** + * Creates a function that invokes the method at `object[key]` with `partialArgs` prepended to the arguments it receives. + * + * This method differs from `bind` by allowing bound functions to reference methods that may be redefined or don't yet exist. + * + * The `bindKey.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * @template T - The type of the object to bind. + * @template K - The type of the key to bind. + * @param {T} object - The object to invoke the method on. + * @param {K} key - The key of the method. + * @param {...any} partialArgs - The arguments to be partially applied. + * @returns {T[K] extends (...args: any[]) => any ? (...args: any[]) => ReturnType : never} - Returns the new bound function. + * + * @example + * const object = { + * user: 'fred', + * greet: function (greeting, punctuation) { + * return greeting + ' ' + this.user + punctuation; + * }, + * }; + * + * let bound = bindKey(object, 'greet', 'hi'); + * bound('!'); + * // => 'hi fred!' + * + * object.greet = function (greeting, punctuation) { + * return greeting + 'ya ' + this.user + punctuation; + * }; + * + * bound('!'); + * // => 'hiya fred!' + * + * // Bound with placeholders. + * bound = bindKey(object, 'greet', bindKey.placeholder, '!'); + * bound('hi'); + * // => 'hiya fred!' + */ +declare function bindKey(object: object, key: string, ...partialArgs: any[]): (...args: any[]) => any; +declare namespace bindKey { + var placeholder: typeof bindKeyPlaceholder; +} +declare const bindKeyPlaceholder: unique symbol; + +export { bindKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.js new file mode 100644 index 0000000000000000000000000000000000000000..4836e7ef478a18022c461ac6b912b360fa991e4a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.js @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function bindKey(object, key, ...partialArgs) { + const bound = function (...providedArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === bindKey.placeholder) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + if (this instanceof bound) { + return new object[key](...args); + } + return object[key].apply(object, args); + }; + return bound; +} +const bindKeyPlaceholder = Symbol('bindKey.placeholder'); +bindKey.placeholder = bindKeyPlaceholder; + +exports.bindKey = bindKey; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.mjs new file mode 100644 index 0000000000000000000000000000000000000000..034755f06a69449939c1eb1251f6a3d9f58cffe4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/bindKey.mjs @@ -0,0 +1,27 @@ +function bindKey(object, key, ...partialArgs) { + const bound = function (...providedArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === bindKey.placeholder) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + if (this instanceof bound) { + return new object[key](...args); + } + return object[key].apply(object, args); + }; + return bound; +} +const bindKeyPlaceholder = Symbol('bindKey.placeholder'); +bindKey.placeholder = bindKeyPlaceholder; + +export { bindKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5338f2cc885194e9d9ccc8beadd6d33ea275005b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.d.mts @@ -0,0 +1,154 @@ +type __ = typeof curryPlaceholder; +interface CurriedFunction1 { + (): CurriedFunction1; + (t1: T1): R; +} +interface CurriedFunction2 { + (): CurriedFunction2; + (t1: T1): CurriedFunction1; + (t1: __, t2: T2): CurriedFunction1; + (t1: T1, t2: T2): R; +} +interface CurriedFunction3 { + (): CurriedFunction3; + (t1: T1): CurriedFunction2; + (t1: __, t2: T2): CurriedFunction2; + (t1: T1, t2: T2): CurriedFunction1; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: T1, t2: __, t3: T3): CurriedFunction1; + (t1: __, t2: T2, t3: T3): CurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; +} +interface CurriedFunction4 { + (): CurriedFunction4; + (t1: T1): CurriedFunction3; + (t1: __, t2: T2): CurriedFunction3; + (t1: T1, t2: T2): CurriedFunction2; + (t1: __, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: __, t2: T2, t3: T3): CurriedFunction2; + (t1: T1, t2: T2, t3: T3): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; +} +interface CurriedFunction5 { + (): CurriedFunction5; + (t1: T1): CurriedFunction4; + (t1: __, t2: T2): CurriedFunction4; + (t1: T1, t2: T2): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction4; + (t1: T1, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: T2, t3: T3): CurriedFunction3; + (t1: T1, t2: T2, t3: T3): CurriedFunction2; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: __, t5: T5): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; +} +/** + * Creates a curried function that accepts a single argument. + * @param {(t1: T1) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction1} - Returns the new curried function. + * @example + * const greet = (name: string) => `Hello ${name}`; + * const curriedGreet = curry(greet); + * curriedGreet('John'); // => 'Hello John' + */ +declare function curry(func: (t1: T1) => R, arity?: number): CurriedFunction1; +/** + * Creates a curried function that accepts two arguments. + * @param {(t1: T1, t2: T2) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction2} - Returns the new curried function. + * @example + * const add = (a: number, b: number) => a + b; + * const curriedAdd = curry(add); + * curriedAdd(1)(2); // => 3 + * curriedAdd(1, 2); // => 3 + */ +declare function curry(func: (t1: T1, t2: T2) => R, arity?: number): CurriedFunction2; +/** + * Creates a curried function that accepts three arguments. + * @param {(t1: T1, t2: T2, t3: T3) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction3} - Returns the new curried function. + * @example + * const volume = (l: number, w: number, h: number) => l * w * h; + * const curriedVolume = curry(volume); + * curriedVolume(2)(3)(4); // => 24 + * curriedVolume(2, 3)(4); // => 24 + * curriedVolume(2, 3, 4); // => 24 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): CurriedFunction3; +/** + * Creates a curried function that accepts four arguments. + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction4} - Returns the new curried function. + * @example + * const fn = (a: number, b: number, c: number, d: number) => a + b + c + d; + * const curriedFn = curry(fn); + * curriedFn(1)(2)(3)(4); // => 10 + * curriedFn(1, 2)(3, 4); // => 10 + * curriedFn(1, 2, 3, 4); // => 10 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): CurriedFunction4; +/** + * Creates a curried function that accepts five arguments. + * @param {(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction5} - Returns the new curried function. + * @example + * const fn = (a: number, b: number, c: number, d: number, e: number) => a + b + c + d + e; + * const curriedFn = curry(fn); + * curriedFn(1)(2)(3)(4)(5); // => 15 + * curriedFn(1, 2)(3, 4)(5); // => 15 + * curriedFn(1, 2, 3, 4, 5); // => 15 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): CurriedFunction5; +/** + * Creates a curried function that accepts any number of arguments. + * @param {(...args: any[]) => any} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {(...args: any[]) => any} - Returns the new curried function. + * @example + * const sum = (...args: number[]) => args.reduce((a, b) => a + b, 0); + * const curriedSum = curry(sum); + * curriedSum(1, 2, 3); // => 6 + * curriedSum(1)(2, 3); // => 6 + * curriedSum(1)(2)(3); // => 6 + */ +declare function curry(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; +declare namespace curry { + var placeholder: typeof curryPlaceholder; +} +declare const curryPlaceholder: unique symbol; + +export { curry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5338f2cc885194e9d9ccc8beadd6d33ea275005b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.d.ts @@ -0,0 +1,154 @@ +type __ = typeof curryPlaceholder; +interface CurriedFunction1 { + (): CurriedFunction1; + (t1: T1): R; +} +interface CurriedFunction2 { + (): CurriedFunction2; + (t1: T1): CurriedFunction1; + (t1: __, t2: T2): CurriedFunction1; + (t1: T1, t2: T2): R; +} +interface CurriedFunction3 { + (): CurriedFunction3; + (t1: T1): CurriedFunction2; + (t1: __, t2: T2): CurriedFunction2; + (t1: T1, t2: T2): CurriedFunction1; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: T1, t2: __, t3: T3): CurriedFunction1; + (t1: __, t2: T2, t3: T3): CurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; +} +interface CurriedFunction4 { + (): CurriedFunction4; + (t1: T1): CurriedFunction3; + (t1: __, t2: T2): CurriedFunction3; + (t1: T1, t2: T2): CurriedFunction2; + (t1: __, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction2; + (t1: __, t2: T2, t3: T3): CurriedFunction2; + (t1: T1, t2: T2, t3: T3): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; +} +interface CurriedFunction5 { + (): CurriedFunction5; + (t1: T1): CurriedFunction4; + (t1: __, t2: T2): CurriedFunction4; + (t1: T1, t2: T2): CurriedFunction3; + (t1: __, t2: __, t3: T3): CurriedFunction4; + (t1: T1, t2: __, t3: T3): CurriedFunction3; + (t1: __, t2: T2, t3: T3): CurriedFunction3; + (t1: T1, t2: T2, t3: T3): CurriedFunction2; + (t1: __, t2: __, t3: __, t4: T4): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: T4): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: T4): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: T4): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: T4): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4): CurriedFunction1; + (t1: __, t2: __, t3: __, t4: __, t5: T5): CurriedFunction4; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction3; + (t1: __, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction2; + (t1: __, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction2; + (t1: __, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: __, t2: T2, t3: T3, t4: T4, t5: T5): CurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; +} +/** + * Creates a curried function that accepts a single argument. + * @param {(t1: T1) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction1} - Returns the new curried function. + * @example + * const greet = (name: string) => `Hello ${name}`; + * const curriedGreet = curry(greet); + * curriedGreet('John'); // => 'Hello John' + */ +declare function curry(func: (t1: T1) => R, arity?: number): CurriedFunction1; +/** + * Creates a curried function that accepts two arguments. + * @param {(t1: T1, t2: T2) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction2} - Returns the new curried function. + * @example + * const add = (a: number, b: number) => a + b; + * const curriedAdd = curry(add); + * curriedAdd(1)(2); // => 3 + * curriedAdd(1, 2); // => 3 + */ +declare function curry(func: (t1: T1, t2: T2) => R, arity?: number): CurriedFunction2; +/** + * Creates a curried function that accepts three arguments. + * @param {(t1: T1, t2: T2, t3: T3) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction3} - Returns the new curried function. + * @example + * const volume = (l: number, w: number, h: number) => l * w * h; + * const curriedVolume = curry(volume); + * curriedVolume(2)(3)(4); // => 24 + * curriedVolume(2, 3)(4); // => 24 + * curriedVolume(2, 3, 4); // => 24 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): CurriedFunction3; +/** + * Creates a curried function that accepts four arguments. + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction4} - Returns the new curried function. + * @example + * const fn = (a: number, b: number, c: number, d: number) => a + b + c + d; + * const curriedFn = curry(fn); + * curriedFn(1)(2)(3)(4); // => 10 + * curriedFn(1, 2)(3, 4); // => 10 + * curriedFn(1, 2, 3, 4); // => 10 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): CurriedFunction4; +/** + * Creates a curried function that accepts five arguments. + * @param {(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {CurriedFunction5} - Returns the new curried function. + * @example + * const fn = (a: number, b: number, c: number, d: number, e: number) => a + b + c + d + e; + * const curriedFn = curry(fn); + * curriedFn(1)(2)(3)(4)(5); // => 15 + * curriedFn(1, 2)(3, 4)(5); // => 15 + * curriedFn(1, 2, 3, 4, 5); // => 15 + */ +declare function curry(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): CurriedFunction5; +/** + * Creates a curried function that accepts any number of arguments. + * @param {(...args: any[]) => any} func - The function to curry. + * @param {number=func.length} arity - The arity of func. + * @returns {(...args: any[]) => any} - Returns the new curried function. + * @example + * const sum = (...args: number[]) => args.reduce((a, b) => a + b, 0); + * const curriedSum = curry(sum); + * curriedSum(1, 2, 3); // => 6 + * curriedSum(1)(2, 3); // => 6 + * curriedSum(1)(2)(3); // => 6 + */ +declare function curry(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; +declare namespace curry { + var placeholder: typeof curryPlaceholder; +} +declare const curryPlaceholder: unique symbol; + +export { curry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.js new file mode 100644 index 0000000000000000000000000000000000000000..faf4febb8eec65de2d6ce2965afc62d6813085aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.js @@ -0,0 +1,61 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function curry(func, arity = func.length, guard) { + arity = guard ? func.length : arity; + arity = Number.parseInt(arity, 10); + if (Number.isNaN(arity) || arity < 1) { + arity = 0; + } + const wrapper = function (...partialArgs) { + const holders = partialArgs.filter(item => item === curry.placeholder); + const length = partialArgs.length - holders.length; + if (length < arity) { + return makeCurry(func, arity - length, partialArgs); + } + if (this instanceof wrapper) { + return new func(...partialArgs); + } + return func.apply(this, partialArgs); + }; + wrapper.placeholder = curryPlaceholder; + return wrapper; +} +function makeCurry(func, arity, partialArgs) { + function wrapper(...providedArgs) { + const holders = providedArgs.filter(item => item === curry.placeholder); + const length = providedArgs.length - holders.length; + providedArgs = composeArgs(providedArgs, partialArgs); + if (length < arity) { + return makeCurry(func, arity - length, providedArgs); + } + if (this instanceof wrapper) { + return new func(...providedArgs); + } + return func.apply(this, providedArgs); + } + wrapper.placeholder = curryPlaceholder; + return wrapper; +} +function composeArgs(providedArgs, partialArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === curry.placeholder && startIndex < providedArgs.length) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + return args; +} +const curryPlaceholder = Symbol('curry.placeholder'); +curry.placeholder = curryPlaceholder; + +exports.curry = curry; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.mjs new file mode 100644 index 0000000000000000000000000000000000000000..140700f084fe561b35cbad75ed473c746690b516 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curry.mjs @@ -0,0 +1,57 @@ +function curry(func, arity = func.length, guard) { + arity = guard ? func.length : arity; + arity = Number.parseInt(arity, 10); + if (Number.isNaN(arity) || arity < 1) { + arity = 0; + } + const wrapper = function (...partialArgs) { + const holders = partialArgs.filter(item => item === curry.placeholder); + const length = partialArgs.length - holders.length; + if (length < arity) { + return makeCurry(func, arity - length, partialArgs); + } + if (this instanceof wrapper) { + return new func(...partialArgs); + } + return func.apply(this, partialArgs); + }; + wrapper.placeholder = curryPlaceholder; + return wrapper; +} +function makeCurry(func, arity, partialArgs) { + function wrapper(...providedArgs) { + const holders = providedArgs.filter(item => item === curry.placeholder); + const length = providedArgs.length - holders.length; + providedArgs = composeArgs(providedArgs, partialArgs); + if (length < arity) { + return makeCurry(func, arity - length, providedArgs); + } + if (this instanceof wrapper) { + return new func(...providedArgs); + } + return func.apply(this, providedArgs); + } + wrapper.placeholder = curryPlaceholder; + return wrapper; +} +function composeArgs(providedArgs, partialArgs) { + const args = []; + let startIndex = 0; + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === curry.placeholder && startIndex < providedArgs.length) { + args.push(providedArgs[startIndex++]); + } + else { + args.push(arg); + } + } + for (let i = startIndex; i < providedArgs.length; i++) { + args.push(providedArgs[i]); + } + return args; +} +const curryPlaceholder = Symbol('curry.placeholder'); +curry.placeholder = curryPlaceholder; + +export { curry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d5ddb119dc9d7964af4f435cbabc804eb86050fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.d.mts @@ -0,0 +1,85 @@ +type __ = typeof curryRightPlaceholder; +interface RightCurriedFunction1 { + (): RightCurriedFunction1; + (t1: T1): R; +} +interface RightCurriedFunction2 { + (): RightCurriedFunction2; + (t2: T2): RightCurriedFunction1; + (t1: T1, t2: __): RightCurriedFunction1; + (t1: T1, t2: T2): R; +} +interface RightCurriedFunction3 { + (): RightCurriedFunction3; + (t3: T3): RightCurriedFunction2; + (t2: T2, t3: __): RightCurriedFunction2; + (t2: T2, t3: T3): RightCurriedFunction1; + (t1: T1, t2: __, t3: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; +} +interface RightCurriedFunction4 { + (): RightCurriedFunction4; + (t4: T4): RightCurriedFunction3; + (t3: T3, t4: __): RightCurriedFunction3; + (t3: T3, t4: T4): RightCurriedFunction2; + (t2: T2, t3: __, t4: __): RightCurriedFunction3; + (t2: T2, t3: T3, t4: __): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __): RightCurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; +} +interface RightCurriedFunction5 { + (): RightCurriedFunction5; + (t5: T5): RightCurriedFunction4; + (t4: T4, t5: __): RightCurriedFunction4; + (t4: T4, t5: T5): RightCurriedFunction3; + (t3: T3, t4: __, t5: __): RightCurriedFunction4; + (t3: T3, t4: T4, t5: __): RightCurriedFunction3; + (t3: T3, t4: __, t5: T5): RightCurriedFunction3; + (t3: T3, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t1: T1, t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t1: T1, t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; +} +declare function curryRight(func: (t1: T1) => R, arity?: number): RightCurriedFunction1; +declare function curryRight(func: (t1: T1, t2: T2) => R, arity?: number): RightCurriedFunction2; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): RightCurriedFunction3; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): RightCurriedFunction4; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): RightCurriedFunction5; +declare function curryRight(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; +declare namespace curryRight { + var placeholder: typeof curryRightPlaceholder; +} +declare const curryRightPlaceholder: unique symbol; + +export { curryRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d5ddb119dc9d7964af4f435cbabc804eb86050fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.d.ts @@ -0,0 +1,85 @@ +type __ = typeof curryRightPlaceholder; +interface RightCurriedFunction1 { + (): RightCurriedFunction1; + (t1: T1): R; +} +interface RightCurriedFunction2 { + (): RightCurriedFunction2; + (t2: T2): RightCurriedFunction1; + (t1: T1, t2: __): RightCurriedFunction1; + (t1: T1, t2: T2): R; +} +interface RightCurriedFunction3 { + (): RightCurriedFunction3; + (t3: T3): RightCurriedFunction2; + (t2: T2, t3: __): RightCurriedFunction2; + (t2: T2, t3: T3): RightCurriedFunction1; + (t1: T1, t2: __, t3: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3): R; +} +interface RightCurriedFunction4 { + (): RightCurriedFunction4; + (t4: T4): RightCurriedFunction3; + (t3: T3, t4: __): RightCurriedFunction3; + (t3: T3, t4: T4): RightCurriedFunction2; + (t2: T2, t3: __, t4: __): RightCurriedFunction3; + (t2: T2, t3: T3, t4: __): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __): RightCurriedFunction3; + (t1: T1, t2: T2, t3: __, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4): R; +} +interface RightCurriedFunction5 { + (): RightCurriedFunction5; + (t5: T5): RightCurriedFunction4; + (t4: T4, t5: __): RightCurriedFunction4; + (t4: T4, t5: T5): RightCurriedFunction3; + (t3: T3, t4: __, t5: __): RightCurriedFunction4; + (t3: T3, t4: T4, t5: __): RightCurriedFunction3; + (t3: T3, t4: __, t5: T5): RightCurriedFunction3; + (t3: T3, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t2: T2, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: __, t4: __, t5: __): RightCurriedFunction4; + (t1: T1, t2: T2, t3: __, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: T3, t4: __, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: T4, t5: __): RightCurriedFunction3; + (t1: T1, t2: __, t3: __, t4: __, t5: T5): RightCurriedFunction3; + (t1: T1, t2: T2, t3: T3, t4: __, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: T2, t3: __, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: T4, t5: __): RightCurriedFunction2; + (t1: T1, t2: __, t3: T3, t4: __, t5: T5): RightCurriedFunction2; + (t1: T1, t2: __, t3: __, t4: T4, t5: T5): RightCurriedFunction2; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: __): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: __, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: __, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: __, t3: T3, t4: T4, t5: T5): RightCurriedFunction1; + (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): R; +} +declare function curryRight(func: (t1: T1) => R, arity?: number): RightCurriedFunction1; +declare function curryRight(func: (t1: T1, t2: T2) => R, arity?: number): RightCurriedFunction2; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3) => R, arity?: number): RightCurriedFunction3; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arity?: number): RightCurriedFunction4; +declare function curryRight(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) => R, arity?: number): RightCurriedFunction5; +declare function curryRight(func: (...args: any[]) => any, arity?: number): (...args: any[]) => any; +declare namespace curryRight { + var placeholder: typeof curryRightPlaceholder; +} +declare const curryRightPlaceholder: unique symbol; + +export { curryRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.js new file mode 100644 index 0000000000000000000000000000000000000000..c7268a5d9bc3ebefc996bca1fab3823236791bb5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.js @@ -0,0 +1,68 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function curryRight(func, arity = func.length, guard) { + arity = guard ? func.length : arity; + arity = Number.parseInt(arity, 10); + if (Number.isNaN(arity) || arity < 1) { + arity = 0; + } + const wrapper = function (...partialArgs) { + const holders = partialArgs.filter(item => item === curryRight.placeholder); + const length = partialArgs.length - holders.length; + if (length < arity) { + return makeCurryRight(func, arity - length, partialArgs); + } + if (this instanceof wrapper) { + return new func(...partialArgs); + } + return func.apply(this, partialArgs); + }; + wrapper.placeholder = curryRightPlaceholder; + return wrapper; +} +function makeCurryRight(func, arity, partialArgs) { + function wrapper(...providedArgs) { + const holders = providedArgs.filter(item => item === curryRight.placeholder); + const length = providedArgs.length - holders.length; + providedArgs = composeArgs(providedArgs, partialArgs); + if (length < arity) { + return makeCurryRight(func, arity - length, providedArgs); + } + if (this instanceof wrapper) { + return new func(...providedArgs); + } + return func.apply(this, providedArgs); + } + wrapper.placeholder = curryRightPlaceholder; + return wrapper; +} +function composeArgs(providedArgs, partialArgs) { + const placeholderLength = partialArgs.filter(arg => arg === curryRight.placeholder).length; + const rangeLength = Math.max(providedArgs.length - placeholderLength, 0); + const args = []; + let providedIndex = 0; + for (let i = 0; i < rangeLength; i++) { + args.push(providedArgs[providedIndex++]); + } + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === curryRight.placeholder) { + if (providedIndex < providedArgs.length) { + args.push(providedArgs[providedIndex++]); + } + else { + args.push(arg); + } + } + else { + args.push(arg); + } + } + return args; +} +const curryRightPlaceholder = Symbol('curryRight.placeholder'); +curryRight.placeholder = curryRightPlaceholder; + +exports.curryRight = curryRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8cba122eca2d0fe6267c084aab379c0e02f602a1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/curryRight.mjs @@ -0,0 +1,64 @@ +function curryRight(func, arity = func.length, guard) { + arity = guard ? func.length : arity; + arity = Number.parseInt(arity, 10); + if (Number.isNaN(arity) || arity < 1) { + arity = 0; + } + const wrapper = function (...partialArgs) { + const holders = partialArgs.filter(item => item === curryRight.placeholder); + const length = partialArgs.length - holders.length; + if (length < arity) { + return makeCurryRight(func, arity - length, partialArgs); + } + if (this instanceof wrapper) { + return new func(...partialArgs); + } + return func.apply(this, partialArgs); + }; + wrapper.placeholder = curryRightPlaceholder; + return wrapper; +} +function makeCurryRight(func, arity, partialArgs) { + function wrapper(...providedArgs) { + const holders = providedArgs.filter(item => item === curryRight.placeholder); + const length = providedArgs.length - holders.length; + providedArgs = composeArgs(providedArgs, partialArgs); + if (length < arity) { + return makeCurryRight(func, arity - length, providedArgs); + } + if (this instanceof wrapper) { + return new func(...providedArgs); + } + return func.apply(this, providedArgs); + } + wrapper.placeholder = curryRightPlaceholder; + return wrapper; +} +function composeArgs(providedArgs, partialArgs) { + const placeholderLength = partialArgs.filter(arg => arg === curryRight.placeholder).length; + const rangeLength = Math.max(providedArgs.length - placeholderLength, 0); + const args = []; + let providedIndex = 0; + for (let i = 0; i < rangeLength; i++) { + args.push(providedArgs[providedIndex++]); + } + for (let i = 0; i < partialArgs.length; i++) { + const arg = partialArgs[i]; + if (arg === curryRight.placeholder) { + if (providedIndex < providedArgs.length) { + args.push(providedArgs[providedIndex++]); + } + else { + args.push(arg); + } + } + else { + args.push(arg); + } + } + return args; +} +const curryRightPlaceholder = Symbol('curryRight.placeholder'); +curryRight.placeholder = curryRightPlaceholder; + +export { curryRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1d5cf6be8b01ece207b346806809c2639c77ba91 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.d.mts @@ -0,0 +1,144 @@ +interface DebounceSettings { + /** + * If `true`, the function will be invoked on the leading edge of the timeout. + * @default false + */ + leading?: boolean | undefined; + /** + * The maximum time `func` is allowed to be delayed before it's invoked. + * @default Infinity + */ + maxWait?: number | undefined; + /** + * If `true`, the function will be invoked on the trailing edge of the timeout. + * @default true + */ + trailing?: boolean | undefined; +} +interface DebounceSettingsLeading extends DebounceSettings { + leading: true; +} +interface DebouncedFunc any> { + /** + * Call the original function, but applying the debounce rules. + * + * If the debounced function can be run immediately, this calls it and returns its return + * value. + * + * Otherwise, it returns the return value of the last invocation, or undefined if the debounced + * function was not invoked yet. + */ + (...args: Parameters): ReturnType | undefined; + /** + * Throw away any pending invocation of the debounced function. + */ + cancel(): void; + /** + * If there is a pending invocation of the debounced function, invoke it immediately and return + * its return value. + * + * Otherwise, return the value from the last invocation, or undefined if the debounced function + * was never invoked. + */ + flush(): ReturnType | undefined; +} +interface DebouncedFuncLeading any> extends DebouncedFunc { + (...args: Parameters): ReturnType; + flush(): ReturnType; +} +/** + * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds + * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel` + * method to cancel any pending execution. + * + * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period. + * If `leading` is true, the function runs immediately on the first call. + * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call. + * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen + * (since one debounced function call cannot trigger the function twice). + * + * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called. + * + * @template F - The type of function. + * @param {F} func - The function to debounce. + * @param {number} debounceMs - The number of milliseconds to delay. + * @param {DebounceOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked. + * @returns A new debounced function with a `cancel` method. + * + * @example + * const debouncedFunction = debounce(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' after 1 second if not called again in that time + * debouncedFunction(); + * + * // Will not log anything as the previous call is canceled + * debouncedFunction.cancel(); + * + * // With AbortSignal + * const controller = new AbortController(); + * const signal = controller.signal; + * const debouncedWithSignal = debounce(() => { + * console.log('Function executed'); + * }, 1000, { signal }); + * + * debouncedWithSignal(); + * + * // Will cancel the debounced function call + * controller.abort(); + */ +declare function debounce any>(func: T, wait: number | undefined, options: DebounceSettingsLeading): DebouncedFuncLeading; +/** + * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds + * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel` + * method to cancel any pending execution. + * + * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period. + * If `leading` is true, the function runs immediately on the first call. + * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call. + * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen + * (since one debounced function call cannot trigger the function twice). + * + * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called. + * + * @template F - The type of function. + * @param {F} func - The function to debounce. + * @param {number} debounceMs - The number of milliseconds to delay. + * @param {DebounceOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked. + * @returns A new debounced function with a `cancel` method. + * + * @example + * const debouncedFunction = debounce(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' after 1 second if not called again in that time + * debouncedFunction(); + * + * // Will not log anything as the previous call is canceled + * debouncedFunction.cancel(); + * + * // With AbortSignal + * const controller = new AbortController(); + * const signal = controller.signal; + * const debouncedWithSignal = debounce(() => { + * console.log('Function executed'); + * }, 1000, { signal }); + * + * debouncedWithSignal(); + * + * // Will cancel the debounced function call + * controller.abort(); + */ +declare function debounce any>(func: T, wait?: number, options?: DebounceSettings): DebouncedFunc; + +export { type DebouncedFunc, type DebouncedFuncLeading, debounce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1d5cf6be8b01ece207b346806809c2639c77ba91 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.d.ts @@ -0,0 +1,144 @@ +interface DebounceSettings { + /** + * If `true`, the function will be invoked on the leading edge of the timeout. + * @default false + */ + leading?: boolean | undefined; + /** + * The maximum time `func` is allowed to be delayed before it's invoked. + * @default Infinity + */ + maxWait?: number | undefined; + /** + * If `true`, the function will be invoked on the trailing edge of the timeout. + * @default true + */ + trailing?: boolean | undefined; +} +interface DebounceSettingsLeading extends DebounceSettings { + leading: true; +} +interface DebouncedFunc any> { + /** + * Call the original function, but applying the debounce rules. + * + * If the debounced function can be run immediately, this calls it and returns its return + * value. + * + * Otherwise, it returns the return value of the last invocation, or undefined if the debounced + * function was not invoked yet. + */ + (...args: Parameters): ReturnType | undefined; + /** + * Throw away any pending invocation of the debounced function. + */ + cancel(): void; + /** + * If there is a pending invocation of the debounced function, invoke it immediately and return + * its return value. + * + * Otherwise, return the value from the last invocation, or undefined if the debounced function + * was never invoked. + */ + flush(): ReturnType | undefined; +} +interface DebouncedFuncLeading any> extends DebouncedFunc { + (...args: Parameters): ReturnType; + flush(): ReturnType; +} +/** + * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds + * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel` + * method to cancel any pending execution. + * + * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period. + * If `leading` is true, the function runs immediately on the first call. + * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call. + * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen + * (since one debounced function call cannot trigger the function twice). + * + * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called. + * + * @template F - The type of function. + * @param {F} func - The function to debounce. + * @param {number} debounceMs - The number of milliseconds to delay. + * @param {DebounceOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked. + * @returns A new debounced function with a `cancel` method. + * + * @example + * const debouncedFunction = debounce(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' after 1 second if not called again in that time + * debouncedFunction(); + * + * // Will not log anything as the previous call is canceled + * debouncedFunction.cancel(); + * + * // With AbortSignal + * const controller = new AbortController(); + * const signal = controller.signal; + * const debouncedWithSignal = debounce(() => { + * console.log('Function executed'); + * }, 1000, { signal }); + * + * debouncedWithSignal(); + * + * // Will cancel the debounced function call + * controller.abort(); + */ +declare function debounce any>(func: T, wait: number | undefined, options: DebounceSettingsLeading): DebouncedFuncLeading; +/** + * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds + * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel` + * method to cancel any pending execution. + * + * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period. + * If `leading` is true, the function runs immediately on the first call. + * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call. + * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen + * (since one debounced function call cannot trigger the function twice). + * + * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called. + * + * @template F - The type of function. + * @param {F} func - The function to debounce. + * @param {number} debounceMs - The number of milliseconds to delay. + * @param {DebounceOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked. + * @returns A new debounced function with a `cancel` method. + * + * @example + * const debouncedFunction = debounce(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' after 1 second if not called again in that time + * debouncedFunction(); + * + * // Will not log anything as the previous call is canceled + * debouncedFunction.cancel(); + * + * // With AbortSignal + * const controller = new AbortController(); + * const signal = controller.signal; + * const debouncedWithSignal = debounce(() => { + * console.log('Function executed'); + * }, 1000, { signal }); + * + * debouncedWithSignal(); + * + * // Will cancel the debounced function call + * controller.abort(); + */ +declare function debounce any>(func: T, wait?: number, options?: DebounceSettings): DebouncedFunc; + +export { type DebouncedFunc, type DebouncedFuncLeading, debounce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.js new file mode 100644 index 0000000000000000000000000000000000000000..bf92756857de5652cf6aa8f000d6c67e88a7e070 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.js @@ -0,0 +1,97 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function debounce(func, wait = 0, options = {}) { + if (typeof options !== 'object') { + options = {}; + } + let pendingArgs = null; + let pendingThis = null; + let lastCallTime = null; + let debounceStartTime = 0; + let timeoutId = null; + let lastResult; + const { leading = false, trailing = true, maxWait } = options; + const hasMaxWait = 'maxWait' in options; + const maxWaitMs = hasMaxWait ? Math.max(Number(maxWait) || 0, wait) : 0; + const invoke = (time) => { + if (pendingArgs !== null) { + lastResult = func.apply(pendingThis, pendingArgs); + } + pendingArgs = pendingThis = null; + debounceStartTime = time; + return lastResult; + }; + const handleLeading = (time) => { + debounceStartTime = time; + timeoutId = setTimeout(handleTimeout, wait); + if (leading && pendingArgs !== null) { + return invoke(time); + } + return lastResult; + }; + const handleTrailing = (time) => { + timeoutId = null; + if (trailing && pendingArgs !== null) { + return invoke(time); + } + return lastResult; + }; + const checkCanInvoke = (time) => { + if (lastCallTime === null) { + return true; + } + const timeSinceLastCall = time - lastCallTime; + const hasDebounceDelayPassed = timeSinceLastCall >= wait || timeSinceLastCall < 0; + const hasMaxWaitPassed = hasMaxWait && time - debounceStartTime >= maxWaitMs; + return hasDebounceDelayPassed || hasMaxWaitPassed; + }; + const calculateRemainingWait = (time) => { + const timeSinceLastCall = lastCallTime === null ? 0 : time - lastCallTime; + const remainingDebounceTime = wait - timeSinceLastCall; + const remainingMaxWaitTime = maxWaitMs - (time - debounceStartTime); + return hasMaxWait ? Math.min(remainingDebounceTime, remainingMaxWaitTime) : remainingDebounceTime; + }; + const handleTimeout = () => { + const currentTime = Date.now(); + if (checkCanInvoke(currentTime)) { + return handleTrailing(currentTime); + } + timeoutId = setTimeout(handleTimeout, calculateRemainingWait(currentTime)); + }; + const debouncedFunction = function (...args) { + const currentTime = Date.now(); + const canInvoke = checkCanInvoke(currentTime); + pendingArgs = args; + pendingThis = this; + lastCallTime = currentTime; + if (canInvoke) { + if (timeoutId === null) { + return handleLeading(currentTime); + } + if (hasMaxWait) { + clearTimeout(timeoutId); + timeoutId = setTimeout(handleTimeout, wait); + return invoke(currentTime); + } + } + if (timeoutId === null) { + timeoutId = setTimeout(handleTimeout, wait); + } + return lastResult; + }; + debouncedFunction.cancel = () => { + if (timeoutId !== null) { + clearTimeout(timeoutId); + } + debounceStartTime = 0; + lastCallTime = pendingArgs = pendingThis = timeoutId = null; + }; + debouncedFunction.flush = () => { + return timeoutId === null ? lastResult : handleTrailing(Date.now()); + }; + return debouncedFunction; +} + +exports.debounce = debounce; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.mjs new file mode 100644 index 0000000000000000000000000000000000000000..771f4708df04a5098f185bb0bab112a718a53a11 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/debounce.mjs @@ -0,0 +1,93 @@ +function debounce(func, wait = 0, options = {}) { + if (typeof options !== 'object') { + options = {}; + } + let pendingArgs = null; + let pendingThis = null; + let lastCallTime = null; + let debounceStartTime = 0; + let timeoutId = null; + let lastResult; + const { leading = false, trailing = true, maxWait } = options; + const hasMaxWait = 'maxWait' in options; + const maxWaitMs = hasMaxWait ? Math.max(Number(maxWait) || 0, wait) : 0; + const invoke = (time) => { + if (pendingArgs !== null) { + lastResult = func.apply(pendingThis, pendingArgs); + } + pendingArgs = pendingThis = null; + debounceStartTime = time; + return lastResult; + }; + const handleLeading = (time) => { + debounceStartTime = time; + timeoutId = setTimeout(handleTimeout, wait); + if (leading && pendingArgs !== null) { + return invoke(time); + } + return lastResult; + }; + const handleTrailing = (time) => { + timeoutId = null; + if (trailing && pendingArgs !== null) { + return invoke(time); + } + return lastResult; + }; + const checkCanInvoke = (time) => { + if (lastCallTime === null) { + return true; + } + const timeSinceLastCall = time - lastCallTime; + const hasDebounceDelayPassed = timeSinceLastCall >= wait || timeSinceLastCall < 0; + const hasMaxWaitPassed = hasMaxWait && time - debounceStartTime >= maxWaitMs; + return hasDebounceDelayPassed || hasMaxWaitPassed; + }; + const calculateRemainingWait = (time) => { + const timeSinceLastCall = lastCallTime === null ? 0 : time - lastCallTime; + const remainingDebounceTime = wait - timeSinceLastCall; + const remainingMaxWaitTime = maxWaitMs - (time - debounceStartTime); + return hasMaxWait ? Math.min(remainingDebounceTime, remainingMaxWaitTime) : remainingDebounceTime; + }; + const handleTimeout = () => { + const currentTime = Date.now(); + if (checkCanInvoke(currentTime)) { + return handleTrailing(currentTime); + } + timeoutId = setTimeout(handleTimeout, calculateRemainingWait(currentTime)); + }; + const debouncedFunction = function (...args) { + const currentTime = Date.now(); + const canInvoke = checkCanInvoke(currentTime); + pendingArgs = args; + pendingThis = this; + lastCallTime = currentTime; + if (canInvoke) { + if (timeoutId === null) { + return handleLeading(currentTime); + } + if (hasMaxWait) { + clearTimeout(timeoutId); + timeoutId = setTimeout(handleTimeout, wait); + return invoke(currentTime); + } + } + if (timeoutId === null) { + timeoutId = setTimeout(handleTimeout, wait); + } + return lastResult; + }; + debouncedFunction.cancel = () => { + if (timeoutId !== null) { + clearTimeout(timeoutId); + } + debounceStartTime = 0; + lastCallTime = pendingArgs = pendingThis = timeoutId = null; + }; + debouncedFunction.flush = () => { + return timeoutId === null ? lastResult : handleTrailing(Date.now()); + }; + return debouncedFunction; +} + +export { debounce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e30472bcacd1bcb42d90dd634ff93d481f206774 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.d.mts @@ -0,0 +1,14 @@ +/** + * Defers invoking the `func` until the current call stack has cleared. Any additional arguments are provided to func when it's invoked. + * + * @param {(...args: any[]) => any} func The function to defer. + * @param {...any[]} args The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * + * @example + * defer(console.log, 'deferred'); + * // => Logs 'deferred' after the current call stack has cleared. + */ +declare function defer(func: (...args: any[]) => any, ...args: any[]): number; + +export { defer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e30472bcacd1bcb42d90dd634ff93d481f206774 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.d.ts @@ -0,0 +1,14 @@ +/** + * Defers invoking the `func` until the current call stack has cleared. Any additional arguments are provided to func when it's invoked. + * + * @param {(...args: any[]) => any} func The function to defer. + * @param {...any[]} args The arguments to invoke `func` with. + * @returns {number} Returns the timer id. + * + * @example + * defer(console.log, 'deferred'); + * // => Logs 'deferred' after the current call stack has cleared. + */ +declare function defer(func: (...args: any[]) => any, ...args: any[]): number; + +export { defer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.js new file mode 100644 index 0000000000000000000000000000000000000000..506deaf5228bb2096e8ebe1ea61b16107b51ba8f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function defer(func, ...args) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return setTimeout(func, 1, ...args); +} + +exports.defer = defer; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.mjs new file mode 100644 index 0000000000000000000000000000000000000000..dfbffb5d60d6c7d4be0fc8b48c477673350ab74e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/defer.mjs @@ -0,0 +1,8 @@ +function defer(func, ...args) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return setTimeout(func, 1, ...args); +} + +export { defer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b32fb9b0ff14534c5fecc5f45f0293973ca0b45c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.d.mts @@ -0,0 +1,29 @@ +/** + * Invokes the specified function after a delay of the given number of milliseconds. + * Any additional arguments are passed to the function when it is invoked. + * + * @param {(...args: any[]) => any} func - The function to delay. + * @param {number} wait - The number of milliseconds to delay the invocation. + * @param {...any[]} args - The arguments to pass to the function when it is invoked. + * @returns {number} Returns the timer id. + * @throws {TypeError} If the first argument is not a function. + * + * @example + * // Example 1: Delayed function execution + * const timerId = delay( + * (greeting, recipient) => { + * console.log(`${greeting}, ${recipient}!`); + * }, + * 1000, + * 'Hello', + * 'Alice' + * ); + * // => 'Hello, Alice!' will be logged after one second. + * + * // Example 2: Clearing the timeout before execution + * clearTimeout(timerId); + * // The function will not be executed because the timeout was cleared. + */ +declare function delay(func: (...args: any[]) => any, wait: number, ...args: any[]): number; + +export { delay }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b32fb9b0ff14534c5fecc5f45f0293973ca0b45c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.d.ts @@ -0,0 +1,29 @@ +/** + * Invokes the specified function after a delay of the given number of milliseconds. + * Any additional arguments are passed to the function when it is invoked. + * + * @param {(...args: any[]) => any} func - The function to delay. + * @param {number} wait - The number of milliseconds to delay the invocation. + * @param {...any[]} args - The arguments to pass to the function when it is invoked. + * @returns {number} Returns the timer id. + * @throws {TypeError} If the first argument is not a function. + * + * @example + * // Example 1: Delayed function execution + * const timerId = delay( + * (greeting, recipient) => { + * console.log(`${greeting}, ${recipient}!`); + * }, + * 1000, + * 'Hello', + * 'Alice' + * ); + * // => 'Hello, Alice!' will be logged after one second. + * + * // Example 2: Clearing the timeout before execution + * clearTimeout(timerId); + * // The function will not be executed because the timeout was cleared. + */ +declare function delay(func: (...args: any[]) => any, wait: number, ...args: any[]): number; + +export { delay }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.js new file mode 100644 index 0000000000000000000000000000000000000000..1a369dc34fb29b0dedda5631c3efc0176c5fba38 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('../util/toNumber.js'); + +function delay(func, wait, ...args) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return setTimeout(func, toNumber.toNumber(wait) || 0, ...args); +} + +exports.delay = delay; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c36328c1565c3377a59104473e7f17becf9ed473 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/delay.mjs @@ -0,0 +1,10 @@ +import { toNumber } from '../util/toNumber.mjs'; + +function delay(func, wait, ...args) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return setTimeout(func, toNumber(wait) || 0, ...args); +} + +export { delay }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9319e385edc4ae4fadd43bc666ed78dc10cfc384 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.d.mts @@ -0,0 +1,18 @@ +/** + * Reverses the order of arguments for a given function. + * + * @template T - The type of the function being flipped. + * @param {T} func - The function whose arguments will be reversed. + * @returns {T} A new function that takes the reversed arguments and returns the result of calling `func`. + * + * @example + * var flipped = flip(function() { + * return Array.prototype.slice.call(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ +declare function flip any>(func: T): T; + +export { flip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9319e385edc4ae4fadd43bc666ed78dc10cfc384 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.d.ts @@ -0,0 +1,18 @@ +/** + * Reverses the order of arguments for a given function. + * + * @template T - The type of the function being flipped. + * @param {T} func - The function whose arguments will be reversed. + * @returns {T} A new function that takes the reversed arguments and returns the result of calling `func`. + * + * @example + * var flipped = flip(function() { + * return Array.prototype.slice.call(arguments); + * }); + * + * flipped('a', 'b', 'c', 'd'); + * // => ['d', 'c', 'b', 'a'] + */ +declare function flip any>(func: T): T; + +export { flip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.js new file mode 100644 index 0000000000000000000000000000000000000000..6e86cedd18b65ef6baa056a68647b7040f49d5af --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function flip(func) { + return function (...args) { + return func.apply(this, args.reverse()); + }; +} + +exports.flip = flip; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.mjs new file mode 100644 index 0000000000000000000000000000000000000000..100ff7435db3b83b455aef1cfa042811df35c964 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flip.mjs @@ -0,0 +1,7 @@ +function flip(func) { + return function (...args) { + return func.apply(this, args.reverse()); + }; +} + +export { flip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5e6f4baf828d1facc1e8fdd8e5dc74810e7e0172 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.d.mts @@ -0,0 +1,119 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function. + * + * @template A - The type of the arguments. + * @template R - The type of the return values. + * @param {(...args: A) => R} f1 - The first function to invoke. + * @param {(a: R) => R} f2 - The second function to invoke. + * @param {(a: R) => R} f3 - The third function to invoke. + * @param {(a: R) => R} f4 - The fourth function to invoke. + * @param {(a: R) => R} f5 - The fifth function to invoke. + * @param {(a: R) => R} f6 - The sixth function to invoke. + * @param {(a: R) => R} f7 - The seventh function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function square(n) { + * return n * n; + * } + * + * var addSquare = flow([add, square]); + * addSquare(1, 2); + * // => 9 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (...args: A) => R7; +/** + * Creates a new function that executes up to 7 functions in sequence, with additional functions flattened. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => n.toString(); + * + * const combined = flow(add, square, double, toString); + * console.log(combined(1, 2)); // "18" + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): (...args: A) => any; +/** + * Creates a new function that executes 6 functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: A) => R6; +/** + * Creates a new function that executes 5 functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5; +/** + * Creates a new function that executes 4 functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4; +/** + * Creates a new function that executes 3 functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3; +/** + * Creates a new function that executes 2 functions in sequence. + * The return value of the first function is passed as an argument to the second function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const addThenSquare = flow(add, square); + * console.log(addThenSquare(1, 2)); // 9 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2; +/** + * Creates a new function that executes the given functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(...func: Array any>>): (...args: any[]) => any; + +export { flow }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..981e693bf68b34625049d3dc452ef4c0e41f77b3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.d.ts @@ -0,0 +1,119 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Creates a new function that executes the given functions in sequence. The return value of the previous function is passed as an argument to the next function. + * + * @template A - The type of the arguments. + * @template R - The type of the return values. + * @param {(...args: A) => R} f1 - The first function to invoke. + * @param {(a: R) => R} f2 - The second function to invoke. + * @param {(a: R) => R} f3 - The third function to invoke. + * @param {(a: R) => R} f4 - The fourth function to invoke. + * @param {(a: R) => R} f5 - The fifth function to invoke. + * @param {(a: R) => R} f6 - The sixth function to invoke. + * @param {(a: R) => R} f7 - The seventh function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function square(n) { + * return n * n; + * } + * + * var addSquare = flow([add, square]); + * addSquare(1, 2); + * // => 9 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (...args: A) => R7; +/** + * Creates a new function that executes up to 7 functions in sequence, with additional functions flattened. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => n.toString(); + * + * const combined = flow(add, square, double, toString); + * console.log(combined(1, 2)); // "18" + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...func: Array any>>): (...args: A) => any; +/** + * Creates a new function that executes 6 functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: A) => R6; +/** + * Creates a new function that executes 5 functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5; +/** + * Creates a new function that executes 4 functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4; +/** + * Creates a new function that executes 3 functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3; +/** + * Creates a new function that executes 2 functions in sequence. + * The return value of the first function is passed as an argument to the second function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const addThenSquare = flow(add, square); + * console.log(addThenSquare(1, 2)); // 9 + */ +declare function flow(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2; +/** + * Creates a new function that executes the given functions in sequence. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flow(add, square, double); + * console.log(combined(1, 2)); // 18 + */ +declare function flow(...func: Array any>>): (...args: any[]) => any; + +export { flow }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.js new file mode 100644 index 0000000000000000000000000000000000000000..82adb877bd091e5622262cc4ba3c44c9b2ff7e80 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('../../array/flatten.js'); +const flow$1 = require('../../function/flow.js'); + +function flow(...funcs) { + const flattenFuncs = flatten.flatten(funcs, 1); + if (flattenFuncs.some(func => typeof func !== 'function')) { + throw new TypeError('Expected a function'); + } + return flow$1.flow(...flattenFuncs); +} + +exports.flow = flow; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6a8cf450ad1190f8a19c3cc57de582a74c3ef74d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flow.mjs @@ -0,0 +1,12 @@ +import { flatten } from '../../array/flatten.mjs'; +import { flow as flow$1 } from '../../function/flow.mjs'; + +function flow(...funcs) { + const flattenFuncs = flatten(funcs, 1); + if (flattenFuncs.some(func => typeof func !== 'function')) { + throw new TypeError('Expected a function'); + } + return flow$1(...flattenFuncs); +} + +export { flow }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..625ebe1c7a9aeb0c24afab218ec3db35f2142e37 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.d.mts @@ -0,0 +1,117 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function. + * + * @template A - The type of the arguments. + * @template R - The type of the return values. + * @param {(a: R) => R} f7 - The seventh function to invoke. + * @param {(a: R) => R} f6 - The sixth function to invoke. + * @param {(a: R) => R} f5 - The fifth function to invoke. + * @param {(a: R) => R} f4 - The fourth function to invoke. + * @param {(a: R) => R} f3 - The third function to invoke. + * @param {(a: R) => R} f2 - The second function to invoke. + * @param {(...args: A) => R} f1 - The first function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function square(n) { + * return n * n; + * } + * + * var addSquare = flowRight(square, add); + * addSquare(1, 2); + * // => 9 + */ +declare function flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R7; +/** + * Creates a new function that executes 6 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * const append = (s: string) => s + '!'; + * const length = (s: string) => s.length; + * + * const combined = flowRight(length, append, toString, double, square, add); + * console.log(combined(1, 2)); // 7 + */ +declare function flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R6; +/** + * Creates a new function that executes 5 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * const append = (s: string) => s + '!'; + * + * const combined = flowRight(append, toString, double, square, add); + * console.log(combined(1, 2)); // '18!' + */ +declare function flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5; +/** + * Creates a new function that executes 4 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * + * const combined = flowRight(toString, double, square, add); + * console.log(combined(1, 2)); // '18' + */ +declare function flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4; +/** + * Creates a new function that executes 3 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flowRight(double, square, add); + * console.log(combined(1, 2)); // 18 + */ +declare function flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3; +/** + * Creates a new function that executes 2 functions in sequence from right to left. + * The return value of the first function is passed as an argument to the second function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const combined = flowRight(square, add); + * console.log(combined(1, 2)); // 9 + */ +declare function flowRight(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2; +/** + * Creates a new function that executes the given functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * + * // Pass functions as separate arguments + * const combined1 = flowRight(toString, double, square, add); + * console.log(combined1(1, 2)); // '18' + * + * // Pass functions as arrays + * const combined2 = flowRight([toString, double], [square, add]); + * console.log(combined2(1, 2)); // '18' + */ +declare function flowRight(...func: Array any>>): (...args: any[]) => any; + +export { flowRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..79bac1b030e20c78f5164fecec33da2cb7cead39 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.d.ts @@ -0,0 +1,117 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Creates a new function that executes the given functions in sequence from right to left. The return value of the previous function is passed as an argument to the next function. + * + * @template A - The type of the arguments. + * @template R - The type of the return values. + * @param {(a: R) => R} f7 - The seventh function to invoke. + * @param {(a: R) => R} f6 - The sixth function to invoke. + * @param {(a: R) => R} f5 - The fifth function to invoke. + * @param {(a: R) => R} f4 - The fourth function to invoke. + * @param {(a: R) => R} f3 - The third function to invoke. + * @param {(a: R) => R} f2 - The second function to invoke. + * @param {(...args: A) => R} f1 - The first function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function square(n) { + * return n * n; + * } + * + * var addSquare = flowRight(square, add); + * addSquare(1, 2); + * // => 9 + */ +declare function flowRight(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R7; +/** + * Creates a new function that executes 6 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * const append = (s: string) => s + '!'; + * const length = (s: string) => s.length; + * + * const combined = flowRight(length, append, toString, double, square, add); + * console.log(combined(1, 2)); // 7 + */ +declare function flowRight(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R6; +/** + * Creates a new function that executes 5 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * const append = (s: string) => s + '!'; + * + * const combined = flowRight(append, toString, double, square, add); + * console.log(combined(1, 2)); // '18!' + */ +declare function flowRight(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R5; +/** + * Creates a new function that executes 4 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * + * const combined = flowRight(toString, double, square, add); + * console.log(combined(1, 2)); // '18' + */ +declare function flowRight(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R4; +/** + * Creates a new function that executes 3 functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * + * const combined = flowRight(double, square, add); + * console.log(combined(1, 2)); // 18 + */ +declare function flowRight(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R3; +/** + * Creates a new function that executes 2 functions in sequence from right to left. + * The return value of the first function is passed as an argument to the second function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const combined = flowRight(square, add); + * console.log(combined(1, 2)); // 9 + */ +declare function flowRight(f2: (a: R1) => R2, f1: (...args: A) => R1): (...args: A) => R2; +/** + * Creates a new function that executes the given functions in sequence from right to left. + * The return value of each function is passed as an argument to the next function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toString = (n: number) => String(n); + * + * // Pass functions as separate arguments + * const combined1 = flowRight(toString, double, square, add); + * console.log(combined1(1, 2)); // '18' + * + * // Pass functions as arrays + * const combined2 = flowRight([toString, double], [square, add]); + * console.log(combined2(1, 2)); // '18' + */ +declare function flowRight(...func: Array any>>): (...args: any[]) => any; + +export { flowRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.js new file mode 100644 index 0000000000000000000000000000000000000000..45d605a9974e73fd05f0242e1e4f5a9f25adc9c2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('../../array/flatten.js'); +const flowRight$1 = require('../../function/flowRight.js'); + +function flowRight(...funcs) { + const flattenFuncs = flatten.flatten(funcs, 1); + if (flattenFuncs.some(func => typeof func !== 'function')) { + throw new TypeError('Expected a function'); + } + return flowRight$1.flowRight(...flattenFuncs); +} + +exports.flowRight = flowRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f246f5c9412b8d8d5002aaa5aee2eee07fe10523 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/flowRight.mjs @@ -0,0 +1,12 @@ +import { flatten } from '../../array/flatten.mjs'; +import { flowRight as flowRight$1 } from '../../function/flowRight.mjs'; + +function flowRight(...funcs) { + const flattenFuncs = flatten(funcs, 1); + if (flattenFuncs.some(func => typeof func !== 'function')) { + throw new TypeError('Expected a function'); + } + return flowRight$1(...flattenFuncs); +} + +export { flowRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4100066a761fd908aab7bf519945ce14e6e5094d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.d.mts @@ -0,0 +1,42 @@ +/** + * Returns the input value unchanged. + * + * @template T - The type of the input value. + * @param {T} x - The value to be returned. + * @returns {T} The input value. + * + * @example + * // Returns 5 + * identity(5); + * + * @example + * // Returns 'hello' + * identity('hello'); + * + * @example + * // Returns { key: 'value' } + * identity({ key: 'value' }); + */ +declare function identity(value: T): T; +/** + * Returns the input value unchanged. + * + * @template T - The type of the input value. + * @param {T} x - The value to be returned. + * @returns {T} The input value. + * + * @example + * // Returns 5 + * identity(5); + * + * @example + * // Returns 'hello' + * identity('hello'); + * + * @example + * // Returns { key: 'value' } + * identity({ key: 'value' }); + */ +declare function identity(): undefined; + +export { identity }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4100066a761fd908aab7bf519945ce14e6e5094d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.d.ts @@ -0,0 +1,42 @@ +/** + * Returns the input value unchanged. + * + * @template T - The type of the input value. + * @param {T} x - The value to be returned. + * @returns {T} The input value. + * + * @example + * // Returns 5 + * identity(5); + * + * @example + * // Returns 'hello' + * identity('hello'); + * + * @example + * // Returns { key: 'value' } + * identity({ key: 'value' }); + */ +declare function identity(value: T): T; +/** + * Returns the input value unchanged. + * + * @template T - The type of the input value. + * @param {T} x - The value to be returned. + * @returns {T} The input value. + * + * @example + * // Returns 5 + * identity(5); + * + * @example + * // Returns 'hello' + * identity('hello'); + * + * @example + * // Returns { key: 'value' } + * identity({ key: 'value' }); + */ +declare function identity(): undefined; + +export { identity }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.js new file mode 100644 index 0000000000000000000000000000000000000000..6341454e9097280502d96720879e630cd1973a5b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function identity(x) { + return x; +} + +exports.identity = identity; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0ef39394d51b4a023d416b1744a3dd9f19a2b507 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/identity.mjs @@ -0,0 +1,5 @@ +function identity(x) { + return x; +} + +export { identity }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..debf70448375e86d97ce2fd37032c32a1d3cc8f4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.d.mts @@ -0,0 +1,119 @@ +interface MapCache { + /** + * Removes the value associated with the specified key from the cache. + * + * @param key - The key of the value to remove + * @returns `true` if an element was removed, `false` if the key wasn't found + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.delete('user'); // Returns true + * cache.delete('unknown'); // Returns false + * ``` + */ + delete(key: any): boolean; + /** + * Retrieves the value associated with the specified key from the cache. + * + * @param key - The key of the value to retrieve + * @returns The cached value or undefined if not found + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.get('user'); // Returns { id: 123, name: 'John' } + * cache.get('unknown'); // Returns undefined + * ``` + */ + get(key: any): any; + /** + * Checks if the cache contains a value for the specified key. + * + * @param key - The key to check for existence + * @returns `true` if the key exists in the cache, otherwise `false` + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.has('user'); // Returns true + * cache.has('unknown'); // Returns false + * ``` + */ + has(key: any): boolean; + /** + * Stores a value in the cache with the specified key. + * If the key already exists, its value is updated. + * + * @param key - The key to associate with the value + * @param value - The value to store in the cache + * @returns The cache instance for method chaining + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }) + * .set('settings', { theme: 'dark' }); + * ``` + */ + set(key: any, value: any): this; + /** + * Removes all key-value pairs from the cache. + * This method is optional as some cache implementations may be immutable. + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.set('settings', { theme: 'dark' }); + * cache.clear(); // Cache is now empty + * ``` + */ + clear?(): void; +} +/** + * Constructor interface for creating a new MapCache instance. + * This defines the shape of a constructor that can create cache objects + * conforming to the MapCache interface. + * + * @example + * ```typescript + * class CustomCache implements MapCache { + * // Cache implementation + * } + * + * const CacheConstructor: MapCacheConstructor = CustomCache; + * const cache = new CacheConstructor(); + * ``` + */ +interface MapCacheConstructor { + new (): MapCache; +} +/** + * Represents a function that has been memoized. + * A memoized function maintains the same signature as the original function + * but adds a cache property to store previously computed results. + * + * @template T - The type of the original function being memoized + */ +interface MemoizedFunction { + /** + * The cache storing previously computed results + */ + cache: MapCache; +} +/** + * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for + * storing the result based on the arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with + * the this binding of the memoized function. + * + * @template T - The type of the original function being memoized + * @param {T} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @return {MemoizedFunction} Returns the new memoizing function. + */ +declare function memoize any>(func: T, resolver?: (...args: Parameters) => any): T & MemoizedFunction; +declare namespace memoize { + var Cache: MapCacheConstructor; +} + +export { memoize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..debf70448375e86d97ce2fd37032c32a1d3cc8f4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.d.ts @@ -0,0 +1,119 @@ +interface MapCache { + /** + * Removes the value associated with the specified key from the cache. + * + * @param key - The key of the value to remove + * @returns `true` if an element was removed, `false` if the key wasn't found + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.delete('user'); // Returns true + * cache.delete('unknown'); // Returns false + * ``` + */ + delete(key: any): boolean; + /** + * Retrieves the value associated with the specified key from the cache. + * + * @param key - The key of the value to retrieve + * @returns The cached value or undefined if not found + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.get('user'); // Returns { id: 123, name: 'John' } + * cache.get('unknown'); // Returns undefined + * ``` + */ + get(key: any): any; + /** + * Checks if the cache contains a value for the specified key. + * + * @param key - The key to check for existence + * @returns `true` if the key exists in the cache, otherwise `false` + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.has('user'); // Returns true + * cache.has('unknown'); // Returns false + * ``` + */ + has(key: any): boolean; + /** + * Stores a value in the cache with the specified key. + * If the key already exists, its value is updated. + * + * @param key - The key to associate with the value + * @param value - The value to store in the cache + * @returns The cache instance for method chaining + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }) + * .set('settings', { theme: 'dark' }); + * ``` + */ + set(key: any, value: any): this; + /** + * Removes all key-value pairs from the cache. + * This method is optional as some cache implementations may be immutable. + * + * @example + * ```typescript + * cache.set('user', { id: 123, name: 'John' }); + * cache.set('settings', { theme: 'dark' }); + * cache.clear(); // Cache is now empty + * ``` + */ + clear?(): void; +} +/** + * Constructor interface for creating a new MapCache instance. + * This defines the shape of a constructor that can create cache objects + * conforming to the MapCache interface. + * + * @example + * ```typescript + * class CustomCache implements MapCache { + * // Cache implementation + * } + * + * const CacheConstructor: MapCacheConstructor = CustomCache; + * const cache = new CacheConstructor(); + * ``` + */ +interface MapCacheConstructor { + new (): MapCache; +} +/** + * Represents a function that has been memoized. + * A memoized function maintains the same signature as the original function + * but adds a cache property to store previously computed results. + * + * @template T - The type of the original function being memoized + */ +interface MemoizedFunction { + /** + * The cache storing previously computed results + */ + cache: MapCache; +} +/** + * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for + * storing the result based on the arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with + * the this binding of the memoized function. + * + * @template T - The type of the original function being memoized + * @param {T} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @return {MemoizedFunction} Returns the new memoizing function. + */ +declare function memoize any>(func: T, resolver?: (...args: Parameters) => any): T & MemoizedFunction; +declare namespace memoize { + var Cache: MapCacheConstructor; +} + +export { memoize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.js new file mode 100644 index 0000000000000000000000000000000000000000..93ae0f29a0fba4cf35afcac15e931f0c87ca24a7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function memoize(func, resolver) { + if (typeof func !== 'function' || (resolver != null && typeof resolver !== 'function')) { + throw new TypeError('Expected a function'); + } + const memoized = function (...args) { + const key = resolver ? resolver.apply(this, args) : args[0]; + const cache = memoized.cache; + if (cache.has(key)) { + return cache.get(key); + } + const result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + const CacheConstructor = memoize.Cache || Map; + memoized.cache = new CacheConstructor(); + return memoized; +} +memoize.Cache = Map; + +exports.memoize = memoize; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9b0a0bd0c007afa0edb49b767d5d516eddb09e97 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/memoize.mjs @@ -0,0 +1,21 @@ +function memoize(func, resolver) { + if (typeof func !== 'function' || (resolver != null && typeof resolver !== 'function')) { + throw new TypeError('Expected a function'); + } + const memoized = function (...args) { + const key = resolver ? resolver.apply(this, args) : args[0]; + const cache = memoized.cache; + if (cache.has(key)) { + return cache.get(key); + } + const result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + const CacheConstructor = memoize.Cache || Map; + memoized.cache = new CacheConstructor(); + return memoized; +} +memoize.Cache = Map; + +export { memoize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..20fc375454f47cf018bf0477c08f02f3eabacd4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.d.mts @@ -0,0 +1,18 @@ +/** + * Creates a function that negates the result of the predicate function. + * + * @template T - The type of the arguments array. + * @param {(...args: T) => boolean} predicate - The predicate to negate. + * @returns {(...args: T) => boolean} The new negated function. + * + * @example + * function isEven(n) { + * return n % 2 == 0; + * } + * + * filter([1, 2, 3, 4, 5, 6], negate(isEven)); + * // => [1, 3, 5] + */ +declare function negate(predicate: (...args: T) => boolean): (...args: T) => boolean; + +export { negate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..20fc375454f47cf018bf0477c08f02f3eabacd4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.d.ts @@ -0,0 +1,18 @@ +/** + * Creates a function that negates the result of the predicate function. + * + * @template T - The type of the arguments array. + * @param {(...args: T) => boolean} predicate - The predicate to negate. + * @returns {(...args: T) => boolean} The new negated function. + * + * @example + * function isEven(n) { + * return n % 2 == 0; + * } + * + * filter([1, 2, 3, 4, 5, 6], negate(isEven)); + * // => [1, 3, 5] + */ +declare function negate(predicate: (...args: T) => boolean): (...args: T) => boolean; + +export { negate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.js new file mode 100644 index 0000000000000000000000000000000000000000..4b835832be8edad04ccea555991fcda408c5ae10 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function negate(func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return function (...args) { + return !func.apply(this, args); + }; +} + +exports.negate = negate; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2d3470ea63baceeda0bfbc813f823f59de52b078 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/negate.mjs @@ -0,0 +1,10 @@ +function negate(func) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + return function (...args) { + return !func.apply(this, args); + }; +} + +export { negate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a1f3c565f13ade1a821d3bab589e5898f5ae5593 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.d.mts @@ -0,0 +1,12 @@ +/** + * A no-operation function that does nothing. + * This can be used as a placeholder or default function. + * + * @example + * noop(); // Does nothing + * + * @returns {void} This function does not return anything. + */ +declare function noop(..._: any[]): void; + +export { noop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a1f3c565f13ade1a821d3bab589e5898f5ae5593 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.d.ts @@ -0,0 +1,12 @@ +/** + * A no-operation function that does nothing. + * This can be used as a placeholder or default function. + * + * @example + * noop(); // Does nothing + * + * @returns {void} This function does not return anything. + */ +declare function noop(..._: any[]): void; + +export { noop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.js new file mode 100644 index 0000000000000000000000000000000000000000..d3cfde274278c370a13f0b1facc0a9a19c9b66bb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.js @@ -0,0 +1,7 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function noop(..._) { } + +exports.noop = noop; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.mjs new file mode 100644 index 0000000000000000000000000000000000000000..18bbf4596be57eb75cdd474fcd64a994899d1ff4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/noop.mjs @@ -0,0 +1,3 @@ +function noop(..._) { } + +export { noop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cd7a5636d44d76203d4b58a457fc834741577647 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.d.mts @@ -0,0 +1,18 @@ +/** + * Creates a function that gets the argument at index `n`. If `n` is negative, the nth argument from the end is returned. + * + * @param {number} [n=0] - The index of the argument to return. + * @returns {(...args: any[]) => any} Returns the new function. + * + * @example + * var func = nthArg(1); + * func('a', 'b', 'c', 'd'); + * // => 'b' + * + * var func = nthArg(-2); + * func('a', 'b', 'c', 'd'); + * // => 'c' + */ +declare function nthArg(n?: number): (...args: any[]) => any; + +export { nthArg }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cd7a5636d44d76203d4b58a457fc834741577647 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.d.ts @@ -0,0 +1,18 @@ +/** + * Creates a function that gets the argument at index `n`. If `n` is negative, the nth argument from the end is returned. + * + * @param {number} [n=0] - The index of the argument to return. + * @returns {(...args: any[]) => any} Returns the new function. + * + * @example + * var func = nthArg(1); + * func('a', 'b', 'c', 'd'); + * // => 'b' + * + * var func = nthArg(-2); + * func('a', 'b', 'c', 'd'); + * // => 'c' + */ +declare function nthArg(n?: number): (...args: any[]) => any; + +export { nthArg }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.js new file mode 100644 index 0000000000000000000000000000000000000000..32be2e54d00109020176341529a569625df1eb05 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('../util/toInteger.js'); + +function nthArg(n = 0) { + return function (...args) { + return args.at(toInteger.toInteger(n)); + }; +} + +exports.nthArg = nthArg; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0cd7b9b6f3b95247b7e8308e9a7b86ad8afcf55a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/nthArg.mjs @@ -0,0 +1,9 @@ +import { toInteger } from '../util/toInteger.mjs'; + +function nthArg(n = 0) { + return function (...args) { + return args.at(toInteger(n)); + }; +} + +export { nthArg }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fa1edb3a5b40fe7e2504ec825ece083c37086fcb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.d.mts @@ -0,0 +1,3 @@ +declare function once any>(func: T): T; + +export { once }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fa1edb3a5b40fe7e2504ec825ece083c37086fcb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.d.ts @@ -0,0 +1,3 @@ +declare function once any>(func: T): T; + +export { once }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.js new file mode 100644 index 0000000000000000000000000000000000000000..27c8af9da55ca248a8f7bdc294ef9d4e71577ef4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const once$1 = require('../../function/once.js'); + +function once(func) { + return once$1.once(func); +} + +exports.once = once; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.mjs new file mode 100644 index 0000000000000000000000000000000000000000..cb61ca6f4a96231e3d51d8f15cef8bd106ebf7ea --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/once.mjs @@ -0,0 +1,7 @@ +import { once as once$1 } from '../../function/once.mjs'; + +function once(func) { + return once$1(func); +} + +export { once }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cf62447ec7df9982f234b00376882ca9adfab2e5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.d.mts @@ -0,0 +1,52 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Creates a function that invokes `func` with its arguments transformed by corresponding transform functions. + * + * Transform functions can be: + * - Functions that accept and return a value + * - Property names (strings) to get a property value from each argument + * - Objects to check if arguments match the object properties + * - Arrays of [property, value] to check if argument properties match values + * + * If a transform is nullish, the identity function is used instead. + * Only transforms arguments up to the number of transform functions provided. + * + * @template F - The type of the function to wrap + * @template T - The type of the transform functions array + * @param {F} func - The function to wrap + * @param {T} transforms - The functions to transform arguments. Each transform can be: + * - A function that accepts and returns a value + * - A string to get a property value (e.g. 'name' gets the name property) + * - An object to check if arguments match its properties + * - An array of [property, value] to check property matches + * @returns {(...args: any[]) => ReturnType} A new function that transforms arguments before passing them to func + * @throws {TypeError} If func is not a function. + * @example + * ```ts + * function doubled(n: number) { + * return n * 2; + * } + * + * function square(n: number) { + * return n * n; + * } + * + * const func = overArgs((x, y) => [x, y], [doubled, square]); + * + * func(5, 3); + * // => [10, 9] + * + * // With property shorthand + * const user = { name: 'John', age: 30 }; + * const getUserInfo = overArgs( + * (name, age) => `${name} is ${age} years old`, + * ['name', 'age'] + * ); + * getUserInfo(user, user); + * // => "John is 30 years old" + * ``` + */ +declare function overArgs(func: (...args: any[]) => any, ..._transforms: Array any>>): (...args: any[]) => any; + +export { overArgs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c6e0e7c16998f7ea35800b7c62bbe2bdc0ba48ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.d.ts @@ -0,0 +1,52 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Creates a function that invokes `func` with its arguments transformed by corresponding transform functions. + * + * Transform functions can be: + * - Functions that accept and return a value + * - Property names (strings) to get a property value from each argument + * - Objects to check if arguments match the object properties + * - Arrays of [property, value] to check if argument properties match values + * + * If a transform is nullish, the identity function is used instead. + * Only transforms arguments up to the number of transform functions provided. + * + * @template F - The type of the function to wrap + * @template T - The type of the transform functions array + * @param {F} func - The function to wrap + * @param {T} transforms - The functions to transform arguments. Each transform can be: + * - A function that accepts and returns a value + * - A string to get a property value (e.g. 'name' gets the name property) + * - An object to check if arguments match its properties + * - An array of [property, value] to check property matches + * @returns {(...args: any[]) => ReturnType} A new function that transforms arguments before passing them to func + * @throws {TypeError} If func is not a function. + * @example + * ```ts + * function doubled(n: number) { + * return n * 2; + * } + * + * function square(n: number) { + * return n * n; + * } + * + * const func = overArgs((x, y) => [x, y], [doubled, square]); + * + * func(5, 3); + * // => [10, 9] + * + * // With property shorthand + * const user = { name: 'John', age: 30 }; + * const getUserInfo = overArgs( + * (name, age) => `${name} is ${age} years old`, + * ['name', 'age'] + * ); + * getUserInfo(user, user); + * // => "John is 30 years old" + * ``` + */ +declare function overArgs(func: (...args: any[]) => any, ..._transforms: Array any>>): (...args: any[]) => any; + +export { overArgs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.js new file mode 100644 index 0000000000000000000000000000000000000000..2956495207d180a1c52494cafa465e91e7fbd211 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const iteratee = require('../util/iteratee.js'); + +function overArgs(func, ..._transforms) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + const transforms = _transforms.flat(); + return function (...args) { + const length = Math.min(args.length, transforms.length); + const transformedArgs = [...args]; + for (let i = 0; i < length; i++) { + const transform = iteratee.iteratee(transforms[i] ?? identity.identity); + transformedArgs[i] = transform.call(this, args[i]); + } + return func.apply(this, transformedArgs); + }; +} + +exports.overArgs = overArgs; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2a607e10abd9b0b2af28d8131d384cdcab8bae35 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/overArgs.mjs @@ -0,0 +1,20 @@ +import { identity } from '../../function/identity.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function overArgs(func, ..._transforms) { + if (typeof func !== 'function') { + throw new TypeError('Expected a function'); + } + const transforms = _transforms.flat(); + return function (...args) { + const length = Math.min(args.length, transforms.length); + const transformedArgs = [...args]; + for (let i = 0; i < length; i++) { + const transform = iteratee(transforms[i] ?? identity); + transformedArgs[i] = transform.call(this, args[i]); + } + return func.apply(this, transformedArgs); + }; +} + +export { overArgs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..63b0c0529dbd642298b681fcc6b49a28c0912158 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.d.mts @@ -0,0 +1,204 @@ +import { Toolkit } from '../toolkit.mjs'; + +type __ = Placeholder | Toolkit; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}`; + * const sayHello = partial(greet, _, 'world'); + * console.log(sayHello('Hello')); // => 'Hello world' + */ +declare function partial(func: (t1: T1, t2: T2) => R, plc1: __, arg2: T2): (t1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const addToY = partial(calculate, _, 2); + * console.log(addToY(1, 3)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, arg2: T2): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const addZ = partial(calculate, _, _, 3); + * console.log(addZ(1, 2)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, plc2: __, arg3: T3): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const withXandZ = partial(calculate, 1, _, 3); + * console.log(withXandZ(2)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const withYandZ = partial(calculate, _, 2, 3); + * console.log(withYandZ(1)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, arg2: T2, arg3: T3): (t1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withB = partial(format, _, 'b'); + * console.log(withB('a', 'c', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2): (t1: T1, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withC = partial(format, _, _, 'c'); + * console.log(withC('a', 'b', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, arg3: T3): (t1: T1, t2: T2, t4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withAandC = partial(format, 'a', _, 'c'); + * console.log(withAandC('b', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2, t4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBandC = partial(format, _, 'b', 'c'); + * console.log(withBandC('a', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, arg3: T3): (t1: T1, t4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withD = partial(format, _, _, _, 'd'); + * console.log(withD('a', 'b', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, plc3: __, arg4: T4): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withAandD = partial(format, 'a', _, _, 'd'); + * console.log(withAandD('b', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, arg4: T4): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBandD = partial(format, _, 'b', _, 'd'); + * console.log(withBandD('a', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, plc3: __, arg4: T4): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withABandD = partial(format, 'a', 'b', _, 'd'); + * console.log(withABandD('c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, arg4: T4): (t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withCandD = partial(format, _, _, 'c', 'd'); + * console.log(withCandD('a', 'b')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, arg3: T3, arg4: T4): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withACandD = partial(format, 'a', _, 'c', 'd'); + * console.log(withACandD('b')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, arg4: T4): (t2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBCandD = partial(format, _, 'b', 'c', 'd'); + * console.log(withBCandD('a')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, arg3: T3, arg4: T4): (t1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const sum = (...numbers: number[]) => numbers.reduce((a, b) => a + b, 0); + * const partialSum = partial(sum); + * console.log(partialSum(1, 2, 3)); // => 6 + */ +declare function partial(func: (...ts: TS) => R): (...ts: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const log = (prefix: string, ...messages: string[]) => console.log(prefix, ...messages); + * const debugLog = partial(log, '[DEBUG]'); + * debugLog('message 1', 'message 2'); // => '[DEBUG] message 1 message 2' + */ +declare function partial(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (prefix: string, separator: string, ...messages: string[]) => `${prefix}${messages.join(separator)}`; + * const logWithPrefix = partial(format, '[LOG]', ' - '); + * console.log(logWithPrefix('msg1', 'msg2')); // => '[LOG]msg1 - msg2' + */ +declare function partial(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (type: string, level: string, message: string, ...tags: string[]) => + * `[${type}][${level}] ${message} ${tags.join(',')}`; + * const errorLog = partial(format, 'ERROR', 'HIGH', 'Something went wrong'); + * console.log(errorLog('critical', 'urgent')); // => '[ERROR][HIGH] Something went wrong critical,urgent' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string, ...rest: string[]) => + * `${a}-${b}-${c}-${d}:${rest.join(',')}`; + * const prefixedFormat = partial(format, 'a', 'b', 'c', 'd'); + * console.log(prefixedFormat('e', 'f')); // => 'a-b-c-d:e,f' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R; +declare namespace partial { + var placeholder: Placeholder; +} +type Placeholder = symbol | (((value: any) => any) & { + partial: typeof partial; +}); + +export { partial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..899498bfa0184af5eeb948547545778c62e189e4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.d.ts @@ -0,0 +1,204 @@ +import { Toolkit } from '../toolkit.js'; + +type __ = Placeholder | Toolkit; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}`; + * const sayHello = partial(greet, _, 'world'); + * console.log(sayHello('Hello')); // => 'Hello world' + */ +declare function partial(func: (t1: T1, t2: T2) => R, plc1: __, arg2: T2): (t1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const addToY = partial(calculate, _, 2); + * console.log(addToY(1, 3)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, arg2: T2): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const addZ = partial(calculate, _, _, 3); + * console.log(addZ(1, 2)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, plc2: __, arg3: T3): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const withXandZ = partial(calculate, 1, _, 3); + * console.log(withXandZ(2)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const calculate = (x: number, y: number, z: number) => x + y + z; + * const withYandZ = partial(calculate, _, 2, 3); + * console.log(withYandZ(1)); // => 6 + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3) => R, plc1: __, arg2: T2, arg3: T3): (t1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withB = partial(format, _, 'b'); + * console.log(withB('a', 'c', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2): (t1: T1, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withC = partial(format, _, _, 'c'); + * console.log(withC('a', 'b', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, arg3: T3): (t1: T1, t2: T2, t4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withAandC = partial(format, 'a', _, 'c'); + * console.log(withAandC('b', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2, t4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBandC = partial(format, _, 'b', 'c'); + * console.log(withBandC('a', 'd')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, arg3: T3): (t1: T1, t4: T4) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withD = partial(format, _, _, _, 'd'); + * console.log(withD('a', 'b', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, plc3: __, arg4: T4): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withAandD = partial(format, 'a', _, _, 'd'); + * console.log(withAandD('b', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, arg4: T4): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBandD = partial(format, _, 'b', _, 'd'); + * console.log(withBandD('a', 'c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, plc3: __, arg4: T4): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withABandD = partial(format, 'a', 'b', _, 'd'); + * console.log(withABandD('c')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, arg4: T4): (t3: T3) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withCandD = partial(format, _, _, 'c', 'd'); + * console.log(withCandD('a', 'b')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, plc2: __, arg3: T3, arg4: T4): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withACandD = partial(format, 'a', _, 'c', 'd'); + * console.log(withACandD('b')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, arg4: T4): (t2: T2) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`; + * const withBCandD = partial(format, _, 'b', 'c', 'd'); + * console.log(withBCandD('a')); // => 'a-b-c-d' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, plc1: __, arg2: T2, arg3: T3, arg4: T4): (t1: T1) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const sum = (...numbers: number[]) => numbers.reduce((a, b) => a + b, 0); + * const partialSum = partial(sum); + * console.log(partialSum(1, 2, 3)); // => 6 + */ +declare function partial(func: (...ts: TS) => R): (...ts: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const log = (prefix: string, ...messages: string[]) => console.log(prefix, ...messages); + * const debugLog = partial(log, '[DEBUG]'); + * debugLog('message 1', 'message 2'); // => '[DEBUG] message 1 message 2' + */ +declare function partial(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (prefix: string, separator: string, ...messages: string[]) => `${prefix}${messages.join(separator)}`; + * const logWithPrefix = partial(format, '[LOG]', ' - '); + * console.log(logWithPrefix('msg1', 'msg2')); // => '[LOG]msg1 - msg2' + */ +declare function partial(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (type: string, level: string, message: string, ...tags: string[]) => + * `[${type}][${level}] ${message} ${tags.join(',')}`; + * const errorLog = partial(format, 'ERROR', 'HIGH', 'Something went wrong'); + * console.log(errorLog('critical', 'urgent')); // => '[ERROR][HIGH] Something went wrong critical,urgent' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R; +/** + * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding. + * + * @example + * const format = (a: string, b: string, c: string, d: string, ...rest: string[]) => + * `${a}-${b}-${c}-${d}:${rest.join(',')}`; + * const prefixedFormat = partial(format, 'a', 'b', 'c', 'd'); + * console.log(prefixedFormat('e', 'f')); // => 'a-b-c-d:e,f' + */ +declare function partial(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R; +declare namespace partial { + var placeholder: Placeholder; +} +type Placeholder = symbol | (((value: any) => any) & { + partial: typeof partial; +}); + +export { partial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.js new file mode 100644 index 0000000000000000000000000000000000000000..905e92dacf384345b223947137bde3e9da593dd2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const partial$1 = require('../../function/partial.js'); + +function partial(func, ...partialArgs) { + return partial$1.partialImpl(func, partial.placeholder, ...partialArgs); +} +partial.placeholder = Symbol('compat.partial.placeholder'); + +exports.partial = partial; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d738c95be53cdcc4f7ddf5e98dbaa46a41db1bae --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partial.mjs @@ -0,0 +1,8 @@ +import { partialImpl } from '../../function/partial.mjs'; + +function partial(func, ...partialArgs) { + return partialImpl(func, partial.placeholder, ...partialArgs); +} +partial.placeholder = Symbol('compat.partial.placeholder'); + +export { partial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1fa6c444466e9013bd1841dadc812b0a6a703f5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.d.mts @@ -0,0 +1,622 @@ +import { Toolkit } from '../toolkit.mjs'; + +type __ = Placeholder | Toolkit; +/** + * Creates a function that invokes the provided function with no arguments. + * + * @template R The return type of the function + * @param {() => R} func The function to partially apply + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = () => 'Hello!'; + * const sayHello = partialRight(greet); + * sayHello(); // => 'Hello!' + */ +declare function partialRight(func: () => R): () => R; +/** + * Creates a function that invokes the provided function with one argument. + * + * @template T The type of the argument + * @template R The return type of the function + * @param {(t1: T) => R} func The function to partially apply + * @returns {(t1: T) => R} Returns the new partially applied function + * + * @example + * const greet = (name: string) => `Hello ${name}!`; + * const greetPerson = partialRight(greet); + * greetPerson('Fred'); // => 'Hello Fred!' + */ +declare function partialRight(func: (t1: T) => R): (t1: T) => R; +/** + * Creates a function that invokes the provided function with one argument pre-filled. + * + * @template T The type of the argument + * @template R The return type of the function + * @param {(t1: T) => R} func The function to partially apply + * @param {T} arg1 The argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (name: string) => `Hello ${name}!`; + * const greetFred = partialRight(greet, 'Fred'); + * greetFred(); // => 'Hello Fred!' + */ +declare function partialRight(func: (t1: T) => R, arg1: T): () => R; +/** + * Creates a function that invokes the provided function with two arguments. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const greetWithParams = partialRight(greet); + * greetWithParams('Hi', 'Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with one argument pre-filled and a placeholder. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T1} arg1 The argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const hiWithName = partialRight(greet, 'Hi', partialRight.placeholder); + * hiWithName('Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg1: T1, plc2: __): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T2} arg2 The argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const greetFred = partialRight(greet, 'Fred'); + * greetFred('Hi'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg2: T2): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with both arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const sayHiToFred = partialRight(greet, 'Hi', 'Fred'); + * sayHiToFred(); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg1: T1, arg2: T2): () => R; +/** + * Creates a function that invokes the provided function with no pre-filled arguments. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetWithArgs = partialRight(greet); + * greetWithArgs('Hi', 'Fred', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first argument pre-filled and placeholders for the rest. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiWithNameAndPunc = partialRight(greet, 'Hi', partialRight.placeholder, partialRight.placeholder); + * hiWithNameAndPunc('Fred', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, plc3: __): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled and a placeholder for the third. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetFredWithPunc = partialRight(greet, 'Fred', partialRight.placeholder); + * greetFredWithPunc('Hi', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg2: T2, plc3: __): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first two arguments pre-filled and a placeholder for the third. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @returns {(t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiToFredWithPunc = partialRight(greet, 'Hi', 'Fred', partialRight.placeholder); + * hiToFredWithPunc('!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, arg2: T2, plc3: __): (t3: T3) => R; +/** + * Creates a function that invokes the provided function with the third argument pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetWithExclamation = partialRight(greet, '!'); + * greetWithExclamation('Hi', 'Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg3: T3): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with the first and third arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiWithNameAndExclamation = partialRight(greet, 'Hi', partialRight.placeholder, '!'); + * hiWithNameAndExclamation('Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second and third arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetFredWithExclamation = partialRight(greet, 'Fred', '!'); + * greetFredWithExclamation('Hi'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg2: T2, arg3: T3): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with all three arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const sayHiToFredWithExclamation = partialRight(greet, 'Hi', 'Fred', '!'); + * sayHiToFredWithExclamation(); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R; +/** + * Creates a function that invokes the provided function with no pre-filled arguments. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const formatWithArgs = partialRight(format); + * formatWithArgs('Hi', 'Fred', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): (t1: T1, t2: T2, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first argument pre-filled and placeholders for the rest. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiWithRest = partialRight(format, 'Hi', partialRight.placeholder, partialRight.placeholder, partialRight.placeholder); + * hiWithRest('Fred', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, plc4: __): (t2: T2, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled and placeholders for the rest. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredWithRest = partialRight(format, 'Fred', partialRight.placeholder, partialRight.placeholder); + * greetFredWithRest('Hi', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, plc3: __, plc4: __): (t1: T1, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first two arguments pre-filled and placeholders for the rest. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredWithRest = partialRight(format, 'Hi', 'Fred', partialRight.placeholder, partialRight.placeholder); + * hiToFredWithRest('morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, plc4: __): (t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the third argument pre-filled and a placeholder for the fourth. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t2: T2, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const atMorningWithPunc = partialRight(format, 'morning', partialRight.placeholder); + * atMorningWithPunc('Hi', 'Fred', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg3: T3, plc4: __): (t1: T1, t2: T2, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first and third arguments pre-filled and a placeholder for the fourth. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t2: T2, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiAtMorningWithNameAndPunc = partialRight(format, 'Hi', partialRight.placeholder, 'morning', partialRight.placeholder); + * hiAtMorningWithNameAndPunc('Fred', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, plc4: __): (t2: T2, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the second and third arguments pre-filled and a placeholder for the fourth. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredAtMorningWithPunc = partialRight(format, 'Fred', 'morning', partialRight.placeholder); + * greetFredAtMorningWithPunc('Hi', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, arg3: T3, plc4: __): (t1: T1, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first three arguments pre-filled and a placeholder for the fourth. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredAtMorningWithPunc = partialRight(format, 'Hi', 'Fred', 'morning', partialRight.placeholder); + * hiToFredAtMorningWithPunc('!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, arg3: T3, plc4: __): (t4: T4) => R; +/** + * Creates a function that invokes the provided function with the fourth argument pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const withExclamation = partialRight(format, '!'); + * withExclamation('Hi', 'Fred', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg4: T4): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first and fourth arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiWithExclamation = partialRight(format, 'Hi', partialRight.placeholder, partialRight.placeholder, '!'); + * hiWithExclamation('Fred', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, arg4: T4): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the second and fourth arguments pre-filled and a placeholder for the third. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredWithTime = partialRight(format, 'Fred', partialRight.placeholder, '!'); + * greetFredWithTime('Hi', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, plc3: __, arg4: T4): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first, second and fourth arguments pre-filled and a placeholder for the third. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredWithTime = partialRight(format, 'Hi', 'Fred', partialRight.placeholder, '!'); + * hiToFredWithTime('morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, arg4: T4): (t3: T3) => R; +/** + * Creates a function that invokes the provided function with the third and fourth arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const inMorningWithExclamation = partialRight(format, 'morning', '!'); + * inMorningWithExclamation('Hi', 'Fred'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg3: T3, arg4: T4): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with the first, third and fourth arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiInMorningWithExclamation = partialRight(format, 'Hi', partialRight.placeholder, 'morning', '!'); + * hiInMorningWithExclamation('Fred'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, arg4: T4): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second, third and fourth arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredInMorningWithExclamation = partialRight(format, 'Fred', 'morning', '!'); + * greetFredInMorningWithExclamation('Hi'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with all arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const sayHiToFredInMorningWithExclamation = partialRight(format, 'Hi', 'Fred', 'morning', '!'); + * sayHiToFredInMorningWithExclamation(); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R; +/** + * Creates a function that invokes the provided function with partially applied arguments appended to the arguments it receives. + * The partialRight.placeholder value can be used as a placeholder for partially applied arguments. + * + * @template F The type of the function to partially apply + * @param {F} func The function to partially apply arguments to + * @param {...any[]} args The arguments to be partially applied + * @returns {(...args: any[]) => ReturnType} Returns the new partially applied function + * + * @example + * function greet(greeting: string, name: string) { + * return greeting + ' ' + name; + * } + * + * const greetFred = partialRight(greet, 'Fred'); + * greetFred('Hi'); // => 'Hi Fred' + * + * // Using placeholders + * const sayHelloTo = partialRight(greet, 'Hello', partialRight.placeholder); + * sayHelloTo('Fred'); // => 'Hello Fred' + */ +declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; +declare namespace partialRight { + var placeholder: Placeholder; +} +type Placeholder = symbol | (((value: any) => any) & { + partialRight: typeof partialRight; +}); + +export { partialRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0cf4a9b9404d821254c9681ecf313d53f77d1aa5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.d.ts @@ -0,0 +1,622 @@ +import { Toolkit } from '../toolkit.js'; + +type __ = Placeholder | Toolkit; +/** + * Creates a function that invokes the provided function with no arguments. + * + * @template R The return type of the function + * @param {() => R} func The function to partially apply + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = () => 'Hello!'; + * const sayHello = partialRight(greet); + * sayHello(); // => 'Hello!' + */ +declare function partialRight(func: () => R): () => R; +/** + * Creates a function that invokes the provided function with one argument. + * + * @template T The type of the argument + * @template R The return type of the function + * @param {(t1: T) => R} func The function to partially apply + * @returns {(t1: T) => R} Returns the new partially applied function + * + * @example + * const greet = (name: string) => `Hello ${name}!`; + * const greetPerson = partialRight(greet); + * greetPerson('Fred'); // => 'Hello Fred!' + */ +declare function partialRight(func: (t1: T) => R): (t1: T) => R; +/** + * Creates a function that invokes the provided function with one argument pre-filled. + * + * @template T The type of the argument + * @template R The return type of the function + * @param {(t1: T) => R} func The function to partially apply + * @param {T} arg1 The argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (name: string) => `Hello ${name}!`; + * const greetFred = partialRight(greet, 'Fred'); + * greetFred(); // => 'Hello Fred!' + */ +declare function partialRight(func: (t1: T) => R, arg1: T): () => R; +/** + * Creates a function that invokes the provided function with two arguments. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const greetWithParams = partialRight(greet); + * greetWithParams('Hi', 'Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with one argument pre-filled and a placeholder. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T1} arg1 The argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const hiWithName = partialRight(greet, 'Hi', partialRight.placeholder); + * hiWithName('Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg1: T1, plc2: __): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T2} arg2 The argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const greetFred = partialRight(greet, 'Fred'); + * greetFred('Hi'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg2: T2): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with both arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string) => `${greeting} ${name}!`; + * const sayHiToFred = partialRight(greet, 'Hi', 'Fred'); + * sayHiToFred(); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2) => R, arg1: T1, arg2: T2): () => R; +/** + * Creates a function that invokes the provided function with no pre-filled arguments. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetWithArgs = partialRight(greet); + * greetWithArgs('Hi', 'Fred', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first argument pre-filled and placeholders for the rest. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiWithNameAndPunc = partialRight(greet, 'Hi', partialRight.placeholder, partialRight.placeholder); + * hiWithNameAndPunc('Fred', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, plc3: __): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled and a placeholder for the third. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetFredWithPunc = partialRight(greet, 'Fred', partialRight.placeholder); + * greetFredWithPunc('Hi', '!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg2: T2, plc3: __): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first two arguments pre-filled and a placeholder for the third. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @returns {(t3: T3) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiToFredWithPunc = partialRight(greet, 'Hi', 'Fred', partialRight.placeholder); + * hiToFredWithPunc('!'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, arg2: T2, plc3: __): (t3: T3) => R; +/** + * Creates a function that invokes the provided function with the third argument pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetWithExclamation = partialRight(greet, '!'); + * greetWithExclamation('Hi', 'Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg3: T3): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with the first and third arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const hiWithNameAndExclamation = partialRight(greet, 'Hi', partialRight.placeholder, '!'); + * hiWithNameAndExclamation('Fred'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, plc2: __, arg3: T3): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second and third arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const greetFredWithExclamation = partialRight(greet, 'Fred', '!'); + * greetFredWithExclamation('Hi'); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg2: T2, arg3: T3): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with all three arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting} ${name}${punctuation}`; + * const sayHiToFredWithExclamation = partialRight(greet, 'Hi', 'Fred', '!'); + * sayHiToFredWithExclamation(); // => 'Hi Fred!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R; +/** + * Creates a function that invokes the provided function with no pre-filled arguments. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @returns {(t1: T1, t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const formatWithArgs = partialRight(format); + * formatWithArgs('Hi', 'Fred', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): (t1: T1, t2: T2, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first argument pre-filled and placeholders for the rest. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t2: T2, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiWithRest = partialRight(format, 'Hi', partialRight.placeholder, partialRight.placeholder, partialRight.placeholder); + * hiWithRest('Fred', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, plc4: __): (t2: T2, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the second argument pre-filled and placeholders for the rest. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredWithRest = partialRight(format, 'Fred', partialRight.placeholder, partialRight.placeholder); + * greetFredWithRest('Hi', 'morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, plc3: __, plc4: __): (t1: T1, t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first two arguments pre-filled and placeholders for the rest. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t3: T3, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredWithRest = partialRight(format, 'Hi', 'Fred', partialRight.placeholder, partialRight.placeholder); + * hiToFredWithRest('morning', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, plc4: __): (t3: T3, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the third argument pre-filled and a placeholder for the fourth. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t2: T2, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const atMorningWithPunc = partialRight(format, 'morning', partialRight.placeholder); + * atMorningWithPunc('Hi', 'Fred', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg3: T3, plc4: __): (t1: T1, t2: T2, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first and third arguments pre-filled and a placeholder for the fourth. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t2: T2, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiAtMorningWithNameAndPunc = partialRight(format, 'Hi', partialRight.placeholder, 'morning', partialRight.placeholder); + * hiAtMorningWithNameAndPunc('Fred', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, plc4: __): (t2: T2, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the second and third arguments pre-filled and a placeholder for the fourth. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t1: T1, t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredAtMorningWithPunc = partialRight(format, 'Fred', 'morning', partialRight.placeholder); + * greetFredAtMorningWithPunc('Hi', '!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, arg3: T3, plc4: __): (t1: T1, t4: T4) => R; +/** + * Creates a function that invokes the provided function with the first three arguments pre-filled and a placeholder for the fourth. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {__} plc4 The placeholder for the fourth argument + * @returns {(t4: T4) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredAtMorningWithPunc = partialRight(format, 'Hi', 'Fred', 'morning', partialRight.placeholder); + * hiToFredAtMorningWithPunc('!'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, arg3: T3, plc4: __): (t4: T4) => R; +/** + * Creates a function that invokes the provided function with the fourth argument pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const withExclamation = partialRight(format, '!'); + * withExclamation('Hi', 'Fred', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg4: T4): (t1: T1, t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first and fourth arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t2: T2, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiWithExclamation = partialRight(format, 'Hi', partialRight.placeholder, partialRight.placeholder, '!'); + * hiWithExclamation('Fred', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, plc3: __, arg4: T4): (t2: T2, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the second and fourth arguments pre-filled and a placeholder for the third. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredWithTime = partialRight(format, 'Fred', partialRight.placeholder, '!'); + * greetFredWithTime('Hi', 'morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, plc3: __, arg4: T4): (t1: T1, t3: T3) => R; +/** + * Creates a function that invokes the provided function with the first, second and fourth arguments pre-filled and a placeholder for the third. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {__} plc3 The placeholder for the third argument + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t3: T3) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiToFredWithTime = partialRight(format, 'Hi', 'Fred', partialRight.placeholder, '!'); + * hiToFredWithTime('morning'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, plc3: __, arg4: T4): (t3: T3) => R; +/** + * Creates a function that invokes the provided function with the third and fourth arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1, t2: T2) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const inMorningWithExclamation = partialRight(format, 'morning', '!'); + * inMorningWithExclamation('Hi', 'Fred'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg3: T3, arg4: T4): (t1: T1, t2: T2) => R; +/** + * Creates a function that invokes the provided function with the first, third and fourth arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {__} plc2 The placeholder for the second argument + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t2: T2) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const hiInMorningWithExclamation = partialRight(format, 'Hi', partialRight.placeholder, 'morning', '!'); + * hiInMorningWithExclamation('Fred'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, plc2: __, arg3: T3, arg4: T4): (t2: T2) => R; +/** + * Creates a function that invokes the provided function with the second, third and fourth arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {(t1: T1) => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const greetFredInMorningWithExclamation = partialRight(format, 'Fred', 'morning', '!'); + * greetFredInMorningWithExclamation('Hi'); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (t1: T1) => R; +/** + * Creates a function that invokes the provided function with all arguments pre-filled. + * + * @template T1 The type of the first argument + * @template T2 The type of the second argument + * @template T3 The type of the third argument + * @template T4 The type of the fourth argument + * @template R The return type of the function + * @param {(t1: T1, t2: T2, t3: T3, t4: T4) => R} func The function to partially apply + * @param {T1} arg1 The first argument to pre-fill + * @param {T2} arg2 The second argument to pre-fill + * @param {T3} arg3 The third argument to pre-fill + * @param {T4} arg4 The fourth argument to pre-fill + * @returns {() => R} Returns the new partially applied function + * + * @example + * const format = (greeting: string, name: string, time: string, punctuation: string) => + * `${greeting} ${name}, it's ${time}${punctuation}`; + * const sayHiToFredInMorningWithExclamation = partialRight(format, 'Hi', 'Fred', 'morning', '!'); + * sayHiToFredInMorningWithExclamation(); // => 'Hi Fred, it's morning!' + */ +declare function partialRight(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R; +/** + * Creates a function that invokes the provided function with partially applied arguments appended to the arguments it receives. + * The partialRight.placeholder value can be used as a placeholder for partially applied arguments. + * + * @template F The type of the function to partially apply + * @param {F} func The function to partially apply arguments to + * @param {...any[]} args The arguments to be partially applied + * @returns {(...args: any[]) => ReturnType} Returns the new partially applied function + * + * @example + * function greet(greeting: string, name: string) { + * return greeting + ' ' + name; + * } + * + * const greetFred = partialRight(greet, 'Fred'); + * greetFred('Hi'); // => 'Hi Fred' + * + * // Using placeholders + * const sayHelloTo = partialRight(greet, 'Hello', partialRight.placeholder); + * sayHelloTo('Fred'); // => 'Hello Fred' + */ +declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; +declare namespace partialRight { + var placeholder: Placeholder; +} +type Placeholder = symbol | (((value: any) => any) & { + partialRight: typeof partialRight; +}); + +export { partialRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.js new file mode 100644 index 0000000000000000000000000000000000000000..1217ee9b269a878eb548f7392a78f957d736f242 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const partialRight$1 = require('../../function/partialRight.js'); + +function partialRight(func, ...partialArgs) { + return partialRight$1.partialRightImpl(func, partialRight.placeholder, ...partialArgs); +} +partialRight.placeholder = Symbol('compat.partialRight.placeholder'); + +exports.partialRight = partialRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ad20a9a50e41234ab6e9f9a986cf6a516cf7c9e0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/partialRight.mjs @@ -0,0 +1,8 @@ +import { partialRightImpl } from '../../function/partialRight.mjs'; + +function partialRight(func, ...partialArgs) { + return partialRightImpl(func, partialRight.placeholder, ...partialArgs); +} +partialRight.placeholder = Symbol('compat.partialRight.placeholder'); + +export { partialRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ea99179895546864b253e0c591700bc3cfd6b7bc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.d.mts @@ -0,0 +1,20 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Creates a function that invokes `func` with arguments arranged according to the specified `indices` + * where the argument value at the first index is provided as the first argument, + * the argument value at the second index is provided as the second argument, and so on. + * + * @template F The type of the function to re-arrange. + * @param {F} func The function to rearrange arguments for. + * @param {Array} indices The arranged argument indices. + * @returns {(...args: any[]) => ReturnType} Returns the new function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const rearrangedGreet = rearg(greet, 1, 0); + * console.log(rearrangedGreet('World', 'Hello')); // Output: "Hello, World!" + */ +declare function rearg(func: (...args: any[]) => any, ...indices: Array>): (...args: any[]) => any; + +export { rearg }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a4c8227305be758307b2d2763f715ca9b379b389 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.d.ts @@ -0,0 +1,20 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Creates a function that invokes `func` with arguments arranged according to the specified `indices` + * where the argument value at the first index is provided as the first argument, + * the argument value at the second index is provided as the second argument, and so on. + * + * @template F The type of the function to re-arrange. + * @param {F} func The function to rearrange arguments for. + * @param {Array} indices The arranged argument indices. + * @returns {(...args: any[]) => ReturnType} Returns the new function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const rearrangedGreet = rearg(greet, 1, 0); + * console.log(rearrangedGreet('World', 'Hello')); // Output: "Hello, World!" + */ +declare function rearg(func: (...args: any[]) => any, ...indices: Array>): (...args: any[]) => any; + +export { rearg }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.js new file mode 100644 index 0000000000000000000000000000000000000000..2842efb286dfcfe973d5b4f699dc5e0f58eed196 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('../array/flatten.js'); + +function rearg(func, ...indices) { + const flattenIndices = flatten.flatten(indices); + return function (...args) { + const reorderedArgs = flattenIndices.map(i => args[i]).slice(0, args.length); + for (let i = reorderedArgs.length; i < args.length; i++) { + reorderedArgs.push(args[i]); + } + return func.apply(this, reorderedArgs); + }; +} + +exports.rearg = rearg; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.mjs new file mode 100644 index 0000000000000000000000000000000000000000..680a9fe9a747c0b30aefdf16b8e6333d4eff3377 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rearg.mjs @@ -0,0 +1,14 @@ +import { flatten } from '../array/flatten.mjs'; + +function rearg(func, ...indices) { + const flattenIndices = flatten(indices); + return function (...args) { + const reorderedArgs = flattenIndices.map(i => args[i]).slice(0, args.length); + for (let i = reorderedArgs.length; i < args.length; i++) { + reorderedArgs.push(args[i]); + } + return func.apply(this, reorderedArgs); + }; +} + +export { rearg }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..95fe43b181bdd36ee4a0210d603d1d6f17c7f6b8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.d.mts @@ -0,0 +1,33 @@ +/** + * Creates a function that transforms the arguments of the provided function `func`. + * The transformed arguments are passed to `func` such that the arguments starting from a specified index + * are grouped into an array, while the previous arguments are passed as individual elements. + * + * @template F - The type of the function being transformed. + * @param {F} func - The function whose arguments are to be transformed. + * @param {number} [start=func.length - 1] - The index from which to start grouping the remaining arguments into an array. + * Defaults to `func.length - 1`, grouping all arguments after the last parameter. + * @returns {(...args: any[]) => ReturnType} A new function that, when called, returns the result of calling `func` with the transformed arguments. + * + * The transformed arguments are: + * - The first `start` arguments as individual elements. + * - The remaining arguments from index `start` onward grouped into an array. + * @example + * function fn(a, b, c) { + * return [a, b, c]; + * } + * + * // Using default start index (func.length - 1, which is 2 in this case) + * const transformedFn = rest(fn); + * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]] + * + * // Using start index 1 + * const transformedFnWithStart = rest(fn, 1); + * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]] + * + * // With fewer arguments than the start index + * console.log(transformedFn(1)); // [1, undefined, []] + */ +declare function rest(func: (...args: any[]) => any, start?: number): (...args: any[]) => any; + +export { rest }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..95fe43b181bdd36ee4a0210d603d1d6f17c7f6b8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.d.ts @@ -0,0 +1,33 @@ +/** + * Creates a function that transforms the arguments of the provided function `func`. + * The transformed arguments are passed to `func` such that the arguments starting from a specified index + * are grouped into an array, while the previous arguments are passed as individual elements. + * + * @template F - The type of the function being transformed. + * @param {F} func - The function whose arguments are to be transformed. + * @param {number} [start=func.length - 1] - The index from which to start grouping the remaining arguments into an array. + * Defaults to `func.length - 1`, grouping all arguments after the last parameter. + * @returns {(...args: any[]) => ReturnType} A new function that, when called, returns the result of calling `func` with the transformed arguments. + * + * The transformed arguments are: + * - The first `start` arguments as individual elements. + * - The remaining arguments from index `start` onward grouped into an array. + * @example + * function fn(a, b, c) { + * return [a, b, c]; + * } + * + * // Using default start index (func.length - 1, which is 2 in this case) + * const transformedFn = rest(fn); + * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]] + * + * // Using start index 1 + * const transformedFnWithStart = rest(fn, 1); + * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]] + * + * // With fewer arguments than the start index + * console.log(transformedFn(1)); // [1, undefined, []] + */ +declare function rest(func: (...args: any[]) => any, start?: number): (...args: any[]) => any; + +export { rest }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.js new file mode 100644 index 0000000000000000000000000000000000000000..0415b84fd713425a0d676212a5ccc444195288f5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const rest$1 = require('../../function/rest.js'); + +function rest(func, start = func.length - 1) { + start = Number.parseInt(start, 10); + if (Number.isNaN(start) || start < 0) { + start = func.length - 1; + } + return rest$1.rest(func, start); +} + +exports.rest = rest; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5f8999d81c39790de18b30b7c031c3a7ebccdd7f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/rest.mjs @@ -0,0 +1,11 @@ +import { rest as rest$1 } from '../../function/rest.mjs'; + +function rest(func, start = func.length - 1) { + start = Number.parseInt(start, 10); + if (Number.isNaN(start) || start < 0) { + start = func.length - 1; + } + return rest$1(func, start); +} + +export { rest }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..097d69038eb3e8fa4b6e6cd5047da8ddc1a7fc50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.d.mts @@ -0,0 +1,47 @@ +/** + * Creates a new function that spreads elements of an array argument into individual arguments + * for the original function. The array argument is positioned based on the `argsIndex` parameter. + * + * @template F - A function type with any number of parameters and any return type. + * @param {F} func - The function to be transformed. It can be any function with any number of arguments. + * @param {number} [argsIndex=0] - The index where the array argument is positioned among the other arguments. + * If `argsIndex` is negative or `NaN`, it defaults to `0`. If it's a fractional number, it is rounded to the nearest integer. + * @returns {(...args: any[]) => ReturnType} - A new function that takes multiple arguments, including an array of arguments at the specified `argsIndex`, + * and returns the result of calling the original function with those arguments. + * + * @example + * function add(a, b) { + * return a + b; + * } + * + * const spreadAdd = spread(add); + * console.log(spreadAdd([1, 2])); // Output: 3 + * + * @example + * // Example function to spread arguments over + * function add(a, b) { + * return a + b; + * } + * + * // Create a new function that uses `spread` to combine arguments + * const spreadAdd = spread(add, 1); + * + * // Calling `spreadAdd` with an array as the second argument + * console.log(spreadAdd(1, [2])); // Output: 3 + * + * @example + * // Function with default arguments + * function greet(name, greeting = 'Hello') { + * return `${greeting}, ${name}!`; + * } + * + * // Create a new function that uses `spread` to position the argument array at index 0 + * const spreadGreet = spread(greet, 0); + * + * // Calling `spreadGreet` with an array of arguments + * console.log(spreadGreet(['Alice'])); // Output: Hello, Alice! + * console.log(spreadGreet(['Bob', 'Hi'])); // Output: Hi, Bob! + */ +declare function spread(func: (...args: any[]) => R, argsIndex?: number): (...args: any[]) => R; + +export { spread }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..097d69038eb3e8fa4b6e6cd5047da8ddc1a7fc50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.d.ts @@ -0,0 +1,47 @@ +/** + * Creates a new function that spreads elements of an array argument into individual arguments + * for the original function. The array argument is positioned based on the `argsIndex` parameter. + * + * @template F - A function type with any number of parameters and any return type. + * @param {F} func - The function to be transformed. It can be any function with any number of arguments. + * @param {number} [argsIndex=0] - The index where the array argument is positioned among the other arguments. + * If `argsIndex` is negative or `NaN`, it defaults to `0`. If it's a fractional number, it is rounded to the nearest integer. + * @returns {(...args: any[]) => ReturnType} - A new function that takes multiple arguments, including an array of arguments at the specified `argsIndex`, + * and returns the result of calling the original function with those arguments. + * + * @example + * function add(a, b) { + * return a + b; + * } + * + * const spreadAdd = spread(add); + * console.log(spreadAdd([1, 2])); // Output: 3 + * + * @example + * // Example function to spread arguments over + * function add(a, b) { + * return a + b; + * } + * + * // Create a new function that uses `spread` to combine arguments + * const spreadAdd = spread(add, 1); + * + * // Calling `spreadAdd` with an array as the second argument + * console.log(spreadAdd(1, [2])); // Output: 3 + * + * @example + * // Function with default arguments + * function greet(name, greeting = 'Hello') { + * return `${greeting}, ${name}!`; + * } + * + * // Create a new function that uses `spread` to position the argument array at index 0 + * const spreadGreet = spread(greet, 0); + * + * // Calling `spreadGreet` with an array of arguments + * console.log(spreadGreet(['Alice'])); // Output: Hello, Alice! + * console.log(spreadGreet(['Bob', 'Hi'])); // Output: Hi, Bob! + */ +declare function spread(func: (...args: any[]) => R, argsIndex?: number): (...args: any[]) => R; + +export { spread }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.js new file mode 100644 index 0000000000000000000000000000000000000000..af095569742fe2ef5ea6011e522b05d10954b448 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function spread(func, argsIndex = 0) { + argsIndex = Number.parseInt(argsIndex, 10); + if (Number.isNaN(argsIndex) || argsIndex < 0) { + argsIndex = 0; + } + return function (...args) { + const array = args[argsIndex]; + const params = args.slice(0, argsIndex); + if (array) { + params.push(...array); + } + return func.apply(this, params); + }; +} + +exports.spread = spread; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.mjs new file mode 100644 index 0000000000000000000000000000000000000000..149cd2aba994fe5d02cf82cd2d6523b4e9694edc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/spread.mjs @@ -0,0 +1,16 @@ +function spread(func, argsIndex = 0) { + argsIndex = Number.parseInt(argsIndex, 10); + if (Number.isNaN(argsIndex) || argsIndex < 0) { + argsIndex = 0; + } + return function (...args) { + const array = args[argsIndex]; + const params = args.slice(0, argsIndex); + if (array) { + params.push(...array); + } + return func.apply(this, params); + }; +} + +export { spread }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f09d0ecedf5e36313581a247c6b6613812d26815 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.d.mts @@ -0,0 +1,81 @@ +import { DebouncedFuncLeading, DebouncedFunc } from './debounce.mjs'; + +interface ThrottleSettings { + /** + * If `true`, the function will be invoked on the leading edge of the timeout. + * @default true + */ + leading?: boolean | undefined; + /** + * If `true`, the function will be invoked on the trailing edge of the timeout. + * @default true + */ + trailing?: boolean | undefined; +} +type ThrottleSettingsLeading = (ThrottleSettings & { + leading: true; +}) | Omit; +/** + * Creates a throttled function that only invokes the provided function at most once + * per every `throttleMs` milliseconds. Subsequent calls to the throttled function + * within the wait time will not trigger the execution of the original function. + * + * @template F - The type of function. + * @param {F} func - The function to throttle. + * @param {number} throttleMs - The number of milliseconds to throttle executions to. + * @param {ThrottleOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @returns {(...args: Parameters) => void} A new throttled function that accepts the same parameters as the original function. + * + * @example + * const throttledFunction = throttle(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' immediately + * throttledFunction(); + * + * // Will not log anything as it is within the throttle time + * throttledFunction(); + * + * // After 1 second + * setTimeout(() => { + * throttledFunction(); // Will log 'Function executed' + * }, 1000); + */ +declare function throttle any>(func: T, throttleMs?: number, options?: ThrottleSettingsLeading): DebouncedFuncLeading; +/** + * Creates a throttled function that only invokes the provided function at most once + * per every `throttleMs` milliseconds. Subsequent calls to the throttled function + * within the wait time will not trigger the execution of the original function. + * + * @template F - The type of function. + * @param {F} func - The function to throttle. + * @param {number} throttleMs - The number of milliseconds to throttle executions to. + * @param {ThrottleOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @returns {(...args: Parameters) => void} A new throttled function that accepts the same parameters as the original function. + * + * @example + * const throttledFunction = throttle(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' immediately + * throttledFunction(); + * + * // Will not log anything as it is within the throttle time + * throttledFunction(); + * + * // After 1 second + * setTimeout(() => { + * throttledFunction(); // Will log 'Function executed' + * }, 1000); + */ +declare function throttle any>(func: T, throttleMs?: number, options?: ThrottleSettings): DebouncedFunc; + +export { throttle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..00044f421d4e4431264702a769a6dcfbd76f6065 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.d.ts @@ -0,0 +1,81 @@ +import { DebouncedFuncLeading, DebouncedFunc } from './debounce.js'; + +interface ThrottleSettings { + /** + * If `true`, the function will be invoked on the leading edge of the timeout. + * @default true + */ + leading?: boolean | undefined; + /** + * If `true`, the function will be invoked on the trailing edge of the timeout. + * @default true + */ + trailing?: boolean | undefined; +} +type ThrottleSettingsLeading = (ThrottleSettings & { + leading: true; +}) | Omit; +/** + * Creates a throttled function that only invokes the provided function at most once + * per every `throttleMs` milliseconds. Subsequent calls to the throttled function + * within the wait time will not trigger the execution of the original function. + * + * @template F - The type of function. + * @param {F} func - The function to throttle. + * @param {number} throttleMs - The number of milliseconds to throttle executions to. + * @param {ThrottleOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @returns {(...args: Parameters) => void} A new throttled function that accepts the same parameters as the original function. + * + * @example + * const throttledFunction = throttle(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' immediately + * throttledFunction(); + * + * // Will not log anything as it is within the throttle time + * throttledFunction(); + * + * // After 1 second + * setTimeout(() => { + * throttledFunction(); // Will log 'Function executed' + * }, 1000); + */ +declare function throttle any>(func: T, throttleMs?: number, options?: ThrottleSettingsLeading): DebouncedFuncLeading; +/** + * Creates a throttled function that only invokes the provided function at most once + * per every `throttleMs` milliseconds. Subsequent calls to the throttled function + * within the wait time will not trigger the execution of the original function. + * + * @template F - The type of function. + * @param {F} func - The function to throttle. + * @param {number} throttleMs - The number of milliseconds to throttle executions to. + * @param {ThrottleOptions} options - The options object + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function. + * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout. + * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout. + * @returns {(...args: Parameters) => void} A new throttled function that accepts the same parameters as the original function. + * + * @example + * const throttledFunction = throttle(() => { + * console.log('Function executed'); + * }, 1000); + * + * // Will log 'Function executed' immediately + * throttledFunction(); + * + * // Will not log anything as it is within the throttle time + * throttledFunction(); + * + * // After 1 second + * setTimeout(() => { + * throttledFunction(); // Will log 'Function executed' + * }, 1000); + */ +declare function throttle any>(func: T, throttleMs?: number, options?: ThrottleSettings): DebouncedFunc; + +export { throttle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.js new file mode 100644 index 0000000000000000000000000000000000000000..d60a2070af7407cfb5261e8d2002b930a97d5a79 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const debounce = require('./debounce.js'); + +function throttle(func, throttleMs = 0, options = {}) { + const { leading = true, trailing = true } = options; + return debounce.debounce(func, throttleMs, { + leading, + maxWait: throttleMs, + trailing, + }); +} + +exports.throttle = throttle; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e0fb53e97a5bcb9a749232ec8da13e24e445690b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/throttle.mjs @@ -0,0 +1,12 @@ +import { debounce } from './debounce.mjs'; + +function throttle(func, throttleMs = 0, options = {}) { + const { leading = true, trailing = true } = options; + return debounce(func, throttleMs, { + leading, + maxWait: throttleMs, + trailing, + }); +} + +export { throttle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..47084000041b2b0203630bb024663154bcb0bb4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.d.mts @@ -0,0 +1,17 @@ +/** + * Creates a function that accepts up to one argument, ignoring any additional arguments. + * + * @template F - The type of the function. + * @param {F} func - The function to cap arguments for. + * @returns {(...args: any[]) => ReturnType} Returns the new capped function. + * + * @example + * function fn(a, b, c) { + * console.log(arguments); + * } + * + * unary(fn)(1, 2, 3); // [Arguments] { '0': 1 } + */ +declare function unary(func: (arg1: T, ...args: any[]) => U): (arg1: T) => U; + +export { unary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..47084000041b2b0203630bb024663154bcb0bb4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.d.ts @@ -0,0 +1,17 @@ +/** + * Creates a function that accepts up to one argument, ignoring any additional arguments. + * + * @template F - The type of the function. + * @param {F} func - The function to cap arguments for. + * @returns {(...args: any[]) => ReturnType} Returns the new capped function. + * + * @example + * function fn(a, b, c) { + * console.log(arguments); + * } + * + * unary(fn)(1, 2, 3); // [Arguments] { '0': 1 } + */ +declare function unary(func: (arg1: T, ...args: any[]) => U): (arg1: T) => U; + +export { unary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.js new file mode 100644 index 0000000000000000000000000000000000000000..d56f0566038ef80344587bb79411daadd1e766b2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const ary = require('./ary.js'); + +function unary(func) { + return ary.ary(func, 1); +} + +exports.unary = unary; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f4b2cb1d6c1222069ff38e7d4de6800711609f87 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/unary.mjs @@ -0,0 +1,7 @@ +import { ary } from './ary.mjs'; + +function unary(func) { + return ary(func, 1); +} + +export { unary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ed5129287b1c9dde7e405df337c0ab966590b930 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.d.mts @@ -0,0 +1,20 @@ +/** + * Creates a new function that wraps the given function `func`. + * In this process, you can apply additional logic defined in the `wrapper` function before and after the execution of the original function. + * + * If a `value` is provided instead of a function, this value is passed as the first argument to the `wrapper` function. + * + * @example + * // Wrap a function + * const greet = (name: string) => `Hi, ${name}`; + * const wrapped = wrap(greet, (value, name) => `[LOG] ${value(name)}`); + * wrapped('Bob'); // => "[LOG] Hi, Bob" + * + * @example + * // Wrap a primitive value + * const wrapped = wrap('value', v => `

${v}

`); + * wrapped(); // => "

value

" + */ +declare function wrap(value: T, wrapper: (value: T, ...args: U[]) => V): (...args: U[]) => V; + +export { wrap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ed5129287b1c9dde7e405df337c0ab966590b930 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.d.ts @@ -0,0 +1,20 @@ +/** + * Creates a new function that wraps the given function `func`. + * In this process, you can apply additional logic defined in the `wrapper` function before and after the execution of the original function. + * + * If a `value` is provided instead of a function, this value is passed as the first argument to the `wrapper` function. + * + * @example + * // Wrap a function + * const greet = (name: string) => `Hi, ${name}`; + * const wrapped = wrap(greet, (value, name) => `[LOG] ${value(name)}`); + * wrapped('Bob'); // => "[LOG] Hi, Bob" + * + * @example + * // Wrap a primitive value + * const wrapped = wrap('value', v => `

${v}

`); + * wrapped(); // => "

value

" + */ +declare function wrap(value: T, wrapper: (value: T, ...args: U[]) => V): (...args: U[]) => V; + +export { wrap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.js new file mode 100644 index 0000000000000000000000000000000000000000..4c52f01d7fa0843a7d5b54ace296ac483348c772 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const isFunction = require('../../predicate/isFunction.js'); + +function wrap(value, wrapper) { + return function (...args) { + const wrapFn = isFunction.isFunction(wrapper) ? wrapper : identity.identity; + return wrapFn.apply(this, [value, ...args]); + }; +} + +exports.wrap = wrap; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1104804b05866a2e0f0ba409e579fa1bcb553422 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/function/wrap.mjs @@ -0,0 +1,11 @@ +import { identity } from '../../function/identity.mjs'; +import { isFunction } from '../../predicate/isFunction.mjs'; + +function wrap(value, wrapper) { + return function (...args) { + const wrapFn = isFunction(wrapper) ? wrapper : identity; + return wrapFn.apply(this, [value, ...args]); + }; +} + +export { wrap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7e6b365e8309f0579b7a323a13da60b34ce00828 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.d.mts @@ -0,0 +1,18 @@ +/** + * Adds two numbers while safely handling `NaN` values. + * + * This function takes two numbers and returns their sum. If either of the numbers is `NaN`, + * the function returns `NaN`. + * + * @param {number} value - The first number to add. + * @param {number} other - The second number to add. + * @returns {number} The sum of the two numbers, or `NaN` if any input is `NaN`. + * + * @example + * const result1 = add(2, 3); // result1 will be 5 + * const result2 = add(5, NaN); // result2 will be NaN + * const result3 = add(NaN, 10); // result3 will be NaN + */ +declare function add(value: number, other: number): number; + +export { add }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7e6b365e8309f0579b7a323a13da60b34ce00828 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.d.ts @@ -0,0 +1,18 @@ +/** + * Adds two numbers while safely handling `NaN` values. + * + * This function takes two numbers and returns their sum. If either of the numbers is `NaN`, + * the function returns `NaN`. + * + * @param {number} value - The first number to add. + * @param {number} other - The second number to add. + * @returns {number} The sum of the two numbers, or `NaN` if any input is `NaN`. + * + * @example + * const result1 = add(2, 3); // result1 will be 5 + * const result2 = add(5, NaN); // result2 will be NaN + * const result3 = add(NaN, 10); // result3 will be NaN + */ +declare function add(value: number, other: number): number; + +export { add }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.js new file mode 100644 index 0000000000000000000000000000000000000000..e50f0c2289f11b93674eb926cba5361fe3cd0020 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('../util/toNumber.js'); +const toString = require('../util/toString.js'); + +function add(value, other) { + if (value === undefined && other === undefined) { + return 0; + } + if (value === undefined || other === undefined) { + return value ?? other; + } + if (typeof value === 'string' || typeof other === 'string') { + value = toString.toString(value); + other = toString.toString(other); + } + else { + value = toNumber.toNumber(value); + other = toNumber.toNumber(other); + } + return value + other; +} + +exports.add = add; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fbaca9eae163452d9ec025f9c14003185dc61c01 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/add.mjs @@ -0,0 +1,22 @@ +import { toNumber } from '../util/toNumber.mjs'; +import { toString } from '../util/toString.mjs'; + +function add(value, other) { + if (value === undefined && other === undefined) { + return 0; + } + if (value === undefined || other === undefined) { + return value ?? other; + } + if (typeof value === 'string' || typeof other === 'string') { + value = toString(value); + other = toString(other); + } + else { + value = toNumber(value); + other = toNumber(other); + } + return value + other; +} + +export { add }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..54145cf6965b899b6b5dcefb32027e5a63f5dd69 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.d.mts @@ -0,0 +1,15 @@ +/** + * Computes number rounded up to precision. + * + * @param {number | string} number The number to round up. + * @param {number | string} precision The precision to round up to. + * @returns {number} Returns the rounded up number. + * + * @example + * ceil(4.006); // => 5 + * ceil(6.004, 2); // => 6.01 + * ceil(6040, -2); // => 6100 + */ +declare function ceil(number: number, precision?: number): number; + +export { ceil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..54145cf6965b899b6b5dcefb32027e5a63f5dd69 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.d.ts @@ -0,0 +1,15 @@ +/** + * Computes number rounded up to precision. + * + * @param {number | string} number The number to round up. + * @param {number | string} precision The precision to round up to. + * @returns {number} Returns the rounded up number. + * + * @example + * ceil(4.006); // => 5 + * ceil(6.004, 2); // => 6.01 + * ceil(6040, -2); // => 6100 + */ +declare function ceil(number: number, precision?: number): number; + +export { ceil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.js new file mode 100644 index 0000000000000000000000000000000000000000..b5740c131f8049a515ab9dd841a48435597f61e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const decimalAdjust = require('../_internal/decimalAdjust.js'); + +function ceil(number, precision = 0) { + return decimalAdjust.decimalAdjust('ceil', number, precision); +} + +exports.ceil = ceil; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.mjs new file mode 100644 index 0000000000000000000000000000000000000000..55bf7035b131b07b2851003f9f78edf0cfa68d01 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/ceil.mjs @@ -0,0 +1,7 @@ +import { decimalAdjust } from '../_internal/decimalAdjust.mjs'; + +function ceil(number, precision = 0) { + return decimalAdjust('ceil', number, precision); +} + +export { ceil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..76a1294aaf87b656022b4e8bba729c71fd1cd127 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.d.mts @@ -0,0 +1,26 @@ +/** + * Clamps a number within the specified bounds. + * + * @param {number} number The number to clamp + * @param {number} lower The lower bound + * @param {number} upper The upper bound + * @returns {number} Returns the clamped number + * @example + * clamp(3, 2, 4) // => 3 + * clamp(0, 5, 10) // => 5 + * clamp(15, 5, 10) // => 10 + */ +declare function clamp(number: number, lower: number, upper: number): number; +/** + * Clamps a number to an upper bound. + * + * @param {number} number The number to clamp + * @param {number} upper The upper bound + * @returns {number} Returns the clamped number + * @example + * clamp(5, 3) // => 3 + * clamp(2, 3) // => 2 + */ +declare function clamp(number: number, upper: number): number; + +export { clamp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..76a1294aaf87b656022b4e8bba729c71fd1cd127 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.d.ts @@ -0,0 +1,26 @@ +/** + * Clamps a number within the specified bounds. + * + * @param {number} number The number to clamp + * @param {number} lower The lower bound + * @param {number} upper The upper bound + * @returns {number} Returns the clamped number + * @example + * clamp(3, 2, 4) // => 3 + * clamp(0, 5, 10) // => 5 + * clamp(15, 5, 10) // => 10 + */ +declare function clamp(number: number, lower: number, upper: number): number; +/** + * Clamps a number to an upper bound. + * + * @param {number} number The number to clamp + * @param {number} upper The upper bound + * @returns {number} Returns the clamped number + * @example + * clamp(5, 3) // => 3 + * clamp(2, 3) // => 2 + */ +declare function clamp(number: number, upper: number): number; + +export { clamp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.js new file mode 100644 index 0000000000000000000000000000000000000000..9ccb206c2f04692b78cd861c841d50a70e259542 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const clamp$1 = require('../../math/clamp.js'); + +function clamp(value, bound1, bound2) { + if (Number.isNaN(bound1)) { + bound1 = 0; + } + if (Number.isNaN(bound2)) { + bound2 = 0; + } + return clamp$1.clamp(value, bound1, bound2); +} + +exports.clamp = clamp; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.mjs new file mode 100644 index 0000000000000000000000000000000000000000..597ac8e0ee13d3dede22246abf6eec4f4dca760c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/clamp.mjs @@ -0,0 +1,13 @@ +import { clamp as clamp$1 } from '../../math/clamp.mjs'; + +function clamp(value, bound1, bound2) { + if (Number.isNaN(bound1)) { + bound1 = 0; + } + if (Number.isNaN(bound2)) { + bound2 = 0; + } + return clamp$1(value, bound1, bound2); +} + +export { clamp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..64e73536e0b92e015913cee3e4461a83370d68ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.d.mts @@ -0,0 +1,18 @@ +/** + * Divide two numbers. + * + * If either of the numbers is `NaN`, the function returns `NaN`. + * + * @param {number} value The first number in a division. + * @param {number} other The second number in a division. + * @returns {number} The quotient of value and other. + * + * @example + * divide(6, 3); // => 2 + * divide(2, NaN); // => NaN + * divide(NaN, 3); // => NaN + * divide(NaN, NaN); // => NaN + */ +declare function divide(value: number, other: number): number; + +export { divide }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..64e73536e0b92e015913cee3e4461a83370d68ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.d.ts @@ -0,0 +1,18 @@ +/** + * Divide two numbers. + * + * If either of the numbers is `NaN`, the function returns `NaN`. + * + * @param {number} value The first number in a division. + * @param {number} other The second number in a division. + * @returns {number} The quotient of value and other. + * + * @example + * divide(6, 3); // => 2 + * divide(2, NaN); // => NaN + * divide(NaN, 3); // => NaN + * divide(NaN, NaN); // => NaN + */ +declare function divide(value: number, other: number): number; + +export { divide }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.js new file mode 100644 index 0000000000000000000000000000000000000000..c9f6cec412b8088c2c01ca198b76b92e661ef487 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('../util/toNumber.js'); +const toString = require('../util/toString.js'); + +function divide(value, other) { + if (value === undefined && other === undefined) { + return 1; + } + if (value === undefined || other === undefined) { + return value ?? other; + } + if (typeof value === 'string' || typeof other === 'string') { + value = toString.toString(value); + other = toString.toString(other); + } + else { + value = toNumber.toNumber(value); + other = toNumber.toNumber(other); + } + return value / other; +} + +exports.divide = divide; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.mjs new file mode 100644 index 0000000000000000000000000000000000000000..68802a2e04acb8ca0b498126b1952cd0b0046c28 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/divide.mjs @@ -0,0 +1,22 @@ +import { toNumber } from '../util/toNumber.mjs'; +import { toString } from '../util/toString.mjs'; + +function divide(value, other) { + if (value === undefined && other === undefined) { + return 1; + } + if (value === undefined || other === undefined) { + return value ?? other; + } + if (typeof value === 'string' || typeof other === 'string') { + value = toString(value); + other = toString(other); + } + else { + value = toNumber(value); + other = toNumber(other); + } + return value / other; +} + +export { divide }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1b808da30cc28eeb11fc3e2a6d5f62894752422a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.d.mts @@ -0,0 +1,15 @@ +/** + * Computes number rounded down to precision. + * + * @param {number | string} number The number to round down. + * @param {number | string} precision The precision to round down to. + * @returns {number} Returns the rounded down number. + * + * @example + * floor(4.006); // => 4 + * floor(0.046, 2); // => 0.04 + * floor(4060, -2); // => 4000 + */ +declare function floor(number: number, precision?: number): number; + +export { floor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1b808da30cc28eeb11fc3e2a6d5f62894752422a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.d.ts @@ -0,0 +1,15 @@ +/** + * Computes number rounded down to precision. + * + * @param {number | string} number The number to round down. + * @param {number | string} precision The precision to round down to. + * @returns {number} Returns the rounded down number. + * + * @example + * floor(4.006); // => 4 + * floor(0.046, 2); // => 0.04 + * floor(4060, -2); // => 4000 + */ +declare function floor(number: number, precision?: number): number; + +export { floor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.js new file mode 100644 index 0000000000000000000000000000000000000000..5065045b867fec10aa641a315c72232ecab69b48 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const decimalAdjust = require('../_internal/decimalAdjust.js'); + +function floor(number, precision = 0) { + return decimalAdjust.decimalAdjust('floor', number, precision); +} + +exports.floor = floor; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0c39324375de7878d694f4c69eb499be38fb472e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/floor.mjs @@ -0,0 +1,7 @@ +import { decimalAdjust } from '../_internal/decimalAdjust.mjs'; + +function floor(number, precision = 0) { + return decimalAdjust('floor', number, precision); +} + +export { floor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bb5d0035dcc6f2026ae229c222cc3abd6b367c35 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.d.mts @@ -0,0 +1,17 @@ +/** + * Checks if the value is within a specified range. + * + * @param {number} value The value to check. + * @param {number} minimum The lower bound of the range (inclusive). + * @param {number} maximum The upper bound of the range (exclusive). + * @returns {boolean} `true` if the value is within the specified range, otherwise `false`. + * @throws {Error} Throws an error if the `minimum` is greater or equal than the `maximum`. + * + * @example + * const result1 = inRange(3, 5); // result1 will be true. + * const result2 = inRange(1, 2, 5); // result2 will be false. + * const result3 = inRange(1, 5, 2); // If the minimum is greater or equal than the maximum, an error is thrown. + */ +declare function inRange(value: number, minimum: number, maximum?: number): boolean; + +export { inRange }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bb5d0035dcc6f2026ae229c222cc3abd6b367c35 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.d.ts @@ -0,0 +1,17 @@ +/** + * Checks if the value is within a specified range. + * + * @param {number} value The value to check. + * @param {number} minimum The lower bound of the range (inclusive). + * @param {number} maximum The upper bound of the range (exclusive). + * @returns {boolean} `true` if the value is within the specified range, otherwise `false`. + * @throws {Error} Throws an error if the `minimum` is greater or equal than the `maximum`. + * + * @example + * const result1 = inRange(3, 5); // result1 will be true. + * const result2 = inRange(1, 2, 5); // result2 will be false. + * const result3 = inRange(1, 5, 2); // If the minimum is greater or equal than the maximum, an error is thrown. + */ +declare function inRange(value: number, minimum: number, maximum?: number): boolean; + +export { inRange }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.js new file mode 100644 index 0000000000000000000000000000000000000000..025fcdf9aa6d3e64099c915a3bb9586968cb360d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.js @@ -0,0 +1,32 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const inRange$1 = require('../../math/inRange.js'); + +function inRange(value, minimum, maximum) { + if (!minimum) { + minimum = 0; + } + if (maximum != null && !maximum) { + maximum = 0; + } + if (minimum != null && typeof minimum !== 'number') { + minimum = Number(minimum); + } + if (maximum == null && minimum === 0) { + return false; + } + if (maximum != null && typeof maximum !== 'number') { + maximum = Number(maximum); + } + if (maximum != null && minimum > maximum) { + [minimum, maximum] = [maximum, minimum]; + } + if (minimum === maximum) { + return false; + } + return inRange$1.inRange(value, minimum, maximum); +} + +exports.inRange = inRange; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.mjs new file mode 100644 index 0000000000000000000000000000000000000000..59adc2083a74f0ef0c0cd422d746b95e19d56c82 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/inRange.mjs @@ -0,0 +1,28 @@ +import { inRange as inRange$1 } from '../../math/inRange.mjs'; + +function inRange(value, minimum, maximum) { + if (!minimum) { + minimum = 0; + } + if (maximum != null && !maximum) { + maximum = 0; + } + if (minimum != null && typeof minimum !== 'number') { + minimum = Number(minimum); + } + if (maximum == null && minimum === 0) { + return false; + } + if (maximum != null && typeof maximum !== 'number') { + maximum = Number(maximum); + } + if (maximum != null && minimum > maximum) { + [minimum, maximum] = [maximum, minimum]; + } + if (minimum === maximum) { + return false; + } + return inRange$1(value, minimum, maximum); +} + +export { inRange }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..75d8a19ad08b003e5a311e04d06347b9c5e4456a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.d.mts @@ -0,0 +1,10 @@ +/** + * Finds the element in an array that has the maximum value. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} [items] - The array of elements to search. Defaults to an empty array. + * @returns {T | undefined} - The element with the maximum value, or undefined if the array is empty. + */ +declare function max(items: ArrayLike | null | undefined): T | undefined; + +export { max }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..75d8a19ad08b003e5a311e04d06347b9c5e4456a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.d.ts @@ -0,0 +1,10 @@ +/** + * Finds the element in an array that has the maximum value. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} [items] - The array of elements to search. Defaults to an empty array. + * @returns {T | undefined} - The element with the maximum value, or undefined if the array is empty. + */ +declare function max(items: ArrayLike | null | undefined): T | undefined; + +export { max }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.js new file mode 100644 index 0000000000000000000000000000000000000000..2d20ec180ee965fe8c6f8628a5389c9249a50352 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function max(items) { + if (!items || items.length === 0) { + return undefined; + } + let maxResult = undefined; + for (let i = 0; i < items.length; i++) { + const current = items[i]; + if (current == null || Number.isNaN(current) || typeof current === 'symbol') { + continue; + } + if (maxResult === undefined || current > maxResult) { + maxResult = current; + } + } + return maxResult; +} + +exports.max = max; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.mjs new file mode 100644 index 0000000000000000000000000000000000000000..89c70542b017a6d3d1d8795c02a36d5d029ba497 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/max.mjs @@ -0,0 +1,18 @@ +function max(items) { + if (!items || items.length === 0) { + return undefined; + } + let maxResult = undefined; + for (let i = 0; i < items.length; i++) { + const current = items[i]; + if (current == null || Number.isNaN(current) || typeof current === 'symbol') { + continue; + } + if (maxResult === undefined || current > maxResult) { + maxResult = current; + } + } + return maxResult; +} + +export { max }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c3c676c5f0201760384a2acd9ec6c64d888fdde7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.d.mts @@ -0,0 +1,33 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Finds the element in an array that has the maximum value when applying + * the `iteratee` to each element. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} items The array of elements to search. + * @param {ValueIteratee} iteratee + * The criteria used to determine the maximum value. + * - If a **function** is provided, it extracts a numeric value from each element. + * - If a **string** is provided, it is treated as a key to extract values from the objects. + * - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair. + * - If an **object** is provided, it matches elements that contain the specified properties. + * @returns {T | undefined} The element with the maximum value as determined by the `iteratee`. + * @example + * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 } + * maxBy([], x => x.a); // Returns: undefined + * maxBy( + * [ + * { name: 'john', age: 30 }, + * { name: 'jane', age: 28 }, + * { name: 'joe', age: 26 }, + * ], + * x => x.age + * ); // Returns: { name: 'john', age: 30 } + * maxBy([{ a: 1 }, { a: 2 }], 'a'); // Returns: { a: 2 } + * maxBy([{ a: 1 }, { a: 2 }], ['a', 1]); // Returns: { a: 1 } + * maxBy([{ a: 1 }, { a: 2 }], { a: 1 }); // Returns: { a: 1 } + */ +declare function maxBy(items: ArrayLike | null | undefined, iteratee?: ValueIteratee): T | undefined; + +export { maxBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..37c6c8c830a782b4a0140aec7b4446797c08db47 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.d.ts @@ -0,0 +1,33 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Finds the element in an array that has the maximum value when applying + * the `iteratee` to each element. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} items The array of elements to search. + * @param {ValueIteratee} iteratee + * The criteria used to determine the maximum value. + * - If a **function** is provided, it extracts a numeric value from each element. + * - If a **string** is provided, it is treated as a key to extract values from the objects. + * - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair. + * - If an **object** is provided, it matches elements that contain the specified properties. + * @returns {T | undefined} The element with the maximum value as determined by the `iteratee`. + * @example + * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 } + * maxBy([], x => x.a); // Returns: undefined + * maxBy( + * [ + * { name: 'john', age: 30 }, + * { name: 'jane', age: 28 }, + * { name: 'joe', age: 26 }, + * ], + * x => x.age + * ); // Returns: { name: 'john', age: 30 } + * maxBy([{ a: 1 }, { a: 2 }], 'a'); // Returns: { a: 2 } + * maxBy([{ a: 1 }, { a: 2 }], ['a', 1]); // Returns: { a: 1 } + * maxBy([{ a: 1 }, { a: 2 }], { a: 1 }); // Returns: { a: 1 } + */ +declare function maxBy(items: ArrayLike | null | undefined, iteratee?: ValueIteratee): T | undefined; + +export { maxBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.js new file mode 100644 index 0000000000000000000000000000000000000000..33facd36a35e260e6d4ad0324169170b09267d90 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const maxBy$1 = require('../../array/maxBy.js'); +const identity = require('../../function/identity.js'); +const iteratee = require('../util/iteratee.js'); + +function maxBy(items, iteratee$1) { + if (items == null) { + return undefined; + } + return maxBy$1.maxBy(Array.from(items), iteratee.iteratee(iteratee$1 ?? identity.identity)); +} + +exports.maxBy = maxBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6fe836fd76d829a03637af1408befbd53b09dd51 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/maxBy.mjs @@ -0,0 +1,12 @@ +import { maxBy as maxBy$1 } from '../../array/maxBy.mjs'; +import { identity } from '../../function/identity.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function maxBy(items, iteratee$1) { + if (items == null) { + return undefined; + } + return maxBy$1(Array.from(items), iteratee(iteratee$1 ?? identity)); +} + +export { maxBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a379ec26700ee4f3899448e447e79930f73614e6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.d.mts @@ -0,0 +1,16 @@ +/** + * Calculates the average of an array of numbers. + * + * If the array is empty, this function returns `NaN`. + * + * @param {ArrayLike | null | undefined} nums - An array of numbers to calculate the average. + * @returns {number} The average of all the numbers in the array. + * + * @example + * const numbers = [1, 2, 3, 4, 5]; + * const result = mean(numbers); + * // result will be 3 + */ +declare function mean(nums: ArrayLike | null | undefined): number; + +export { mean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a379ec26700ee4f3899448e447e79930f73614e6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.d.ts @@ -0,0 +1,16 @@ +/** + * Calculates the average of an array of numbers. + * + * If the array is empty, this function returns `NaN`. + * + * @param {ArrayLike | null | undefined} nums - An array of numbers to calculate the average. + * @returns {number} The average of all the numbers in the array. + * + * @example + * const numbers = [1, 2, 3, 4, 5]; + * const result = mean(numbers); + * // result will be 3 + */ +declare function mean(nums: ArrayLike | null | undefined): number; + +export { mean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.js new file mode 100644 index 0000000000000000000000000000000000000000..17e17f0ccc476e4e8a36197fe9e02104cbe12591 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const sum = require('./sum.js'); + +function mean(nums) { + const length = nums ? nums.length : 0; + return length === 0 ? NaN : sum.sum(nums) / length; +} + +exports.mean = mean; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5d14e00188aa1fd1fe293f36ef83f02b65349167 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/mean.mjs @@ -0,0 +1,8 @@ +import { sum } from './sum.mjs'; + +function mean(nums) { + const length = nums ? nums.length : 0; + return length === 0 ? NaN : sum(nums) / length; +} + +export { mean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5c7226958dfbe78713f0c71a0a082a3cdac339fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.d.mts @@ -0,0 +1,27 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Calculates the average of an array of numbers when applying + * the `iteratee` function to each element. + * + * If the array is empty, this function returns `NaN`. + * + * @template T - The type of elements in the array. + * @param {T[]} items An array to calculate the average. + * @param {((element: T) => unknown) | PropertyKey | [PropertyKey, any] | PartialShallow} iteratee + * The criteria used to determine the maximum value. + * - If a **function** is provided, it extracts a numeric value from each element. + * - If a **string** is provided, it is treated as a key to extract values from the objects. + * - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair. + * - If an **object** is provided, it matches elements that contain the specified properties. + * @returns {number} The average of all the numbers as determined by the `iteratee` function. + * + * @example + * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2 + * meanBy([], x => x.a); // Returns: NaN + * meanBy([[2], [3], [1]], 0); // Returns: 2 + * meanBy([{ a: 2 }, { a: 3 }, { a: 1 }], 'a'); // Returns: 2 + */ +declare function meanBy(items: ArrayLike | null | undefined, iteratee?: ValueIteratee): number; + +export { meanBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fcba15caff0f17498cb538cbcb550d6804034028 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.d.ts @@ -0,0 +1,27 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Calculates the average of an array of numbers when applying + * the `iteratee` function to each element. + * + * If the array is empty, this function returns `NaN`. + * + * @template T - The type of elements in the array. + * @param {T[]} items An array to calculate the average. + * @param {((element: T) => unknown) | PropertyKey | [PropertyKey, any] | PartialShallow} iteratee + * The criteria used to determine the maximum value. + * - If a **function** is provided, it extracts a numeric value from each element. + * - If a **string** is provided, it is treated as a key to extract values from the objects. + * - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair. + * - If an **object** is provided, it matches elements that contain the specified properties. + * @returns {number} The average of all the numbers as determined by the `iteratee` function. + * + * @example + * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2 + * meanBy([], x => x.a); // Returns: NaN + * meanBy([[2], [3], [1]], 0); // Returns: 2 + * meanBy([{ a: 2 }, { a: 3 }, { a: 1 }], 'a'); // Returns: 2 + */ +declare function meanBy(items: ArrayLike | null | undefined, iteratee?: ValueIteratee): number; + +export { meanBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.js new file mode 100644 index 0000000000000000000000000000000000000000..b71ea0b2d7c0f37829563ee03f4d5092a6705cda --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const meanBy$1 = require('../../math/meanBy.js'); +const iteratee = require('../util/iteratee.js'); + +function meanBy(items, iteratee$1) { + if (items == null) { + return NaN; + } + return meanBy$1.meanBy(Array.from(items), iteratee.iteratee(iteratee$1 ?? identity.identity)); +} + +exports.meanBy = meanBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0a7f2754ff4ab19e9cc901af087e44ce6594fc4b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/meanBy.mjs @@ -0,0 +1,12 @@ +import { identity } from '../../function/identity.mjs'; +import { meanBy as meanBy$1 } from '../../math/meanBy.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function meanBy(items, iteratee$1) { + if (items == null) { + return NaN; + } + return meanBy$1(Array.from(items), iteratee(iteratee$1 ?? identity)); +} + +export { meanBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..78b2fb4c8834c2069e3e5f51e7c5cfa98a551d01 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.d.mts @@ -0,0 +1,10 @@ +/** + * Finds the element in an array that has the minimum value. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} [items] - The array of elements to search. Defaults to an empty array. + * @returns {T | undefined} - The element with the minimum value, or undefined if the array is empty. + */ +declare function min(items: ArrayLike | null | undefined): T | undefined; + +export { min }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..78b2fb4c8834c2069e3e5f51e7c5cfa98a551d01 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.d.ts @@ -0,0 +1,10 @@ +/** + * Finds the element in an array that has the minimum value. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} [items] - The array of elements to search. Defaults to an empty array. + * @returns {T | undefined} - The element with the minimum value, or undefined if the array is empty. + */ +declare function min(items: ArrayLike | null | undefined): T | undefined; + +export { min }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.js new file mode 100644 index 0000000000000000000000000000000000000000..1386632cc48c81ea33285bb5a22a58973420e121 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function min(items) { + if (!items || items.length === 0) { + return undefined; + } + let minResult = undefined; + for (let i = 0; i < items.length; i++) { + const current = items[i]; + if (current == null || Number.isNaN(current) || typeof current === 'symbol') { + continue; + } + if (minResult === undefined || current < minResult) { + minResult = current; + } + } + return minResult; +} + +exports.min = min; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6abde6a9248b45f2d4758f80d2229faa8c9d683f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/min.mjs @@ -0,0 +1,18 @@ +function min(items) { + if (!items || items.length === 0) { + return undefined; + } + let minResult = undefined; + for (let i = 0; i < items.length; i++) { + const current = items[i]; + if (current == null || Number.isNaN(current) || typeof current === 'symbol') { + continue; + } + if (minResult === undefined || current < minResult) { + minResult = current; + } + } + return minResult; +} + +export { min }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ebb103ad4a7e064d57fee2db405b5658f0738564 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.d.mts @@ -0,0 +1,33 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Finds the element in an array that has the minium value when applying + * the `iteratee` to each element. + * + * @template T - The type of elements in the array. + * @param {T[]} items The array of elements to search. + * @param {((element: T) => number) | keyof T | [keyof T, unknown] | Partial} iteratee + * The criteria used to determine the minium value. + * - If a **function** is provided, it extracts a numeric value from each element. + * - If a **string** is provided, it is treated as a key to extract values from the objects. + * - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair. + * - If an **object** is provided, it matches elements that contain the specified properties. + * @returns {T | undefined} The element with the minium value as determined by the `iteratee`. + * @example + * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 } + * minBy([], x => x.a); // Returns: undefined + * minBy( + * [ + * { name: 'john', age: 30 }, + * { name: 'jane', age: 28 }, + * { name: 'joe', age: 26 }, + * ], + * x => x.age + * ); // Returns: { name: 'joe', age: 26 } + * minBy([{ a: 1 }, { a: 2 }], 'a'); // Returns: { a: 1 } + * minBy([{ a: 1 }, { a: 2 }], ['a', 1]); // Returns: { a: 2 } + * minBy([{ a: 1 }, { a: 2 }], { a: 1 }); // Returns: { a: 2 } + */ +declare function minBy(items: ArrayLike | null | undefined, iteratee?: ValueIteratee): T | undefined; + +export { minBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b8a08a461390c668f1a079d15ff2ae88aed10bd4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.d.ts @@ -0,0 +1,33 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Finds the element in an array that has the minium value when applying + * the `iteratee` to each element. + * + * @template T - The type of elements in the array. + * @param {T[]} items The array of elements to search. + * @param {((element: T) => number) | keyof T | [keyof T, unknown] | Partial} iteratee + * The criteria used to determine the minium value. + * - If a **function** is provided, it extracts a numeric value from each element. + * - If a **string** is provided, it is treated as a key to extract values from the objects. + * - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair. + * - If an **object** is provided, it matches elements that contain the specified properties. + * @returns {T | undefined} The element with the minium value as determined by the `iteratee`. + * @example + * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 } + * minBy([], x => x.a); // Returns: undefined + * minBy( + * [ + * { name: 'john', age: 30 }, + * { name: 'jane', age: 28 }, + * { name: 'joe', age: 26 }, + * ], + * x => x.age + * ); // Returns: { name: 'joe', age: 26 } + * minBy([{ a: 1 }, { a: 2 }], 'a'); // Returns: { a: 1 } + * minBy([{ a: 1 }, { a: 2 }], ['a', 1]); // Returns: { a: 2 } + * minBy([{ a: 1 }, { a: 2 }], { a: 1 }); // Returns: { a: 2 } + */ +declare function minBy(items: ArrayLike | null | undefined, iteratee?: ValueIteratee): T | undefined; + +export { minBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.js new file mode 100644 index 0000000000000000000000000000000000000000..02cba407a71ceda102422e579378b343507d1696 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const minBy$1 = require('../../array/minBy.js'); +const identity = require('../../function/identity.js'); +const iteratee = require('../util/iteratee.js'); + +function minBy(items, iteratee$1) { + if (items == null) { + return undefined; + } + return minBy$1.minBy(Array.from(items), iteratee.iteratee(iteratee$1 ?? identity.identity)); +} + +exports.minBy = minBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a85e56d4bddec1ab77959785682f64f4f18b3530 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/minBy.mjs @@ -0,0 +1,12 @@ +import { minBy as minBy$1 } from '../../array/minBy.mjs'; +import { identity } from '../../function/identity.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function minBy(items, iteratee$1) { + if (items == null) { + return undefined; + } + return minBy$1(Array.from(items), iteratee(iteratee$1 ?? identity)); +} + +export { minBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f98fd58c9e0483a4279c53ef0ce4d76719a5e3d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.d.mts @@ -0,0 +1,18 @@ +/** + * Multiply two numbers. + * + * If either of the numbers is `NaN`, the function returns `NaN`. + * + * @param {number} value The first number in a multiplication + * @param {number} other The second number in a multiplication + * @returns {number} The product of value and other + * + * @example + * multiply(2, 3); // => 6 + * multiply(2, NaN); // => NaN + * multiply(NaN, 3); // => NaN + * multiply(NaN, NaN); // => NaN + */ +declare function multiply(value: number, other: number): number; + +export { multiply }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f98fd58c9e0483a4279c53ef0ce4d76719a5e3d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.d.ts @@ -0,0 +1,18 @@ +/** + * Multiply two numbers. + * + * If either of the numbers is `NaN`, the function returns `NaN`. + * + * @param {number} value The first number in a multiplication + * @param {number} other The second number in a multiplication + * @returns {number} The product of value and other + * + * @example + * multiply(2, 3); // => 6 + * multiply(2, NaN); // => NaN + * multiply(NaN, 3); // => NaN + * multiply(NaN, NaN); // => NaN + */ +declare function multiply(value: number, other: number): number; + +export { multiply }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.js new file mode 100644 index 0000000000000000000000000000000000000000..8896fe7d1bca5ad5b51e709bb8c00e97fb52df93 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('../util/toNumber.js'); +const toString = require('../util/toString.js'); + +function multiply(value, other) { + if (value === undefined && other === undefined) { + return 1; + } + if (value === undefined || other === undefined) { + return value ?? other; + } + if (typeof value === 'string' || typeof other === 'string') { + value = toString.toString(value); + other = toString.toString(other); + } + else { + value = toNumber.toNumber(value); + other = toNumber.toNumber(other); + } + return value * other; +} + +exports.multiply = multiply; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3684027806fe480a9a698c5a396c695554cce983 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/multiply.mjs @@ -0,0 +1,22 @@ +import { toNumber } from '../util/toNumber.mjs'; +import { toString } from '../util/toString.mjs'; + +function multiply(value, other) { + if (value === undefined && other === undefined) { + return 1; + } + if (value === undefined || other === undefined) { + return value ?? other; + } + if (typeof value === 'string' || typeof other === 'string') { + value = toString(value); + other = toString(other); + } + else { + value = toNumber(value); + other = toNumber(other); + } + return value * other; +} + +export { multiply }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..885b8471a6757c38a8de0609c2b8582b4efc4530 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.d.mts @@ -0,0 +1,20 @@ +/** + * Converts `string` to an integer of the specified radix. If `radix` is undefined or 0, a `radix` of 10 is used unless `string` is a hexadecimal, in which case a `radix` of 16 is used. + * + * @param {string} string The string to convert to an integer. + * @param {number} radix The radix to use when converting the string to an integer. Defaults to `0`. + * @param {unknown} guard Enables use as an iteratee for methods like `Array#map`. + * @returns {number} Returns the converted integer. + * + * @example + * parseInt('08'); // => 8 + * parseInt('0x20'); // => 32 + * + * parseInt('08', 10); // => 8 + * parseInt('0x20', 16); // => 32 + * + * ['6', '08', '10'].map(parseInt); // => [6, 8, 10] + */ +declare function parseInt(string: string, radix?: number): number; + +export { parseInt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..885b8471a6757c38a8de0609c2b8582b4efc4530 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.d.ts @@ -0,0 +1,20 @@ +/** + * Converts `string` to an integer of the specified radix. If `radix` is undefined or 0, a `radix` of 10 is used unless `string` is a hexadecimal, in which case a `radix` of 16 is used. + * + * @param {string} string The string to convert to an integer. + * @param {number} radix The radix to use when converting the string to an integer. Defaults to `0`. + * @param {unknown} guard Enables use as an iteratee for methods like `Array#map`. + * @returns {number} Returns the converted integer. + * + * @example + * parseInt('08'); // => 8 + * parseInt('0x20'); // => 32 + * + * parseInt('08', 10); // => 8 + * parseInt('0x20', 16); // => 32 + * + * ['6', '08', '10'].map(parseInt); // => [6, 8, 10] + */ +declare function parseInt(string: string, radix?: number): number; + +export { parseInt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9198095d87b4eaad6aac991c509571475e5562 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function parseInt(string, radix = 0, guard) { + if (guard) { + radix = 0; + } + return Number.parseInt(string, radix); +} + +exports.parseInt = parseInt; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.mjs new file mode 100644 index 0000000000000000000000000000000000000000..11fd9468856fa837aee5f75c2b6d90e2f87bc8c7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/parseInt.mjs @@ -0,0 +1,8 @@ +function parseInt(string, radix = 0, guard) { + if (guard) { + radix = 0; + } + return Number.parseInt(string, radix); +} + +export { parseInt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1213905c69a3ee0d1ee24c68f8c221f311809718 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.d.mts @@ -0,0 +1,46 @@ +/** + * Generate a random number between 0 and 1. + * @param {boolean} [floating] - Whether to return a floating point number. Defaults to true. + * @returns {number} A random number between 0 and 1. + * @example + * random(); // Returns a random number between 0 and 1 + * random(true); // Returns a random floating point number between 0 and 1 + * random(false); // Returns a random integer between 0 and 1 + */ +declare function random(floating?: boolean): number; +/** + * Generate a random number between 0 and max. + * @param {number} max - The upper bound (exclusive). + * @param {boolean} [floating] - Whether to return a floating point number. Defaults to true. + * @returns {number} A random number between 0 and max. + * @example + * random(5); // Returns a random number between 0 and 5 + * random(10, true); // Returns a random floating point number between 0 and 10 + * random(3, false); // Returns a random integer between 0 and 3 + */ +declare function random(max: number, floating?: boolean): number; +/** + * Generate a random number between min and max. + * @param {number} min - The lower bound (inclusive). + * @param {number} max - The upper bound (exclusive). + * @param {boolean} [floating] - Whether to return a floating point number. Defaults to true. + * @returns {number} A random number between min and max. + * @example + * random(1, 5); // Returns a random number between 1 and 5 + * random(0, 10, true); // Returns a random floating point number between 0 and 10 + * random(1, 6, false); // Returns a random integer between 1 and 6 + */ +declare function random(min: number, max: number, floating?: boolean): number; +/** + * Generate a random number between 0 and min, using guard object for special cases. + * @param {number} min - The upper bound (exclusive). + * @param {string | number} index - The index or key to check in the guard object. + * @param {object} guard - The guard object to validate the parameters. + * @returns {number} A random number between 0 and min. + * @example + * const guard = { 5: 5 }; + * random(5, 5, guard); // Returns a random number between 0 and 5 + */ +declare function random(min: number, index: string | number, guard: object): number; + +export { random }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1213905c69a3ee0d1ee24c68f8c221f311809718 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.d.ts @@ -0,0 +1,46 @@ +/** + * Generate a random number between 0 and 1. + * @param {boolean} [floating] - Whether to return a floating point number. Defaults to true. + * @returns {number} A random number between 0 and 1. + * @example + * random(); // Returns a random number between 0 and 1 + * random(true); // Returns a random floating point number between 0 and 1 + * random(false); // Returns a random integer between 0 and 1 + */ +declare function random(floating?: boolean): number; +/** + * Generate a random number between 0 and max. + * @param {number} max - The upper bound (exclusive). + * @param {boolean} [floating] - Whether to return a floating point number. Defaults to true. + * @returns {number} A random number between 0 and max. + * @example + * random(5); // Returns a random number between 0 and 5 + * random(10, true); // Returns a random floating point number between 0 and 10 + * random(3, false); // Returns a random integer between 0 and 3 + */ +declare function random(max: number, floating?: boolean): number; +/** + * Generate a random number between min and max. + * @param {number} min - The lower bound (inclusive). + * @param {number} max - The upper bound (exclusive). + * @param {boolean} [floating] - Whether to return a floating point number. Defaults to true. + * @returns {number} A random number between min and max. + * @example + * random(1, 5); // Returns a random number between 1 and 5 + * random(0, 10, true); // Returns a random floating point number between 0 and 10 + * random(1, 6, false); // Returns a random integer between 1 and 6 + */ +declare function random(min: number, max: number, floating?: boolean): number; +/** + * Generate a random number between 0 and min, using guard object for special cases. + * @param {number} min - The upper bound (exclusive). + * @param {string | number} index - The index or key to check in the guard object. + * @param {object} guard - The guard object to validate the parameters. + * @returns {number} A random number between 0 and min. + * @example + * const guard = { 5: 5 }; + * random(5, 5, guard); // Returns a random number between 0 and 5 + */ +declare function random(min: number, index: string | number, guard: object): number; + +export { random }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.js new file mode 100644 index 0000000000000000000000000000000000000000..97fee364091e39f498809f80a654806c66220c73 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.js @@ -0,0 +1,74 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const clamp = require('./clamp.js'); +const random$1 = require('../../math/random.js'); +const randomInt = require('../../math/randomInt.js'); + +function random(...args) { + let minimum = 0; + let maximum = 1; + let floating = false; + switch (args.length) { + case 1: { + if (typeof args[0] === 'boolean') { + floating = args[0]; + } + else { + maximum = args[0]; + } + break; + } + case 2: { + if (typeof args[1] === 'boolean') { + maximum = args[0]; + floating = args[1]; + } + else { + minimum = args[0]; + maximum = args[1]; + } + } + case 3: { + if (typeof args[2] === 'object' && args[2] != null && args[2][args[1]] === args[0]) { + minimum = 0; + maximum = args[0]; + floating = false; + } + else { + minimum = args[0]; + maximum = args[1]; + floating = args[2]; + } + } + } + if (typeof minimum !== 'number') { + minimum = Number(minimum); + } + if (typeof maximum !== 'number') { + minimum = Number(maximum); + } + if (!minimum) { + minimum = 0; + } + if (!maximum) { + maximum = 0; + } + if (minimum > maximum) { + [minimum, maximum] = [maximum, minimum]; + } + minimum = clamp.clamp(minimum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); + maximum = clamp.clamp(maximum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); + if (minimum === maximum) { + return minimum; + } + if (floating) { + return random$1.random(minimum, maximum + 1); + } + else { + return randomInt.randomInt(minimum, maximum + 1); + } +} + +exports.random = random; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0d567de68357a8b8c72676a4f45e905ae3c3bb5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/random.mjs @@ -0,0 +1,70 @@ +import { clamp } from './clamp.mjs'; +import { random as random$1 } from '../../math/random.mjs'; +import { randomInt } from '../../math/randomInt.mjs'; + +function random(...args) { + let minimum = 0; + let maximum = 1; + let floating = false; + switch (args.length) { + case 1: { + if (typeof args[0] === 'boolean') { + floating = args[0]; + } + else { + maximum = args[0]; + } + break; + } + case 2: { + if (typeof args[1] === 'boolean') { + maximum = args[0]; + floating = args[1]; + } + else { + minimum = args[0]; + maximum = args[1]; + } + } + case 3: { + if (typeof args[2] === 'object' && args[2] != null && args[2][args[1]] === args[0]) { + minimum = 0; + maximum = args[0]; + floating = false; + } + else { + minimum = args[0]; + maximum = args[1]; + floating = args[2]; + } + } + } + if (typeof minimum !== 'number') { + minimum = Number(minimum); + } + if (typeof maximum !== 'number') { + minimum = Number(maximum); + } + if (!minimum) { + minimum = 0; + } + if (!maximum) { + maximum = 0; + } + if (minimum > maximum) { + [minimum, maximum] = [maximum, minimum]; + } + minimum = clamp(minimum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); + maximum = clamp(maximum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); + if (minimum === maximum) { + return minimum; + } + if (floating) { + return random$1(minimum, maximum + 1); + } + else { + return randomInt(minimum, maximum + 1); + } +} + +export { random }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c4e82200f8b9dbca951a20af8fbb14f93e7f606a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.d.mts @@ -0,0 +1,33 @@ +/** + * Creates an array of numbers progressing from `start` up to, but not including, `end`. + * + * @param {number} start - The starting number of the range (inclusive) + * @param {number} end - The end number of the range (exclusive) + * @param {number} step - The value to increment or decrement by + * @returns {number[]} An array of numbers from start to end + * @example + * range(4) + * // => [0, 1, 2, 3] + * + * range(1, 5) + * // => [1, 2, 3, 4] + * + * range(0, 20, 5) + * // => [0, 5, 10, 15] + */ +declare function range(start: number, end?: number, step?: number): number[]; +/** + * Creates an array of numbers progressing from 0 up to, but not including, `end`. + * Used internally when range is called as an iteratee. + * + * @param {number} end - The end of the range (exclusive) + * @param {string|number} index - The index argument passed to the iteratee + * @param {object} guard - The guard object passed to the iteratee + * @returns {number[]} An array of numbers from 0 to end + * @example + * [1, 2, 3].map(range) + * // => [[0], [0, 1], [0, 1, 2]] + */ +declare function range(end: number, index: string | number, guard: object): number[]; + +export { range }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c4e82200f8b9dbca951a20af8fbb14f93e7f606a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.d.ts @@ -0,0 +1,33 @@ +/** + * Creates an array of numbers progressing from `start` up to, but not including, `end`. + * + * @param {number} start - The starting number of the range (inclusive) + * @param {number} end - The end number of the range (exclusive) + * @param {number} step - The value to increment or decrement by + * @returns {number[]} An array of numbers from start to end + * @example + * range(4) + * // => [0, 1, 2, 3] + * + * range(1, 5) + * // => [1, 2, 3, 4] + * + * range(0, 20, 5) + * // => [0, 5, 10, 15] + */ +declare function range(start: number, end?: number, step?: number): number[]; +/** + * Creates an array of numbers progressing from 0 up to, but not including, `end`. + * Used internally when range is called as an iteratee. + * + * @param {number} end - The end of the range (exclusive) + * @param {string|number} index - The index argument passed to the iteratee + * @param {object} guard - The guard object passed to the iteratee + * @returns {number[]} An array of numbers from 0 to end + * @example + * [1, 2, 3].map(range) + * // => [[0], [0, 1], [0, 1, 2]] + */ +declare function range(end: number, index: string | number, guard: object): number[]; + +export { range }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.js new file mode 100644 index 0000000000000000000000000000000000000000..4b92f0d9c819e16839a14e596d5eb955b2677531 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isIterateeCall = require('../_internal/isIterateeCall.js'); +const toFinite = require('../util/toFinite.js'); + +function range(start, end, step) { + if (step && typeof step !== 'number' && isIterateeCall.isIterateeCall(start, end, step)) { + end = step = undefined; + } + start = toFinite.toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } + else { + end = toFinite.toFinite(end); + } + step = step === undefined ? (start < end ? 1 : -1) : toFinite.toFinite(step); + const length = Math.max(Math.ceil((end - start) / (step || 1)), 0); + const result = new Array(length); + for (let index = 0; index < length; index++) { + result[index] = start; + start += step; + } + return result; +} + +exports.range = range; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0768e34c0fcd6c19c58e6c42fdd46fcc22806bae --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/range.mjs @@ -0,0 +1,26 @@ +import { isIterateeCall } from '../_internal/isIterateeCall.mjs'; +import { toFinite } from '../util/toFinite.mjs'; + +function range(start, end, step) { + if (step && typeof step !== 'number' && isIterateeCall(start, end, step)) { + end = step = undefined; + } + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } + else { + end = toFinite(end); + } + step = step === undefined ? (start < end ? 1 : -1) : toFinite(step); + const length = Math.max(Math.ceil((end - start) / (step || 1)), 0); + const result = new Array(length); + for (let index = 0; index < length; index++) { + result[index] = start; + start += step; + } + return result; +} + +export { range }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ee59f8bb9c1ea46e636bb349a5fb9da9d92a5a6c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.d.mts @@ -0,0 +1,31 @@ +/** + * Creates an array of numbers from `start` to `end` with optional `step`. + * @param {number} start - The starting number of the range (inclusive). + * @param {number} [end] - The end number of the range (exclusive). + * @param {number} [step] - The step value for the range. + * @returns {number[]} An array of numbers from `start` to `end` with the specified `step`. + * @example + * // Returns [0, 1, 2, 3] + * rangeRight(4); + * @example + * // Returns [0, 2, 4, 6] + * rangeRight(0, 8, 2); + * @example + * // Returns [5, 4, 3, 2, 1] + * rangeRight(1, 6); + */ +declare function rangeRight(start: number, end?: number, step?: number): number[]; +/** + * Creates an array of numbers from 0 to `end` with step 1. + * Used when called as an iteratee for methods like `_.map`. + * @param {number} end - The end number of the range (exclusive). + * @param {string | number} index - The index parameter (used for iteratee calls). + * @param {object} guard - The guard parameter (used for iteratee calls). + * @returns {number[]} An array of numbers from 0 to `end` with step 1. + * @example + * // Returns [0, 1, 2, 3] + * rangeRight(4, 'index', {}); + */ +declare function rangeRight(end: number, index: string | number, guard: object): number[]; + +export { rangeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee59f8bb9c1ea46e636bb349a5fb9da9d92a5a6c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.d.ts @@ -0,0 +1,31 @@ +/** + * Creates an array of numbers from `start` to `end` with optional `step`. + * @param {number} start - The starting number of the range (inclusive). + * @param {number} [end] - The end number of the range (exclusive). + * @param {number} [step] - The step value for the range. + * @returns {number[]} An array of numbers from `start` to `end` with the specified `step`. + * @example + * // Returns [0, 1, 2, 3] + * rangeRight(4); + * @example + * // Returns [0, 2, 4, 6] + * rangeRight(0, 8, 2); + * @example + * // Returns [5, 4, 3, 2, 1] + * rangeRight(1, 6); + */ +declare function rangeRight(start: number, end?: number, step?: number): number[]; +/** + * Creates an array of numbers from 0 to `end` with step 1. + * Used when called as an iteratee for methods like `_.map`. + * @param {number} end - The end number of the range (exclusive). + * @param {string | number} index - The index parameter (used for iteratee calls). + * @param {object} guard - The guard parameter (used for iteratee calls). + * @returns {number[]} An array of numbers from 0 to `end` with step 1. + * @example + * // Returns [0, 1, 2, 3] + * rangeRight(4, 'index', {}); + */ +declare function rangeRight(end: number, index: string | number, guard: object): number[]; + +export { rangeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.js new file mode 100644 index 0000000000000000000000000000000000000000..8e54ae4f022e658612b37a9845b8d95411fe8ec4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isIterateeCall = require('../_internal/isIterateeCall.js'); +const toFinite = require('../util/toFinite.js'); + +function rangeRight(start, end, step) { + if (step && typeof step !== 'number' && isIterateeCall.isIterateeCall(start, end, step)) { + end = step = undefined; + } + start = toFinite.toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } + else { + end = toFinite.toFinite(end); + } + step = step === undefined ? (start < end ? 1 : -1) : toFinite.toFinite(step); + const length = Math.max(Math.ceil((end - start) / (step || 1)), 0); + const result = new Array(length); + for (let index = length - 1; index >= 0; index--) { + result[index] = start; + start += step; + } + return result; +} + +exports.rangeRight = rangeRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a30ed09be6223a5e6e62647a07a0b8a632fdf6e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/rangeRight.mjs @@ -0,0 +1,26 @@ +import { isIterateeCall } from '../_internal/isIterateeCall.mjs'; +import { toFinite } from '../util/toFinite.mjs'; + +function rangeRight(start, end, step) { + if (step && typeof step !== 'number' && isIterateeCall(start, end, step)) { + end = step = undefined; + } + start = toFinite(start); + if (end === undefined) { + end = start; + start = 0; + } + else { + end = toFinite(end); + } + step = step === undefined ? (start < end ? 1 : -1) : toFinite(step); + const length = Math.max(Math.ceil((end - start) / (step || 1)), 0); + const result = new Array(length); + for (let index = length - 1; index >= 0; index--) { + result[index] = start; + start += step; + } + return result; +} + +export { rangeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..59c1f30da8c35666c4859abe6d03232372f5bc17 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.d.mts @@ -0,0 +1,15 @@ +/** + * Computes number rounded to precision. + * + * @param {number} number The number to round. + * @param {number} precision The precision to round to. + * @returns {number} Returns the rounded number. + * + * @example + * round(4.006); // => 4 + * round(4.006, 2); // => 4.01 + * round(4060, -2); // => 4100 + */ +declare function round(number: number, precision?: number): number; + +export { round }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..59c1f30da8c35666c4859abe6d03232372f5bc17 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.d.ts @@ -0,0 +1,15 @@ +/** + * Computes number rounded to precision. + * + * @param {number} number The number to round. + * @param {number} precision The precision to round to. + * @returns {number} Returns the rounded number. + * + * @example + * round(4.006); // => 4 + * round(4.006, 2); // => 4.01 + * round(4060, -2); // => 4100 + */ +declare function round(number: number, precision?: number): number; + +export { round }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.js new file mode 100644 index 0000000000000000000000000000000000000000..5d978cc5f3f760435afa55f43d9feb2dac1aa2bc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const decimalAdjust = require('../_internal/decimalAdjust.js'); + +function round(number, precision = 0) { + return decimalAdjust.decimalAdjust('round', number, precision); +} + +exports.round = round; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0c86cba994a4484a34f1795e250323bfff44a4af --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/round.mjs @@ -0,0 +1,7 @@ +import { decimalAdjust } from '../_internal/decimalAdjust.mjs'; + +function round(number, precision = 0) { + return decimalAdjust('round', number, precision); +} + +export { round }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9f85d546b9de9d00ec15b181d2301acbcced443a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.d.mts @@ -0,0 +1,17 @@ +/** + * Subtracts one number from another. + * + * If either of the numbers is `NaN`, the function returns `NaN`. + * + * @param {number} value The first number. (minuend) + * @param {number} other The second number.(subtrahend) + * @returns {number} The difference of the two numbers, or `NaN` if any input is `NaN`. + * + * @example + * subtract(6, 3); // => 3 + * subtract(6, NaN); // => NaN + * subtract(NaN, 3); // => NaN + */ +declare function subtract(value: number, other: number): number; + +export { subtract }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f85d546b9de9d00ec15b181d2301acbcced443a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.d.ts @@ -0,0 +1,17 @@ +/** + * Subtracts one number from another. + * + * If either of the numbers is `NaN`, the function returns `NaN`. + * + * @param {number} value The first number. (minuend) + * @param {number} other The second number.(subtrahend) + * @returns {number} The difference of the two numbers, or `NaN` if any input is `NaN`. + * + * @example + * subtract(6, 3); // => 3 + * subtract(6, NaN); // => NaN + * subtract(NaN, 3); // => NaN + */ +declare function subtract(value: number, other: number): number; + +export { subtract }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.js new file mode 100644 index 0000000000000000000000000000000000000000..35a6904a47174507a32e73cea3a8ab69dafaddd2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('../util/toNumber.js'); +const toString = require('../util/toString.js'); + +function subtract(value, other) { + if (value === undefined && other === undefined) { + return 0; + } + if (value === undefined || other === undefined) { + return value ?? other; + } + if (typeof value === 'string' || typeof other === 'string') { + value = toString.toString(value); + other = toString.toString(other); + } + else { + value = toNumber.toNumber(value); + other = toNumber.toNumber(other); + } + return value - other; +} + +exports.subtract = subtract; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.mjs new file mode 100644 index 0000000000000000000000000000000000000000..37719af2acaad8acb1c57fb7134ee6fdb8ea4277 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/subtract.mjs @@ -0,0 +1,22 @@ +import { toNumber } from '../util/toNumber.mjs'; +import { toString } from '../util/toString.mjs'; + +function subtract(value, other) { + if (value === undefined && other === undefined) { + return 0; + } + if (value === undefined || other === undefined) { + return value ?? other; + } + if (typeof value === 'string' || typeof other === 'string') { + value = toString(value); + other = toString(other); + } + else { + value = toNumber(value); + other = toNumber(other); + } + return value - other; +} + +export { subtract }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7971bdc7f9123d751278bb504297484068c86cbd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.d.mts @@ -0,0 +1,19 @@ +/** + * Computes the sum of the values that are returned by the `iteratee` function. + * + * It does not coerce values to `number`. + * + * @param {ArrayLike | null | undefined} array - The array to iterate over. + * @returns {number} Returns the sum. + * + * @example + * sum([1, 2, 3]); // => 6 + * sum([1n, 2n, 3n]); // => 6n + * sum(["1", "2"]); // => "12" + * sum([1, undefined, 2]); // => 3 + * sum(null); // => 0 + * sum(undefined); // => 0 + */ +declare function sum(array: ArrayLike | null | undefined): number; + +export { sum }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7971bdc7f9123d751278bb504297484068c86cbd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.d.ts @@ -0,0 +1,19 @@ +/** + * Computes the sum of the values that are returned by the `iteratee` function. + * + * It does not coerce values to `number`. + * + * @param {ArrayLike | null | undefined} array - The array to iterate over. + * @returns {number} Returns the sum. + * + * @example + * sum([1, 2, 3]); // => 6 + * sum([1n, 2n, 3n]); // => 6n + * sum(["1", "2"]); // => "12" + * sum([1, undefined, 2]); // => 3 + * sum(null); // => 0 + * sum(undefined); // => 0 + */ +declare function sum(array: ArrayLike | null | undefined): number; + +export { sum }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.js new file mode 100644 index 0000000000000000000000000000000000000000..2de763d7e461f4e3107b078afd50e00c19c334b9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const sumBy = require('./sumBy.js'); + +function sum(array) { + return sumBy.sumBy(array); +} + +exports.sum = sum; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f1f14721b936edacf77fd7cd3a8b0d712bfa9830 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sum.mjs @@ -0,0 +1,7 @@ +import { sumBy } from './sumBy.mjs'; + +function sum(array) { + return sumBy(array); +} + +export { sum }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ecef0a83f7904562622b681c1c7a53c13363c570 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.d.mts @@ -0,0 +1,21 @@ +/** + * Computes the sum of the values that are returned by the `iteratee` function. + * + * It does not coerce values to `number`. + * + * @template T - The type of the array elements. + * @param {ArrayLike | null | undefined} array - The array to iterate over. + * @param {((value: T) => number) | string} iteratee - The function invoked per iteration. + * @returns {number} Returns the sum. + * + * @example + * sumBy([1, undefined, 2], value => value); // => 3 + * sumBy(null); // => 0 + * sumBy(undefined); // => 0 + * sumBy([1, 2, 3]); // => 6 + * sumBy([1n, 2n, 3n]); // => 6n + * sumBy([{ a: "1" }, { a: "2" }], object => object.a); // => "12" + */ +declare function sumBy(array: ArrayLike | null | undefined, iteratee?: ((value: T) => number) | string): number; + +export { sumBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ecef0a83f7904562622b681c1c7a53c13363c570 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.d.ts @@ -0,0 +1,21 @@ +/** + * Computes the sum of the values that are returned by the `iteratee` function. + * + * It does not coerce values to `number`. + * + * @template T - The type of the array elements. + * @param {ArrayLike | null | undefined} array - The array to iterate over. + * @param {((value: T) => number) | string} iteratee - The function invoked per iteration. + * @returns {number} Returns the sum. + * + * @example + * sumBy([1, undefined, 2], value => value); // => 3 + * sumBy(null); // => 0 + * sumBy(undefined); // => 0 + * sumBy([1, 2, 3]); // => 6 + * sumBy([1n, 2n, 3n]); // => 6n + * sumBy([{ a: "1" }, { a: "2" }], object => object.a); // => "12" + */ +declare function sumBy(array: ArrayLike | null | undefined, iteratee?: ((value: T) => number) | string): number; + +export { sumBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.js new file mode 100644 index 0000000000000000000000000000000000000000..48cf5bcfd3e5d280fc3c9b1c65a7d49efe69b5a2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.js @@ -0,0 +1,29 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const iteratee = require('../util/iteratee.js'); + +function sumBy(array, iteratee$1) { + if (!array || !array.length) { + return 0; + } + if (iteratee$1 != null) { + iteratee$1 = iteratee.iteratee(iteratee$1); + } + let result = undefined; + for (let i = 0; i < array.length; i++) { + const current = iteratee$1 ? iteratee$1(array[i]) : array[i]; + if (current !== undefined) { + if (result === undefined) { + result = current; + } + else { + result += current; + } + } + } + return result; +} + +exports.sumBy = sumBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1114448710c8bcb93868c48e6974a5afbe17c7f4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/math/sumBy.mjs @@ -0,0 +1,25 @@ +import { iteratee } from '../util/iteratee.mjs'; + +function sumBy(array, iteratee$1) { + if (!array || !array.length) { + return 0; + } + if (iteratee$1 != null) { + iteratee$1 = iteratee(iteratee$1); + } + let result = undefined; + for (let i = 0; i < array.length; i++) { + const current = iteratee$1 ? iteratee$1(array[i]) : array[i]; + if (current !== undefined) { + if (result === undefined) { + result = current; + } + else { + result += current; + } + } + } + return result; +} + +export { sumBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cb4cae074de83caa4edb31e2899b3b67e0614d48 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.d.mts @@ -0,0 +1,110 @@ +/** + * Assigns properties from one source object to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source - The source object whose properties will be assigned to the target object. + * @returns {T & U} The updated target object with properties from the source object assigned. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * const result = assign(target, source); + * // => { a: 1, b: 3, c: 4 } + */ +declare function assign(object: T, source: U): T & U; +/** + * Assigns properties from two source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @returns {T & U & V} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const result = assign(target, source1, source2); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assign(object: T, source1: U, source2: V): T & U & V; +/** + * Assigns properties from three source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @returns {T & U & V & W} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const result = assign(target, source1, source2, source3); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assign(object: T, source1: U, source2: V, source3: W): T & U & V & W; +/** + * Assigns properties from four source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @template X - The type of the fourth source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {X} source4 - The fourth source object whose properties will be assigned to the target object. + * @returns {T & U & V & W & X} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * const result = assign(target, source1, source2, source3, source4); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function assign(object: T, source1: U, source2: V, source3: W, source4: X): T & U & V & W & X; +/** + * Assigns properties from a target object to itself. + * + * @template T - The type of the target object. + * @param {T} object - The target object. + * @returns {T} The target object. + * + * @example + * const target = { a: 1, b: 2 }; + * const result = assign(target); + * // => { a: 1, b: 2 } + */ +declare function assign(object: T): T; +/** + * Assigns properties from multiple source objects to a target object. + * + * @param {any} object - The target object to which properties will be assigned. + * @param {...any[]} otherArgs - The source objects whose properties will be assigned to the target object. + * @returns {any} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const result = assign(target, { b: 2 }, { c: 3 }, { d: 4 }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assign(object: any, ...otherArgs: any[]): any; + +export { assign }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb4cae074de83caa4edb31e2899b3b67e0614d48 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.d.ts @@ -0,0 +1,110 @@ +/** + * Assigns properties from one source object to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source - The source object whose properties will be assigned to the target object. + * @returns {T & U} The updated target object with properties from the source object assigned. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * const result = assign(target, source); + * // => { a: 1, b: 3, c: 4 } + */ +declare function assign(object: T, source: U): T & U; +/** + * Assigns properties from two source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @returns {T & U & V} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const result = assign(target, source1, source2); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assign(object: T, source1: U, source2: V): T & U & V; +/** + * Assigns properties from three source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @returns {T & U & V & W} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const result = assign(target, source1, source2, source3); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assign(object: T, source1: U, source2: V, source3: W): T & U & V & W; +/** + * Assigns properties from four source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @template X - The type of the fourth source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {X} source4 - The fourth source object whose properties will be assigned to the target object. + * @returns {T & U & V & W & X} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * const result = assign(target, source1, source2, source3, source4); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function assign(object: T, source1: U, source2: V, source3: W, source4: X): T & U & V & W & X; +/** + * Assigns properties from a target object to itself. + * + * @template T - The type of the target object. + * @param {T} object - The target object. + * @returns {T} The target object. + * + * @example + * const target = { a: 1, b: 2 }; + * const result = assign(target); + * // => { a: 1, b: 2 } + */ +declare function assign(object: T): T; +/** + * Assigns properties from multiple source objects to a target object. + * + * @param {any} object - The target object to which properties will be assigned. + * @param {...any[]} otherArgs - The source objects whose properties will be assigned to the target object. + * @returns {any} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const result = assign(target, { b: 2 }, { c: 3 }, { d: 4 }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assign(object: any, ...otherArgs: any[]): any; + +export { assign }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.js new file mode 100644 index 0000000000000000000000000000000000000000..112c1567b2d21ddad154adf47d98f92bf623c452 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keys = require('./keys.js'); +const eq = require('../util/eq.js'); + +function assign(object, ...sources) { + for (let i = 0; i < sources.length; i++) { + assignImpl(object, sources[i]); + } + return object; +} +function assignImpl(object, source) { + const keys$1 = keys.keys(source); + for (let i = 0; i < keys$1.length; i++) { + const key = keys$1[i]; + if (!(key in object) || !eq.eq(object[key], source[key])) { + object[key] = source[key]; + } + } +} + +exports.assign = assign; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7f2c87c4cfdc81ef21aa7d3798aef213f67b139d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assign.mjs @@ -0,0 +1,20 @@ +import { keys } from './keys.mjs'; +import { eq } from '../util/eq.mjs'; + +function assign(object, ...sources) { + for (let i = 0; i < sources.length; i++) { + assignImpl(object, sources[i]); + } + return object; +} +function assignImpl(object, source) { + const keys$1 = keys(source); + for (let i = 0; i < keys$1.length; i++) { + const key = keys$1[i]; + if (!(key in object) || !eq(object[key], source[key])) { + object[key] = source[key]; + } + } +} + +export { assign }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..de32e912add58c171b5d1fe9a257f7763502bb87 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.d.mts @@ -0,0 +1,111 @@ +/** + * Assigns own and inherited properties from one source object to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source - The source object whose properties will be assigned to the target object. + * @returns {T & U} The updated target object with properties from the source object assigned. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * const result = assignIn(target, source); + * // => { a: 1, b: 3, c: 4 } + */ +declare function assignIn(object: T, source: U): T & U; +/** + * Assigns own and inherited properties from two source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @returns {T & U & V} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const result = assignIn(target, source1, source2); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignIn(object: T, source1: U, source2: V): T & U & V; +/** + * Assigns own and inherited properties from three source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @returns {T & U & V & W} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const result = assignIn(target, source1, source2, source3); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assignIn(object: T, source1: U, source2: V, source3: W): T & U & V & W; +/** + * Assigns own and inherited properties from four source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @template X - The type of the fourth source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {X} source4 - The fourth source object whose properties will be assigned to the target object. + * @returns {T & U & V & W & X} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * const result = assignIn(target, source1, source2, source3, source4); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function assignIn(object: T, source1: U, source2: V, source3: W, source4: X): T & U & V & W & X; +/** + * Returns the target object as-is. + * + * @template T - The type of the target object. + * @param {T} object - The target object. + * @returns {T} The target object. + * + * @example + * const target = { a: 1, b: 2 }; + * const result = assignIn(target); + * // => { a: 1, b: 2 } + */ +declare function assignIn(object: T): T; +/** + * Assigns own and inherited properties from multiple source objects to a target object. + * + * @template R - The type of the result. + * @param {any} object - The target object to which properties will be assigned. + * @param {...any[]} otherArgs - The source objects whose properties will be assigned to the target object. + * @returns {R} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const result = assignIn(target, { b: 2 }, { c: 3 }, { d: 4 }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assignIn(object: any, ...otherArgs: any[]): R; + +export { assignIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..de32e912add58c171b5d1fe9a257f7763502bb87 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.d.ts @@ -0,0 +1,111 @@ +/** + * Assigns own and inherited properties from one source object to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source - The source object whose properties will be assigned to the target object. + * @returns {T & U} The updated target object with properties from the source object assigned. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * const result = assignIn(target, source); + * // => { a: 1, b: 3, c: 4 } + */ +declare function assignIn(object: T, source: U): T & U; +/** + * Assigns own and inherited properties from two source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @returns {T & U & V} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const result = assignIn(target, source1, source2); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignIn(object: T, source1: U, source2: V): T & U & V; +/** + * Assigns own and inherited properties from three source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @returns {T & U & V & W} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const result = assignIn(target, source1, source2, source3); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assignIn(object: T, source1: U, source2: V, source3: W): T & U & V & W; +/** + * Assigns own and inherited properties from four source objects to a target object. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @template X - The type of the fourth source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {X} source4 - The fourth source object whose properties will be assigned to the target object. + * @returns {T & U & V & W & X} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * const result = assignIn(target, source1, source2, source3, source4); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function assignIn(object: T, source1: U, source2: V, source3: W, source4: X): T & U & V & W & X; +/** + * Returns the target object as-is. + * + * @template T - The type of the target object. + * @param {T} object - The target object. + * @returns {T} The target object. + * + * @example + * const target = { a: 1, b: 2 }; + * const result = assignIn(target); + * // => { a: 1, b: 2 } + */ +declare function assignIn(object: T): T; +/** + * Assigns own and inherited properties from multiple source objects to a target object. + * + * @template R - The type of the result. + * @param {any} object - The target object to which properties will be assigned. + * @param {...any[]} otherArgs - The source objects whose properties will be assigned to the target object. + * @returns {R} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const result = assignIn(target, { b: 2 }, { c: 3 }, { d: 4 }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assignIn(object: any, ...otherArgs: any[]): R; + +export { assignIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.js new file mode 100644 index 0000000000000000000000000000000000000000..bafbedad78c4e8f3591c4fda819f26f764f54315 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keysIn = require('./keysIn.js'); +const eq = require('../util/eq.js'); + +function assignIn(object, ...sources) { + for (let i = 0; i < sources.length; i++) { + assignInImpl(object, sources[i]); + } + return object; +} +function assignInImpl(object, source) { + const keys = keysIn.keysIn(source); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (!(key in object) || !eq.eq(object[key], source[key])) { + object[key] = source[key]; + } + } +} + +exports.assignIn = assignIn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a05cf166f4677c426fecac4d223dbb60618fc899 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignIn.mjs @@ -0,0 +1,20 @@ +import { keysIn } from './keysIn.mjs'; +import { eq } from '../util/eq.mjs'; + +function assignIn(object, ...sources) { + for (let i = 0; i < sources.length; i++) { + assignInImpl(object, sources[i]); + } + return object; +} +function assignInImpl(object, source) { + const keys = keysIn(source); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (!(key in object) || !eq(object[key], source[key])) { + object[key] = source[key]; + } + } +} + +export { assignIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..94fd0ad733c3f6223dcd52149c6c9aa93753a302 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.d.mts @@ -0,0 +1,126 @@ +type AssignCustomizer = (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any; +/** + * Assigns own and inherited properties from one source object to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source - The source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U} The updated target object with properties from the source object assigned. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * const result = assignInWith(target, source, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 4 } + */ +declare function assignInWith(object: T, source: U, customizer: AssignCustomizer): T & U; +/** + * Assigns own and inherited properties from two source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const result = assignInWith(target, source1, source2, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignInWith(object: T, source1: U, source2: V, customizer: AssignCustomizer): T & U & V; +/** + * Assigns own and inherited properties from three source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V & W} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const result = assignInWith(target, source1, source2, source3, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assignInWith(object: T, source1: U, source2: V, source3: W, customizer: AssignCustomizer): T & U & V & W; +/** + * Assigns own and inherited properties from four source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @template X - The type of the fourth source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {X} source4 - The fourth source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V & W & X} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * const result = assignInWith(target, source1, source2, source3, source4, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function assignInWith(object: T, source1: U, source2: V, source3: W, source4: X, customizer: AssignCustomizer): T & U & V & W & X; +/** + * Returns the target object as-is. + * + * @template T - The type of the target object. + * @param {T} object - The target object. + * @returns {T} The target object. + * + * @example + * const target = { a: 1, b: 2 }; + * const result = assignInWith(target); + * // => { a: 1, b: 2 } + */ +declare function assignInWith(object: T): T; +/** + * Assigns own and inherited properties from multiple source objects to a target object using a customizer function. + * + * @template R - The type of the result. + * @param {any} object - The target object to which properties will be assigned. + * @param {...any[]} otherArgs - The source objects and customizer function. + * @returns {R} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const result = assignInWith(target, { b: 2 }, { c: 3 }, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignInWith(object: any, ...otherArgs: any[]): R; + +export { assignInWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..94fd0ad733c3f6223dcd52149c6c9aa93753a302 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.d.ts @@ -0,0 +1,126 @@ +type AssignCustomizer = (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any; +/** + * Assigns own and inherited properties from one source object to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source - The source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U} The updated target object with properties from the source object assigned. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * const result = assignInWith(target, source, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 4 } + */ +declare function assignInWith(object: T, source: U, customizer: AssignCustomizer): T & U; +/** + * Assigns own and inherited properties from two source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const result = assignInWith(target, source1, source2, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignInWith(object: T, source1: U, source2: V, customizer: AssignCustomizer): T & U & V; +/** + * Assigns own and inherited properties from three source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V & W} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const result = assignInWith(target, source1, source2, source3, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assignInWith(object: T, source1: U, source2: V, source3: W, customizer: AssignCustomizer): T & U & V & W; +/** + * Assigns own and inherited properties from four source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @template X - The type of the fourth source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {X} source4 - The fourth source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V & W & X} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * const result = assignInWith(target, source1, source2, source3, source4, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function assignInWith(object: T, source1: U, source2: V, source3: W, source4: X, customizer: AssignCustomizer): T & U & V & W & X; +/** + * Returns the target object as-is. + * + * @template T - The type of the target object. + * @param {T} object - The target object. + * @returns {T} The target object. + * + * @example + * const target = { a: 1, b: 2 }; + * const result = assignInWith(target); + * // => { a: 1, b: 2 } + */ +declare function assignInWith(object: T): T; +/** + * Assigns own and inherited properties from multiple source objects to a target object using a customizer function. + * + * @template R - The type of the result. + * @param {any} object - The target object to which properties will be assigned. + * @param {...any[]} otherArgs - The source objects and customizer function. + * @returns {R} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const result = assignInWith(target, { b: 2 }, { c: 3 }, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignInWith(object: any, ...otherArgs: any[]): R; + +export { assignInWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.js new file mode 100644 index 0000000000000000000000000000000000000000..6026b70e7ff247187af6523bb31d0618ea011be7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keysIn = require('./keysIn.js'); +const eq = require('../util/eq.js'); + +function assignInWith(object, ...sources) { + let getValueToAssign = sources[sources.length - 1]; + if (typeof getValueToAssign === 'function') { + sources.pop(); + } + else { + getValueToAssign = undefined; + } + for (let i = 0; i < sources.length; i++) { + assignInWithImpl(object, sources[i], getValueToAssign); + } + return object; +} +function assignInWithImpl(object, source, getValueToAssign) { + const keys = keysIn.keysIn(source); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const objValue = object[key]; + const srcValue = source[key]; + const newValue = getValueToAssign?.(objValue, srcValue, key, object, source) ?? srcValue; + if (!(key in object) || !eq.eq(objValue, newValue)) { + object[key] = newValue; + } + } +} + +exports.assignInWith = assignInWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..72453c36ae83107b1cdc3a33149541980407ba0d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignInWith.mjs @@ -0,0 +1,30 @@ +import { keysIn } from './keysIn.mjs'; +import { eq } from '../util/eq.mjs'; + +function assignInWith(object, ...sources) { + let getValueToAssign = sources[sources.length - 1]; + if (typeof getValueToAssign === 'function') { + sources.pop(); + } + else { + getValueToAssign = undefined; + } + for (let i = 0; i < sources.length; i++) { + assignInWithImpl(object, sources[i], getValueToAssign); + } + return object; +} +function assignInWithImpl(object, source, getValueToAssign) { + const keys = keysIn(source); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const objValue = object[key]; + const srcValue = source[key]; + const newValue = getValueToAssign?.(objValue, srcValue, key, object, source) ?? srcValue; + if (!(key in object) || !eq(objValue, newValue)) { + object[key] = newValue; + } + } +} + +export { assignInWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..069367bb56fa8aab71dc486178ef14f0d7f743db --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.d.mts @@ -0,0 +1,126 @@ +type AssignCustomizer = (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any; +/** + * Assigns own properties from one source object to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source - The source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U} The updated target object with properties from the source object assigned. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * const result = assignWith(target, source, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 4 } + */ +declare function assignWith(object: T, source: U, customizer: AssignCustomizer): T & U; +/** + * Assigns own properties from two source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const result = assignWith(target, source1, source2, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignWith(object: T, source1: U, source2: V, customizer: AssignCustomizer): T & U & V; +/** + * Assigns own properties from three source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V & W} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const result = assignWith(target, source1, source2, source3, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assignWith(object: T, source1: U, source2: V, source3: W, customizer: AssignCustomizer): T & U & V & W; +/** + * Assigns own properties from four source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @template X - The type of the fourth source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {X} source4 - The fourth source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V & W & X} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * const result = assignWith(target, source1, source2, source3, source4, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function assignWith(object: T, source1: U, source2: V, source3: W, source4: X, customizer: AssignCustomizer): T & U & V & W & X; +/** + * Returns the target object as-is. + * + * @template T - The type of the target object. + * @param {T} object - The target object. + * @returns {T} The target object. + * + * @example + * const target = { a: 1, b: 2 }; + * const result = assignWith(target); + * // => { a: 1, b: 2 } + */ +declare function assignWith(object: T): T; +/** + * Assigns own properties from multiple source objects to a target object using a customizer function. + * + * @template R - The type of the result. + * @param {any} object - The target object to which properties will be assigned. + * @param {...any[]} otherArgs - The source objects and customizer function. + * @returns {R} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const result = assignWith(target, { b: 2 }, { c: 3 }, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignWith(object: any, ...otherArgs: any[]): R; + +export { assignWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..069367bb56fa8aab71dc486178ef14f0d7f743db --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.d.ts @@ -0,0 +1,126 @@ +type AssignCustomizer = (objectValue: any, sourceValue: any, key?: string, object?: {}, source?: {}) => any; +/** + * Assigns own properties from one source object to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source - The source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U} The updated target object with properties from the source object assigned. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * const result = assignWith(target, source, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 4 } + */ +declare function assignWith(object: T, source: U, customizer: AssignCustomizer): T & U; +/** + * Assigns own properties from two source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const result = assignWith(target, source1, source2, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignWith(object: T, source1: U, source2: V, customizer: AssignCustomizer): T & U & V; +/** + * Assigns own properties from three source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V & W} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const result = assignWith(target, source1, source2, source3, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function assignWith(object: T, source1: U, source2: V, source3: W, customizer: AssignCustomizer): T & U & V & W; +/** + * Assigns own properties from four source objects to a target object using a customizer function. + * + * @template T - The type of the target object. + * @template U - The type of the first source object. + * @template V - The type of the second source object. + * @template W - The type of the third source object. + * @template X - The type of the fourth source object. + * @param {T} object - The target object to which properties will be assigned. + * @param {U} source1 - The first source object whose properties will be assigned to the target object. + * @param {V} source2 - The second source object whose properties will be assigned to the target object. + * @param {W} source3 - The third source object whose properties will be assigned to the target object. + * @param {X} source4 - The fourth source object whose properties will be assigned to the target object. + * @param {AssignCustomizer} customizer - The function to customize assigned values. + * @returns {T & U & V & W & X} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * const result = assignWith(target, source1, source2, source3, source4, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function assignWith(object: T, source1: U, source2: V, source3: W, source4: X, customizer: AssignCustomizer): T & U & V & W & X; +/** + * Returns the target object as-is. + * + * @template T - The type of the target object. + * @param {T} object - The target object. + * @returns {T} The target object. + * + * @example + * const target = { a: 1, b: 2 }; + * const result = assignWith(target); + * // => { a: 1, b: 2 } + */ +declare function assignWith(object: T): T; +/** + * Assigns own properties from multiple source objects to a target object using a customizer function. + * + * @template R - The type of the result. + * @param {any} object - The target object to which properties will be assigned. + * @param {...any[]} otherArgs - The source objects and customizer function. + * @returns {R} The updated target object with properties from the source objects assigned. + * + * @example + * const target = { a: 1 }; + * const result = assignWith(target, { b: 2 }, { c: 3 }, (objValue, srcValue) => { + * return objValue === undefined ? srcValue : objValue; + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function assignWith(object: any, ...otherArgs: any[]): R; + +export { assignWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.js new file mode 100644 index 0000000000000000000000000000000000000000..f14a46aa79ce1c8603118b439707b071531b6b3f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keys = require('./keys.js'); +const eq = require('../util/eq.js'); + +function assignWith(object, ...sources) { + let getValueToAssign = sources[sources.length - 1]; + if (typeof getValueToAssign === 'function') { + sources.pop(); + } + else { + getValueToAssign = undefined; + } + for (let i = 0; i < sources.length; i++) { + assignWithImpl(object, sources[i], getValueToAssign); + } + return object; +} +function assignWithImpl(object, source, getValueToAssign) { + const keys$1 = keys.keys(source); + for (let i = 0; i < keys$1.length; i++) { + const key = keys$1[i]; + const objValue = object[key]; + const srcValue = source[key]; + const newValue = getValueToAssign?.(objValue, srcValue, key, object, source) ?? srcValue; + if (!(key in object) || !eq.eq(objValue, newValue)) { + object[key] = newValue; + } + } +} + +exports.assignWith = assignWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..28a6969e569f1c34f10fde58784eff7eae99deeb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/assignWith.mjs @@ -0,0 +1,30 @@ +import { keys } from './keys.mjs'; +import { eq } from '../util/eq.mjs'; + +function assignWith(object, ...sources) { + let getValueToAssign = sources[sources.length - 1]; + if (typeof getValueToAssign === 'function') { + sources.pop(); + } + else { + getValueToAssign = undefined; + } + for (let i = 0; i < sources.length; i++) { + assignWithImpl(object, sources[i], getValueToAssign); + } + return object; +} +function assignWithImpl(object, source, getValueToAssign) { + const keys$1 = keys(source); + for (let i = 0; i < keys$1.length; i++) { + const key = keys$1[i]; + const objValue = object[key]; + const srcValue = source[key]; + const newValue = getValueToAssign?.(objValue, srcValue, key, object, source) ?? srcValue; + if (!(key in object) || !eq(objValue, newValue)) { + object[key] = newValue; + } + } +} + +export { assignWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a16641e4ec61d5ff45d3b83ae66fa75421469523 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.d.mts @@ -0,0 +1,33 @@ +type PropertyName = string | number | symbol; +type Many = T | readonly T[]; +type PropertyPath = Many; +/** + * Gets values at given paths from a dictionary or numeric dictionary. + * + * @template T - The type of the values in the dictionary. + * @param {Record | Record | null | undefined} object - The dictionary to query. + * @param {...PropertyPath[]} props - The property paths to get values for. + * @returns {T[]} Returns an array of the picked values. + * + * @example + * const object = { 'a': 1, 'b': 2, 'c': 3 }; + * at(object, 'a', 'c'); + * // => [1, 3] + */ +declare function at(object: Record | Record | null | undefined, ...props: PropertyPath[]): T[]; +/** + * Gets values at given keys from an object. + * + * @template T - The type of the object. + * @param {T | null | undefined} object - The object to query. + * @param {...Array>} props - The property keys to get values for. + * @returns {Array} Returns an array of the picked values. + * + * @example + * const object = { 'a': 1, 'b': 2, 'c': 3 }; + * at(object, 'a', 'c'); + * // => [1, 3] + */ +declare function at(object: T | null | undefined, ...props: Array>): Array; + +export { at }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a16641e4ec61d5ff45d3b83ae66fa75421469523 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.d.ts @@ -0,0 +1,33 @@ +type PropertyName = string | number | symbol; +type Many = T | readonly T[]; +type PropertyPath = Many; +/** + * Gets values at given paths from a dictionary or numeric dictionary. + * + * @template T - The type of the values in the dictionary. + * @param {Record | Record | null | undefined} object - The dictionary to query. + * @param {...PropertyPath[]} props - The property paths to get values for. + * @returns {T[]} Returns an array of the picked values. + * + * @example + * const object = { 'a': 1, 'b': 2, 'c': 3 }; + * at(object, 'a', 'c'); + * // => [1, 3] + */ +declare function at(object: Record | Record | null | undefined, ...props: PropertyPath[]): T[]; +/** + * Gets values at given keys from an object. + * + * @template T - The type of the object. + * @param {T | null | undefined} object - The object to query. + * @param {...Array>} props - The property keys to get values for. + * @returns {Array} Returns an array of the picked values. + * + * @example + * const object = { 'a': 1, 'b': 2, 'c': 3 }; + * at(object, 'a', 'c'); + * // => [1, 3] + */ +declare function at(object: T | null | undefined, ...props: Array>): Array; + +export { at }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.js new file mode 100644 index 0000000000000000000000000000000000000000..54fbc11d4145242cbfdada8e71c34f4104f56ae5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.js @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const get = require('./get.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isString = require('../predicate/isString.js'); + +function at(object, ...paths) { + if (paths.length === 0) { + return []; + } + const allPaths = []; + for (let i = 0; i < paths.length; i++) { + const path = paths[i]; + if (!isArrayLike.isArrayLike(path) || isString.isString(path)) { + allPaths.push(path); + continue; + } + for (let j = 0; j < path.length; j++) { + allPaths.push(path[j]); + } + } + const result = []; + for (let i = 0; i < allPaths.length; i++) { + result.push(get.get(object, allPaths[i])); + } + return result; +} + +exports.at = at; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f072973d5ffa267da58939beb1561240f0366541 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/at.mjs @@ -0,0 +1,27 @@ +import { get } from './get.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isString } from '../predicate/isString.mjs'; + +function at(object, ...paths) { + if (paths.length === 0) { + return []; + } + const allPaths = []; + for (let i = 0; i < paths.length; i++) { + const path = paths[i]; + if (!isArrayLike(path) || isString(path)) { + allPaths.push(path); + continue; + } + for (let j = 0; j < path.length; j++) { + allPaths.push(path[j]); + } + } + const result = []; + for (let i = 0; i < allPaths.length; i++) { + result.push(get(object, allPaths[i])); + } + return result; +} + +export { at }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..44890e79754e43c7630475462229cc122565e053 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.d.mts @@ -0,0 +1,31 @@ +/** + * Creates a shallow clone of the given object. + * + * @template T - The type of the object. + * @param {T} obj - The object to clone. + * @returns {T} - A shallow clone of the given object. + * + * @example + * // Clone a primitive objs + * const num = 29; + * const clonedNum = clone(num); + * console.log(clonedNum); // 29 + * console.log(clonedNum === num) ; // true + * + * @example + * // Clone an array + * const arr = [1, 2, 3]; + * const clonedArr = clone(arr); + * console.log(clonedArr); // [1, 2, 3] + * console.log(clonedArr === arr); // false + * + * @example + * // Clone an object + * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] }; + * const clonedObj = clone(obj); + * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] } + * console.log(clonedObj === obj); // false + */ +declare function clone(obj: T): T; + +export { clone }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..44890e79754e43c7630475462229cc122565e053 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.d.ts @@ -0,0 +1,31 @@ +/** + * Creates a shallow clone of the given object. + * + * @template T - The type of the object. + * @param {T} obj - The object to clone. + * @returns {T} - A shallow clone of the given object. + * + * @example + * // Clone a primitive objs + * const num = 29; + * const clonedNum = clone(num); + * console.log(clonedNum); // 29 + * console.log(clonedNum === num) ; // true + * + * @example + * // Clone an array + * const arr = [1, 2, 3]; + * const clonedArr = clone(arr); + * console.log(clonedArr); // [1, 2, 3] + * console.log(clonedArr === arr); // false + * + * @example + * // Clone an object + * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] }; + * const clonedObj = clone(obj); + * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] } + * console.log(clonedObj === obj); // false + */ +declare function clone(obj: T): T; + +export { clone }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.js new file mode 100644 index 0000000000000000000000000000000000000000..177d411944a9abba722e51f6057c57bd7e5926ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.js @@ -0,0 +1,164 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isPrimitive = require('../../predicate/isPrimitive.js'); +const getTag = require('../_internal/getTag.js'); +const tags = require('../_internal/tags.js'); +const isArray = require('../predicate/isArray.js'); +const isTypedArray = require('../predicate/isTypedArray.js'); + +function clone(obj) { + if (isPrimitive.isPrimitive(obj)) { + return obj; + } + const tag = getTag.getTag(obj); + if (!isCloneableObject(obj)) { + return {}; + } + if (isArray.isArray(obj)) { + const result = Array.from(obj); + if (obj.length > 0 && typeof obj[0] === 'string' && Object.hasOwn(obj, 'index')) { + result.index = obj.index; + result.input = obj.input; + } + return result; + } + if (isTypedArray.isTypedArray(obj)) { + const typedArray = obj; + const Ctor = typedArray.constructor; + return new Ctor(typedArray.buffer, typedArray.byteOffset, typedArray.length); + } + if (tag === tags.arrayBufferTag) { + return new ArrayBuffer(obj.byteLength); + } + if (tag === tags.dataViewTag) { + const dataView = obj; + const buffer = dataView.buffer; + const byteOffset = dataView.byteOffset; + const byteLength = dataView.byteLength; + const clonedBuffer = new ArrayBuffer(byteLength); + const srcView = new Uint8Array(buffer, byteOffset, byteLength); + const destView = new Uint8Array(clonedBuffer); + destView.set(srcView); + return new DataView(clonedBuffer); + } + if (tag === tags.booleanTag || tag === tags.numberTag || tag === tags.stringTag) { + const Ctor = obj.constructor; + const clone = new Ctor(obj.valueOf()); + if (tag === tags.stringTag) { + cloneStringObjectProperties(clone, obj); + } + else { + copyOwnProperties(clone, obj); + } + return clone; + } + if (tag === tags.dateTag) { + return new Date(Number(obj)); + } + if (tag === tags.regexpTag) { + const regExp = obj; + const clone = new RegExp(regExp.source, regExp.flags); + clone.lastIndex = regExp.lastIndex; + return clone; + } + if (tag === tags.symbolTag) { + return Object(Symbol.prototype.valueOf.call(obj)); + } + if (tag === tags.mapTag) { + const map = obj; + const result = new Map(); + map.forEach((obj, key) => { + result.set(key, obj); + }); + return result; + } + if (tag === tags.setTag) { + const set = obj; + const result = new Set(); + set.forEach(obj => { + result.add(obj); + }); + return result; + } + if (tag === tags.argumentsTag) { + const args = obj; + const result = {}; + copyOwnProperties(result, args); + result.length = args.length; + result[Symbol.iterator] = args[Symbol.iterator]; + return result; + } + const result = {}; + copyPrototype(result, obj); + copyOwnProperties(result, obj); + copySymbolProperties(result, obj); + return result; +} +function isCloneableObject(object) { + switch (getTag.getTag(object)) { + case tags.argumentsTag: + case tags.arrayTag: + case tags.arrayBufferTag: + case tags.dataViewTag: + case tags.booleanTag: + case tags.dateTag: + case tags.float32ArrayTag: + case tags.float64ArrayTag: + case tags.int8ArrayTag: + case tags.int16ArrayTag: + case tags.int32ArrayTag: + case tags.mapTag: + case tags.numberTag: + case tags.objectTag: + case tags.regexpTag: + case tags.setTag: + case tags.stringTag: + case tags.symbolTag: + case tags.uint8ArrayTag: + case tags.uint8ClampedArrayTag: + case tags.uint16ArrayTag: + case tags.uint32ArrayTag: { + return true; + } + default: { + return false; + } + } +} +function copyOwnProperties(target, source) { + for (const key in source) { + if (Object.hasOwn(source, key)) { + target[key] = source[key]; + } + } +} +function copySymbolProperties(target, source) { + const symbols = Object.getOwnPropertySymbols(source); + for (let i = 0; i < symbols.length; i++) { + const symbol = symbols[i]; + if (Object.prototype.propertyIsEnumerable.call(source, symbol)) { + target[symbol] = source[symbol]; + } + } +} +function cloneStringObjectProperties(target, source) { + const stringLength = source.valueOf().length; + for (const key in source) { + if (Object.hasOwn(source, key) && (Number.isNaN(Number(key)) || Number(key) >= stringLength)) { + target[key] = source[key]; + } + } +} +function copyPrototype(target, source) { + const proto = Object.getPrototypeOf(source); + if (proto !== null) { + const Ctor = source.constructor; + if (typeof Ctor === 'function') { + Object.setPrototypeOf(target, proto); + } + } +} + +exports.clone = clone; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.mjs new file mode 100644 index 0000000000000000000000000000000000000000..64e3f6ad4496fa7b68e735eee14099acab79cf16 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/clone.mjs @@ -0,0 +1,160 @@ +import { isPrimitive } from '../../predicate/isPrimitive.mjs'; +import { getTag } from '../_internal/getTag.mjs'; +import { arrayBufferTag, dataViewTag, booleanTag, numberTag, stringTag, dateTag, regexpTag, symbolTag, mapTag, setTag, argumentsTag, uint32ArrayTag, uint16ArrayTag, uint8ClampedArrayTag, uint8ArrayTag, objectTag, int32ArrayTag, int16ArrayTag, int8ArrayTag, float64ArrayTag, float32ArrayTag, arrayTag } from '../_internal/tags.mjs'; +import { isArray } from '../predicate/isArray.mjs'; +import { isTypedArray } from '../predicate/isTypedArray.mjs'; + +function clone(obj) { + if (isPrimitive(obj)) { + return obj; + } + const tag = getTag(obj); + if (!isCloneableObject(obj)) { + return {}; + } + if (isArray(obj)) { + const result = Array.from(obj); + if (obj.length > 0 && typeof obj[0] === 'string' && Object.hasOwn(obj, 'index')) { + result.index = obj.index; + result.input = obj.input; + } + return result; + } + if (isTypedArray(obj)) { + const typedArray = obj; + const Ctor = typedArray.constructor; + return new Ctor(typedArray.buffer, typedArray.byteOffset, typedArray.length); + } + if (tag === arrayBufferTag) { + return new ArrayBuffer(obj.byteLength); + } + if (tag === dataViewTag) { + const dataView = obj; + const buffer = dataView.buffer; + const byteOffset = dataView.byteOffset; + const byteLength = dataView.byteLength; + const clonedBuffer = new ArrayBuffer(byteLength); + const srcView = new Uint8Array(buffer, byteOffset, byteLength); + const destView = new Uint8Array(clonedBuffer); + destView.set(srcView); + return new DataView(clonedBuffer); + } + if (tag === booleanTag || tag === numberTag || tag === stringTag) { + const Ctor = obj.constructor; + const clone = new Ctor(obj.valueOf()); + if (tag === stringTag) { + cloneStringObjectProperties(clone, obj); + } + else { + copyOwnProperties(clone, obj); + } + return clone; + } + if (tag === dateTag) { + return new Date(Number(obj)); + } + if (tag === regexpTag) { + const regExp = obj; + const clone = new RegExp(regExp.source, regExp.flags); + clone.lastIndex = regExp.lastIndex; + return clone; + } + if (tag === symbolTag) { + return Object(Symbol.prototype.valueOf.call(obj)); + } + if (tag === mapTag) { + const map = obj; + const result = new Map(); + map.forEach((obj, key) => { + result.set(key, obj); + }); + return result; + } + if (tag === setTag) { + const set = obj; + const result = new Set(); + set.forEach(obj => { + result.add(obj); + }); + return result; + } + if (tag === argumentsTag) { + const args = obj; + const result = {}; + copyOwnProperties(result, args); + result.length = args.length; + result[Symbol.iterator] = args[Symbol.iterator]; + return result; + } + const result = {}; + copyPrototype(result, obj); + copyOwnProperties(result, obj); + copySymbolProperties(result, obj); + return result; +} +function isCloneableObject(object) { + switch (getTag(object)) { + case argumentsTag: + case arrayTag: + case arrayBufferTag: + case dataViewTag: + case booleanTag: + case dateTag: + case float32ArrayTag: + case float64ArrayTag: + case int8ArrayTag: + case int16ArrayTag: + case int32ArrayTag: + case mapTag: + case numberTag: + case objectTag: + case regexpTag: + case setTag: + case stringTag: + case symbolTag: + case uint8ArrayTag: + case uint8ClampedArrayTag: + case uint16ArrayTag: + case uint32ArrayTag: { + return true; + } + default: { + return false; + } + } +} +function copyOwnProperties(target, source) { + for (const key in source) { + if (Object.hasOwn(source, key)) { + target[key] = source[key]; + } + } +} +function copySymbolProperties(target, source) { + const symbols = Object.getOwnPropertySymbols(source); + for (let i = 0; i < symbols.length; i++) { + const symbol = symbols[i]; + if (Object.prototype.propertyIsEnumerable.call(source, symbol)) { + target[symbol] = source[symbol]; + } + } +} +function cloneStringObjectProperties(target, source) { + const stringLength = source.valueOf().length; + for (const key in source) { + if (Object.hasOwn(source, key) && (Number.isNaN(Number(key)) || Number(key) >= stringLength)) { + target[key] = source[key]; + } + } +} +function copyPrototype(target, source) { + const proto = Object.getPrototypeOf(source); + if (proto !== null) { + const Ctor = source.constructor; + if (typeof Ctor === 'function') { + Object.setPrototypeOf(target, proto); + } + } +} + +export { clone }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..15e0af0cea9c660d8d36be63e4b5a345b268ed17 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.d.mts @@ -0,0 +1,49 @@ +/** + * Creates a deep clone of the given object. + * + * @template T - The type of the object. + * @param {T} obj - The object to clone. + * @returns {T} - A deep clone of the given object. + * + * @example + * // Clone a primitive values + * const num = 29; + * const clonedNum = clone(num); + * console.log(clonedNum); // 29 + * console.log(clonedNum === num) ; // true + * + * @example + * // Clone an array + * const arr = [1, 2, 3]; + * const clonedArr = clone(arr); + * console.log(clonedArr); // [1, 2, 3] + * console.log(clonedArr === arr); // false + * + * @example + * // Clone an array with nested objects + * const arr = [1, { a: 1 }, [1, 2, 3]]; + * const clonedArr = clone(arr); + * arr[1].a = 2; + * console.log(arr); // [2, { a: 2 }, [1, 2, 3]] + * console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]] + * console.log(clonedArr === arr); // false + * + * @example + * // Clone an object + * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] }; + * const clonedObj = clone(obj); + * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] } + * console.log(clonedObj === obj); // false + * + * @example + * // Clone an object with nested objects + * const obj = { a: 1, b: { c: 1 } }; + * const clonedObj = clone(obj); + * obj.b.c = 2; + * console.log(obj); // { a: 1, b: { c: 2 } } + * console.log(clonedObj); // { a: 1, b: { c: 1 } } + * console.log(clonedObj === obj); // false + */ +declare function cloneDeep(obj: T): T; + +export { cloneDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..15e0af0cea9c660d8d36be63e4b5a345b268ed17 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.d.ts @@ -0,0 +1,49 @@ +/** + * Creates a deep clone of the given object. + * + * @template T - The type of the object. + * @param {T} obj - The object to clone. + * @returns {T} - A deep clone of the given object. + * + * @example + * // Clone a primitive values + * const num = 29; + * const clonedNum = clone(num); + * console.log(clonedNum); // 29 + * console.log(clonedNum === num) ; // true + * + * @example + * // Clone an array + * const arr = [1, 2, 3]; + * const clonedArr = clone(arr); + * console.log(clonedArr); // [1, 2, 3] + * console.log(clonedArr === arr); // false + * + * @example + * // Clone an array with nested objects + * const arr = [1, { a: 1 }, [1, 2, 3]]; + * const clonedArr = clone(arr); + * arr[1].a = 2; + * console.log(arr); // [2, { a: 2 }, [1, 2, 3]] + * console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]] + * console.log(clonedArr === arr); // false + * + * @example + * // Clone an object + * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] }; + * const clonedObj = clone(obj); + * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] } + * console.log(clonedObj === obj); // false + * + * @example + * // Clone an object with nested objects + * const obj = { a: 1, b: { c: 1 } }; + * const clonedObj = clone(obj); + * obj.b.c = 2; + * console.log(obj); // { a: 1, b: { c: 2 } } + * console.log(clonedObj); // { a: 1, b: { c: 1 } } + * console.log(clonedObj === obj); // false + */ +declare function cloneDeep(obj: T): T; + +export { cloneDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.js new file mode 100644 index 0000000000000000000000000000000000000000..e04bd9fbf76bcee2a50739f68e9fabe005efc792 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const cloneDeepWith = require('./cloneDeepWith.js'); + +function cloneDeep(obj) { + return cloneDeepWith.cloneDeepWith(obj); +} + +exports.cloneDeep = cloneDeep; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c3fc65b65232c3e8ef77a71d6e8bf7e771ee3b3d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeep.mjs @@ -0,0 +1,7 @@ +import { cloneDeepWith } from './cloneDeepWith.mjs'; + +function cloneDeep(obj) { + return cloneDeepWith(obj); +} + +export { cloneDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d8b1f964de3c506e269f4652f1a68b5ddf9e6b59 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.d.mts @@ -0,0 +1,34 @@ +type CloneDeepWithCustomizer = (value: any, key: number | string | undefined, object: TObject | undefined, stack: any) => any; +/** + * Creates a deep clone of the given value using a customizer function. + * + * @template T - The type of the value. + * @param {T} value - The value to clone. + * @param {CloneDeepWithCustomizer} customizer - A function to customize the cloning process. + * @returns {any} - A deep clone of the given value. + * + * @example + * const obj = { a: 1, b: 2 }; + * const clonedObj = cloneDeepWith(obj, (value) => { + * if (typeof value === 'number') { + * return value * 2; + * } + * }); + * // => { a: 2, b: 4 } + */ +declare function cloneDeepWith(value: T, customizer: CloneDeepWithCustomizer): any; +/** + * Creates a deep clone of the given value. + * + * @template T - The type of the value. + * @param {T} value - The value to clone. + * @returns {T} - A deep clone of the given value. + * + * @example + * const obj = { a: 1, b: { c: 2 } }; + * const clonedObj = cloneDeepWith(obj); + * // => { a: 1, b: { c: 2 } } + */ +declare function cloneDeepWith(value: T): T; + +export { cloneDeepWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d8b1f964de3c506e269f4652f1a68b5ddf9e6b59 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.d.ts @@ -0,0 +1,34 @@ +type CloneDeepWithCustomizer = (value: any, key: number | string | undefined, object: TObject | undefined, stack: any) => any; +/** + * Creates a deep clone of the given value using a customizer function. + * + * @template T - The type of the value. + * @param {T} value - The value to clone. + * @param {CloneDeepWithCustomizer} customizer - A function to customize the cloning process. + * @returns {any} - A deep clone of the given value. + * + * @example + * const obj = { a: 1, b: 2 }; + * const clonedObj = cloneDeepWith(obj, (value) => { + * if (typeof value === 'number') { + * return value * 2; + * } + * }); + * // => { a: 2, b: 4 } + */ +declare function cloneDeepWith(value: T, customizer: CloneDeepWithCustomizer): any; +/** + * Creates a deep clone of the given value. + * + * @template T - The type of the value. + * @param {T} value - The value to clone. + * @returns {T} - A deep clone of the given value. + * + * @example + * const obj = { a: 1, b: { c: 2 } }; + * const clonedObj = cloneDeepWith(obj); + * // => { a: 1, b: { c: 2 } } + */ +declare function cloneDeepWith(value: T): T; + +export { cloneDeepWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.js new file mode 100644 index 0000000000000000000000000000000000000000..2a3846913b2419fbe19d1e2a1477a87e45ff3180 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.js @@ -0,0 +1,39 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const cloneDeepWith$1 = require('../../object/cloneDeepWith.js'); +const tags = require('../_internal/tags.js'); + +function cloneDeepWith(obj, customizer) { + return cloneDeepWith$1.cloneDeepWith(obj, (value, key, object, stack) => { + const cloned = customizer?.(value, key, object, stack); + if (cloned != null) { + return cloned; + } + if (typeof obj !== 'object') { + return undefined; + } + switch (Object.prototype.toString.call(obj)) { + case tags.numberTag: + case tags.stringTag: + case tags.booleanTag: { + const result = new obj.constructor(obj?.valueOf()); + cloneDeepWith$1.copyProperties(result, obj); + return result; + } + case tags.argumentsTag: { + const result = {}; + cloneDeepWith$1.copyProperties(result, obj); + result.length = obj.length; + result[Symbol.iterator] = obj[Symbol.iterator]; + return result; + } + default: { + return undefined; + } + } + }); +} + +exports.cloneDeepWith = cloneDeepWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..38630ec7ac1ff053d73307bf20facaf584f9581c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.mjs @@ -0,0 +1,35 @@ +import { cloneDeepWith as cloneDeepWith$1, copyProperties } from '../../object/cloneDeepWith.mjs'; +import { argumentsTag, booleanTag, stringTag, numberTag } from '../_internal/tags.mjs'; + +function cloneDeepWith(obj, customizer) { + return cloneDeepWith$1(obj, (value, key, object, stack) => { + const cloned = customizer?.(value, key, object, stack); + if (cloned != null) { + return cloned; + } + if (typeof obj !== 'object') { + return undefined; + } + switch (Object.prototype.toString.call(obj)) { + case numberTag: + case stringTag: + case booleanTag: { + const result = new obj.constructor(obj?.valueOf()); + copyProperties(result, obj); + return result; + } + case argumentsTag: { + const result = {}; + copyProperties(result, obj); + result.length = obj.length; + result[Symbol.iterator] = obj[Symbol.iterator]; + return result; + } + default: { + return undefined; + } + } + }); +} + +export { cloneDeepWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f5be72bde446ce6dcbda10292c946d1b541b240d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.d.mts @@ -0,0 +1,54 @@ +type CloneWithCustomizer = (value: T, key: number | string | undefined, object: any, stack: any) => R; +/** + * Creates a shallow clone of a value with customizer that returns a specific result type. + * + * @template T - The type of the value to clone. + * @template R - The result type extending primitive types or objects. + * @param {T} value - The value to clone. + * @param {CloneWithCustomizer} customizer - The function to customize cloning. + * @returns {R} Returns the cloned value. + * + * @example + * const obj = { a: 1, b: 2 }; + * const cloned = cloneWith(obj, (value) => { + * if (typeof value === 'object') { + * return JSON.parse(JSON.stringify(value)); + * } + * }); + * // => { a: 1, b: 2 } + */ +declare function cloneWith(value: T, customizer: CloneWithCustomizer): R; +/** + * Creates a shallow clone of a value with optional customizer. + * + * @template T - The type of the value to clone. + * @template R - The result type. + * @param {T} value - The value to clone. + * @param {CloneWithCustomizer} customizer - The function to customize cloning. + * @returns {R | T} Returns the cloned value or the customized result. + * + * @example + * const obj = { a: 1, b: 2 }; + * const cloned = cloneWith(obj, (value) => { + * if (typeof value === 'number') { + * return value * 2; + * } + * }); + * // => { a: 2, b: 4 } + */ +declare function cloneWith(value: T, customizer: CloneWithCustomizer): R | T; +/** + * Creates a shallow clone of a value. + * + * @template T - The type of the value to clone. + * @param {T} value - The value to clone. + * @returns {T} Returns the cloned value. + * + * @example + * const obj = { a: 1, b: 2 }; + * const cloned = cloneWith(obj); + * // => { a: 1, b: 2 } + */ +declare function cloneWith(value: T): T; + +export { cloneWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f5be72bde446ce6dcbda10292c946d1b541b240d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.d.ts @@ -0,0 +1,54 @@ +type CloneWithCustomizer = (value: T, key: number | string | undefined, object: any, stack: any) => R; +/** + * Creates a shallow clone of a value with customizer that returns a specific result type. + * + * @template T - The type of the value to clone. + * @template R - The result type extending primitive types or objects. + * @param {T} value - The value to clone. + * @param {CloneWithCustomizer} customizer - The function to customize cloning. + * @returns {R} Returns the cloned value. + * + * @example + * const obj = { a: 1, b: 2 }; + * const cloned = cloneWith(obj, (value) => { + * if (typeof value === 'object') { + * return JSON.parse(JSON.stringify(value)); + * } + * }); + * // => { a: 1, b: 2 } + */ +declare function cloneWith(value: T, customizer: CloneWithCustomizer): R; +/** + * Creates a shallow clone of a value with optional customizer. + * + * @template T - The type of the value to clone. + * @template R - The result type. + * @param {T} value - The value to clone. + * @param {CloneWithCustomizer} customizer - The function to customize cloning. + * @returns {R | T} Returns the cloned value or the customized result. + * + * @example + * const obj = { a: 1, b: 2 }; + * const cloned = cloneWith(obj, (value) => { + * if (typeof value === 'number') { + * return value * 2; + * } + * }); + * // => { a: 2, b: 4 } + */ +declare function cloneWith(value: T, customizer: CloneWithCustomizer): R | T; +/** + * Creates a shallow clone of a value. + * + * @template T - The type of the value to clone. + * @param {T} value - The value to clone. + * @returns {T} Returns the cloned value. + * + * @example + * const obj = { a: 1, b: 2 }; + * const cloned = cloneWith(obj); + * // => { a: 1, b: 2 } + */ +declare function cloneWith(value: T): T; + +export { cloneWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.js new file mode 100644 index 0000000000000000000000000000000000000000..67aa323cdd5ae00a9c4a4871fac4e88b1ca40c39 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const clone = require('./clone.js'); + +function cloneWith(value, customizer) { + if (!customizer) { + return clone.clone(value); + } + const result = customizer(value); + if (result !== undefined) { + return result; + } + return clone.clone(value); +} + +exports.cloneWith = cloneWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..13fb6ef0e09b83262b92003c85df83ff8e4b52f1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/cloneWith.mjs @@ -0,0 +1,14 @@ +import { clone } from './clone.mjs'; + +function cloneWith(value, customizer) { + if (!customizer) { + return clone(value); + } + const result = customizer(value); + if (result !== undefined) { + return result; + } + return clone(value); +} + +export { cloneWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5d933a9065110f7a217cbc9196eb3b6ac68a1791 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.d.mts @@ -0,0 +1,16 @@ +/** + * Creates an object that inherits from the prototype object. + * + * If `properties` are provided, they will be added to the new object. + * Only string-keyed enumerable properties directly owned by the `properties` object are copied. + * Inherited properties or those with `Symbol` keys are not copied. + * + * @template T - The prototype object type. + * @template U - The properties object type. + * @param {T} prototype - The object to inherit from. + * @param {U} properties - The properties to assign to the created object. + * @returns {T & U} The new object. + */ +declare function create(prototype: T, properties?: U): T & U; + +export { create }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d933a9065110f7a217cbc9196eb3b6ac68a1791 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.d.ts @@ -0,0 +1,16 @@ +/** + * Creates an object that inherits from the prototype object. + * + * If `properties` are provided, they will be added to the new object. + * Only string-keyed enumerable properties directly owned by the `properties` object are copied. + * Inherited properties or those with `Symbol` keys are not copied. + * + * @template T - The prototype object type. + * @template U - The properties object type. + * @param {T} prototype - The object to inherit from. + * @param {U} properties - The properties to assign to the created object. + * @returns {T & U} The new object. + */ +declare function create(prototype: T, properties?: U): T & U; + +export { create }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.js new file mode 100644 index 0000000000000000000000000000000000000000..72d389703520ff3238e6de074ccde4f2bf8105e6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keys = require('./keys.js'); +const assignValue = require('../_internal/assignValue.js'); +const isObject = require('../predicate/isObject.js'); + +function create(prototype, properties) { + const proto = isObject.isObject(prototype) ? Object.create(prototype) : {}; + if (properties != null) { + const propsKeys = keys.keys(properties); + for (let i = 0; i < propsKeys.length; i++) { + const key = propsKeys[i]; + const propsValue = properties[key]; + assignValue.assignValue(proto, key, propsValue); + } + } + return proto; +} + +exports.create = create; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a79167e8ea5e7139a87f5746fccd1605566cfd88 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/create.mjs @@ -0,0 +1,18 @@ +import { keys } from './keys.mjs'; +import { assignValue } from '../_internal/assignValue.mjs'; +import { isObject } from '../predicate/isObject.mjs'; + +function create(prototype, properties) { + const proto = isObject(prototype) ? Object.create(prototype) : {}; + if (properties != null) { + const propsKeys = keys(properties); + for (let i = 0; i < propsKeys.length; i++) { + const key = propsKeys[i]; + const propsValue = properties[key]; + assignValue(proto, key, propsValue); + } + } + return proto; +} + +export { create }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ef6a8c18dc37906b4e1736fec5202c844a73fced --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.d.mts @@ -0,0 +1,100 @@ +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @template S - The type of the object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S} source - The object that specifies the default values to apply. + * @returns {NonNullable} The `object` that has been updated with default values from `source`. + * + * @example + * defaults({ a: 1 }, { b: 2 }); // { a: 1, b: 2 } + * defaults({ a: undefined }, { a: 1 }); // { a: 1 } + */ +declare function defaults(object: T, source: S): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @returns {NonNullable} The `object` that has been updated with default values from `source1` and `source2`. + * + * @example + * defaults({ a: 1 }, { b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 } + * defaults({ a: undefined }, { a: 1 }, { b: 2 }); // { a: 1, b: 2 } + */ +declare function defaults(object: T, source1: S1, source2: S2): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @template S3 - The type of the third object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @param {S3} source3 - The third object that specifies the default values to apply. + * @returns {NonNullable} The `object` that has been updated with default values from `source1`, `source2`, and `source3`. + * + * @example + * defaults({ a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }); // { a: 1, b: 2, c: 3, d: 4 } + * defaults({ a: undefined }, { a: 1 }, { b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 } + */ +declare function defaults(object: T, source1: S1, source2: S2, source3: S3): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @template S3 - The type of the third object that provides default values. + * @template S4 - The type of the fourth object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @param {S3} source3 - The third object that specifies the default values to apply. + * @param {S4} source4 - The fourth object that specifies the default values to apply. + * @returns {NonNullable} The `object` that has been updated with default values from `source1`, `source2`, `source3`, and `source4`. + * + * @example + * defaults({ a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }, { e: 5 }); // { a: 1, b: 2, c: 3, d: 4, e: 5 } + * defaults({ a: undefined }, { a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }); // { a: 1, b: 2, c: 3, d: 4 } + */ +declare function defaults(object: T, source1: S1, source2: S2, source3: S3, source4: S4): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @param {T} object - The target object that will receive default values. + * @returns {NonNullable} The `object` that has been updated with default values. + * + * @example + * defaults({ a: 1 }); // { a: 1 } + * defaults({ a: undefined }); // { a: undefined } + */ +declare function defaults(object: T): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @param {any} object - The target object that will receive default values. + * @param {...any[]} sources - The objects that specify the default values to apply. + * @returns {any} The `object` that has been updated with default values from `sources`. + * + * @example + * defaults({}, { a: 1 }, { b: 2 }); // { a: 1, b: 2 } + * defaults({ a: undefined }, { a: 1 }); // { a: 1 } + */ +declare function defaults(object: any, ...sources: any[]): any; + +export { defaults }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ef6a8c18dc37906b4e1736fec5202c844a73fced --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.d.ts @@ -0,0 +1,100 @@ +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @template S - The type of the object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S} source - The object that specifies the default values to apply. + * @returns {NonNullable} The `object` that has been updated with default values from `source`. + * + * @example + * defaults({ a: 1 }, { b: 2 }); // { a: 1, b: 2 } + * defaults({ a: undefined }, { a: 1 }); // { a: 1 } + */ +declare function defaults(object: T, source: S): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @returns {NonNullable} The `object` that has been updated with default values from `source1` and `source2`. + * + * @example + * defaults({ a: 1 }, { b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 } + * defaults({ a: undefined }, { a: 1 }, { b: 2 }); // { a: 1, b: 2 } + */ +declare function defaults(object: T, source1: S1, source2: S2): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @template S3 - The type of the third object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @param {S3} source3 - The third object that specifies the default values to apply. + * @returns {NonNullable} The `object` that has been updated with default values from `source1`, `source2`, and `source3`. + * + * @example + * defaults({ a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }); // { a: 1, b: 2, c: 3, d: 4 } + * defaults({ a: undefined }, { a: 1 }, { b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 } + */ +declare function defaults(object: T, source1: S1, source2: S2, source3: S3): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @template S3 - The type of the third object that provides default values. + * @template S4 - The type of the fourth object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @param {S3} source3 - The third object that specifies the default values to apply. + * @param {S4} source4 - The fourth object that specifies the default values to apply. + * @returns {NonNullable} The `object` that has been updated with default values from `source1`, `source2`, `source3`, and `source4`. + * + * @example + * defaults({ a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }, { e: 5 }); // { a: 1, b: 2, c: 3, d: 4, e: 5 } + * defaults({ a: undefined }, { a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }); // { a: 1, b: 2, c: 3, d: 4 } + */ +declare function defaults(object: T, source1: S1, source2: S2, source3: S3, source4: S4): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @template T - The type of the object being processed. + * @param {T} object - The target object that will receive default values. + * @returns {NonNullable} The `object` that has been updated with default values. + * + * @example + * defaults({ a: 1 }); // { a: 1 } + * defaults({ a: undefined }); // { a: undefined } + */ +declare function defaults(object: T): NonNullable; +/** + * Assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * @param {any} object - The target object that will receive default values. + * @param {...any[]} sources - The objects that specify the default values to apply. + * @returns {any} The `object` that has been updated with default values from `sources`. + * + * @example + * defaults({}, { a: 1 }, { b: 2 }); // { a: 1, b: 2 } + * defaults({ a: undefined }, { a: 1 }); // { a: 1 } + */ +declare function defaults(object: any, ...sources: any[]): any; + +export { defaults }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.js new file mode 100644 index 0000000000000000000000000000000000000000..e03af3378f6ac2e8581e04f31d61de53bd45e849 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.js @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isIterateeCall = require('../_internal/isIterateeCall.js'); +const eq = require('../util/eq.js'); + +function defaults(object, ...sources) { + object = Object(object); + const objectProto = Object.prototype; + let length = sources.length; + const guard = length > 2 ? sources[2] : undefined; + if (guard && isIterateeCall.isIterateeCall(sources[0], sources[1], guard)) { + length = 1; + } + for (let i = 0; i < length; i++) { + const source = sources[i]; + const keys = Object.keys(source); + for (let j = 0; j < keys.length; j++) { + const key = keys[j]; + const value = object[key]; + if (value === undefined || + (!Object.hasOwn(object, key) && eq.eq(value, objectProto[key]))) { + object[key] = source[key]; + } + } + } + return object; +} + +exports.defaults = defaults; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.mjs new file mode 100644 index 0000000000000000000000000000000000000000..19f25400910a27682453f58e7728f30f1d85728e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaults.mjs @@ -0,0 +1,27 @@ +import { isIterateeCall } from '../_internal/isIterateeCall.mjs'; +import { eq } from '../util/eq.mjs'; + +function defaults(object, ...sources) { + object = Object(object); + const objectProto = Object.prototype; + let length = sources.length; + const guard = length > 2 ? sources[2] : undefined; + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + length = 1; + } + for (let i = 0; i < length; i++) { + const source = sources[i]; + const keys = Object.keys(source); + for (let j = 0; j < keys.length; j++) { + const key = keys[j]; + const value = object[key]; + if (value === undefined || + (!Object.hasOwn(object, key) && eq(value, objectProto[key]))) { + object[key] = source[key]; + } + } + } + return object; +} + +export { defaults }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..50616f79b0194b5fbd67f16a1e960959e6699eb7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.d.mts @@ -0,0 +1,23 @@ +/** + * Recursively assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * Similar to `defaults` but recursively applies default values to nested objects. + * Source objects are applied in order from left to right, and once a property has been assigned a value, + * any subsequent values for that property will be ignored. + * + * Note: This function modifies the first argument, `object`. + * + * @template T - The type of the object being processed. + * @param {any} target - The target object that will receive default values. + * @param {any[]} sources - One or more source objects that specify default values to apply. + * @returns {any} The `object` that has been updated with default values from all sources, recursively merging nested objects. + * + * @example + * defaultsDeep({ a: { b: 2 } }, { a: { b: 3, c: 3 }, d: 4 }); // { a: { b: 2, c: 3 }, d: 4 } + * defaultsDeep({ a: { b: undefined } }, { a: { b: 1 } }); // { a: { b: 1 } } + * defaultsDeep({ a: null }, { a: { b: 1 } }); // { a: null } + */ +declare function defaultsDeep(target: any, ...sources: any[]): any; + +export { defaultsDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..50616f79b0194b5fbd67f16a1e960959e6699eb7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.d.ts @@ -0,0 +1,23 @@ +/** + * Recursively assigns default values to an `object`, ensuring that certain properties do not remain `undefined`. + * It sets default values for properties that are either `undefined` or inherited from `Object.prototype`. + * + * Similar to `defaults` but recursively applies default values to nested objects. + * Source objects are applied in order from left to right, and once a property has been assigned a value, + * any subsequent values for that property will be ignored. + * + * Note: This function modifies the first argument, `object`. + * + * @template T - The type of the object being processed. + * @param {any} target - The target object that will receive default values. + * @param {any[]} sources - One or more source objects that specify default values to apply. + * @returns {any} The `object` that has been updated with default values from all sources, recursively merging nested objects. + * + * @example + * defaultsDeep({ a: { b: 2 } }, { a: { b: 3, c: 3 }, d: 4 }); // { a: { b: 2, c: 3 }, d: 4 } + * defaultsDeep({ a: { b: undefined } }, { a: { b: 1 } }); // { a: { b: 1 } } + * defaultsDeep({ a: null }, { a: { b: 1 } }); // { a: null } + */ +declare function defaultsDeep(target: any, ...sources: any[]): any; + +export { defaultsDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.js new file mode 100644 index 0000000000000000000000000000000000000000..fdc795b04c03accad33b7f1cb82d17051bbd987c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.js @@ -0,0 +1,47 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isPlainObject = require('../predicate/isPlainObject.js'); + +function defaultsDeep(target, ...sources) { + target = Object(target); + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + if (source != null) { + const stack = new WeakMap(); + defaultsDeepRecursive(target, source, stack); + } + } + return target; +} +function defaultsDeepRecursive(target, source, stack) { + for (const key in source) { + const sourceValue = source[key]; + const targetValue = target[key]; + const targetHasKey = Object.hasOwn(target, key); + if (!targetHasKey || targetValue === undefined) { + if (stack.has(sourceValue)) { + target[key] = stack.get(sourceValue); + } + else if (isPlainObject.isPlainObject(sourceValue)) { + const newObj = {}; + stack.set(sourceValue, newObj); + target[key] = newObj; + defaultsDeepRecursive(newObj, sourceValue, stack); + } + else { + target[key] = sourceValue; + } + } + else if (isPlainObject.isPlainObject(targetValue) && isPlainObject.isPlainObject(sourceValue)) { + const inStack = stack.has(sourceValue); + if (!inStack || (inStack && stack.get(sourceValue) !== targetValue)) { + stack.set(sourceValue, targetValue); + defaultsDeepRecursive(targetValue, sourceValue, stack); + } + } + } +} + +exports.defaultsDeep = defaultsDeep; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a789bb8236c3eba5dd77c4ecb863e1f3f3aaa67f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/defaultsDeep.mjs @@ -0,0 +1,43 @@ +import { isPlainObject } from '../predicate/isPlainObject.mjs'; + +function defaultsDeep(target, ...sources) { + target = Object(target); + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + if (source != null) { + const stack = new WeakMap(); + defaultsDeepRecursive(target, source, stack); + } + } + return target; +} +function defaultsDeepRecursive(target, source, stack) { + for (const key in source) { + const sourceValue = source[key]; + const targetValue = target[key]; + const targetHasKey = Object.hasOwn(target, key); + if (!targetHasKey || targetValue === undefined) { + if (stack.has(sourceValue)) { + target[key] = stack.get(sourceValue); + } + else if (isPlainObject(sourceValue)) { + const newObj = {}; + stack.set(sourceValue, newObj); + target[key] = newObj; + defaultsDeepRecursive(newObj, sourceValue, stack); + } + else { + target[key] = sourceValue; + } + } + else if (isPlainObject(targetValue) && isPlainObject(sourceValue)) { + const inStack = stack.has(sourceValue); + if (!inStack || (inStack && stack.get(sourceValue) !== targetValue)) { + stack.set(sourceValue, targetValue); + defaultsDeepRecursive(targetValue, sourceValue, stack); + } + } + } +} + +export { defaultsDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9adbf05424ab81a25aad047172bf2314ce974bab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.d.mts @@ -0,0 +1,17 @@ +import { ObjectIteratee } from '../_internal/ObjectIteratee.mjs'; + +/** + * Finds the key of the first element that matches the given predicate. + * + * This function determines the type of the predicate and delegates the search + * to the appropriate helper function. It supports predicates as functions, objects, + * arrays, or strings. + * + * @template T - The type of the object. + * @param {T | null | undefined} obj - The object to inspect. + * @param {ObjectIteratee} predicate - The predicate to match. + * @returns {string | undefined} Returns the key of the matched element, else `undefined`. + */ +declare function findKey(obj: T | null | undefined, predicate?: ObjectIteratee): string | undefined; + +export { findKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..081e423f0266256cb381301330b3d5d3ffcdecfd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.d.ts @@ -0,0 +1,17 @@ +import { ObjectIteratee } from '../_internal/ObjectIteratee.js'; + +/** + * Finds the key of the first element that matches the given predicate. + * + * This function determines the type of the predicate and delegates the search + * to the appropriate helper function. It supports predicates as functions, objects, + * arrays, or strings. + * + * @template T - The type of the object. + * @param {T | null | undefined} obj - The object to inspect. + * @param {ObjectIteratee} predicate - The predicate to match. + * @returns {string | undefined} Returns the key of the matched element, else `undefined`. + */ +declare function findKey(obj: T | null | undefined, predicate?: ObjectIteratee): string | undefined; + +export { findKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.js new file mode 100644 index 0000000000000000000000000000000000000000..a96f766edd77a1e73a4e305ca881d19068c8318e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const findKey$1 = require('../../object/findKey.js'); +const identity = require('../function/identity.js'); +const isObject = require('../predicate/isObject.js'); +const iteratee = require('../util/iteratee.js'); + +function findKey(obj, predicate) { + if (!isObject.isObject(obj)) { + return undefined; + } + const iteratee$1 = iteratee.iteratee(predicate ?? identity.identity); + return findKey$1.findKey(obj, iteratee$1); +} + +exports.findKey = findKey; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.mjs new file mode 100644 index 0000000000000000000000000000000000000000..92b43b2c64e1ceefd0c15f02ade9d3d06a8fd9b9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findKey.mjs @@ -0,0 +1,14 @@ +import { findKey as findKey$1 } from '../../object/findKey.mjs'; +import { identity } from '../function/identity.mjs'; +import { isObject } from '../predicate/isObject.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function findKey(obj, predicate) { + if (!isObject(obj)) { + return undefined; + } + const iteratee$1 = iteratee(predicate ?? identity); + return findKey$1(obj, iteratee$1); +} + +export { findKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..60cd010f98712f4662678ea442569aa960472c30 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.d.mts @@ -0,0 +1,17 @@ +import { ObjectIteratee } from '../_internal/ObjectIteratee.mjs'; + +/** + * Finds the key of the last element that matches the given predicate. + * + * This function determines the type of the predicate and delegates the search + * to the appropriate helper function. It supports predicates as functions, objects, + * arrays, or strings. + * + * @template T - The type of the object. + * @param {T | null | undefined} obj - The object to inspect. + * @param {ObjectIteratee} predicate - The predicate to match. + * @returns {string | undefined} Returns the key of the matched element, else `undefined`. + */ +declare function findLastKey(obj: T | null | undefined, predicate?: ObjectIteratee): string | undefined; + +export { findLastKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9505f67d03137a62c0164037e9bfb9c8c5dcfae6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.d.ts @@ -0,0 +1,17 @@ +import { ObjectIteratee } from '../_internal/ObjectIteratee.js'; + +/** + * Finds the key of the last element that matches the given predicate. + * + * This function determines the type of the predicate and delegates the search + * to the appropriate helper function. It supports predicates as functions, objects, + * arrays, or strings. + * + * @template T - The type of the object. + * @param {T | null | undefined} obj - The object to inspect. + * @param {ObjectIteratee} predicate - The predicate to match. + * @returns {string | undefined} Returns the key of the matched element, else `undefined`. + */ +declare function findLastKey(obj: T | null | undefined, predicate?: ObjectIteratee): string | undefined; + +export { findLastKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.js new file mode 100644 index 0000000000000000000000000000000000000000..20ee2f8a9034e7a4cb04b6f7fe7201dbd7d5a1f7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../function/identity.js'); +const isObject = require('../predicate/isObject.js'); +const iteratee = require('../util/iteratee.js'); + +function findLastKey(obj, predicate) { + if (!isObject.isObject(obj)) { + return undefined; + } + const iteratee$1 = iteratee.iteratee(predicate ?? identity.identity); + const keys = Object.keys(obj); + return keys.findLast(key => iteratee$1(obj[key], key, obj)); +} + +exports.findLastKey = findLastKey; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.mjs new file mode 100644 index 0000000000000000000000000000000000000000..dc53dd16b8101977166d0c80c29dc85371037bc9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/findLastKey.mjs @@ -0,0 +1,14 @@ +import { identity } from '../function/identity.mjs'; +import { isObject } from '../predicate/isObject.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function findLastKey(obj, predicate) { + if (!isObject(obj)) { + return undefined; + } + const iteratee$1 = iteratee(predicate ?? identity); + const keys = Object.keys(obj); + return keys.findLast(key => iteratee$1(obj[key], key, obj)); +} + +export { findLastKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e613bc8c69b28dd058d5cd28dce32d5bfc575bb1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.d.mts @@ -0,0 +1,58 @@ +/** + * Iterates over an object and invokes the `iteratee` function for each property. + * + * Iterates over string keyed properties including inherited properties. + * + * The iteration is terminated early if the `iteratee` function returns `false`. + * + * @template T - The type of the object + * @param {T} object - The object to iterate over + * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration + * @returns {T} Returns the object + * + * @example + * // Iterate over all properties including inherited ones + * const obj = { a: 1, b: 2 }; + * forIn(obj, (value, key) => { + * console.log(key, value); + * }); + * // Output: 'a' 1, 'b' 2 + * + * // Early termination + * forIn(obj, (value, key) => { + * console.log(key, value); + * return key !== 'a'; // stop after 'a' + * }); + * // Output: 'a' 1 + */ +declare function forIn(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T; +/** + * Iterates over an object and invokes the `iteratee` function for each property. + * + * Iterates over string keyed properties including inherited properties. + * + * The iteration is terminated early if the `iteratee` function returns `false`. + * + * @template T - The type of the object + * @param {T | null | undefined} object - The object to iterate over + * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration + * @returns {T | null | undefined} Returns the object + * + * @example + * // Iterate over all properties including inherited ones + * const obj = { a: 1, b: 2 }; + * forIn(obj, (value, key) => { + * console.log(key, value); + * }); + * // Output: 'a' 1, 'b' 2 + * + * // Early termination + * forIn(obj, (value, key) => { + * console.log(key, value); + * return key !== 'a'; // stop after 'a' + * }); + * // Output: 'a' 1 + */ +declare function forIn(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined; + +export { forIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e613bc8c69b28dd058d5cd28dce32d5bfc575bb1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.d.ts @@ -0,0 +1,58 @@ +/** + * Iterates over an object and invokes the `iteratee` function for each property. + * + * Iterates over string keyed properties including inherited properties. + * + * The iteration is terminated early if the `iteratee` function returns `false`. + * + * @template T - The type of the object + * @param {T} object - The object to iterate over + * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration + * @returns {T} Returns the object + * + * @example + * // Iterate over all properties including inherited ones + * const obj = { a: 1, b: 2 }; + * forIn(obj, (value, key) => { + * console.log(key, value); + * }); + * // Output: 'a' 1, 'b' 2 + * + * // Early termination + * forIn(obj, (value, key) => { + * console.log(key, value); + * return key !== 'a'; // stop after 'a' + * }); + * // Output: 'a' 1 + */ +declare function forIn(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T; +/** + * Iterates over an object and invokes the `iteratee` function for each property. + * + * Iterates over string keyed properties including inherited properties. + * + * The iteration is terminated early if the `iteratee` function returns `false`. + * + * @template T - The type of the object + * @param {T | null | undefined} object - The object to iterate over + * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration + * @returns {T | null | undefined} Returns the object + * + * @example + * // Iterate over all properties including inherited ones + * const obj = { a: 1, b: 2 }; + * forIn(obj, (value, key) => { + * console.log(key, value); + * }); + * // Output: 'a' 1, 'b' 2 + * + * // Early termination + * forIn(obj, (value, key) => { + * console.log(key, value); + * return key !== 'a'; // stop after 'a' + * }); + * // Output: 'a' 1 + */ +declare function forIn(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined; + +export { forIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.js new file mode 100644 index 0000000000000000000000000000000000000000..223cd4f9f799ac0db0361708c0f90856b569b1d1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); + +function forIn(object, iteratee = identity.identity) { + if (object == null) { + return object; + } + for (const key in object) { + const result = iteratee(object[key], key, object); + if (result === false) { + break; + } + } + return object; +} + +exports.forIn = forIn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..03a072b7f030786b928ae7d8797b988ff4aa7039 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forIn.mjs @@ -0,0 +1,16 @@ +import { identity } from '../../function/identity.mjs'; + +function forIn(object, iteratee = identity) { + if (object == null) { + return object; + } + for (const key in object) { + const result = iteratee(object[key], key, object); + if (result === false) { + break; + } + } + return object; +} + +export { forIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0bbf3b0299e50b1c202d02d8625d6874ab553c88 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.d.mts @@ -0,0 +1,58 @@ +/** + * Iterates over an object in reverse order and invokes the `iteratee` function for each property. + * + * Iterates over string keyed properties including inherited properties in reverse order. + * + * The iteration is terminated early if the `iteratee` function returns `false`. + * + * @template T - The type of the object + * @param {T} object - The object to iterate over + * @param {(value: T[keyof T], key: string, collection: T) => any} iteratee - The function invoked per iteration + * @returns {T} Returns the object + * + * @example + * // Iterate over all properties including inherited ones + * const obj = { a: 1, b: 2 }; + * forInRight(obj, (value, key) => { + * console.log(key, value); + * }); + * // Output: 'b' 2, 'a' 1 + * + * // Early termination + * forInRight(obj, (value, key) => { + * console.log(key, value); + * return key !== 'a'; // stop after 'a' + * }); + * // Output: 'b' 2 + */ +declare function forInRight(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T; +/** + * Iterates over an object in reverse order and invokes the `iteratee` function for each property. + * + * Iterates over string keyed properties including inherited properties in reverse order. + * + * The iteration is terminated early if the `iteratee` function returns `false`. + * + * @template T - The type of the object + * @param {T | null | undefined} object - The object to iterate over + * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration + * @returns {T | null | undefined} Returns the object + * + * @example + * // Iterate over all properties including inherited ones + * const obj = { a: 1, b: 2 }; + * forInRight(obj, (value, key) => { + * console.log(key, value); + * }); + * // Output: 'b' 2, 'a' 1 + * + * // Early termination + * forInRight(obj, (value, key) => { + * console.log(key, value); + * return key !== 'a'; // stop after 'a' + * }); + * // Output: 'b' 2 + */ +declare function forInRight(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined; + +export { forInRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0bbf3b0299e50b1c202d02d8625d6874ab553c88 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.d.ts @@ -0,0 +1,58 @@ +/** + * Iterates over an object in reverse order and invokes the `iteratee` function for each property. + * + * Iterates over string keyed properties including inherited properties in reverse order. + * + * The iteration is terminated early if the `iteratee` function returns `false`. + * + * @template T - The type of the object + * @param {T} object - The object to iterate over + * @param {(value: T[keyof T], key: string, collection: T) => any} iteratee - The function invoked per iteration + * @returns {T} Returns the object + * + * @example + * // Iterate over all properties including inherited ones + * const obj = { a: 1, b: 2 }; + * forInRight(obj, (value, key) => { + * console.log(key, value); + * }); + * // Output: 'b' 2, 'a' 1 + * + * // Early termination + * forInRight(obj, (value, key) => { + * console.log(key, value); + * return key !== 'a'; // stop after 'a' + * }); + * // Output: 'b' 2 + */ +declare function forInRight(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T; +/** + * Iterates over an object in reverse order and invokes the `iteratee` function for each property. + * + * Iterates over string keyed properties including inherited properties in reverse order. + * + * The iteration is terminated early if the `iteratee` function returns `false`. + * + * @template T - The type of the object + * @param {T | null | undefined} object - The object to iterate over + * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration + * @returns {T | null | undefined} Returns the object + * + * @example + * // Iterate over all properties including inherited ones + * const obj = { a: 1, b: 2 }; + * forInRight(obj, (value, key) => { + * console.log(key, value); + * }); + * // Output: 'b' 2, 'a' 1 + * + * // Early termination + * forInRight(obj, (value, key) => { + * console.log(key, value); + * return key !== 'a'; // stop after 'a' + * }); + * // Output: 'b' 2 + */ +declare function forInRight(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined; + +export { forInRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.js new file mode 100644 index 0000000000000000000000000000000000000000..c572abc0eff75b386344d6e4357d4635ad57be0a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); + +function forInRight(object, iteratee = identity.identity) { + if (object == null) { + return object; + } + const keys = []; + for (const key in object) { + keys.push(key); + } + for (let i = keys.length - 1; i >= 0; i--) { + const key = keys[i]; + const result = iteratee(object[key], key, object); + if (result === false) { + break; + } + } + return object; +} + +exports.forInRight = forInRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..20ff6eb38947f224e9a08475979ed8df2b58433d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forInRight.mjs @@ -0,0 +1,21 @@ +import { identity } from '../../function/identity.mjs'; + +function forInRight(object, iteratee = identity) { + if (object == null) { + return object; + } + const keys = []; + for (const key in object) { + keys.push(key); + } + for (let i = keys.length - 1; i >= 0; i--) { + const key = keys[i]; + const result = iteratee(object[key], key, object); + if (result === false) { + break; + } + } + return object; +} + +export { forInRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1c1943bb39f4d0a84862c6a4f454abe9d58c8b72 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.d.mts @@ -0,0 +1,54 @@ +/** + * Iterates over an object's properties and calls the `iteratee` function for each property. + * + * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys. + * + * The `iteratee` function can terminate the iteration early by returning `false`. + * + * @template T - The type of the object. + * @param {T} object The object to iterate over. + * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used. + * @return {T} Returns object. + * + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * forOwn(new Foo(), function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ +declare function forOwn(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T; +/** + * Iterates over an object's properties and calls the `iteratee` function for each property. + * + * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys. + * + * The `iteratee` function can terminate the iteration early by returning `false`. + * + * @template T - The type of the object. + * @param {T | null | undefined} object The object to iterate over. + * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used. + * @return {T | null | undefined} Returns object. + * + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * forOwn(new Foo(), function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ +declare function forOwn(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined; + +export { forOwn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1c1943bb39f4d0a84862c6a4f454abe9d58c8b72 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.d.ts @@ -0,0 +1,54 @@ +/** + * Iterates over an object's properties and calls the `iteratee` function for each property. + * + * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys. + * + * The `iteratee` function can terminate the iteration early by returning `false`. + * + * @template T - The type of the object. + * @param {T} object The object to iterate over. + * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used. + * @return {T} Returns object. + * + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * forOwn(new Foo(), function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ +declare function forOwn(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T; +/** + * Iterates over an object's properties and calls the `iteratee` function for each property. + * + * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys. + * + * The `iteratee` function can terminate the iteration early by returning `false`. + * + * @template T - The type of the object. + * @param {T | null | undefined} object The object to iterate over. + * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used. + * @return {T | null | undefined} Returns object. + * + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * forOwn(new Foo(), function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). + */ +declare function forOwn(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined; + +export { forOwn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.js new file mode 100644 index 0000000000000000000000000000000000000000..1093ebbdae256bd4bb25afd875a1928e06ff152c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keys = require('./keys.js'); +const identity = require('../../function/identity.js'); + +function forOwn(object, iteratee = identity.identity) { + if (object == null) { + return object; + } + const iterable = Object(object); + const keys$1 = keys.keys(object); + for (let i = 0; i < keys$1.length; ++i) { + const key = keys$1[i]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; +} + +exports.forOwn = forOwn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..952b3aaee4952b3699acac4d71e672efcda6bb6c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwn.mjs @@ -0,0 +1,19 @@ +import { keys } from './keys.mjs'; +import { identity } from '../../function/identity.mjs'; + +function forOwn(object, iteratee = identity) { + if (object == null) { + return object; + } + const iterable = Object(object); + const keys$1 = keys(object); + for (let i = 0; i < keys$1.length; ++i) { + const key = keys$1[i]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; +} + +export { forOwn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..36838871fc09f09372a65311728b121c7364f4ba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.d.mts @@ -0,0 +1,54 @@ +/** + * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property. + * + * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys. + * + * The `iteratee` function can terminate the iteration early by returning `false`. + * + * @template T - The type of the object. + * @param {T} object The object to iterate over. + * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used. + * @return {T} Returns object. + * + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * forOwnRight(new Foo(), function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' (iteration order is not guaranteed). + */ +declare function forOwnRight(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T; +/** + * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property. + * + * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys. + * + * The `iteratee` function can terminate the iteration early by returning `false`. + * + * @template T - The type of the object. + * @param {T | null | undefined} object The object to iterate over. + * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used. + * @return {T | null | undefined} Returns object. + * + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * forOwnRight(new Foo(), function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' (iteration order is not guaranteed). + */ +declare function forOwnRight(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined; + +export { forOwnRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..36838871fc09f09372a65311728b121c7364f4ba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.d.ts @@ -0,0 +1,54 @@ +/** + * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property. + * + * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys. + * + * The `iteratee` function can terminate the iteration early by returning `false`. + * + * @template T - The type of the object. + * @param {T} object The object to iterate over. + * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used. + * @return {T} Returns object. + * + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * forOwnRight(new Foo(), function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' (iteration order is not guaranteed). + */ +declare function forOwnRight(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T; +/** + * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property. + * + * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys. + * + * The `iteratee` function can terminate the iteration early by returning `false`. + * + * @template T - The type of the object. + * @param {T | null | undefined} object The object to iterate over. + * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used. + * @return {T | null | undefined} Returns object. + * + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * forOwnRight(new Foo(), function(value, key) { + * console.log(key); + * }); + * // => Logs 'b' then 'a' (iteration order is not guaranteed). + */ +declare function forOwnRight(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined; + +export { forOwnRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.js new file mode 100644 index 0000000000000000000000000000000000000000..d24e10cd11780bae0a24a000b27e6cfedc5b0e18 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keys = require('./keys.js'); +const identity = require('../../function/identity.js'); + +function forOwnRight(object, iteratee = identity.identity) { + if (object == null) { + return object; + } + const iterable = Object(object); + const keys$1 = keys.keys(object); + for (let i = keys$1.length - 1; i >= 0; --i) { + const key = keys$1[i]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; +} + +exports.forOwnRight = forOwnRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..62bb95f0f052d2e9d976d4f4eb18c9b82ec9003b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/forOwnRight.mjs @@ -0,0 +1,19 @@ +import { keys } from './keys.mjs'; +import { identity } from '../../function/identity.mjs'; + +function forOwnRight(object, iteratee = identity) { + if (object == null) { + return object; + } + const iterable = Object(object); + const keys$1 = keys(object); + for (let i = keys$1.length - 1; i >= 0; --i) { + const key = keys$1[i]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; +} + +export { forOwnRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..618fef7eac760d43f2347f24040d6d980814045c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.d.mts @@ -0,0 +1,28 @@ +type PropertyName = string | number | symbol; +/** + * Converts an array of key-value pairs into an object. + * + * @template T - The type of the values. + * @param {ArrayLike<[PropertyName, T]> | null | undefined} pairs - An array of key-value pairs. + * @returns {Record} - An object where keys are strings and values are of type T. + * + * @example + * const pairs = [['a', 1], ['b', 2]]; + * const result = fromPairs(pairs); + * // => { a: 1, b: 2 } + */ +declare function fromPairs(pairs: ArrayLike<[PropertyName, T]> | null | undefined): Record; +/** + * Converts an array of key-value pairs into an object. + * + * @param {ArrayLike | null | undefined} pairs - An array of key-value pairs. + * @returns {Record} - An object where keys are strings and values can be any type. + * + * @example + * const pairs = [['a', 1], ['b', 'hello']]; + * const result = fromPairs(pairs); + * // => { a: 1, b: 'hello' } + */ +declare function fromPairs(pairs: ArrayLike | null | undefined): Record; + +export { fromPairs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..618fef7eac760d43f2347f24040d6d980814045c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.d.ts @@ -0,0 +1,28 @@ +type PropertyName = string | number | symbol; +/** + * Converts an array of key-value pairs into an object. + * + * @template T - The type of the values. + * @param {ArrayLike<[PropertyName, T]> | null | undefined} pairs - An array of key-value pairs. + * @returns {Record} - An object where keys are strings and values are of type T. + * + * @example + * const pairs = [['a', 1], ['b', 2]]; + * const result = fromPairs(pairs); + * // => { a: 1, b: 2 } + */ +declare function fromPairs(pairs: ArrayLike<[PropertyName, T]> | null | undefined): Record; +/** + * Converts an array of key-value pairs into an object. + * + * @param {ArrayLike | null | undefined} pairs - An array of key-value pairs. + * @returns {Record} - An object where keys are strings and values can be any type. + * + * @example + * const pairs = [['a', 1], ['b', 'hello']]; + * const result = fromPairs(pairs); + * // => { a: 1, b: 'hello' } + */ +declare function fromPairs(pairs: ArrayLike | null | undefined): Record; + +export { fromPairs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.js new file mode 100644 index 0000000000000000000000000000000000000000..63b8dfaaef0e96fbd57454f4dfab9ec724a51429 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLike = require('../predicate/isArrayLike.js'); + +function fromPairs(pairs) { + if (!isArrayLike.isArrayLike(pairs)) { + return {}; + } + const result = {}; + for (let i = 0; i < pairs.length; i++) { + const [key, value] = pairs[i]; + result[key] = value; + } + return result; +} + +exports.fromPairs = fromPairs; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b2d058cdedbb8724539fbc1d66e23a874054838b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/fromPairs.mjs @@ -0,0 +1,15 @@ +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function fromPairs(pairs) { + if (!isArrayLike(pairs)) { + return {}; + } + const result = {}; + for (let i = 0; i < pairs.length; i++) { + const [key, value] = pairs[i]; + result[key] = value; + } + return result; +} + +export { fromPairs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d8123e42e1f074a55ac3ca2333c53b625335dddb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.d.mts @@ -0,0 +1,20 @@ +/** + * Creates an array of property names from an object where the property values are functions. + * + * @param {any} object - The object to inspect. + * @returns {string[]} - An array of function property names. + * + * @example + * function Foo() { + * this.a = () => 'a'; + * this.b = () => 'b'; + * } + * + * Foo.prototype.c = () => 'c'; + * + * functions(new Foo); + * // => ['a', 'b'] + */ +declare function functions(object: any): string[]; + +export { functions }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d8123e42e1f074a55ac3ca2333c53b625335dddb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.d.ts @@ -0,0 +1,20 @@ +/** + * Creates an array of property names from an object where the property values are functions. + * + * @param {any} object - The object to inspect. + * @returns {string[]} - An array of function property names. + * + * @example + * function Foo() { + * this.a = () => 'a'; + * this.b = () => 'b'; + * } + * + * Foo.prototype.c = () => 'c'; + * + * functions(new Foo); + * // => ['a', 'b'] + */ +declare function functions(object: any): string[]; + +export { functions }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.js new file mode 100644 index 0000000000000000000000000000000000000000..907153d76bf5111d2a5fd54b0acc8a273335dd87 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keys = require('./keys.js'); + +function functions(object) { + if (object == null) { + return []; + } + return keys.keys(object).filter(key => typeof object[key] === 'function'); +} + +exports.functions = functions; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c71eab076c30cb6261b30a0187c3b6be09d4047a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functions.mjs @@ -0,0 +1,10 @@ +import { keys } from './keys.mjs'; + +function functions(object) { + if (object == null) { + return []; + } + return keys(object).filter(key => typeof object[key] === 'function'); +} + +export { functions }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..642b357c1e0893df8adf706ab8443e01acb2bcb5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.d.mts @@ -0,0 +1,20 @@ +/** + * Returns an array of property names whose values are functions, including inherited properties. + * + * @param {*} object The object to inspect. + * @returns {Array} Returns the function names. + * @example + * + * function Foo() { + * this.a = function() { return 'a'; }; + * this.b = function() { return 'b'; }; + * } + * + * Foo.prototype.c = function() { return 'c'; }; + * + * functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */ +declare function functionsIn(object: any): string[]; + +export { functionsIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..642b357c1e0893df8adf706ab8443e01acb2bcb5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.d.ts @@ -0,0 +1,20 @@ +/** + * Returns an array of property names whose values are functions, including inherited properties. + * + * @param {*} object The object to inspect. + * @returns {Array} Returns the function names. + * @example + * + * function Foo() { + * this.a = function() { return 'a'; }; + * this.b = function() { return 'b'; }; + * } + * + * Foo.prototype.c = function() { return 'c'; }; + * + * functionsIn(new Foo); + * // => ['a', 'b', 'c'] + */ +declare function functionsIn(object: any): string[]; + +export { functionsIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.js new file mode 100644 index 0000000000000000000000000000000000000000..a8325a76617efc95a02c6350ed069070b525478a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isFunction = require('../../predicate/isFunction.js'); + +function functionsIn(object) { + if (object == null) { + return []; + } + const result = []; + for (const key in object) { + if (isFunction.isFunction(object[key])) { + result.push(key); + } + } + return result; +} + +exports.functionsIn = functionsIn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..228467cdb97980bb27bf43755277a9e7bcf9380c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/functionsIn.mjs @@ -0,0 +1,16 @@ +import { isFunction } from '../../predicate/isFunction.mjs'; + +function functionsIn(object) { + if (object == null) { + return []; + } + const result = []; + for (const key in object) { + if (isFunction(object[key])) { + result.push(key); + } + } + return result; +} + +export { functionsIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9ba9095dc724e2745daa3cf6719ce6e841c82b97 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.d.mts @@ -0,0 +1,327 @@ +import { GetFieldType } from '../_internal/GetFieldType.mjs'; +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey + * @param {TObject} object - The object to query. + * @param {TKey | [TKey]} path - The path of the property to get. + * @returns {TObject[TKey]} Returns the resolved value. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * get(object, 'a[0].b.c'); + * // => 3 + */ +declare function get(object: TObject, path: TKey | [TKey]): TObject[TKey]; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey + * @param {TObject | null | undefined} object - The object to query. + * @param {TKey | [TKey]} path - The path of the property to get. + * @returns {TObject[TKey] | undefined} Returns the resolved value. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * get(object, 'a[0].b.c'); + * // => 3 + */ +declare function get(object: TObject | null | undefined, path: TKey | [TKey]): TObject[TKey] | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey + * @template TDefault + * @param {TObject | null | undefined} object - The object to query. + * @param {TKey | [TKey]} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude | TDefault} Returns the resolved value. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * get(object, 'a[0].b.c', 'default'); + * // => 3 + */ +declare function get(object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault): Exclude | TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @param {TObject} object - The object to query. + * @param {[TKey1, TKey2]} path - The path of the property to get. + * @returns {TObject[TKey1][TKey2]} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': 2 } }; + * get(object, ['a', 'b']); + * // => 2 + */ +declare function get(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2]; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2]} path - The path of the property to get. + * @returns {NonNullable[TKey2] | undefined} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': 2 } }; + * get(object, ['a', 'b']); + * // => 2 + */ +declare function get>(object: TObject | null | undefined, path: [TKey1, TKey2]): NonNullable[TKey2] | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TDefault + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2]} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude[TKey2], undefined> | TDefault} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': 2 } }; + * get(object, ['a', 'b'], 'default'); + * // => 2 + */ +declare function get, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2], defaultValue: TDefault): Exclude[TKey2], undefined> | TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @param {TObject} object - The object to query. + * @param {[TKey1, TKey2, TKey3]} path - The path of the property to get. + * @returns {TObject[TKey1][TKey2][TKey3]} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': 3 } } }; + * get(object, ['a', 'b', 'c']); + * // => 3 + */ +declare function get(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3]; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2, TKey3]} path - The path of the property to get. + * @returns {NonNullable[TKey2]>[TKey3] | undefined} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': 3 } } }; + * get(object, ['a', 'b', 'c']); + * // => 3 + */ +declare function get, TKey3 extends keyof NonNullable[TKey2]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): NonNullable[TKey2]>[TKey3] | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @template TDefault + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2, TKey3]} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude[TKey2]>[TKey3], undefined> | TDefault} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': 3 } } }; + * get(object, ['a', 'b', 'c'], 'default'); + * // => 3 + */ +declare function get, TKey3 extends keyof NonNullable[TKey2]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3], defaultValue: TDefault): Exclude[TKey2]>[TKey3], undefined> | TDefault; +/** + * Gets the value at path of object. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @template TKey4 + * @param {TObject} object - The object to query. + * @param {[TKey1, TKey2, TKey3, TKey4]} path - The path of the property to get. + * @returns {TObject[TKey1][TKey2][TKey3][TKey4]} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': { 'd': 4 } } } }; + * get(object, ['a', 'b', 'c', 'd']); + * // => 4 + */ +declare function get(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4]; +/** + * Gets the value at path of object. If the resolved value is undefined, undefined is returned. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @template TKey4 + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2, TKey3, TKey4]} path - The path of the property to get. + * @returns {NonNullable[TKey2]>[TKey3]>[TKey4] | undefined} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': { 'd': 4 } } } }; + * get(object, ['a', 'b', 'c', 'd']); + * // => 4 + */ +declare function get, TKey3 extends keyof NonNullable[TKey2]>, TKey4 extends keyof NonNullable[TKey2]>[TKey3]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4]): NonNullable[TKey2]>[TKey3]>[TKey4] | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @template TKey4 + * @template TDefault + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2, TKey3, TKey4]} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude[TKey2]>[TKey3]>[TKey4], undefined> | TDefault} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': { 'd': 4 } } } }; + * get(object, ['a', 'b', 'c', 'd'], 'default'); + * // => 4 + */ +declare function get, TKey3 extends keyof NonNullable[TKey2]>, TKey4 extends keyof NonNullable[TKey2]>[TKey3]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4], defaultValue: TDefault): Exclude[TKey2]>[TKey3]>[TKey4], undefined> | TDefault; +/** + * Gets the value at path of object. + * + * @template T + * @param {Record} object - The object to query. + * @param {number} path - The path of the property to get. + * @returns {T} Returns the resolved value. + * + * @example + * const object = { 0: 'a', 1: 'b', 2: 'c' }; + * get(object, 1); + * // => 'b' + */ +declare function get(object: Record, path: number): T; +/** + * Gets the value at path of object. If the resolved value is undefined, undefined is returned. + * + * @template T + * @param {Record | null | undefined} object - The object to query. + * @param {number} path - The path of the property to get. + * @returns {T | undefined} Returns the resolved value. + * + * @example + * const object = { 0: 'a', 1: 'b', 2: 'c' }; + * get(object, 1); + * // => 'b' + */ +declare function get(object: Record | null | undefined, path: number): T | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template T + * @template TDefault + * @param {Record | null | undefined} object - The object to query. + * @param {number} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {T | TDefault} Returns the resolved value. + * + * @example + * const object = { 0: 'a', 1: 'b', 2: 'c' }; + * get(object, 1, 'default'); + * // => 'b' + */ +declare function get(object: Record | null | undefined, path: number, defaultValue: TDefault): T | TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TDefault + * @param {null | undefined} object - The object to query. + * @param {PropertyPath} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {TDefault} Returns the default value. + * + * @example + * get(null, 'a.b.c', 'default'); + * // => 'default' + */ +declare function get(object: null | undefined, path: PropertyPath, defaultValue: TDefault): TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, undefined is returned. + * + * @param {null | undefined} object - The object to query. + * @param {PropertyPath} path - The path of the property to get. + * @returns {undefined} Returns undefined. + * + * @example + * get(null, 'a.b.c'); + * // => undefined + */ +declare function get(object: null | undefined, path: PropertyPath): undefined; +/** + * Gets the value at path of object using type-safe path. + * + * @template TObject + * @template TPath + * @param {TObject} data - The object to query. + * @param {TPath} path - The path of the property to get. + * @returns {string extends TPath ? any : GetFieldType} Returns the resolved value. + * + * @example + * const object = { a: { b: { c: 1 } } }; + * get(object, 'a.b.c'); + * // => 1 + */ +declare function get(data: TObject, path: TPath): string extends TPath ? any : GetFieldType; +/** + * Gets the value at path of object using type-safe path. If the resolved value is undefined, the defaultValue is returned. + * + * @template TObject + * @template TPath + * @template TDefault + * @param {TObject} data - The object to query. + * @param {TPath} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude, null | undefined> | TDefault} Returns the resolved value. + * + * @example + * const object = { a: { b: { c: 1 } } }; + * get(object, 'a.b.d', 'default'); + * // => 'default' + */ +declare function get>(data: TObject, path: TPath, defaultValue: TDefault): Exclude, null | undefined> | TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned. + * + * @param {any} object - The object to query. + * @param {PropertyPath} path - The path of the property to get. + * @param {any} [defaultValue] - The value returned if the resolved value is undefined. + * @returns {any} Returns the resolved value. + * + * @example + * const object = { a: { b: { c: 1 } } }; + * get(object, 'a.b.c', 'default'); + * // => 1 + */ +declare function get(object: any, path: PropertyPath, defaultValue?: any): any; + +export { get }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..08715433dde2d4e52c7e1627779dfd77a449dd2a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.d.ts @@ -0,0 +1,327 @@ +import { GetFieldType } from '../_internal/GetFieldType.js'; +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey + * @param {TObject} object - The object to query. + * @param {TKey | [TKey]} path - The path of the property to get. + * @returns {TObject[TKey]} Returns the resolved value. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * get(object, 'a[0].b.c'); + * // => 3 + */ +declare function get(object: TObject, path: TKey | [TKey]): TObject[TKey]; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey + * @param {TObject | null | undefined} object - The object to query. + * @param {TKey | [TKey]} path - The path of the property to get. + * @returns {TObject[TKey] | undefined} Returns the resolved value. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * get(object, 'a[0].b.c'); + * // => 3 + */ +declare function get(object: TObject | null | undefined, path: TKey | [TKey]): TObject[TKey] | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey + * @template TDefault + * @param {TObject | null | undefined} object - The object to query. + * @param {TKey | [TKey]} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude | TDefault} Returns the resolved value. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * get(object, 'a[0].b.c', 'default'); + * // => 3 + */ +declare function get(object: TObject | null | undefined, path: TKey | [TKey], defaultValue: TDefault): Exclude | TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @param {TObject} object - The object to query. + * @param {[TKey1, TKey2]} path - The path of the property to get. + * @returns {TObject[TKey1][TKey2]} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': 2 } }; + * get(object, ['a', 'b']); + * // => 2 + */ +declare function get(object: TObject, path: [TKey1, TKey2]): TObject[TKey1][TKey2]; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2]} path - The path of the property to get. + * @returns {NonNullable[TKey2] | undefined} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': 2 } }; + * get(object, ['a', 'b']); + * // => 2 + */ +declare function get>(object: TObject | null | undefined, path: [TKey1, TKey2]): NonNullable[TKey2] | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TDefault + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2]} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude[TKey2], undefined> | TDefault} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': 2 } }; + * get(object, ['a', 'b'], 'default'); + * // => 2 + */ +declare function get, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2], defaultValue: TDefault): Exclude[TKey2], undefined> | TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @param {TObject} object - The object to query. + * @param {[TKey1, TKey2, TKey3]} path - The path of the property to get. + * @returns {TObject[TKey1][TKey2][TKey3]} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': 3 } } }; + * get(object, ['a', 'b', 'c']); + * // => 3 + */ +declare function get(object: TObject, path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3]; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2, TKey3]} path - The path of the property to get. + * @returns {NonNullable[TKey2]>[TKey3] | undefined} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': 3 } } }; + * get(object, ['a', 'b', 'c']); + * // => 3 + */ +declare function get, TKey3 extends keyof NonNullable[TKey2]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3]): NonNullable[TKey2]>[TKey3] | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @template TDefault + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2, TKey3]} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude[TKey2]>[TKey3], undefined> | TDefault} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': 3 } } }; + * get(object, ['a', 'b', 'c'], 'default'); + * // => 3 + */ +declare function get, TKey3 extends keyof NonNullable[TKey2]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3], defaultValue: TDefault): Exclude[TKey2]>[TKey3], undefined> | TDefault; +/** + * Gets the value at path of object. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @template TKey4 + * @param {TObject} object - The object to query. + * @param {[TKey1, TKey2, TKey3, TKey4]} path - The path of the property to get. + * @returns {TObject[TKey1][TKey2][TKey3][TKey4]} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': { 'd': 4 } } } }; + * get(object, ['a', 'b', 'c', 'd']); + * // => 4 + */ +declare function get(object: TObject, path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4]; +/** + * Gets the value at path of object. If the resolved value is undefined, undefined is returned. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @template TKey4 + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2, TKey3, TKey4]} path - The path of the property to get. + * @returns {NonNullable[TKey2]>[TKey3]>[TKey4] | undefined} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': { 'd': 4 } } } }; + * get(object, ['a', 'b', 'c', 'd']); + * // => 4 + */ +declare function get, TKey3 extends keyof NonNullable[TKey2]>, TKey4 extends keyof NonNullable[TKey2]>[TKey3]>>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4]): NonNullable[TKey2]>[TKey3]>[TKey4] | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TObject + * @template TKey1 + * @template TKey2 + * @template TKey3 + * @template TKey4 + * @template TDefault + * @param {TObject | null | undefined} object - The object to query. + * @param {[TKey1, TKey2, TKey3, TKey4]} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude[TKey2]>[TKey3]>[TKey4], undefined> | TDefault} Returns the resolved value. + * + * @example + * const object = { 'a': { 'b': { 'c': { 'd': 4 } } } }; + * get(object, ['a', 'b', 'c', 'd'], 'default'); + * // => 4 + */ +declare function get, TKey3 extends keyof NonNullable[TKey2]>, TKey4 extends keyof NonNullable[TKey2]>[TKey3]>, TDefault>(object: TObject | null | undefined, path: [TKey1, TKey2, TKey3, TKey4], defaultValue: TDefault): Exclude[TKey2]>[TKey3]>[TKey4], undefined> | TDefault; +/** + * Gets the value at path of object. + * + * @template T + * @param {Record} object - The object to query. + * @param {number} path - The path of the property to get. + * @returns {T} Returns the resolved value. + * + * @example + * const object = { 0: 'a', 1: 'b', 2: 'c' }; + * get(object, 1); + * // => 'b' + */ +declare function get(object: Record, path: number): T; +/** + * Gets the value at path of object. If the resolved value is undefined, undefined is returned. + * + * @template T + * @param {Record | null | undefined} object - The object to query. + * @param {number} path - The path of the property to get. + * @returns {T | undefined} Returns the resolved value. + * + * @example + * const object = { 0: 'a', 1: 'b', 2: 'c' }; + * get(object, 1); + * // => 'b' + */ +declare function get(object: Record | null | undefined, path: number): T | undefined; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template T + * @template TDefault + * @param {Record | null | undefined} object - The object to query. + * @param {number} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {T | TDefault} Returns the resolved value. + * + * @example + * const object = { 0: 'a', 1: 'b', 2: 'c' }; + * get(object, 1, 'default'); + * // => 'b' + */ +declare function get(object: Record | null | undefined, path: number, defaultValue: TDefault): T | TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned in its place. + * + * @template TDefault + * @param {null | undefined} object - The object to query. + * @param {PropertyPath} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {TDefault} Returns the default value. + * + * @example + * get(null, 'a.b.c', 'default'); + * // => 'default' + */ +declare function get(object: null | undefined, path: PropertyPath, defaultValue: TDefault): TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, undefined is returned. + * + * @param {null | undefined} object - The object to query. + * @param {PropertyPath} path - The path of the property to get. + * @returns {undefined} Returns undefined. + * + * @example + * get(null, 'a.b.c'); + * // => undefined + */ +declare function get(object: null | undefined, path: PropertyPath): undefined; +/** + * Gets the value at path of object using type-safe path. + * + * @template TObject + * @template TPath + * @param {TObject} data - The object to query. + * @param {TPath} path - The path of the property to get. + * @returns {string extends TPath ? any : GetFieldType} Returns the resolved value. + * + * @example + * const object = { a: { b: { c: 1 } } }; + * get(object, 'a.b.c'); + * // => 1 + */ +declare function get(data: TObject, path: TPath): string extends TPath ? any : GetFieldType; +/** + * Gets the value at path of object using type-safe path. If the resolved value is undefined, the defaultValue is returned. + * + * @template TObject + * @template TPath + * @template TDefault + * @param {TObject} data - The object to query. + * @param {TPath} path - The path of the property to get. + * @param {TDefault} defaultValue - The value returned if the resolved value is undefined. + * @returns {Exclude, null | undefined> | TDefault} Returns the resolved value. + * + * @example + * const object = { a: { b: { c: 1 } } }; + * get(object, 'a.b.d', 'default'); + * // => 'default' + */ +declare function get>(data: TObject, path: TPath, defaultValue: TDefault): Exclude, null | undefined> | TDefault; +/** + * Gets the value at path of object. If the resolved value is undefined, the defaultValue is returned. + * + * @param {any} object - The object to query. + * @param {PropertyPath} path - The path of the property to get. + * @param {any} [defaultValue] - The value returned if the resolved value is undefined. + * @returns {any} Returns the resolved value. + * + * @example + * const object = { a: { b: { c: 1 } } }; + * get(object, 'a.b.c', 'default'); + * // => 1 + */ +declare function get(object: any, path: PropertyPath, defaultValue?: any): any; + +export { get }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.js new file mode 100644 index 0000000000000000000000000000000000000000..6c25b4f915717a1df46a69d0510700f4d34e59ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.js @@ -0,0 +1,82 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isUnsafeProperty = require('../../_internal/isUnsafeProperty.js'); +const isDeepKey = require('../_internal/isDeepKey.js'); +const toKey = require('../_internal/toKey.js'); +const toPath = require('../util/toPath.js'); + +function get(object, path, defaultValue) { + if (object == null) { + return defaultValue; + } + switch (typeof path) { + case 'string': { + if (isUnsafeProperty.isUnsafeProperty(path)) { + return defaultValue; + } + const result = object[path]; + if (result === undefined) { + if (isDeepKey.isDeepKey(path)) { + return get(object, toPath.toPath(path), defaultValue); + } + else { + return defaultValue; + } + } + return result; + } + case 'number': + case 'symbol': { + if (typeof path === 'number') { + path = toKey.toKey(path); + } + const result = object[path]; + if (result === undefined) { + return defaultValue; + } + return result; + } + default: { + if (Array.isArray(path)) { + return getWithPath(object, path, defaultValue); + } + if (Object.is(path?.valueOf(), -0)) { + path = '-0'; + } + else { + path = String(path); + } + if (isUnsafeProperty.isUnsafeProperty(path)) { + return defaultValue; + } + const result = object[path]; + if (result === undefined) { + return defaultValue; + } + return result; + } + } +} +function getWithPath(object, path, defaultValue) { + if (path.length === 0) { + return defaultValue; + } + let current = object; + for (let index = 0; index < path.length; index++) { + if (current == null) { + return defaultValue; + } + if (isUnsafeProperty.isUnsafeProperty(path[index])) { + return defaultValue; + } + current = current[path[index]]; + } + if (current === undefined) { + return defaultValue; + } + return current; +} + +exports.get = get; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.mjs new file mode 100644 index 0000000000000000000000000000000000000000..925b4b6db5311a0d7b5b0c97f6e4b8b37a2f04f7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/get.mjs @@ -0,0 +1,78 @@ +import { isUnsafeProperty } from '../../_internal/isUnsafeProperty.mjs'; +import { isDeepKey } from '../_internal/isDeepKey.mjs'; +import { toKey } from '../_internal/toKey.mjs'; +import { toPath } from '../util/toPath.mjs'; + +function get(object, path, defaultValue) { + if (object == null) { + return defaultValue; + } + switch (typeof path) { + case 'string': { + if (isUnsafeProperty(path)) { + return defaultValue; + } + const result = object[path]; + if (result === undefined) { + if (isDeepKey(path)) { + return get(object, toPath(path), defaultValue); + } + else { + return defaultValue; + } + } + return result; + } + case 'number': + case 'symbol': { + if (typeof path === 'number') { + path = toKey(path); + } + const result = object[path]; + if (result === undefined) { + return defaultValue; + } + return result; + } + default: { + if (Array.isArray(path)) { + return getWithPath(object, path, defaultValue); + } + if (Object.is(path?.valueOf(), -0)) { + path = '-0'; + } + else { + path = String(path); + } + if (isUnsafeProperty(path)) { + return defaultValue; + } + const result = object[path]; + if (result === undefined) { + return defaultValue; + } + return result; + } + } +} +function getWithPath(object, path, defaultValue) { + if (path.length === 0) { + return defaultValue; + } + let current = object; + for (let index = 0; index < path.length; index++) { + if (current == null) { + return defaultValue; + } + if (isUnsafeProperty(path[index])) { + return defaultValue; + } + current = current[path[index]]; + } + if (current === undefined) { + return defaultValue; + } + return current; +} + +export { get }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e306a03469a207ff653dc8086502eb6370dafa8c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.d.mts @@ -0,0 +1,52 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Checks if a given path exists within an object. + * + * @template T + * @template K + * @param {T} object - The object to query. + * @param {K} path - The path to check. + * @returns {object is T & { [P in K]: P extends keyof T ? T[P] : Record extends T ? T[keyof T] : unknown } & { [key: symbol]: unknown }} Returns a type guard indicating if the path exists in the object. + * + * @example + * const obj = { a: 1, b: { c: 2 } }; + * + * if (has(obj, 'a')) { + * console.log(obj.a); // TypeScript knows obj.a exists + * } + * + * if (has(obj, 'b')) { + * console.log(obj.b.c); // TypeScript knows obj.b exists + * } + */ +declare function has(object: T, path: K): object is T & { + [P in K]: P extends keyof T ? T[P] : Record extends T ? T[keyof T] : unknown; +} & { + [key: symbol]: unknown; +}; +/** + * Checks if a given path exists within an object. + * + * @template T + * @param {T} object - The object to query. + * @param {PropertyPath} path - The path to check. This can be a single property key, + * an array of property keys, or a string representing a deep path. + * @returns {boolean} Returns `true` if the path exists in the object, `false` otherwise. + * + * @example + * const obj = { a: { b: { c: 3 } } }; + * + * has(obj, 'a'); // true + * has(obj, ['a', 'b']); // true + * has(obj, ['a', 'b', 'c']); // true + * has(obj, 'a.b.c'); // true + * has(obj, 'a.b.d'); // false + * has(obj, ['a', 'b', 'c', 'd']); // false + * has([], 0); // false + * has([1, 2, 3], 2); // true + * has([1, 2, 3], 5); // false + */ +declare function has(object: T, path: PropertyPath): boolean; + +export { has }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..38f20704939b9432d55b454091299f18cb212229 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.d.ts @@ -0,0 +1,52 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Checks if a given path exists within an object. + * + * @template T + * @template K + * @param {T} object - The object to query. + * @param {K} path - The path to check. + * @returns {object is T & { [P in K]: P extends keyof T ? T[P] : Record extends T ? T[keyof T] : unknown } & { [key: symbol]: unknown }} Returns a type guard indicating if the path exists in the object. + * + * @example + * const obj = { a: 1, b: { c: 2 } }; + * + * if (has(obj, 'a')) { + * console.log(obj.a); // TypeScript knows obj.a exists + * } + * + * if (has(obj, 'b')) { + * console.log(obj.b.c); // TypeScript knows obj.b exists + * } + */ +declare function has(object: T, path: K): object is T & { + [P in K]: P extends keyof T ? T[P] : Record extends T ? T[keyof T] : unknown; +} & { + [key: symbol]: unknown; +}; +/** + * Checks if a given path exists within an object. + * + * @template T + * @param {T} object - The object to query. + * @param {PropertyPath} path - The path to check. This can be a single property key, + * an array of property keys, or a string representing a deep path. + * @returns {boolean} Returns `true` if the path exists in the object, `false` otherwise. + * + * @example + * const obj = { a: { b: { c: 3 } } }; + * + * has(obj, 'a'); // true + * has(obj, ['a', 'b']); // true + * has(obj, ['a', 'b', 'c']); // true + * has(obj, 'a.b.c'); // true + * has(obj, 'a.b.d'); // false + * has(obj, ['a', 'b', 'c', 'd']); // false + * has([], 0); // false + * has([1, 2, 3], 2); // true + * has([1, 2, 3], 5); // false + */ +declare function has(object: T, path: PropertyPath): boolean; + +export { has }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.js new file mode 100644 index 0000000000000000000000000000000000000000..2cda5340b3f99a0aff4efe3d8376581a649bdbe6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.js @@ -0,0 +1,38 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isDeepKey = require('../_internal/isDeepKey.js'); +const isIndex = require('../_internal/isIndex.js'); +const isArguments = require('../predicate/isArguments.js'); +const toPath = require('../util/toPath.js'); + +function has(object, path) { + let resolvedPath; + if (Array.isArray(path)) { + resolvedPath = path; + } + else if (typeof path === 'string' && isDeepKey.isDeepKey(path) && object?.[path] == null) { + resolvedPath = toPath.toPath(path); + } + else { + resolvedPath = [path]; + } + if (resolvedPath.length === 0) { + return false; + } + let current = object; + for (let i = 0; i < resolvedPath.length; i++) { + const key = resolvedPath[i]; + if (current == null || !Object.hasOwn(current, key)) { + const isSparseIndex = (Array.isArray(current) || isArguments.isArguments(current)) && isIndex.isIndex(key) && key < current.length; + if (!isSparseIndex) { + return false; + } + } + current = current[key]; + } + return true; +} + +exports.has = has; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.mjs new file mode 100644 index 0000000000000000000000000000000000000000..eec9020dfcfb42d7286c336f7809e62ec1e2d44b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/has.mjs @@ -0,0 +1,34 @@ +import { isDeepKey } from '../_internal/isDeepKey.mjs'; +import { isIndex } from '../_internal/isIndex.mjs'; +import { isArguments } from '../predicate/isArguments.mjs'; +import { toPath } from '../util/toPath.mjs'; + +function has(object, path) { + let resolvedPath; + if (Array.isArray(path)) { + resolvedPath = path; + } + else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) { + resolvedPath = toPath(path); + } + else { + resolvedPath = [path]; + } + if (resolvedPath.length === 0) { + return false; + } + let current = object; + for (let i = 0; i < resolvedPath.length; i++) { + const key = resolvedPath[i]; + if (current == null || !Object.hasOwn(current, key)) { + const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length; + if (!isSparseIndex) { + return false; + } + } + current = current[key]; + } + return true; +} + +export { has }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c0a515aefde1e4b0538ff02fecb3eb3c63cae370 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.d.mts @@ -0,0 +1,43 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Checks if a given path exists in an object, **including inherited properties**. + * + * You can provide the path as a single property key, an array of property keys, + * or a string representing a deep path. + * + * Unlike `has`, which only checks for own properties, `hasIn` also checks for properties + * in the prototype chain. + * + * If the path is an index and the object is an array or an arguments object, the function will verify + * if the index is valid and within the bounds of the array or arguments object, even if the array or + * arguments object is sparse (i.e., not all indexes are defined). + * + * @template T + * @param {T} object - The object to query. + * @param {PropertyPath} path - The path to check. This can be a single property key, + * an array of property keys, or a string representing a deep path. + * @returns {boolean} Returns `true` if the path exists (own or inherited), `false` otherwise. + * + * @example + * + * const obj = { a: { b: { c: 3 } } }; + * + * hasIn(obj, 'a'); // true + * hasIn(obj, ['a', 'b']); // true + * hasIn(obj, ['a', 'b', 'c']); // true + * hasIn(obj, 'a.b.c'); // true + * hasIn(obj, 'a.b.d'); // false + * hasIn(obj, ['a', 'b', 'c', 'd']); // false + * + * // Example with inherited properties: + * function Rectangle() {} + * Rectangle.prototype.area = function() {}; + * + * const rect = new Rectangle(); + * hasIn(rect, 'area'); // true + * has(rect, 'area'); // false - has only checks own properties + */ +declare function hasIn(object: T, path: PropertyPath): boolean; + +export { hasIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e47c5e96518d266412f2aa5481a68b96188eb9f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.d.ts @@ -0,0 +1,43 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Checks if a given path exists in an object, **including inherited properties**. + * + * You can provide the path as a single property key, an array of property keys, + * or a string representing a deep path. + * + * Unlike `has`, which only checks for own properties, `hasIn` also checks for properties + * in the prototype chain. + * + * If the path is an index and the object is an array or an arguments object, the function will verify + * if the index is valid and within the bounds of the array or arguments object, even if the array or + * arguments object is sparse (i.e., not all indexes are defined). + * + * @template T + * @param {T} object - The object to query. + * @param {PropertyPath} path - The path to check. This can be a single property key, + * an array of property keys, or a string representing a deep path. + * @returns {boolean} Returns `true` if the path exists (own or inherited), `false` otherwise. + * + * @example + * + * const obj = { a: { b: { c: 3 } } }; + * + * hasIn(obj, 'a'); // true + * hasIn(obj, ['a', 'b']); // true + * hasIn(obj, ['a', 'b', 'c']); // true + * hasIn(obj, 'a.b.c'); // true + * hasIn(obj, 'a.b.d'); // false + * hasIn(obj, ['a', 'b', 'c', 'd']); // false + * + * // Example with inherited properties: + * function Rectangle() {} + * Rectangle.prototype.area = function() {}; + * + * const rect = new Rectangle(); + * hasIn(rect, 'area'); // true + * has(rect, 'area'); // false - has only checks own properties + */ +declare function hasIn(object: T, path: PropertyPath): boolean; + +export { hasIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.js new file mode 100644 index 0000000000000000000000000000000000000000..6694db70a71933093fc13d38fd9ecb179387c7d6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.js @@ -0,0 +1,41 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isDeepKey = require('../_internal/isDeepKey.js'); +const isIndex = require('../_internal/isIndex.js'); +const isArguments = require('../predicate/isArguments.js'); +const toPath = require('../util/toPath.js'); + +function hasIn(object, path) { + if (object == null) { + return false; + } + let resolvedPath; + if (Array.isArray(path)) { + resolvedPath = path; + } + else if (typeof path === 'string' && isDeepKey.isDeepKey(path) && object[path] == null) { + resolvedPath = toPath.toPath(path); + } + else { + resolvedPath = [path]; + } + if (resolvedPath.length === 0) { + return false; + } + let current = object; + for (let i = 0; i < resolvedPath.length; i++) { + const key = resolvedPath[i]; + if (current == null || !(key in Object(current))) { + const isSparseIndex = (Array.isArray(current) || isArguments.isArguments(current)) && isIndex.isIndex(key) && key < current.length; + if (!isSparseIndex) { + return false; + } + } + current = current[key]; + } + return true; +} + +exports.hasIn = hasIn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..69ca575b2fb3fb093b2f0382bb1f60d24c0a7866 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/hasIn.mjs @@ -0,0 +1,37 @@ +import { isDeepKey } from '../_internal/isDeepKey.mjs'; +import { isIndex } from '../_internal/isIndex.mjs'; +import { isArguments } from '../predicate/isArguments.mjs'; +import { toPath } from '../util/toPath.mjs'; + +function hasIn(object, path) { + if (object == null) { + return false; + } + let resolvedPath; + if (Array.isArray(path)) { + resolvedPath = path; + } + else if (typeof path === 'string' && isDeepKey(path) && object[path] == null) { + resolvedPath = toPath(path); + } + else { + resolvedPath = [path]; + } + if (resolvedPath.length === 0) { + return false; + } + let current = object; + for (let i = 0; i < resolvedPath.length; i++) { + const key = resolvedPath[i]; + if (current == null || !(key in Object(current))) { + const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length; + if (!isSparseIndex) { + return false; + } + } + current = current[key]; + } + return true; +} + +export { hasIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..946ed759fb3e691eb3abd01052fbbe7ac1d2386b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.d.mts @@ -0,0 +1,13 @@ +/** + * Inverts the keys and values of an object. + * + * @param {object} object - The object to invert. + * @returns {Record} - Returns the new inverted object. + * + * @example + * invert({ a: 1, b: 2, c: 3 }); + * // => { '1': 'a', '2': 'b', '3': 'c' } + */ +declare function invert(object: object): Record; + +export { invert }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..946ed759fb3e691eb3abd01052fbbe7ac1d2386b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.d.ts @@ -0,0 +1,13 @@ +/** + * Inverts the keys and values of an object. + * + * @param {object} object - The object to invert. + * @returns {Record} - Returns the new inverted object. + * + * @example + * invert({ a: 1, b: 2, c: 3 }); + * // => { '1': 'a', '2': 'b', '3': 'c' } + */ +declare function invert(object: object): Record; + +export { invert }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.js new file mode 100644 index 0000000000000000000000000000000000000000..fd2f48bc7446ac970e5a77d76ec738f9c5459707 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const invert$1 = require('../../object/invert.js'); + +function invert(obj) { + return invert$1.invert(obj); +} + +exports.invert = invert; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ae200641d569409ee61b0e5c51a0c6527b982512 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invert.mjs @@ -0,0 +1,7 @@ +import { invert as invert$1 } from '../../object/invert.mjs'; + +function invert(obj) { + return invert$1(obj); +} + +export { invert }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..85f33944f0e9e16230f7f1d6f8275fd5b3d18d13 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.d.mts @@ -0,0 +1,34 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Creates a new object that reverses the keys and values of the given object, similar to the invert. + * The values of the new object are arrays of keys that correspond to the value returned by the `iteratee` function. + * + * @param {Record} object - The object to iterate over + * @param {ValueIteratee} [iteratee] - Optional function to transform values into keys + * @returns {Record} An object with transformed values as keys and arrays of original keys as values + * + * @example + * const obj = { a: 1, b: 2, c: 1 }; + * invertBy(obj); // => { '1': ['a', 'c'], '2': ['b'] } + * + * @example + * const obj = { a: 1, b: 2, c: 1 }; + * invertBy(obj, value => `group${value}`); // => { 'group1': ['a', 'c'], 'group2': ['b'] } + */ +declare function invertBy(object: Record | Record | null | undefined, interatee?: ValueIteratee): Record; +/** + * Creates a new object that reverses the keys and values of the given object, similar to the invert. + * The values of the new object are arrays of keys that correspond to the value returned by the `iteratee` function. + * + * @param {T} object - The object to iterate over + * @param {ValueIteratee} [iteratee] - Optional function to transform values into keys + * @returns {Record} An object with transformed values as keys and arrays of original keys as values + * + * @example + * const obj = { foo: { id: 1 }, bar: { id: 2 }, baz: { id: 1 } }; + * invertBy(obj, value => String(value.id)); // => { '1': ['foo', 'baz'], '2': ['bar'] } + */ +declare function invertBy(object: T | null | undefined, interatee?: ValueIteratee): Record; + +export { invertBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ccc865f76795f71bd392f01f3dabb60b0564f9d8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.d.ts @@ -0,0 +1,34 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Creates a new object that reverses the keys and values of the given object, similar to the invert. + * The values of the new object are arrays of keys that correspond to the value returned by the `iteratee` function. + * + * @param {Record} object - The object to iterate over + * @param {ValueIteratee} [iteratee] - Optional function to transform values into keys + * @returns {Record} An object with transformed values as keys and arrays of original keys as values + * + * @example + * const obj = { a: 1, b: 2, c: 1 }; + * invertBy(obj); // => { '1': ['a', 'c'], '2': ['b'] } + * + * @example + * const obj = { a: 1, b: 2, c: 1 }; + * invertBy(obj, value => `group${value}`); // => { 'group1': ['a', 'c'], 'group2': ['b'] } + */ +declare function invertBy(object: Record | Record | null | undefined, interatee?: ValueIteratee): Record; +/** + * Creates a new object that reverses the keys and values of the given object, similar to the invert. + * The values of the new object are arrays of keys that correspond to the value returned by the `iteratee` function. + * + * @param {T} object - The object to iterate over + * @param {ValueIteratee} [iteratee] - Optional function to transform values into keys + * @returns {Record} An object with transformed values as keys and arrays of original keys as values + * + * @example + * const obj = { foo: { id: 1 }, bar: { id: 2 }, baz: { id: 1 } }; + * invertBy(obj, value => String(value.id)); // => { '1': ['foo', 'baz'], '2': ['bar'] } + */ +declare function invertBy(object: T | null | undefined, interatee?: ValueIteratee): Record; + +export { invertBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.js new file mode 100644 index 0000000000000000000000000000000000000000..13a08670f498ae9bf52e72892596d1ba54f3dfa6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.js @@ -0,0 +1,33 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const isNil = require('../../predicate/isNil.js'); +const iteratee = require('../util/iteratee.js'); + +function invertBy(object, iteratee$1) { + const result = {}; + if (isNil.isNil(object)) { + return result; + } + if (iteratee$1 == null) { + iteratee$1 = identity.identity; + } + const keys = Object.keys(object); + const getString = iteratee.iteratee(iteratee$1); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + const valueStr = getString(value); + if (Array.isArray(result[valueStr])) { + result[valueStr].push(key); + } + else { + result[valueStr] = [key]; + } + } + return result; +} + +exports.invertBy = invertBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..41a6f1bcfc9e5185a7a7aef627cc9d17714ec6e1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/invertBy.mjs @@ -0,0 +1,29 @@ +import { identity } from '../../function/identity.mjs'; +import { isNil } from '../../predicate/isNil.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function invertBy(object, iteratee$1) { + const result = {}; + if (isNil(object)) { + return result; + } + if (iteratee$1 == null) { + iteratee$1 = identity; + } + const keys = Object.keys(object); + const getString = iteratee(iteratee$1); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + const valueStr = getString(value); + if (Array.isArray(result[valueStr])) { + result[valueStr].push(key); + } + else { + result[valueStr] = [key]; + } + } + return result; +} + +export { invertBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b1c062d6e6fd5ce1930ac64a57952b96c4560d9d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.d.mts @@ -0,0 +1,22 @@ +/** + * Creates an array of the own enumerable property names of `object`. + * + * Non-object values are coerced to objects. + * + * @param {object} object The object to query. + * @returns {string[]} Returns the array of property names. + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * Foo.prototype.c = 3; + * keys(new Foo); // ['a', 'b'] (iteration order is not guaranteed) + * + * keys('hi'); // ['0', '1'] + * keys([1, 2, 3]); // ['0', '1', '2'] + * keys({ a: 1, b: 2 }); // ['a', 'b'] + */ +declare function keys(object?: any): string[]; + +export { keys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b1c062d6e6fd5ce1930ac64a57952b96c4560d9d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.d.ts @@ -0,0 +1,22 @@ +/** + * Creates an array of the own enumerable property names of `object`. + * + * Non-object values are coerced to objects. + * + * @param {object} object The object to query. + * @returns {string[]} Returns the array of property names. + * @example + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * Foo.prototype.c = 3; + * keys(new Foo); // ['a', 'b'] (iteration order is not guaranteed) + * + * keys('hi'); // ['0', '1'] + * keys([1, 2, 3]); // ['0', '1', '2'] + * keys({ a: 1, b: 2 }); // ['a', 'b'] + */ +declare function keys(object?: any): string[]; + +export { keys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.js new file mode 100644 index 0000000000000000000000000000000000000000..f9a9f0c79f14efe1b259e3a39e86ead8ea5a7769 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.js @@ -0,0 +1,36 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isBuffer = require('../../predicate/isBuffer.js'); +const isPrototype = require('../_internal/isPrototype.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isTypedArray = require('../predicate/isTypedArray.js'); +const times = require('../util/times.js'); + +function keys(object) { + if (isArrayLike.isArrayLike(object)) { + return arrayLikeKeys(object); + } + const result = Object.keys(Object(object)); + if (!isPrototype.isPrototype(object)) { + return result; + } + return result.filter(key => key !== 'constructor'); +} +function arrayLikeKeys(object) { + const indices = times.times(object.length, index => `${index}`); + const filteredKeys = new Set(indices); + if (isBuffer.isBuffer(object)) { + filteredKeys.add('offset'); + filteredKeys.add('parent'); + } + if (isTypedArray.isTypedArray(object)) { + filteredKeys.add('buffer'); + filteredKeys.add('byteLength'); + filteredKeys.add('byteOffset'); + } + return [...indices, ...Object.keys(object).filter(key => !filteredKeys.has(key))]; +} + +exports.keys = keys; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c798fa16a5678c78722dac12f2ddfde41db2f43a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keys.mjs @@ -0,0 +1,32 @@ +import { isBuffer } from '../../predicate/isBuffer.mjs'; +import { isPrototype } from '../_internal/isPrototype.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isTypedArray } from '../predicate/isTypedArray.mjs'; +import { times } from '../util/times.mjs'; + +function keys(object) { + if (isArrayLike(object)) { + return arrayLikeKeys(object); + } + const result = Object.keys(Object(object)); + if (!isPrototype(object)) { + return result; + } + return result.filter(key => key !== 'constructor'); +} +function arrayLikeKeys(object) { + const indices = times(object.length, index => `${index}`); + const filteredKeys = new Set(indices); + if (isBuffer(object)) { + filteredKeys.add('offset'); + filteredKeys.add('parent'); + } + if (isTypedArray(object)) { + filteredKeys.add('buffer'); + filteredKeys.add('byteLength'); + filteredKeys.add('byteOffset'); + } + return [...indices, ...Object.keys(object).filter(key => !filteredKeys.has(key))]; +} + +export { keys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..381313aef96e572dcc4dfda9dc5e80df70986956 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.d.mts @@ -0,0 +1,26 @@ +/** + * This function retrieves the names of string-keyed properties from an object, including those inherited from its prototype. + * + * - If the value is not an object, it is converted to an object. + * - Array-like objects are treated like arrays. + * - Sparse arrays with some missing indices are treated like dense arrays. + * - If the value is `null` or `undefined`, an empty array is returned. + * - When handling prototype objects, the `constructor` property is excluded from the results. + * + * @param {any} [object] - The object to inspect for keys. + * @returns {string[]} An array of string keys from the object. + * + * @example + * const obj = { a: 1, b: 2 }; + * console.log(keysIn(obj)); // ['a', 'b'] + * + * const arr = [1, 2, 3]; + * console.log(keysIn(arr)); // ['0', '1', '2'] + * + * function Foo() {} + * Foo.prototype.a = 1; + * console.log(keysIn(new Foo())); // ['a'] + */ +declare function keysIn(object?: any): string[]; + +export { keysIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..381313aef96e572dcc4dfda9dc5e80df70986956 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.d.ts @@ -0,0 +1,26 @@ +/** + * This function retrieves the names of string-keyed properties from an object, including those inherited from its prototype. + * + * - If the value is not an object, it is converted to an object. + * - Array-like objects are treated like arrays. + * - Sparse arrays with some missing indices are treated like dense arrays. + * - If the value is `null` or `undefined`, an empty array is returned. + * - When handling prototype objects, the `constructor` property is excluded from the results. + * + * @param {any} [object] - The object to inspect for keys. + * @returns {string[]} An array of string keys from the object. + * + * @example + * const obj = { a: 1, b: 2 }; + * console.log(keysIn(obj)); // ['a', 'b'] + * + * const arr = [1, 2, 3]; + * console.log(keysIn(arr)); // ['0', '1', '2'] + * + * function Foo() {} + * Foo.prototype.a = 1; + * console.log(keysIn(new Foo())); // ['a'] + */ +declare function keysIn(object?: any): string[]; + +export { keysIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.js new file mode 100644 index 0000000000000000000000000000000000000000..f728b651b29b4ed9000fbabda2fc7c2186f5ef4a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.js @@ -0,0 +1,57 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isBuffer = require('../../predicate/isBuffer.js'); +const isPrototype = require('../_internal/isPrototype.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isTypedArray = require('../predicate/isTypedArray.js'); +const times = require('../util/times.js'); + +function keysIn(object) { + if (object == null) { + return []; + } + switch (typeof object) { + case 'object': + case 'function': { + if (isArrayLike.isArrayLike(object)) { + return arrayLikeKeysIn(object); + } + if (isPrototype.isPrototype(object)) { + return prototypeKeysIn(object); + } + return keysInImpl(object); + } + default: { + return keysInImpl(Object(object)); + } + } +} +function keysInImpl(object) { + const result = []; + for (const key in object) { + result.push(key); + } + return result; +} +function prototypeKeysIn(object) { + const keys = keysInImpl(object); + return keys.filter(key => key !== 'constructor'); +} +function arrayLikeKeysIn(object) { + const indices = times.times(object.length, index => `${index}`); + const filteredKeys = new Set(indices); + if (isBuffer.isBuffer(object)) { + filteredKeys.add('offset'); + filteredKeys.add('parent'); + } + if (isTypedArray.isTypedArray(object)) { + filteredKeys.add('buffer'); + filteredKeys.add('byteLength'); + filteredKeys.add('byteOffset'); + } + return [...indices, ...keysInImpl(object).filter(key => !filteredKeys.has(key))]; +} + +exports.keysIn = keysIn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c3ee14eebbf9c2684b56b7bb878d785d3cb3e8f6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/keysIn.mjs @@ -0,0 +1,53 @@ +import { isBuffer } from '../../predicate/isBuffer.mjs'; +import { isPrototype } from '../_internal/isPrototype.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isTypedArray } from '../predicate/isTypedArray.mjs'; +import { times } from '../util/times.mjs'; + +function keysIn(object) { + if (object == null) { + return []; + } + switch (typeof object) { + case 'object': + case 'function': { + if (isArrayLike(object)) { + return arrayLikeKeysIn(object); + } + if (isPrototype(object)) { + return prototypeKeysIn(object); + } + return keysInImpl(object); + } + default: { + return keysInImpl(Object(object)); + } + } +} +function keysInImpl(object) { + const result = []; + for (const key in object) { + result.push(key); + } + return result; +} +function prototypeKeysIn(object) { + const keys = keysInImpl(object); + return keys.filter(key => key !== 'constructor'); +} +function arrayLikeKeysIn(object) { + const indices = times(object.length, index => `${index}`); + const filteredKeys = new Set(indices); + if (isBuffer(object)) { + filteredKeys.add('offset'); + filteredKeys.add('parent'); + } + if (isTypedArray(object)) { + filteredKeys.add('buffer'); + filteredKeys.add('byteLength'); + filteredKeys.add('byteOffset'); + } + return [...indices, ...keysInImpl(object).filter(key => !filteredKeys.has(key))]; +} + +export { keysIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..843581720510f3446f47046a0332d15eb67ad9e2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.d.mts @@ -0,0 +1,31 @@ +import { ListIteratee } from '../_internal/ListIteratee.mjs'; +import { ObjectIteratee } from '../_internal/ObjectIteratee.mjs'; + +/** + * Creates an object with the same values as `object` and keys generated by running each own enumerable string keyed property through `iteratee`. + * + * @template T + * @param {ArrayLike | null | undefined} object - The object to iterate over. + * @param {ValueIteratee} [iteratee] - The function invoked per iteration. + * @returns {Record} - Returns the new mapped object. + * + * @example + * mapKeys([1, 2, 3], (value, index) => `key${index}`); + * // => { 'key0': 1, 'key1': 2, 'key2': 3 } + */ +declare function mapKeys(object: ArrayLike | null | undefined, iteratee?: ListIteratee): Record; +/** + * Creates an object with the same values as `object` and keys generated by running each own enumerable string keyed property through `iteratee`. + * + * @template T + * @param {T | null | undefined} object - The object to iterate over. + * @param {ValueIteratee} [iteratee] - The function invoked per iteration. + * @returns {Record} - Returns the new mapped object. + * + * @example + * mapKeys({ a: 1, b: 2 }, (value, key) => key + value); + * // => { 'a1': 1, 'b2': 2 } + */ +declare function mapKeys(object: T | null | undefined, iteratee?: ObjectIteratee): Record; + +export { mapKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9d6cfd40ef6662d6934ed55fdd3bcbe0e79b8fc9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.d.ts @@ -0,0 +1,31 @@ +import { ListIteratee } from '../_internal/ListIteratee.js'; +import { ObjectIteratee } from '../_internal/ObjectIteratee.js'; + +/** + * Creates an object with the same values as `object` and keys generated by running each own enumerable string keyed property through `iteratee`. + * + * @template T + * @param {ArrayLike | null | undefined} object - The object to iterate over. + * @param {ValueIteratee} [iteratee] - The function invoked per iteration. + * @returns {Record} - Returns the new mapped object. + * + * @example + * mapKeys([1, 2, 3], (value, index) => `key${index}`); + * // => { 'key0': 1, 'key1': 2, 'key2': 3 } + */ +declare function mapKeys(object: ArrayLike | null | undefined, iteratee?: ListIteratee): Record; +/** + * Creates an object with the same values as `object` and keys generated by running each own enumerable string keyed property through `iteratee`. + * + * @template T + * @param {T | null | undefined} object - The object to iterate over. + * @param {ValueIteratee} [iteratee] - The function invoked per iteration. + * @returns {Record} - Returns the new mapped object. + * + * @example + * mapKeys({ a: 1, b: 2 }, (value, key) => key + value); + * // => { 'a1': 1, 'b2': 2 } + */ +declare function mapKeys(object: T | null | undefined, iteratee?: ObjectIteratee): Record; + +export { mapKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.js new file mode 100644 index 0000000000000000000000000000000000000000..306b72b5a2d4f20b204a17cac6083e88a09ae9f6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const mapKeys$1 = require('../../object/mapKeys.js'); +const iteratee = require('../util/iteratee.js'); + +function mapKeys(object, getNewKey = identity.identity) { + if (object == null) { + return {}; + } + return mapKeys$1.mapKeys(object, iteratee.iteratee(getNewKey)); +} + +exports.mapKeys = mapKeys; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.mjs new file mode 100644 index 0000000000000000000000000000000000000000..30ef1bb86f4852768fcb2c53bb26fb5bde2a17fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapKeys.mjs @@ -0,0 +1,12 @@ +import { identity } from '../../function/identity.mjs'; +import { mapKeys as mapKeys$1 } from '../../object/mapKeys.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function mapKeys(object, getNewKey = identity) { + if (object == null) { + return {}; + } + return mapKeys$1(object, iteratee(getNewKey)); +} + +export { mapKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f426f2581fba5a5cc6c04b8d1bc2b3d7dbf5eeb9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.d.mts @@ -0,0 +1,130 @@ +import { ArrayIterator } from '../_internal/ArrayIterator.mjs'; +import { ObjectIterator } from '../_internal/ObjectIterator.mjs'; +import { StringIterator } from '../_internal/StringIterator.mjs'; + +/** + * Creates a new object by mapping each character in a string to a value. + * @param obj - The string to iterate over + * @param callback - The function invoked per character + * @returns A new object with numeric keys and mapped values + * @example + * mapValues('abc', (char) => char.toUpperCase()) + * // => { '0': 'A', '1': 'B', '2': 'C' } + */ +declare function mapValues(obj: string | null | undefined, callback: StringIterator): Record; +/** + * Creates a new object by mapping each element in an array to a value. + * @param array - The array to iterate over + * @param callback - The function invoked per element + * @returns A new object with numeric keys and mapped values + * @example + * mapValues([1, 2], (num) => num * 2) + * // => { '0': 2, '1': 4 } + */ +declare function mapValues(array: T[], callback: ArrayIterator): Record; +/** + * Creates a new object by mapping each property value in an object to a new value. + * @param obj - The object to iterate over + * @param callback - The function invoked per property + * @returns A new object with the same keys and mapped values + * @example + * mapValues({ a: 1, b: 2 }, (num) => num * 2) + * // => { a: 2, b: 4 } + */ +declare function mapValues(obj: T | null | undefined, callback: ObjectIterator): { + [P in keyof T]: U; +}; +/** + * Creates a new object by checking each value against a matcher object. + * @param obj - The object to iterate over + * @param iteratee - The object to match against + * @returns A new object with boolean values indicating matches + * @example + * mapValues({ a: { x: 1 }, b: { x: 2 } }, { x: 2 }) + * // => { a: false, b: true } + */ +declare function mapValues(obj: Record | Record | null | undefined, iteratee: object): Record; +/** + * Creates a new object by checking each value against a matcher object. + * @param obj - The object to iterate over + * @param iteratee - The object to match against + * @returns A new object with boolean values indicating matches + * @example + * mapValues({ a: { x: 1 }, b: { x: 2 } }, { x: 2 }) + * // => { a: false, b: true } + */ +declare function mapValues(obj: T | null | undefined, iteratee: object): { + [P in keyof T]: boolean; +}; +/** + * Creates a new object by extracting a property from each value. + * @param obj - The object to iterate over + * @param iteratee - The property key to extract + * @returns A new object with extracted property values + * @example + * mapValues({ a: { x: 1 }, b: { x: 2 } }, 'x') + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: Record | Record | null | undefined, iteratee: K): Record; +/** + * Creates a new object by extracting values at a path from each value. + * @param obj - The object to iterate over + * @param iteratee - The path to extract + * @returns A new object with extracted values + * @example + * mapValues({ a: { x: { y: 1 } }, b: { x: { y: 2 } } }, 'x.y') + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: Record | Record | null | undefined, iteratee: string): Record; +/** + * Creates a new object by extracting values at a path from each value. + * @param obj - The object to iterate over + * @param iteratee - The path to extract + * @returns A new object with extracted values + * @example + * mapValues({ a: { x: { y: 1 } }, b: { x: { y: 2 } } }, 'x.y') + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: T | null | undefined, iteratee: string): { + [P in keyof T]: any; +}; +/** + * Creates a new object from a string using identity function. + * @param obj - The string to convert + * @returns A new object with characters as values + * @example + * mapValues('abc') + * // => { '0': 'a', '1': 'b', '2': 'c' } + */ +declare function mapValues(obj: string | null | undefined): Record; +/** + * Creates a new object using identity function. + * @param obj - The object to clone + * @returns A new object with the same values + * @example + * mapValues({ a: 1, b: 2 }) + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: Record | Record | null | undefined): Record; +/** + * Creates a new object using identity function. + * @param obj - The object to clone + * @returns A new object with the same values + * @example + * mapValues({ a: 1, b: 2 }) + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: T): T; +/** + * Creates a new object using identity function. + * @param obj - The object to clone + * @returns A new object with the same values, or empty object if input is null/undefined + * @example + * mapValues({ a: 1, b: 2 }) + * // => { a: 1, b: 2 } + * mapValues(null) + * // => {} + */ +declare function mapValues(obj: T | null | undefined): Partial; + +export { mapValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..62f4464103426f7f1afe99bf47a3ff6f67f2cc5d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.d.ts @@ -0,0 +1,130 @@ +import { ArrayIterator } from '../_internal/ArrayIterator.js'; +import { ObjectIterator } from '../_internal/ObjectIterator.js'; +import { StringIterator } from '../_internal/StringIterator.js'; + +/** + * Creates a new object by mapping each character in a string to a value. + * @param obj - The string to iterate over + * @param callback - The function invoked per character + * @returns A new object with numeric keys and mapped values + * @example + * mapValues('abc', (char) => char.toUpperCase()) + * // => { '0': 'A', '1': 'B', '2': 'C' } + */ +declare function mapValues(obj: string | null | undefined, callback: StringIterator): Record; +/** + * Creates a new object by mapping each element in an array to a value. + * @param array - The array to iterate over + * @param callback - The function invoked per element + * @returns A new object with numeric keys and mapped values + * @example + * mapValues([1, 2], (num) => num * 2) + * // => { '0': 2, '1': 4 } + */ +declare function mapValues(array: T[], callback: ArrayIterator): Record; +/** + * Creates a new object by mapping each property value in an object to a new value. + * @param obj - The object to iterate over + * @param callback - The function invoked per property + * @returns A new object with the same keys and mapped values + * @example + * mapValues({ a: 1, b: 2 }, (num) => num * 2) + * // => { a: 2, b: 4 } + */ +declare function mapValues(obj: T | null | undefined, callback: ObjectIterator): { + [P in keyof T]: U; +}; +/** + * Creates a new object by checking each value against a matcher object. + * @param obj - The object to iterate over + * @param iteratee - The object to match against + * @returns A new object with boolean values indicating matches + * @example + * mapValues({ a: { x: 1 }, b: { x: 2 } }, { x: 2 }) + * // => { a: false, b: true } + */ +declare function mapValues(obj: Record | Record | null | undefined, iteratee: object): Record; +/** + * Creates a new object by checking each value against a matcher object. + * @param obj - The object to iterate over + * @param iteratee - The object to match against + * @returns A new object with boolean values indicating matches + * @example + * mapValues({ a: { x: 1 }, b: { x: 2 } }, { x: 2 }) + * // => { a: false, b: true } + */ +declare function mapValues(obj: T | null | undefined, iteratee: object): { + [P in keyof T]: boolean; +}; +/** + * Creates a new object by extracting a property from each value. + * @param obj - The object to iterate over + * @param iteratee - The property key to extract + * @returns A new object with extracted property values + * @example + * mapValues({ a: { x: 1 }, b: { x: 2 } }, 'x') + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: Record | Record | null | undefined, iteratee: K): Record; +/** + * Creates a new object by extracting values at a path from each value. + * @param obj - The object to iterate over + * @param iteratee - The path to extract + * @returns A new object with extracted values + * @example + * mapValues({ a: { x: { y: 1 } }, b: { x: { y: 2 } } }, 'x.y') + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: Record | Record | null | undefined, iteratee: string): Record; +/** + * Creates a new object by extracting values at a path from each value. + * @param obj - The object to iterate over + * @param iteratee - The path to extract + * @returns A new object with extracted values + * @example + * mapValues({ a: { x: { y: 1 } }, b: { x: { y: 2 } } }, 'x.y') + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: T | null | undefined, iteratee: string): { + [P in keyof T]: any; +}; +/** + * Creates a new object from a string using identity function. + * @param obj - The string to convert + * @returns A new object with characters as values + * @example + * mapValues('abc') + * // => { '0': 'a', '1': 'b', '2': 'c' } + */ +declare function mapValues(obj: string | null | undefined): Record; +/** + * Creates a new object using identity function. + * @param obj - The object to clone + * @returns A new object with the same values + * @example + * mapValues({ a: 1, b: 2 }) + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: Record | Record | null | undefined): Record; +/** + * Creates a new object using identity function. + * @param obj - The object to clone + * @returns A new object with the same values + * @example + * mapValues({ a: 1, b: 2 }) + * // => { a: 1, b: 2 } + */ +declare function mapValues(obj: T): T; +/** + * Creates a new object using identity function. + * @param obj - The object to clone + * @returns A new object with the same values, or empty object if input is null/undefined + * @example + * mapValues({ a: 1, b: 2 }) + * // => { a: 1, b: 2 } + * mapValues(null) + * // => {} + */ +declare function mapValues(obj: T | null | undefined): Partial; + +export { mapValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.js new file mode 100644 index 0000000000000000000000000000000000000000..c283a5f0d0faff6893a921a697e545129a57adce --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const mapValues$1 = require('../../object/mapValues.js'); +const iteratee = require('../util/iteratee.js'); + +function mapValues(object, getNewValue = identity.identity) { + if (object == null) { + return {}; + } + return mapValues$1.mapValues(object, iteratee.iteratee(getNewValue)); +} + +exports.mapValues = mapValues; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8ef6b23257d4110f8c9378d1d7eeb70f2cdbbbb9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mapValues.mjs @@ -0,0 +1,12 @@ +import { identity } from '../../function/identity.mjs'; +import { mapValues as mapValues$1 } from '../../object/mapValues.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function mapValues(object, getNewValue = identity) { + if (object == null) { + return {}; + } + return mapValues$1(object, iteratee(getNewValue)); +} + +export { mapValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..be95ba9c68886bad1ce1ac6d39450a0fb0b31376 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.d.mts @@ -0,0 +1,84 @@ +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @template T + * @template U + * @param {T} object - The destination object. + * @param {U} source - The source object. + * @returns {T & U} - Returns `object`. + * + * @example + * const object = { a: [{ b: 2 }, { d: 4 }] }; + * const other = { a: [{ c: 3 }, { e: 5 }] }; + * merge(object, other); + * // => { a: [{ b: 2, c: 3 }, { d: 4, e: 5 }] } + */ +declare function merge(object: T, source: U): T & U; +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @template T + * @template U + * @template V + * @param {T} object - The destination object. + * @param {U} source1 - The first source object. + * @param {V} source2 - The second source object. + * @returns {T & U & V} - Returns `object`. + * + * @example + * merge({ a: 1 }, { b: 2 }, { c: 3 }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function merge(object: T, source1: U, source2: V): T & U & V; +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @template T + * @template U + * @template V + * @template W + * @param {T} object - The destination object. + * @param {U} source1 - The first source object. + * @param {V} source2 - The second source object. + * @param {W} source3 - The third source object. + * @returns {T & U & V & W} - Returns `object`. + * + * @example + * merge({ a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function merge(object: T, source1: U, source2: V, source3: W): T & U & V & W; +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @template T + * @template U + * @template V + * @template W + * @template X + * @param {T} object - The destination object. + * @param {U} source1 - The first source object. + * @param {V} source2 - The second source object. + * @param {W} source3 - The third source object. + * @param {X} source4 - The fourth source object. + * @returns {T & U & V & W & X} - Returns `object`. + * + * @example + * merge({ a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }, { e: 5 }); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function merge(object: T, source1: U, source2: V, source3: W, source4: X): T & U & V & W & X; +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @param {any} object - The destination object. + * @param {...any[]} otherArgs - The source objects. + * @returns {any} - Returns `object`. + * + * @example + * merge({ a: 1 }, { b: 2 }, { c: 3 }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function merge(object: any, ...otherArgs: any[]): any; + +export { merge }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..be95ba9c68886bad1ce1ac6d39450a0fb0b31376 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.d.ts @@ -0,0 +1,84 @@ +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @template T + * @template U + * @param {T} object - The destination object. + * @param {U} source - The source object. + * @returns {T & U} - Returns `object`. + * + * @example + * const object = { a: [{ b: 2 }, { d: 4 }] }; + * const other = { a: [{ c: 3 }, { e: 5 }] }; + * merge(object, other); + * // => { a: [{ b: 2, c: 3 }, { d: 4, e: 5 }] } + */ +declare function merge(object: T, source: U): T & U; +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @template T + * @template U + * @template V + * @param {T} object - The destination object. + * @param {U} source1 - The first source object. + * @param {V} source2 - The second source object. + * @returns {T & U & V} - Returns `object`. + * + * @example + * merge({ a: 1 }, { b: 2 }, { c: 3 }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function merge(object: T, source1: U, source2: V): T & U & V; +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @template T + * @template U + * @template V + * @template W + * @param {T} object - The destination object. + * @param {U} source1 - The first source object. + * @param {V} source2 - The second source object. + * @param {W} source3 - The third source object. + * @returns {T & U & V & W} - Returns `object`. + * + * @example + * merge({ a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function merge(object: T, source1: U, source2: V, source3: W): T & U & V & W; +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @template T + * @template U + * @template V + * @template W + * @template X + * @param {T} object - The destination object. + * @param {U} source1 - The first source object. + * @param {V} source2 - The second source object. + * @param {W} source3 - The third source object. + * @param {X} source4 - The fourth source object. + * @returns {T & U & V & W & X} - Returns `object`. + * + * @example + * merge({ a: 1 }, { b: 2 }, { c: 3 }, { d: 4 }, { e: 5 }); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function merge(object: T, source1: U, source2: V, source3: W, source4: X): T & U & V & W & X; +/** + * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. + * + * @param {any} object - The destination object. + * @param {...any[]} otherArgs - The source objects. + * @returns {any} - Returns `object`. + * + * @example + * merge({ a: 1 }, { b: 2 }, { c: 3 }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function merge(object: any, ...otherArgs: any[]): any; + +export { merge }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.js new file mode 100644 index 0000000000000000000000000000000000000000..4745aeedcbe7ed3f93d0f571d488c5ccb62e2a0d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const mergeWith = require('./mergeWith.js'); +const noop = require('../../function/noop.js'); + +function merge(object, ...sources) { + return mergeWith.mergeWith(object, ...sources, noop.noop); +} + +exports.merge = merge; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.mjs new file mode 100644 index 0000000000000000000000000000000000000000..66b4563dd37846e40a1100f441a0ed14aa8805a9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/merge.mjs @@ -0,0 +1,8 @@ +import { mergeWith } from './mergeWith.mjs'; +import { noop } from '../../function/noop.mjs'; + +function merge(object, ...sources) { + return mergeWith(object, ...sources, noop); +} + +export { merge }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0923e9754380afb28b527e0df5bef256c295f29c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.d.mts @@ -0,0 +1,125 @@ +type MergeWithCustomizer = (objValue: any, srcValue: any, key: string, object: any, source: any, stack: any) => any; +/** + * Merges the properties of a source object into the target object using a customizer function. + * + * @template TObject + * @template TSource + * @param {TObject} object - The target object into which the source object properties will be merged. + * @param {TSource} source - The source object whose properties will be merged into the target object. + * @param {MergeWithCustomizer} customizer - The function to customize assigned values. + * @returns {TObject & TSource} Returns the updated target object with properties from the source object merged in. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * + * const result = mergeWith(target, source, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + * } + * }); + * // => { a: 1, b: 5, c: 4 } + */ +declare function mergeWith(object: TObject, source: TSource, customizer: MergeWithCustomizer): TObject & TSource; +/** + * Merges the properties of two source objects into the target object using a customizer function. + * + * @template TObject + * @template TSource1 + * @template TSource2 + * @param {TObject} object - The target object into which the source objects properties will be merged. + * @param {TSource1} source1 - The first source object. + * @param {TSource2} source2 - The second source object. + * @param {MergeWithCustomizer} customizer - The function to customize assigned values. + * @returns {TObject & TSource1 & TSource2} Returns the updated target object with properties from the source objects merged in. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * + * const result = mergeWith(target, source1, source2, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + * } + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function mergeWith(object: TObject, source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2; +/** + * Merges the properties of three source objects into the target object using a customizer function. + * + * @template TObject + * @template TSource1 + * @template TSource2 + * @template TSource3 + * @param {TObject} object - The target object into which the source objects properties will be merged. + * @param {TSource1} source1 - The first source object. + * @param {TSource2} source2 - The second source object. + * @param {TSource3} source3 - The third source object. + * @param {MergeWithCustomizer} customizer - The function to customize assigned values. + * @returns {TObject & TSource1 & TSource2 & TSource3} Returns the updated target object with properties from the source objects merged in. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * + * const result = mergeWith(target, source1, source2, source3, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + * } + * }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function mergeWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3; +/** + * Merges the properties of four source objects into the target object using a customizer function. + * + * @template TObject + * @template TSource1 + * @template TSource2 + * @template TSource3 + * @template TSource4 + * @param {TObject} object - The target object into which the source objects properties will be merged. + * @param {TSource1} source1 - The first source object. + * @param {TSource2} source2 - The second source object. + * @param {TSource3} source3 - The third source object. + * @param {TSource4} source4 - The fourth source object. + * @param {MergeWithCustomizer} customizer - The function to customize assigned values. + * @returns {TObject & TSource1 & TSource2 & TSource3 & TSource4} Returns the updated target object with properties from the source objects merged in. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * + * const result = mergeWith(target, source1, source2, source3, source4, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + * } + * }); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function mergeWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4; +/** + * Merges the properties of one or more source objects into the target object. + * + * @param {any} object - The target object into which the source object properties will be merged. + * @param {...any} otherArgs - Additional source objects to merge into the target object, including the custom `merge` function. + * @returns {any} The updated target object with properties from the source object(s) merged in. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * + * const result = mergeWith(target, source, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + */ +declare function mergeWith(object: any, ...otherArgs: any[]): any; + +export { mergeWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0923e9754380afb28b527e0df5bef256c295f29c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.d.ts @@ -0,0 +1,125 @@ +type MergeWithCustomizer = (objValue: any, srcValue: any, key: string, object: any, source: any, stack: any) => any; +/** + * Merges the properties of a source object into the target object using a customizer function. + * + * @template TObject + * @template TSource + * @param {TObject} object - The target object into which the source object properties will be merged. + * @param {TSource} source - The source object whose properties will be merged into the target object. + * @param {MergeWithCustomizer} customizer - The function to customize assigned values. + * @returns {TObject & TSource} Returns the updated target object with properties from the source object merged in. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * + * const result = mergeWith(target, source, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + * } + * }); + * // => { a: 1, b: 5, c: 4 } + */ +declare function mergeWith(object: TObject, source: TSource, customizer: MergeWithCustomizer): TObject & TSource; +/** + * Merges the properties of two source objects into the target object using a customizer function. + * + * @template TObject + * @template TSource1 + * @template TSource2 + * @param {TObject} object - The target object into which the source objects properties will be merged. + * @param {TSource1} source1 - The first source object. + * @param {TSource2} source2 - The second source object. + * @param {MergeWithCustomizer} customizer - The function to customize assigned values. + * @returns {TObject & TSource1 & TSource2} Returns the updated target object with properties from the source objects merged in. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * + * const result = mergeWith(target, source1, source2, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + * } + * }); + * // => { a: 1, b: 2, c: 3 } + */ +declare function mergeWith(object: TObject, source1: TSource1, source2: TSource2, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2; +/** + * Merges the properties of three source objects into the target object using a customizer function. + * + * @template TObject + * @template TSource1 + * @template TSource2 + * @template TSource3 + * @param {TObject} object - The target object into which the source objects properties will be merged. + * @param {TSource1} source1 - The first source object. + * @param {TSource2} source2 - The second source object. + * @param {TSource3} source3 - The third source object. + * @param {MergeWithCustomizer} customizer - The function to customize assigned values. + * @returns {TObject & TSource1 & TSource2 & TSource3} Returns the updated target object with properties from the source objects merged in. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * + * const result = mergeWith(target, source1, source2, source3, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + * } + * }); + * // => { a: 1, b: 2, c: 3, d: 4 } + */ +declare function mergeWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3; +/** + * Merges the properties of four source objects into the target object using a customizer function. + * + * @template TObject + * @template TSource1 + * @template TSource2 + * @template TSource3 + * @template TSource4 + * @param {TObject} object - The target object into which the source objects properties will be merged. + * @param {TSource1} source1 - The first source object. + * @param {TSource2} source2 - The second source object. + * @param {TSource3} source3 - The third source object. + * @param {TSource4} source4 - The fourth source object. + * @param {MergeWithCustomizer} customizer - The function to customize assigned values. + * @returns {TObject & TSource1 & TSource2 & TSource3 & TSource4} Returns the updated target object with properties from the source objects merged in. + * + * @example + * const target = { a: 1 }; + * const source1 = { b: 2 }; + * const source2 = { c: 3 }; + * const source3 = { d: 4 }; + * const source4 = { e: 5 }; + * + * const result = mergeWith(target, source1, source2, source3, source4, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + * } + * }); + * // => { a: 1, b: 2, c: 3, d: 4, e: 5 } + */ +declare function mergeWith(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4, customizer: MergeWithCustomizer): TObject & TSource1 & TSource2 & TSource3 & TSource4; +/** + * Merges the properties of one or more source objects into the target object. + * + * @param {any} object - The target object into which the source object properties will be merged. + * @param {...any} otherArgs - Additional source objects to merge into the target object, including the custom `merge` function. + * @returns {any} The updated target object with properties from the source object(s) merged in. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * + * const result = mergeWith(target, source, (objValue, srcValue) => { + * if (typeof objValue === 'number' && typeof srcValue === 'number') { + * return objValue + srcValue; + */ +declare function mergeWith(object: any, ...otherArgs: any[]): any; + +export { mergeWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.js new file mode 100644 index 0000000000000000000000000000000000000000..b0c9d3bee3267601a1056be52b227d9bb7c92402 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.js @@ -0,0 +1,96 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const cloneDeep = require('./cloneDeep.js'); +const isUnsafeProperty = require('../../_internal/isUnsafeProperty.js'); +const clone = require('../../object/clone.js'); +const isPrimitive = require('../../predicate/isPrimitive.js'); +const getSymbols = require('../_internal/getSymbols.js'); +const isArguments = require('../predicate/isArguments.js'); +const isObjectLike = require('../predicate/isObjectLike.js'); +const isPlainObject = require('../predicate/isPlainObject.js'); +const isTypedArray = require('../predicate/isTypedArray.js'); + +function mergeWith(object, ...otherArgs) { + const sources = otherArgs.slice(0, -1); + const merge = otherArgs[otherArgs.length - 1]; + let result = object; + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + result = mergeWithDeep(result, source, merge, new Map()); + } + return result; +} +function mergeWithDeep(target, source, merge, stack) { + if (isPrimitive.isPrimitive(target)) { + target = Object(target); + } + if (source == null || typeof source !== 'object') { + return target; + } + if (stack.has(source)) { + return clone.clone(stack.get(source)); + } + stack.set(source, target); + if (Array.isArray(source)) { + source = source.slice(); + for (let i = 0; i < source.length; i++) { + source[i] = source[i] ?? undefined; + } + } + const sourceKeys = [...Object.keys(source), ...getSymbols.getSymbols(source)]; + for (let i = 0; i < sourceKeys.length; i++) { + const key = sourceKeys[i]; + if (isUnsafeProperty.isUnsafeProperty(key)) { + continue; + } + let sourceValue = source[key]; + let targetValue = target[key]; + if (isArguments.isArguments(sourceValue)) { + sourceValue = { ...sourceValue }; + } + if (isArguments.isArguments(targetValue)) { + targetValue = { ...targetValue }; + } + if (typeof Buffer !== 'undefined' && Buffer.isBuffer(sourceValue)) { + sourceValue = cloneDeep.cloneDeep(sourceValue); + } + if (Array.isArray(sourceValue)) { + if (typeof targetValue === 'object' && targetValue != null) { + const cloned = []; + const targetKeys = Reflect.ownKeys(targetValue); + for (let i = 0; i < targetKeys.length; i++) { + const targetKey = targetKeys[i]; + cloned[targetKey] = targetValue[targetKey]; + } + targetValue = cloned; + } + else { + targetValue = []; + } + } + const merged = merge(targetValue, sourceValue, key, target, source, stack); + if (merged != null) { + target[key] = merged; + } + else if (Array.isArray(sourceValue)) { + target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack); + } + else if (isObjectLike.isObjectLike(targetValue) && isObjectLike.isObjectLike(sourceValue)) { + target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack); + } + else if (targetValue == null && isPlainObject.isPlainObject(sourceValue)) { + target[key] = mergeWithDeep({}, sourceValue, merge, stack); + } + else if (targetValue == null && isTypedArray.isTypedArray(sourceValue)) { + target[key] = cloneDeep.cloneDeep(sourceValue); + } + else if (targetValue === undefined || sourceValue !== undefined) { + target[key] = sourceValue; + } + } + return target; +} + +exports.mergeWith = mergeWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..be54e3fc9167a4dc87c05b125ce379e2df921b65 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/mergeWith.mjs @@ -0,0 +1,92 @@ +import { cloneDeep } from './cloneDeep.mjs'; +import { isUnsafeProperty } from '../../_internal/isUnsafeProperty.mjs'; +import { clone } from '../../object/clone.mjs'; +import { isPrimitive } from '../../predicate/isPrimitive.mjs'; +import { getSymbols } from '../_internal/getSymbols.mjs'; +import { isArguments } from '../predicate/isArguments.mjs'; +import { isObjectLike } from '../predicate/isObjectLike.mjs'; +import { isPlainObject } from '../predicate/isPlainObject.mjs'; +import { isTypedArray } from '../predicate/isTypedArray.mjs'; + +function mergeWith(object, ...otherArgs) { + const sources = otherArgs.slice(0, -1); + const merge = otherArgs[otherArgs.length - 1]; + let result = object; + for (let i = 0; i < sources.length; i++) { + const source = sources[i]; + result = mergeWithDeep(result, source, merge, new Map()); + } + return result; +} +function mergeWithDeep(target, source, merge, stack) { + if (isPrimitive(target)) { + target = Object(target); + } + if (source == null || typeof source !== 'object') { + return target; + } + if (stack.has(source)) { + return clone(stack.get(source)); + } + stack.set(source, target); + if (Array.isArray(source)) { + source = source.slice(); + for (let i = 0; i < source.length; i++) { + source[i] = source[i] ?? undefined; + } + } + const sourceKeys = [...Object.keys(source), ...getSymbols(source)]; + for (let i = 0; i < sourceKeys.length; i++) { + const key = sourceKeys[i]; + if (isUnsafeProperty(key)) { + continue; + } + let sourceValue = source[key]; + let targetValue = target[key]; + if (isArguments(sourceValue)) { + sourceValue = { ...sourceValue }; + } + if (isArguments(targetValue)) { + targetValue = { ...targetValue }; + } + if (typeof Buffer !== 'undefined' && Buffer.isBuffer(sourceValue)) { + sourceValue = cloneDeep(sourceValue); + } + if (Array.isArray(sourceValue)) { + if (typeof targetValue === 'object' && targetValue != null) { + const cloned = []; + const targetKeys = Reflect.ownKeys(targetValue); + for (let i = 0; i < targetKeys.length; i++) { + const targetKey = targetKeys[i]; + cloned[targetKey] = targetValue[targetKey]; + } + targetValue = cloned; + } + else { + targetValue = []; + } + } + const merged = merge(targetValue, sourceValue, key, target, source, stack); + if (merged != null) { + target[key] = merged; + } + else if (Array.isArray(sourceValue)) { + target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack); + } + else if (isObjectLike(targetValue) && isObjectLike(sourceValue)) { + target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack); + } + else if (targetValue == null && isPlainObject(sourceValue)) { + target[key] = mergeWithDeep({}, sourceValue, merge, stack); + } + else if (targetValue == null && isTypedArray(sourceValue)) { + target[key] = cloneDeep(sourceValue); + } + else if (targetValue === undefined || sourceValue !== undefined) { + target[key] = sourceValue; + } + } + return target; +} + +export { mergeWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6046bf375c9ce1b02f5c3cd2bf779194e7c395f8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.d.mts @@ -0,0 +1,45 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Creates a new object with specified keys omitted. + * + * @template T - The type of object. + * @template K - The type of keys to omit. + * @param {T | null | undefined} object - The object to omit keys from. + * @param {...K} paths - The keys to be omitted from the object. + * @returns {Pick>} A new object with the specified keys omitted. + * + * @example + * omit({ a: 1, b: 2, c: 3 }, 'a', 'c'); + * // => { b: 2 } + */ +declare function omit(object: T | null | undefined, ...paths: K): Pick>; +/** + * Creates a new object with specified keys omitted. + * + * @template T - The type of object. + * @template K - The type of keys to omit. + * @param {T | null | undefined} object - The object to omit keys from. + * @param {...Array>} paths - The keys to be omitted from the object. + * @returns {Omit} A new object with the specified keys omitted. + * + * @example + * omit({ a: 1, b: 2, c: 3 }, 'a', ['b', 'c']); + * // => {} + */ +declare function omit(object: T | null | undefined, ...paths: Array>): Omit; +/** + * Creates a new object with specified keys omitted. + * + * @template T - The type of object. + * @param {T | null | undefined} object - The object to omit keys from. + * @param {...Array>} paths - The keys to be omitted from the object. + * @returns {Partial} A new object with the specified keys omitted. + * + * @example + * omit({ a: 1, b: 2, c: 3 }, 'a', 'b'); + * // => { c: 3 } + */ +declare function omit(object: T | null | undefined, ...paths: Array>): Partial; + +export { omit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0350e13d74b7eec24854d866b226b287d2a79301 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.d.ts @@ -0,0 +1,45 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Creates a new object with specified keys omitted. + * + * @template T - The type of object. + * @template K - The type of keys to omit. + * @param {T | null | undefined} object - The object to omit keys from. + * @param {...K} paths - The keys to be omitted from the object. + * @returns {Pick>} A new object with the specified keys omitted. + * + * @example + * omit({ a: 1, b: 2, c: 3 }, 'a', 'c'); + * // => { b: 2 } + */ +declare function omit(object: T | null | undefined, ...paths: K): Pick>; +/** + * Creates a new object with specified keys omitted. + * + * @template T - The type of object. + * @template K - The type of keys to omit. + * @param {T | null | undefined} object - The object to omit keys from. + * @param {...Array>} paths - The keys to be omitted from the object. + * @returns {Omit} A new object with the specified keys omitted. + * + * @example + * omit({ a: 1, b: 2, c: 3 }, 'a', ['b', 'c']); + * // => {} + */ +declare function omit(object: T | null | undefined, ...paths: Array>): Omit; +/** + * Creates a new object with specified keys omitted. + * + * @template T - The type of object. + * @param {T | null | undefined} object - The object to omit keys from. + * @param {...Array>} paths - The keys to be omitted from the object. + * @returns {Partial} A new object with the specified keys omitted. + * + * @example + * omit({ a: 1, b: 2, c: 3 }, 'a', 'b'); + * // => { c: 3 } + */ +declare function omit(object: T | null | undefined, ...paths: Array>): Partial; + +export { omit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.js new file mode 100644 index 0000000000000000000000000000000000000000..b73751573acf840967a8aac4f4b2347d4aa7e000 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const unset = require('./unset.js'); +const cloneDeep = require('../../object/cloneDeep.js'); + +function omit(obj, ...keysArr) { + if (obj == null) { + return {}; + } + const result = cloneDeep.cloneDeep(obj); + for (let i = 0; i < keysArr.length; i++) { + let keys = keysArr[i]; + switch (typeof keys) { + case 'object': { + if (!Array.isArray(keys)) { + keys = Array.from(keys); + } + for (let j = 0; j < keys.length; j++) { + const key = keys[j]; + unset.unset(result, key); + } + break; + } + case 'string': + case 'symbol': + case 'number': { + unset.unset(result, keys); + break; + } + } + } + return result; +} + +exports.omit = omit; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b992c9f76f1911a0013b306fbb7b1640a9ace183 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omit.mjs @@ -0,0 +1,33 @@ +import { unset } from './unset.mjs'; +import { cloneDeep } from '../../object/cloneDeep.mjs'; + +function omit(obj, ...keysArr) { + if (obj == null) { + return {}; + } + const result = cloneDeep(obj); + for (let i = 0; i < keysArr.length; i++) { + let keys = keysArr[i]; + switch (typeof keys) { + case 'object': { + if (!Array.isArray(keys)) { + keys = Array.from(keys); + } + for (let j = 0; j < keys.length; j++) { + const key = keys[j]; + unset(result, key); + } + break; + } + case 'string': + case 'symbol': + case 'number': { + unset(result, keys); + break; + } + } + } + return result; +} + +export { omit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..349f93fb3eacdc5f789e4f705004d3452ca95ade --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.d.mts @@ -0,0 +1,43 @@ +import { ValueKeyIteratee } from '../_internal/ValueKeyIteratee.mjs'; + +/** + * Creates a new object composed of the properties that do not satisfy the predicate function. + * + * @template T + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIteratee} predicate - The function invoked per property. + * @returns {Record} Returns the new object. + * + * @example + * omitBy({ 'a': 1, 'b': '2', 'c': 3 }, isString); + * // => { 'a': 1, 'c': 3 } + */ +declare function omitBy(object: Record | null | undefined, predicate?: ValueKeyIteratee): Record; +/** + * Creates a new object composed of the properties that do not satisfy the predicate function. + * + * @template T + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIteratee} predicate - The function invoked per property. + * @returns {Record} Returns the new object. + * + * @example + * omitBy({ 0: 1, 1: '2', 2: 3 }, isString); + * // => { 0: 1, 2: 3 } + */ +declare function omitBy(object: Record | null | undefined, predicate?: ValueKeyIteratee): Record; +/** + * Creates a new object composed of the properties that do not satisfy the predicate function. + * + * @template T + * @param {T | null | undefined} object - The source object. + * @param {ValueKeyIteratee} predicate - The function invoked per property. + * @returns {Partial} Returns the new object. + * + * @example + * omitBy({ 'a': 1, 'b': '2', 'c': 3 }, isString); + * // => { 'a': 1, 'c': 3 } + */ +declare function omitBy(object: T | null | undefined, predicate: ValueKeyIteratee): Partial; + +export { omitBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..413fd9a6cea394c715e3a46130e553e752fa63db --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.d.ts @@ -0,0 +1,43 @@ +import { ValueKeyIteratee } from '../_internal/ValueKeyIteratee.js'; + +/** + * Creates a new object composed of the properties that do not satisfy the predicate function. + * + * @template T + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIteratee} predicate - The function invoked per property. + * @returns {Record} Returns the new object. + * + * @example + * omitBy({ 'a': 1, 'b': '2', 'c': 3 }, isString); + * // => { 'a': 1, 'c': 3 } + */ +declare function omitBy(object: Record | null | undefined, predicate?: ValueKeyIteratee): Record; +/** + * Creates a new object composed of the properties that do not satisfy the predicate function. + * + * @template T + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIteratee} predicate - The function invoked per property. + * @returns {Record} Returns the new object. + * + * @example + * omitBy({ 0: 1, 1: '2', 2: 3 }, isString); + * // => { 0: 1, 2: 3 } + */ +declare function omitBy(object: Record | null | undefined, predicate?: ValueKeyIteratee): Record; +/** + * Creates a new object composed of the properties that do not satisfy the predicate function. + * + * @template T + * @param {T | null | undefined} object - The source object. + * @param {ValueKeyIteratee} predicate - The function invoked per property. + * @returns {Partial} Returns the new object. + * + * @example + * omitBy({ 'a': 1, 'b': '2', 'c': 3 }, isString); + * // => { 'a': 1, 'c': 3 } + */ +declare function omitBy(object: T | null | undefined, predicate: ValueKeyIteratee): Partial; + +export { omitBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.js new file mode 100644 index 0000000000000000000000000000000000000000..b7fc8dae672d3cae5e414d78e68fac5e0be0eb0f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.js @@ -0,0 +1,32 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keysIn = require('./keysIn.js'); +const range = require('../../math/range.js'); +const getSymbolsIn = require('../_internal/getSymbolsIn.js'); +const identity = require('../function/identity.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isSymbol = require('../predicate/isSymbol.js'); +const iteratee = require('../util/iteratee.js'); + +function omitBy(object, shouldOmit) { + if (object == null) { + return {}; + } + const result = {}; + const predicate = iteratee.iteratee(shouldOmit ?? identity.identity); + const keys = isArrayLike.isArrayLike(object) + ? range.range(0, object.length) + : [...keysIn.keysIn(object), ...getSymbolsIn.getSymbolsIn(object)]; + for (let i = 0; i < keys.length; i++) { + const key = (isSymbol.isSymbol(keys[i]) ? keys[i] : keys[i].toString()); + const value = object[key]; + if (!predicate(value, key, object)) { + result[key] = value; + } + } + return result; +} + +exports.omitBy = omitBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..39aacd52332a588f6901a366491327c1dc9dfd98 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/omitBy.mjs @@ -0,0 +1,28 @@ +import { keysIn } from './keysIn.mjs'; +import { range } from '../../math/range.mjs'; +import { getSymbolsIn } from '../_internal/getSymbolsIn.mjs'; +import { identity } from '../function/identity.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isSymbol } from '../predicate/isSymbol.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function omitBy(object, shouldOmit) { + if (object == null) { + return {}; + } + const result = {}; + const predicate = iteratee(shouldOmit ?? identity); + const keys = isArrayLike(object) + ? range(0, object.length) + : [...keysIn(object), ...getSymbolsIn(object)]; + for (let i = 0; i < keys.length; i++) { + const key = (isSymbol(keys[i]) ? keys[i] : keys[i].toString()); + const value = object[key]; + if (!predicate(value, key, object)) { + result[key] = value; + } + } + return result; +} + +export { omitBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..de7ebf1e9684bd8ed1429f24591071f29ebd782a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.d.mts @@ -0,0 +1,34 @@ +import { Many } from '../_internal/Many.mjs'; +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Creates a new object composed of the picked object properties. + * + * @template T - The type of object. + * @template U - The type of keys to pick. + * @param {T} object - The object to pick keys from. + * @param {...Array>} props - An array of keys to be picked from the object. + * @returns {Pick} A new object with the specified keys picked. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * const result = pick(obj, ['a', 'c']); + * // result will be { a: 1, c: 3 } + */ +declare function pick(object: T, ...props: Array>): Pick; +/** + * Creates a new object composed of the picked object properties. + * + * @template T - The type of object. + * @param {T | null | undefined} object - The object to pick keys from. + * @param {...Array>} props - An array of keys to be picked from the object. + * @returns {Partial} A new object with the specified keys picked. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * const result = pick(obj, ['a', 'c']); + * // result will be { a: 1, c: 3 } + */ +declare function pick(object: T | null | undefined, ...props: Array>): Partial; + +export { pick }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..30ada3f517903c5ca825164ad57f023de1c4465e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.d.ts @@ -0,0 +1,34 @@ +import { Many } from '../_internal/Many.js'; +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Creates a new object composed of the picked object properties. + * + * @template T - The type of object. + * @template U - The type of keys to pick. + * @param {T} object - The object to pick keys from. + * @param {...Array>} props - An array of keys to be picked from the object. + * @returns {Pick} A new object with the specified keys picked. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * const result = pick(obj, ['a', 'c']); + * // result will be { a: 1, c: 3 } + */ +declare function pick(object: T, ...props: Array>): Pick; +/** + * Creates a new object composed of the picked object properties. + * + * @template T - The type of object. + * @param {T | null | undefined} object - The object to pick keys from. + * @param {...Array>} props - An array of keys to be picked from the object. + * @returns {Partial} A new object with the specified keys picked. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * const result = pick(obj, ['a', 'c']); + * // result will be { a: 1, c: 3 } + */ +declare function pick(object: T | null | undefined, ...props: Array>): Partial; + +export { pick }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.js new file mode 100644 index 0000000000000000000000000000000000000000..142fc737604c57fbaf9776742c93a1c7a945140f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.js @@ -0,0 +1,53 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const get = require('./get.js'); +const has = require('./has.js'); +const set = require('./set.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isNil = require('../predicate/isNil.js'); + +function pick(obj, ...keysArr) { + if (isNil.isNil(obj)) { + return {}; + } + const result = {}; + for (let i = 0; i < keysArr.length; i++) { + let keys = keysArr[i]; + switch (typeof keys) { + case 'object': { + if (!Array.isArray(keys)) { + if (isArrayLike.isArrayLike(keys)) { + keys = Array.from(keys); + } + else { + keys = [keys]; + } + } + break; + } + case 'string': + case 'symbol': + case 'number': { + keys = [keys]; + break; + } + } + for (const key of keys) { + const value = get.get(obj, key); + if (value === undefined && !has.has(obj, key)) { + continue; + } + if (typeof key === 'string' && Object.hasOwn(obj, key)) { + result[key] = value; + } + else { + set.set(result, key, value); + } + } + } + return result; +} + +exports.pick = pick; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d2b1b8b85b51d0c8b71bf9fd6bad1db628cfefc6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pick.mjs @@ -0,0 +1,49 @@ +import { get } from './get.mjs'; +import { has } from './has.mjs'; +import { set } from './set.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isNil } from '../predicate/isNil.mjs'; + +function pick(obj, ...keysArr) { + if (isNil(obj)) { + return {}; + } + const result = {}; + for (let i = 0; i < keysArr.length; i++) { + let keys = keysArr[i]; + switch (typeof keys) { + case 'object': { + if (!Array.isArray(keys)) { + if (isArrayLike(keys)) { + keys = Array.from(keys); + } + else { + keys = [keys]; + } + } + break; + } + case 'string': + case 'symbol': + case 'number': { + keys = [keys]; + break; + } + } + for (const key of keys) { + const value = get(obj, key); + if (value === undefined && !has(obj, key)) { + continue; + } + if (typeof key === 'string' && Object.hasOwn(obj, key)) { + result[key] = value; + } + else { + set(result, key, value); + } + } + } + return result; +} + +export { pick }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b5d5d2e52dd54779057e6ce2a61eecdb24133083 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.d.mts @@ -0,0 +1,80 @@ +import { ValueKeyIteratee } from '../_internal/ValueKeyIteratee.mjs'; +import { ValueKeyIterateeTypeGuard } from '../_internal/ValueKeyIterateeTypeGuard.mjs'; + +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object values. + * @template S - The type of filtered values. + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIterateeTypeGuard} predicate - The function invoked per property. + * @returns {Record} Returns the new filtered object. + * + * @example + * const users = { + * 'fred': { 'user': 'fred', 'age': 40 }, + * 'pebbles': { 'user': 'pebbles', 'age': 1 } + * }; + * pickBy(users, ({ age }) => age < 40); + * // => { 'pebbles': { 'user': 'pebbles', 'age': 1 } } + */ +declare function pickBy(object: Record | null | undefined, predicate: ValueKeyIterateeTypeGuard): Record; +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object values. + * @template S - The type of filtered values. + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIterateeTypeGuard} predicate - The function invoked per property. + * @returns {Record} Returns the new filtered object. + * + * @example + * const array = [1, 2, 3, 4]; + * pickBy(array, (value) => value % 2 === 0); + * // => { 1: 2, 3: 4 } + */ +declare function pickBy(object: Record | null | undefined, predicate: ValueKeyIterateeTypeGuard): Record; +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object values. + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIteratee} [predicate] - The function invoked per property. + * @returns {Record} Returns the new filtered object. + * + * @example + * const object = { 'a': 1, 'b': '2', 'c': 3 }; + * pickBy(object, (value) => typeof value === 'string'); + * // => { 'b': '2' } + */ +declare function pickBy(object: Record | null | undefined, predicate?: ValueKeyIteratee): Record; +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object values. + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIteratee} [predicate] - The function invoked per property. + * @returns {Record} Returns the new filtered object. + * + * @example + * const array = [1, 2, 3, 4]; + * pickBy(array, (value) => value > 2); + * // => { 2: 3, 3: 4 } + */ +declare function pickBy(object: Record | null | undefined, predicate?: ValueKeyIteratee): Record; +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object. + * @param {T | null | undefined} object - The source object. + * @param {ValueKeyIteratee} [predicate] - The function invoked per property. + * @returns {Partial} Returns the new filtered object. + * + * @example + * const object = { 'a': 1, 'b': '2', 'c': 3 }; + * pickBy(object, (value) => typeof value === 'string'); + * // => { 'b': '2' } + */ +declare function pickBy(object: T | null | undefined, predicate?: ValueKeyIteratee): Partial; + +export { pickBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..def714f837ccd659e06f83d1cff9cdd94d1eaab7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.d.ts @@ -0,0 +1,80 @@ +import { ValueKeyIteratee } from '../_internal/ValueKeyIteratee.js'; +import { ValueKeyIterateeTypeGuard } from '../_internal/ValueKeyIterateeTypeGuard.js'; + +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object values. + * @template S - The type of filtered values. + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIterateeTypeGuard} predicate - The function invoked per property. + * @returns {Record} Returns the new filtered object. + * + * @example + * const users = { + * 'fred': { 'user': 'fred', 'age': 40 }, + * 'pebbles': { 'user': 'pebbles', 'age': 1 } + * }; + * pickBy(users, ({ age }) => age < 40); + * // => { 'pebbles': { 'user': 'pebbles', 'age': 1 } } + */ +declare function pickBy(object: Record | null | undefined, predicate: ValueKeyIterateeTypeGuard): Record; +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object values. + * @template S - The type of filtered values. + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIterateeTypeGuard} predicate - The function invoked per property. + * @returns {Record} Returns the new filtered object. + * + * @example + * const array = [1, 2, 3, 4]; + * pickBy(array, (value) => value % 2 === 0); + * // => { 1: 2, 3: 4 } + */ +declare function pickBy(object: Record | null | undefined, predicate: ValueKeyIterateeTypeGuard): Record; +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object values. + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIteratee} [predicate] - The function invoked per property. + * @returns {Record} Returns the new filtered object. + * + * @example + * const object = { 'a': 1, 'b': '2', 'c': 3 }; + * pickBy(object, (value) => typeof value === 'string'); + * // => { 'b': '2' } + */ +declare function pickBy(object: Record | null | undefined, predicate?: ValueKeyIteratee): Record; +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object values. + * @param {Record | null | undefined} object - The source object. + * @param {ValueKeyIteratee} [predicate] - The function invoked per property. + * @returns {Record} Returns the new filtered object. + * + * @example + * const array = [1, 2, 3, 4]; + * pickBy(array, (value) => value > 2); + * // => { 2: 3, 3: 4 } + */ +declare function pickBy(object: Record | null | undefined, predicate?: ValueKeyIteratee): Record; +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * @template T - The type of object. + * @param {T | null | undefined} object - The source object. + * @param {ValueKeyIteratee} [predicate] - The function invoked per property. + * @returns {Partial} Returns the new filtered object. + * + * @example + * const object = { 'a': 1, 'b': '2', 'c': 3 }; + * pickBy(object, (value) => typeof value === 'string'); + * // => { 'b': '2' } + */ +declare function pickBy(object: T | null | undefined, predicate?: ValueKeyIteratee): Partial; + +export { pickBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.js new file mode 100644 index 0000000000000000000000000000000000000000..ae6559239e5ad5841f5e3cd6012fe854b8293d81 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keysIn = require('./keysIn.js'); +const range = require('../../math/range.js'); +const getSymbolsIn = require('../_internal/getSymbolsIn.js'); +const identity = require('../function/identity.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isSymbol = require('../predicate/isSymbol.js'); +const iteratee = require('../util/iteratee.js'); + +function pickBy(obj, shouldPick) { + if (obj == null) { + return {}; + } + const predicate = iteratee.iteratee(shouldPick ?? identity.identity); + const result = {}; + const keys = isArrayLike.isArrayLike(obj) ? range.range(0, obj.length) : [...keysIn.keysIn(obj), ...getSymbolsIn.getSymbolsIn(obj)]; + for (let i = 0; i < keys.length; i++) { + const key = (isSymbol.isSymbol(keys[i]) ? keys[i] : keys[i].toString()); + const value = obj[key]; + if (predicate(value, key, obj)) { + result[key] = value; + } + } + return result; +} + +exports.pickBy = pickBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..85a2f7c61dae3ba2ed799a971c8c418d1451eb44 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/pickBy.mjs @@ -0,0 +1,26 @@ +import { keysIn } from './keysIn.mjs'; +import { range } from '../../math/range.mjs'; +import { getSymbolsIn } from '../_internal/getSymbolsIn.mjs'; +import { identity } from '../function/identity.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isSymbol } from '../predicate/isSymbol.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function pickBy(obj, shouldPick) { + if (obj == null) { + return {}; + } + const predicate = iteratee(shouldPick ?? identity); + const result = {}; + const keys = isArrayLike(obj) ? range(0, obj.length) : [...keysIn(obj), ...getSymbolsIn(obj)]; + for (let i = 0; i < keys.length; i++) { + const key = (isSymbol(keys[i]) ? keys[i] : keys[i].toString()); + const value = obj[key]; + if (predicate(value, key, obj)) { + result[key] = value; + } + } + return result; +} + +export { pickBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6de9589a16770572deeb1e2ac8d6a427daaed338 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.d.mts @@ -0,0 +1,5 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +declare function property(path: PropertyPath): (obj: T) => R; + +export { property }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5fb789f3b1a7c8197dfa8b87ea94fc90e63fdc52 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.d.ts @@ -0,0 +1,5 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +declare function property(path: PropertyPath): (obj: T) => R; + +export { property }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.js new file mode 100644 index 0000000000000000000000000000000000000000..be2c300c65394a44a7ebbb8e39446572db5dfa25 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const get = require('./get.js'); + +function property(path) { + return function (object) { + return get.get(object, path); + }; +} + +exports.property = property; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.mjs new file mode 100644 index 0000000000000000000000000000000000000000..067c163e11c0deec4e44b8049261b12c44e99f66 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/property.mjs @@ -0,0 +1,9 @@ +import { get } from './get.mjs'; + +function property(path) { + return function (object) { + return get(object, path); + }; +} + +export { property }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8632869cc9cdf2db2b21b95260c856aeec3f798c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.d.mts @@ -0,0 +1,5 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +declare function propertyOf(object: T): (path: PropertyPath) => any; + +export { propertyOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..91f9e2b71adc273965e4063bb38c51fa25d623cb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.d.ts @@ -0,0 +1,5 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +declare function propertyOf(object: T): (path: PropertyPath) => any; + +export { propertyOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.js new file mode 100644 index 0000000000000000000000000000000000000000..9eb615e66a619bf2b27a8424a97171b7380f7885 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const get = require('./get.js'); + +function propertyOf(object) { + return function (path) { + return get.get(object, path); + }; +} + +exports.propertyOf = propertyOf; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e06ede2f48e32f99dcd0600333e47bfcaa1cdea3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/propertyOf.mjs @@ -0,0 +1,9 @@ +import { get } from './get.mjs'; + +function propertyOf(object) { + return function (path) { + return get(object, path); + }; +} + +export { propertyOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..3be9c77dbb3e2ea954d6541796fda01b398ad2ef --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.d.mts @@ -0,0 +1,37 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Retrieves the value at a given path of an object. + * If the resolved value is a function, it is invoked with the object as its `this` context. + * If the value is `undefined`, the `defaultValue` is returned. + * + * @template T - The type of object. + * @template R - The type of the value to return. + * @param {T} object - The object to query. + * @param {PropertyPath} path - The path of the property to get. + * @param {R | ((...args: any[]) => R)} [defaultValue] - The value returned if the resolved value is `undefined`. + * @returns {R} - Returns the resolved value. + * + * @example + * const obj = { a: { b: { c: 3 } } }; + * result(obj, 'a.b.c'); + * // => 3 + * + * @example + * const obj = { a: () => 5 }; + * result(obj, 'a'); + * // => 5 (calls the function `a` and returns its result) + * + * @example + * const obj = { a: { b: null } }; + * result(obj, 'a.b.c', 'default'); + * // => 'default' + * + * @example + * const obj = { a: { b: { c: 3 } } }; + * result(obj, 'a.b.d', () => 'default'); + * // => 'default' + */ +declare function result(object: any, path: PropertyPath, defaultValue?: R | ((...args: any[]) => R)): R; + +export { result }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2b09ebc45f200b32d01074fbcb4be0b56f643da9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.d.ts @@ -0,0 +1,37 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Retrieves the value at a given path of an object. + * If the resolved value is a function, it is invoked with the object as its `this` context. + * If the value is `undefined`, the `defaultValue` is returned. + * + * @template T - The type of object. + * @template R - The type of the value to return. + * @param {T} object - The object to query. + * @param {PropertyPath} path - The path of the property to get. + * @param {R | ((...args: any[]) => R)} [defaultValue] - The value returned if the resolved value is `undefined`. + * @returns {R} - Returns the resolved value. + * + * @example + * const obj = { a: { b: { c: 3 } } }; + * result(obj, 'a.b.c'); + * // => 3 + * + * @example + * const obj = { a: () => 5 }; + * result(obj, 'a'); + * // => 5 (calls the function `a` and returns its result) + * + * @example + * const obj = { a: { b: null } }; + * result(obj, 'a.b.c', 'default'); + * // => 'default' + * + * @example + * const obj = { a: { b: { c: 3 } } }; + * result(obj, 'a.b.d', () => 'default'); + * // => 'default' + */ +declare function result(object: any, path: PropertyPath, defaultValue?: R | ((...args: any[]) => R)): R; + +export { result }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.js new file mode 100644 index 0000000000000000000000000000000000000000..5b83976b4f1f54dbbcdc066607e24f85b3ccb222 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.js @@ -0,0 +1,28 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isKey = require('../_internal/isKey.js'); +const toKey = require('../_internal/toKey.js'); +const toPath = require('../util/toPath.js'); +const toString = require('../util/toString.js'); + +function result(object, path, defaultValue) { + if (isKey.isKey(path, object)) { + path = [path]; + } + else if (!Array.isArray(path)) { + path = toPath.toPath(toString.toString(path)); + } + const pathLength = Math.max(path.length, 1); + for (let index = 0; index < pathLength; index++) { + const value = object == null ? undefined : object[toKey.toKey(path[index])]; + if (value === undefined) { + return typeof defaultValue === 'function' ? defaultValue.call(object) : defaultValue; + } + object = typeof value === 'function' ? value.call(object) : value; + } + return object; +} + +exports.result = result; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f4fccbe529cedefb21b1f5e671ae5ce3341c9043 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/result.mjs @@ -0,0 +1,24 @@ +import { isKey } from '../_internal/isKey.mjs'; +import { toKey } from '../_internal/toKey.mjs'; +import { toPath } from '../util/toPath.mjs'; +import { toString } from '../util/toString.mjs'; + +function result(object, path, defaultValue) { + if (isKey(path, object)) { + path = [path]; + } + else if (!Array.isArray(path)) { + path = toPath(toString(path)); + } + const pathLength = Math.max(path.length, 1); + for (let index = 0; index < pathLength; index++) { + const value = object == null ? undefined : object[toKey(path[index])]; + if (value === undefined) { + return typeof defaultValue === 'function' ? defaultValue.call(object) : defaultValue; + } + object = typeof value === 'function' ? value.call(object) : value; + } + return object; +} + +export { result }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8e8f5f9e516ca34788577e5b45f8ada36595f212 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.d.mts @@ -0,0 +1,60 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Sets the value at the specified path of the given object. If any part of the path does not exist, it will be created. + * + * @template T - The type of the object. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to set. + * @param {any} value - The value to set. + * @returns {T} - The modified object. + * + * @example + * // Set a value in a nested object + * const obj = { a: { b: { c: 3 } } }; + * set(obj, 'a.b.c', 4); + * console.log(obj.a.b.c); // 4 + * + * @example + * // Set a value in an array + * const arr = [1, 2, 3]; + * set(arr, 1, 4); + * console.log(arr[1]); // 4 + * + * @example + * // Create non-existent path and set value + * const obj = {}; + * set(obj, 'a.b.c', 4); + * console.log(obj); // { a: { b: { c: 4 } } } + */ +declare function set(object: T, path: PropertyPath, value: any): T; +/** + * Sets the value at the specified path of the given object. If any part of the path does not exist, it will be created. + * + * @template R - The return type. + * @param {object} object - The object to modify. + * @param {PropertyPath} path - The path of the property to set. + * @param {any} value - The value to set. + * @returns {R} - The modified object. + * + * @example + * // Set a value in a nested object + * const obj = { a: { b: { c: 3 } } }; + * set(obj, 'a.b.c', 4); + * console.log(obj.a.b.c); // 4 + * + * @example + * // Set a value in an array + * const arr = [1, 2, 3]; + * set(arr, 1, 4); + * console.log(arr[1]); // 4 + * + * @example + * // Create non-existent path and set value + * const obj = {}; + * set(obj, 'a.b.c', 4); + * console.log(obj); // { a: { b: { c: 4 } } } + */ +declare function set(object: object, path: PropertyPath, value: any): R; + +export { set }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..91b04ebf172ed9ccf323f1ca82a494e3a4735f58 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.d.ts @@ -0,0 +1,60 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Sets the value at the specified path of the given object. If any part of the path does not exist, it will be created. + * + * @template T - The type of the object. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to set. + * @param {any} value - The value to set. + * @returns {T} - The modified object. + * + * @example + * // Set a value in a nested object + * const obj = { a: { b: { c: 3 } } }; + * set(obj, 'a.b.c', 4); + * console.log(obj.a.b.c); // 4 + * + * @example + * // Set a value in an array + * const arr = [1, 2, 3]; + * set(arr, 1, 4); + * console.log(arr[1]); // 4 + * + * @example + * // Create non-existent path and set value + * const obj = {}; + * set(obj, 'a.b.c', 4); + * console.log(obj); // { a: { b: { c: 4 } } } + */ +declare function set(object: T, path: PropertyPath, value: any): T; +/** + * Sets the value at the specified path of the given object. If any part of the path does not exist, it will be created. + * + * @template R - The return type. + * @param {object} object - The object to modify. + * @param {PropertyPath} path - The path of the property to set. + * @param {any} value - The value to set. + * @returns {R} - The modified object. + * + * @example + * // Set a value in a nested object + * const obj = { a: { b: { c: 3 } } }; + * set(obj, 'a.b.c', 4); + * console.log(obj.a.b.c); // 4 + * + * @example + * // Set a value in an array + * const arr = [1, 2, 3]; + * set(arr, 1, 4); + * console.log(arr[1]); // 4 + * + * @example + * // Create non-existent path and set value + * const obj = {}; + * set(obj, 'a.b.c', 4); + * console.log(obj); // { a: { b: { c: 4 } } } + */ +declare function set(object: object, path: PropertyPath, value: any): R; + +export { set }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.js new file mode 100644 index 0000000000000000000000000000000000000000..8f8659d76b784eb5457ac045f1afa5fc1416d0b7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const updateWith = require('./updateWith.js'); + +function set(obj, path, value) { + return updateWith.updateWith(obj, path, () => value, () => undefined); +} + +exports.set = set; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1f09cf1be18c9eb4f6974da420000a748aceb828 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/set.mjs @@ -0,0 +1,7 @@ +import { updateWith } from './updateWith.mjs'; + +function set(obj, path, value) { + return updateWith(obj, path, () => value, () => undefined); +} + +export { set }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ba9c2caab701d350e65807643295e1d74976748c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.d.mts @@ -0,0 +1,51 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Sets the value at the specified path of the given object using a customizer function. + * If any part of the path does not exist, it will be created based on the customizer's result. + * + * The customizer is invoked to produce the objects of the path. If the customizer returns + * a value, that value is used for the current path segment. If the customizer returns + * `undefined`, the method will create an appropriate object based on the path - an array + * if the next path segment is a valid array index, or an object otherwise. + * + * @template T - The type of the object. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to set. + * @param {any} value - The value to set. + * @param {(nsValue: any, key: string, nsObject: T) => any} [customizer] - The function to customize assigned values. + * @returns {T} - The modified object. + * + * @example + * // Set a value with a customizer that creates arrays for numeric path segments + * const object = {}; + * setWith(object, '[0][1]', 'a', (value) => Array.isArray(value) ? value : []); + * // => { '0': ['a'] } + */ +declare function setWith(object: T, path: PropertyPath, value: any, customizer?: (nsValue: any, key: string, nsObject: T) => any): T; +/** + * Sets the value at the specified path of the given object using a customizer function. + * If any part of the path does not exist, it will be created based on the customizer's result. + * + * The customizer is invoked to produce the objects of the path. If the customizer returns + * a value, that value is used for the current path segment. If the customizer returns + * `undefined`, the method will create an appropriate object based on the path - an array + * if the next path segment is a valid array index, or an object otherwise. + * + * @template T - The type of the object. + * @template R - The type of the return value. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to set. + * @param {any} value - The value to set. + * @param {(nsValue: any, key: string, nsObject: T) => any} [customizer] - The function to customize assigned values. + * @returns {R} - The modified object. + * + * @example + * // Set a value with a customizer that creates arrays for numeric path segments + * const object = {}; + * setWith(object, '[0][1]', 'a', (value) => Array.isArray(value) ? value : []); + * // => { '0': ['a'] } + */ +declare function setWith(object: T, path: PropertyPath, value: any, customizer?: (nsValue: any, key: string, nsObject: T) => any): R; + +export { setWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..eb0428ac04406cae137798fdff23631373301914 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.d.ts @@ -0,0 +1,51 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Sets the value at the specified path of the given object using a customizer function. + * If any part of the path does not exist, it will be created based on the customizer's result. + * + * The customizer is invoked to produce the objects of the path. If the customizer returns + * a value, that value is used for the current path segment. If the customizer returns + * `undefined`, the method will create an appropriate object based on the path - an array + * if the next path segment is a valid array index, or an object otherwise. + * + * @template T - The type of the object. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to set. + * @param {any} value - The value to set. + * @param {(nsValue: any, key: string, nsObject: T) => any} [customizer] - The function to customize assigned values. + * @returns {T} - The modified object. + * + * @example + * // Set a value with a customizer that creates arrays for numeric path segments + * const object = {}; + * setWith(object, '[0][1]', 'a', (value) => Array.isArray(value) ? value : []); + * // => { '0': ['a'] } + */ +declare function setWith(object: T, path: PropertyPath, value: any, customizer?: (nsValue: any, key: string, nsObject: T) => any): T; +/** + * Sets the value at the specified path of the given object using a customizer function. + * If any part of the path does not exist, it will be created based on the customizer's result. + * + * The customizer is invoked to produce the objects of the path. If the customizer returns + * a value, that value is used for the current path segment. If the customizer returns + * `undefined`, the method will create an appropriate object based on the path - an array + * if the next path segment is a valid array index, or an object otherwise. + * + * @template T - The type of the object. + * @template R - The type of the return value. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to set. + * @param {any} value - The value to set. + * @param {(nsValue: any, key: string, nsObject: T) => any} [customizer] - The function to customize assigned values. + * @returns {R} - The modified object. + * + * @example + * // Set a value with a customizer that creates arrays for numeric path segments + * const object = {}; + * setWith(object, '[0][1]', 'a', (value) => Array.isArray(value) ? value : []); + * // => { '0': ['a'] } + */ +declare function setWith(object: T, path: PropertyPath, value: any, customizer?: (nsValue: any, key: string, nsObject: T) => any): R; + +export { setWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.js new file mode 100644 index 0000000000000000000000000000000000000000..aa93cc44ae572818c96d9cd6bd61394f684efb9f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const updateWith = require('./updateWith.js'); + +function setWith(obj, path, value, customizer) { + let customizerFn; + if (typeof customizer === 'function') { + customizerFn = customizer; + } + else { + customizerFn = () => undefined; + } + return updateWith.updateWith(obj, path, () => value, customizerFn); +} + +exports.setWith = setWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..06cffb8d10ea7acf6c225a06d76c43ea0a7bc3fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/setWith.mjs @@ -0,0 +1,14 @@ +import { updateWith } from './updateWith.mjs'; + +function setWith(obj, path, value, customizer) { + let customizerFn; + if (typeof customizer === 'function') { + customizerFn = customizer; + } + else { + customizerFn = () => undefined; + } + return updateWith(obj, path, () => value, customizerFn); +} + +export { setWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..911e16eaaf66c887a30cb2f8403ed9fa4e151796 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.d.mts @@ -0,0 +1,122 @@ +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @param {T} object - The target object. + * @returns {T} The cloned object. + */ +declare function toDefaulted(object: T): T; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S - The type of the object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S} source - The object that specifies the default values to apply. + * @returns {NonNullable} A new object that combines the target and default values, ensuring no properties are left undefined. + */ +declare function toDefaulted(object: T, source: S): NonNullable; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @returns {NonNullable} A new object that combines the target and default values, ensuring no properties are left undefined. + */ +declare function toDefaulted(object: T, source1: S1, source2: S2): NonNullable; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @template S3 - The type of the third object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @param {S3} source3 - The third object that specifies the default values to apply. + * @returns {NonNullable} A new object that combines the target and default values, ensuring no properties are left undefined. + */ +declare function toDefaulted(object: T, source1: S1, source2: S2, source3: S3): NonNullable; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @template S3 - The type of the third object that provides default values. + * @template S4 - The type of the fourth object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @param {S3} source3 - The third object that specifies the default values to apply. + * @param {S4} source4 - The fourth object that specifies the default values to apply. + * @returns {NonNullable} A new object that combines the target and default values, ensuring no properties are left undefined. + */ +declare function toDefaulted(object: T, source1: S1, source2: S2, source3: S3, source4: S4): NonNullable; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S - The type of the objects that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S[]} sources - The objects that specifies the default values to apply. + * @returns {object} A new object that combines the target and default values, ensuring no properties are left undefined. + * + * @example + * toDefaulted({ a: 1 }, { a: 2, b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 } + * toDefaulted({ a: 1, b: 2 }, { b: 3 }, { c: 3 }); // { a: 1, b: 2, c: 3 } + * toDefaulted({ a: null }, { a: 1 }); // { a: null } + * toDefaulted({ a: undefined }, { a: 1 }); // { a: 1 } + */ +declare function toDefaulted(object: T, ...sources: S[]): object; + +export { toDefaulted }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..911e16eaaf66c887a30cb2f8403ed9fa4e151796 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.d.ts @@ -0,0 +1,122 @@ +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @param {T} object - The target object. + * @returns {T} The cloned object. + */ +declare function toDefaulted(object: T): T; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S - The type of the object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S} source - The object that specifies the default values to apply. + * @returns {NonNullable} A new object that combines the target and default values, ensuring no properties are left undefined. + */ +declare function toDefaulted(object: T, source: S): NonNullable; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @returns {NonNullable} A new object that combines the target and default values, ensuring no properties are left undefined. + */ +declare function toDefaulted(object: T, source1: S1, source2: S2): NonNullable; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @template S3 - The type of the third object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @param {S3} source3 - The third object that specifies the default values to apply. + * @returns {NonNullable} A new object that combines the target and default values, ensuring no properties are left undefined. + */ +declare function toDefaulted(object: T, source1: S1, source2: S2, source3: S3): NonNullable; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S1 - The type of the first object that provides default values. + * @template S2 - The type of the second object that provides default values. + * @template S3 - The type of the third object that provides default values. + * @template S4 - The type of the fourth object that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S1} source1 - The first object that specifies the default values to apply. + * @param {S2} source2 - The second object that specifies the default values to apply. + * @param {S3} source3 - The third object that specifies the default values to apply. + * @param {S4} source4 - The fourth object that specifies the default values to apply. + * @returns {NonNullable} A new object that combines the target and default values, ensuring no properties are left undefined. + */ +declare function toDefaulted(object: T, source1: S1, source2: S2, source3: S3, source4: S4): NonNullable; +/** + * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`. + * It assigns default values to properties that are either `undefined` or come from `Object.prototype`. + * + * You can provide multiple source objects to set these default values, + * and they will be applied in the order they are given, from left to right. + * Once a property has been set, any later values for that property will be ignored. + * + * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead. + * + * @template T - The type of the object being processed. + * @template S - The type of the objects that provides default values. + * @param {T} object - The target object that will receive default values. + * @param {S[]} sources - The objects that specifies the default values to apply. + * @returns {object} A new object that combines the target and default values, ensuring no properties are left undefined. + * + * @example + * toDefaulted({ a: 1 }, { a: 2, b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 } + * toDefaulted({ a: 1, b: 2 }, { b: 3 }, { c: 3 }); // { a: 1, b: 2, c: 3 } + * toDefaulted({ a: null }, { a: 1 }); // { a: null } + * toDefaulted({ a: undefined }, { a: 1 }); // { a: 1 } + */ +declare function toDefaulted(object: T, ...sources: S[]): object; + +export { toDefaulted }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.js new file mode 100644 index 0000000000000000000000000000000000000000..8fc7bdb6ad5b04bdf7554aaaac00cbf520480c26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const cloneDeep = require('./cloneDeep.js'); +const defaults = require('./defaults.js'); + +function toDefaulted(object, ...sources) { + const cloned = cloneDeep.cloneDeep(object); + return defaults.defaults(cloned, ...sources); +} + +exports.toDefaulted = toDefaulted; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e00cb9816224e0556b7d3b61d155889c92f9ca5d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toDefaulted.mjs @@ -0,0 +1,9 @@ +import { cloneDeep } from './cloneDeep.mjs'; +import { defaults } from './defaults.mjs'; + +function toDefaulted(object, ...sources) { + const cloned = cloneDeep(object); + return defaults(cloned, ...sources); +} + +export { toDefaulted }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cc4bde2963e81490c50f53852c9fec18bd76c32d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.d.mts @@ -0,0 +1,25 @@ +/** + * Creates an array of key-value pairs from an object. + * + * @template T + * @param {Record | Record} object - The object to query. + * @returns {Array<[string, T]>} Returns the array of key-value pairs. + * + * @example + * const object = { a: 1, b: 2 }; + * toPairs(object); // [['a', 1], ['b', 2]] + */ +declare function toPairs(object?: Record | Record): Array<[string, T]>; +/** + * Creates an array of key-value pairs from an object. + * + * @param {object} object - The object to query. + * @returns {Array<[string, any]>} Returns the array of key-value pairs. + * + * @example + * const object = { a: 1, b: 2 }; + * toPairs(object); // [['a', 1], ['b', 2]] + */ +declare function toPairs(object?: object): Array<[string, any]>; + +export { toPairs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cc4bde2963e81490c50f53852c9fec18bd76c32d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.d.ts @@ -0,0 +1,25 @@ +/** + * Creates an array of key-value pairs from an object. + * + * @template T + * @param {Record | Record} object - The object to query. + * @returns {Array<[string, T]>} Returns the array of key-value pairs. + * + * @example + * const object = { a: 1, b: 2 }; + * toPairs(object); // [['a', 1], ['b', 2]] + */ +declare function toPairs(object?: Record | Record): Array<[string, T]>; +/** + * Creates an array of key-value pairs from an object. + * + * @param {object} object - The object to query. + * @returns {Array<[string, any]>} Returns the array of key-value pairs. + * + * @example + * const object = { a: 1, b: 2 }; + * toPairs(object); // [['a', 1], ['b', 2]] + */ +declare function toPairs(object?: object): Array<[string, any]>; + +export { toPairs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.js new file mode 100644 index 0000000000000000000000000000000000000000..92459e411897e5120b340e1da52fc46b28188b5a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.js @@ -0,0 +1,29 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keys = require('./keys.js'); +const mapToEntries = require('../_internal/mapToEntries.js'); +const setToEntries = require('../_internal/setToEntries.js'); + +function toPairs(object) { + if (object == null) { + return []; + } + if (object instanceof Set) { + return setToEntries.setToEntries(object); + } + if (object instanceof Map) { + return mapToEntries.mapToEntries(object); + } + const keys$1 = keys.keys(object); + const result = new Array(keys$1.length); + for (let i = 0; i < keys$1.length; i++) { + const key = keys$1[i]; + const value = object[key]; + result[i] = [key, value]; + } + return result; +} + +exports.toPairs = toPairs; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f4eeab465d8825aac103f4f01c3687f932ea4e16 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairs.mjs @@ -0,0 +1,25 @@ +import { keys } from './keys.mjs'; +import { mapToEntries } from '../_internal/mapToEntries.mjs'; +import { setToEntries } from '../_internal/setToEntries.mjs'; + +function toPairs(object) { + if (object == null) { + return []; + } + if (object instanceof Set) { + return setToEntries(object); + } + if (object instanceof Map) { + return mapToEntries(object); + } + const keys$1 = keys(object); + const result = new Array(keys$1.length); + for (let i = 0; i < keys$1.length; i++) { + const key = keys$1[i]; + const value = object[key]; + result[i] = [key, value]; + } + return result; +} + +export { toPairs }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b7f426353352136ca86918df8a6b68750439188b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.d.mts @@ -0,0 +1,25 @@ +/** + * Creates an array of key-value pairs from an object, including inherited properties. + * + * @template T + * @param {Record | Record} object - The object to query. + * @returns {Array<[string, T]>} Returns the array of key-value pairs. + * + * @example + * const object = { a: 1, b: 2 }; + * toPairsIn(object); // [['a', 1], ['b', 2]] + */ +declare function toPairsIn(object?: Record | Record): Array<[string, T]>; +/** + * Creates an array of key-value pairs from an object, including inherited properties. + * + * @param {object} object - The object to query. + * @returns {Array<[string, any]>} Returns the array of key-value pairs. + * + * @example + * const object = { a: 1, b: 2 }; + * toPairsIn(object); // [['a', 1], ['b', 2]] + */ +declare function toPairsIn(object?: object): Array<[string, any]>; + +export { toPairsIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b7f426353352136ca86918df8a6b68750439188b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.d.ts @@ -0,0 +1,25 @@ +/** + * Creates an array of key-value pairs from an object, including inherited properties. + * + * @template T + * @param {Record | Record} object - The object to query. + * @returns {Array<[string, T]>} Returns the array of key-value pairs. + * + * @example + * const object = { a: 1, b: 2 }; + * toPairsIn(object); // [['a', 1], ['b', 2]] + */ +declare function toPairsIn(object?: Record | Record): Array<[string, T]>; +/** + * Creates an array of key-value pairs from an object, including inherited properties. + * + * @param {object} object - The object to query. + * @returns {Array<[string, any]>} Returns the array of key-value pairs. + * + * @example + * const object = { a: 1, b: 2 }; + * toPairsIn(object); // [['a', 1], ['b', 2]] + */ +declare function toPairsIn(object?: object): Array<[string, any]>; + +export { toPairsIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.js new file mode 100644 index 0000000000000000000000000000000000000000..fb671114af87ff01af56c36b99f34f41dcf26d00 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.js @@ -0,0 +1,29 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keysIn = require('./keysIn.js'); +const mapToEntries = require('../_internal/mapToEntries.js'); +const setToEntries = require('../_internal/setToEntries.js'); + +function toPairsIn(object) { + if (object == null) { + return []; + } + if (object instanceof Set) { + return setToEntries.setToEntries(object); + } + if (object instanceof Map) { + return mapToEntries.mapToEntries(object); + } + const keys = keysIn.keysIn(object); + const result = new Array(keys.length); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + result[i] = [key, value]; + } + return result; +} + +exports.toPairsIn = toPairsIn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ab0ab24ee8fab0765c6ec935605abf2524b50023 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/toPairsIn.mjs @@ -0,0 +1,25 @@ +import { keysIn } from './keysIn.mjs'; +import { mapToEntries } from '../_internal/mapToEntries.mjs'; +import { setToEntries } from '../_internal/setToEntries.mjs'; + +function toPairsIn(object) { + if (object == null) { + return []; + } + if (object instanceof Set) { + return setToEntries(object); + } + if (object instanceof Map) { + return mapToEntries(object); + } + const keys = keysIn(object); + const result = new Array(keys.length); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + result[i] = [key, value]; + } + return result; +} + +export { toPairsIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6ceefa3ece88e584bd1a7b9f0583e576c8b64d3a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.d.mts @@ -0,0 +1,74 @@ +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @template T - The type of object. + * @template R - The type of accumulator. + * @param {readonly T[]} object - The array to iterate over. + * @param {(acc: R, curr: T, index: number, arr: T[]) => void} iteratee - The function invoked per iteration. + * @param {R} [accumulator] - The initial value. + * @returns {R} Returns the accumulated value. + * + * @example + * const array = [2, 3, 4]; + * transform(array, (acc, value) => { acc.push(value * 2); }, []); + * // => [4, 6, 8] + */ +declare function transform(object: readonly T[], iteratee: (acc: R, curr: T, index: number, arr: T[]) => void, accumulator?: R): R; +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @template T - The type of object. + * @template R - The type of accumulator. + * @param {Record} object - The object to iterate over. + * @param {(acc: R, curr: T, key: string, dict: Record) => void} iteratee - The function invoked per iteration. + * @param {R} [accumulator] - The initial value. + * @returns {R} Returns the accumulated value. + * + * @example + * const obj = { 'a': 1, 'b': 2, 'c': 1 }; + * transform(obj, (result, value, key) => { (result[value] || (result[value] = [])).push(key) }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } + */ +declare function transform(object: Record, iteratee: (acc: R, curr: T, key: string, dict: Record) => void, accumulator?: R): R; +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @template T - The type of object. + * @template R - The type of accumulator. + * @param {T} object - The object to iterate over. + * @param {(acc: R, curr: T[keyof T], key: keyof T, dict: Record) => void} iteratee - The function invoked per iteration. + * @param {R} [accumulator] - The initial value. + * @returns {R} Returns the accumulated value. + * + * @example + * const obj = { x: 1, y: 2, z: 3 }; + * transform(obj, (acc, value, key) => { acc[key] = value * 2; }, {}); + * // => { x: 2, y: 4, z: 6 } + */ +declare function transform(object: T, iteratee: (acc: R, curr: T[keyof T], key: keyof T, dict: Record) => void, accumulator?: R): R; +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @param {any[]} object - The array to iterate over. + * @returns {any[]} Returns the accumulated value. + * + * @example + * const array = [1, 2, 3]; + * transform(array); + * // => [1, 2, 3] + */ +declare function transform(object: any[]): any[]; +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @param {object} object - The object to iterate over. + * @returns {Record} Returns the accumulated value. + * + * @example + * const obj = { a: 1, b: 2 }; + * transform(obj); + * // => { a: 1, b: 2 } + */ +declare function transform(object: object): Record; + +export { transform }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6ceefa3ece88e584bd1a7b9f0583e576c8b64d3a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.d.ts @@ -0,0 +1,74 @@ +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @template T - The type of object. + * @template R - The type of accumulator. + * @param {readonly T[]} object - The array to iterate over. + * @param {(acc: R, curr: T, index: number, arr: T[]) => void} iteratee - The function invoked per iteration. + * @param {R} [accumulator] - The initial value. + * @returns {R} Returns the accumulated value. + * + * @example + * const array = [2, 3, 4]; + * transform(array, (acc, value) => { acc.push(value * 2); }, []); + * // => [4, 6, 8] + */ +declare function transform(object: readonly T[], iteratee: (acc: R, curr: T, index: number, arr: T[]) => void, accumulator?: R): R; +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @template T - The type of object. + * @template R - The type of accumulator. + * @param {Record} object - The object to iterate over. + * @param {(acc: R, curr: T, key: string, dict: Record) => void} iteratee - The function invoked per iteration. + * @param {R} [accumulator] - The initial value. + * @returns {R} Returns the accumulated value. + * + * @example + * const obj = { 'a': 1, 'b': 2, 'c': 1 }; + * transform(obj, (result, value, key) => { (result[value] || (result[value] = [])).push(key) }, {}); + * // => { '1': ['a', 'c'], '2': ['b'] } + */ +declare function transform(object: Record, iteratee: (acc: R, curr: T, key: string, dict: Record) => void, accumulator?: R): R; +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @template T - The type of object. + * @template R - The type of accumulator. + * @param {T} object - The object to iterate over. + * @param {(acc: R, curr: T[keyof T], key: keyof T, dict: Record) => void} iteratee - The function invoked per iteration. + * @param {R} [accumulator] - The initial value. + * @returns {R} Returns the accumulated value. + * + * @example + * const obj = { x: 1, y: 2, z: 3 }; + * transform(obj, (acc, value, key) => { acc[key] = value * 2; }, {}); + * // => { x: 2, y: 4, z: 6 } + */ +declare function transform(object: T, iteratee: (acc: R, curr: T[keyof T], key: keyof T, dict: Record) => void, accumulator?: R): R; +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @param {any[]} object - The array to iterate over. + * @returns {any[]} Returns the accumulated value. + * + * @example + * const array = [1, 2, 3]; + * transform(array); + * // => [1, 2, 3] + */ +declare function transform(object: any[]): any[]; +/** + * Traverses object values and creates a new object by accumulating them in the desired form. + * + * @param {object} object - The object to iterate over. + * @returns {Record} Returns the accumulated value. + * + * @example + * const obj = { a: 1, b: 2 }; + * transform(obj); + * // => { a: 1, b: 2 } + */ +declare function transform(object: object): Record; + +export { transform }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.js new file mode 100644 index 0000000000000000000000000000000000000000..5abd0331c043d848d46e207b82e16a08db244d9a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const isFunction = require('../../predicate/isFunction.js'); +const forEach = require('../array/forEach.js'); +const isBuffer = require('../predicate/isBuffer.js'); +const isObject = require('../predicate/isObject.js'); +const isTypedArray = require('../predicate/isTypedArray.js'); +const iteratee = require('../util/iteratee.js'); + +function transform(object, iteratee$1 = identity.identity, accumulator) { + const isArrayOrBufferOrTypedArray = Array.isArray(object) || isBuffer.isBuffer(object) || isTypedArray.isTypedArray(object); + iteratee$1 = iteratee.iteratee(iteratee$1); + if (accumulator == null) { + if (isArrayOrBufferOrTypedArray) { + accumulator = []; + } + else if (isObject.isObject(object) && isFunction.isFunction(object.constructor)) { + accumulator = Object.create(Object.getPrototypeOf(object)); + } + else { + accumulator = {}; + } + } + if (object == null) { + return accumulator; + } + forEach.forEach(object, (value, key, object) => iteratee$1(accumulator, value, key, object)); + return accumulator; +} + +exports.transform = transform; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6bf2172a5f7549683458ab1e08c390e5d3bda8d8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/transform.mjs @@ -0,0 +1,30 @@ +import { identity } from '../../function/identity.mjs'; +import { isFunction } from '../../predicate/isFunction.mjs'; +import { forEach } from '../array/forEach.mjs'; +import { isBuffer } from '../predicate/isBuffer.mjs'; +import { isObject } from '../predicate/isObject.mjs'; +import { isTypedArray } from '../predicate/isTypedArray.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function transform(object, iteratee$1 = identity, accumulator) { + const isArrayOrBufferOrTypedArray = Array.isArray(object) || isBuffer(object) || isTypedArray(object); + iteratee$1 = iteratee(iteratee$1); + if (accumulator == null) { + if (isArrayOrBufferOrTypedArray) { + accumulator = []; + } + else if (isObject(object) && isFunction(object.constructor)) { + accumulator = Object.create(Object.getPrototypeOf(object)); + } + else { + accumulator = {}; + } + } + if (object == null) { + return accumulator; + } + forEach(object, (value, key, object) => iteratee$1(accumulator, value, key, object)); + return accumulator; +} + +export { transform }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b0fc5827bb085a342603580acb6838b91abe0ad6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.d.mts @@ -0,0 +1,20 @@ +/** + * Removes the property at the given path of the object. + * + * @param {unknown} obj - The object to modify. + * @param {PropertyKey | readonly PropertyKey[]} path - The path of the property to unset. + * @returns {boolean} - Returns true if the property is deleted, else false. + * + * @example + * const obj = { a: { b: { c: 42 } } }; + * unset(obj, 'a.b.c'); // true + * console.log(obj); // { a: { b: {} } } + * + * @example + * const obj = { a: { b: { c: 42 } } }; + * unset(obj, ['a', 'b', 'c']); // true + * console.log(obj); // { a: { b: {} } } + */ +declare function unset(obj: any, path: PropertyKey | readonly PropertyKey[]): boolean; + +export { unset }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b0fc5827bb085a342603580acb6838b91abe0ad6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.d.ts @@ -0,0 +1,20 @@ +/** + * Removes the property at the given path of the object. + * + * @param {unknown} obj - The object to modify. + * @param {PropertyKey | readonly PropertyKey[]} path - The path of the property to unset. + * @returns {boolean} - Returns true if the property is deleted, else false. + * + * @example + * const obj = { a: { b: { c: 42 } } }; + * unset(obj, 'a.b.c'); // true + * console.log(obj); // { a: { b: {} } } + * + * @example + * const obj = { a: { b: { c: 42 } } }; + * unset(obj, ['a', 'b', 'c']); // true + * console.log(obj); // { a: { b: {} } } + */ +declare function unset(obj: any, path: PropertyKey | readonly PropertyKey[]): boolean; + +export { unset }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.js new file mode 100644 index 0000000000000000000000000000000000000000..e357f6123a7e3ff601f49f9051346511fb09eb4b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.js @@ -0,0 +1,82 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const get = require('./get.js'); +const isUnsafeProperty = require('../../_internal/isUnsafeProperty.js'); +const isDeepKey = require('../_internal/isDeepKey.js'); +const toKey = require('../_internal/toKey.js'); +const toPath = require('../util/toPath.js'); + +function unset(obj, path) { + if (obj == null) { + return true; + } + switch (typeof path) { + case 'symbol': + case 'number': + case 'object': { + if (Array.isArray(path)) { + return unsetWithPath(obj, path); + } + if (typeof path === 'number') { + path = toKey.toKey(path); + } + else if (typeof path === 'object') { + if (Object.is(path?.valueOf(), -0)) { + path = '-0'; + } + else { + path = String(path); + } + } + if (isUnsafeProperty.isUnsafeProperty(path)) { + return false; + } + if (obj?.[path] === undefined) { + return true; + } + try { + delete obj[path]; + return true; + } + catch { + return false; + } + } + case 'string': { + if (obj?.[path] === undefined && isDeepKey.isDeepKey(path)) { + return unsetWithPath(obj, toPath.toPath(path)); + } + if (isUnsafeProperty.isUnsafeProperty(path)) { + return false; + } + try { + delete obj[path]; + return true; + } + catch { + return false; + } + } + } +} +function unsetWithPath(obj, path) { + const parent = get.get(obj, path.slice(0, -1), obj); + const lastKey = path[path.length - 1]; + if (parent?.[lastKey] === undefined) { + return true; + } + if (isUnsafeProperty.isUnsafeProperty(lastKey)) { + return false; + } + try { + delete parent[lastKey]; + return true; + } + catch { + return false; + } +} + +exports.unset = unset; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.mjs new file mode 100644 index 0000000000000000000000000000000000000000..002f32e0827ad94bd51adf854d832b3543132b80 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/unset.mjs @@ -0,0 +1,78 @@ +import { get } from './get.mjs'; +import { isUnsafeProperty } from '../../_internal/isUnsafeProperty.mjs'; +import { isDeepKey } from '../_internal/isDeepKey.mjs'; +import { toKey } from '../_internal/toKey.mjs'; +import { toPath } from '../util/toPath.mjs'; + +function unset(obj, path) { + if (obj == null) { + return true; + } + switch (typeof path) { + case 'symbol': + case 'number': + case 'object': { + if (Array.isArray(path)) { + return unsetWithPath(obj, path); + } + if (typeof path === 'number') { + path = toKey(path); + } + else if (typeof path === 'object') { + if (Object.is(path?.valueOf(), -0)) { + path = '-0'; + } + else { + path = String(path); + } + } + if (isUnsafeProperty(path)) { + return false; + } + if (obj?.[path] === undefined) { + return true; + } + try { + delete obj[path]; + return true; + } + catch { + return false; + } + } + case 'string': { + if (obj?.[path] === undefined && isDeepKey(path)) { + return unsetWithPath(obj, toPath(path)); + } + if (isUnsafeProperty(path)) { + return false; + } + try { + delete obj[path]; + return true; + } + catch { + return false; + } + } + } +} +function unsetWithPath(obj, path) { + const parent = get(obj, path.slice(0, -1), obj); + const lastKey = path[path.length - 1]; + if (parent?.[lastKey] === undefined) { + return true; + } + if (isUnsafeProperty(lastKey)) { + return false; + } + try { + delete parent[lastKey]; + return true; + } + catch { + return false; + } +} + +export { unset }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..085557f650c6ef327ddd6402b819cfe95cca7cde --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.d.mts @@ -0,0 +1,14 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Updates the value at the specified path of the given object using an updater function. + * If any part of the path does not exist, it will be created. + * + * @param {object} obj - The object to modify. + * @param {PropertyPath} path - The path of the property to update. + * @param {(value: any) => any} updater - The function to produce the updated value. + * @returns {any} - The modified object. + */ +declare function update(obj: object, path: PropertyPath, updater: (value: any) => any): any; + +export { update }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0204a685c54d2334e6d4b7f7b070a43d5bff366c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.d.ts @@ -0,0 +1,14 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Updates the value at the specified path of the given object using an updater function. + * If any part of the path does not exist, it will be created. + * + * @param {object} obj - The object to modify. + * @param {PropertyPath} path - The path of the property to update. + * @param {(value: any) => any} updater - The function to produce the updated value. + * @returns {any} - The modified object. + */ +declare function update(obj: object, path: PropertyPath, updater: (value: any) => any): any; + +export { update }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.js new file mode 100644 index 0000000000000000000000000000000000000000..1534d62da9174a740044e0fa7ed4db3da7a2296c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const updateWith = require('./updateWith.js'); + +function update(obj, path, updater) { + return updateWith.updateWith(obj, path, updater, () => undefined); +} + +exports.update = update; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0bce4ad5111b5f2229c3f68c26523026fdd3c7a9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/update.mjs @@ -0,0 +1,7 @@ +import { updateWith } from './updateWith.mjs'; + +function update(obj, path, updater) { + return updateWith(obj, path, updater, () => undefined); +} + +export { update }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bccdd9da7d2e6a437eb6055217c367d0f9c11c18 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.d.mts @@ -0,0 +1,39 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Updates the value at the specified path of the given object using an updater function and a customizer. + * If any part of the path does not exist, it will be created. + * + * @template T - The type of the object. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to update. + * @param {(oldValue: any) => any} updater - The function to produce the updated value. + * @param {(value: any, key: string, object: T) => any} customizer - The function to customize the update process. + * @returns {T} - The modified object. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * updateWith(object, 'a[0].b.c', (n) => n * n); + * // => { 'a': [{ 'b': { 'c': 9 } }] } + */ +declare function updateWith(object: T, path: PropertyPath, updater: (oldValue: any) => any, customizer?: (value: any, key: string, object: T) => any): T; +/** + * Updates the value at the specified path of the given object using an updater function and a customizer. + * If any part of the path does not exist, it will be created. + * + * @template T - The type of the object. + * @template R - The type of the return value. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to update. + * @param {(oldValue: any) => any} updater - The function to produce the updated value. + * @param {(value: any, key: string, object: T) => any} customizer - The function to customize the update process. + * @returns {R} - The modified object. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * updateWith(object, 'a[0].b.c', (n) => n * n); + * // => { 'a': [{ 'b': { 'c': 9 } }] } + */ +declare function updateWith(object: T, path: PropertyPath, updater: (oldValue: any) => any, customizer?: (value: any, key: string, object: T) => any): R; + +export { updateWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4900f873008c83946673b4bc933fc22b54fe67f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.d.ts @@ -0,0 +1,39 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Updates the value at the specified path of the given object using an updater function and a customizer. + * If any part of the path does not exist, it will be created. + * + * @template T - The type of the object. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to update. + * @param {(oldValue: any) => any} updater - The function to produce the updated value. + * @param {(value: any, key: string, object: T) => any} customizer - The function to customize the update process. + * @returns {T} - The modified object. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * updateWith(object, 'a[0].b.c', (n) => n * n); + * // => { 'a': [{ 'b': { 'c': 9 } }] } + */ +declare function updateWith(object: T, path: PropertyPath, updater: (oldValue: any) => any, customizer?: (value: any, key: string, object: T) => any): T; +/** + * Updates the value at the specified path of the given object using an updater function and a customizer. + * If any part of the path does not exist, it will be created. + * + * @template T - The type of the object. + * @template R - The type of the return value. + * @param {T} object - The object to modify. + * @param {PropertyPath} path - The path of the property to update. + * @param {(oldValue: any) => any} updater - The function to produce the updated value. + * @param {(value: any, key: string, object: T) => any} customizer - The function to customize the update process. + * @returns {R} - The modified object. + * + * @example + * const object = { 'a': [{ 'b': { 'c': 3 } }] }; + * updateWith(object, 'a[0].b.c', (n) => n * n); + * // => { 'a': [{ 'b': { 'c': 9 } }] } + */ +declare function updateWith(object: T, path: PropertyPath, updater: (oldValue: any) => any, customizer?: (value: any, key: string, object: T) => any): R; + +export { updateWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.js new file mode 100644 index 0000000000000000000000000000000000000000..ba38a8cbf81d0467274c773273f66156f335f277 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.js @@ -0,0 +1,52 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isUnsafeProperty = require('../../_internal/isUnsafeProperty.js'); +const assignValue = require('../_internal/assignValue.js'); +const isIndex = require('../_internal/isIndex.js'); +const isKey = require('../_internal/isKey.js'); +const toKey = require('../_internal/toKey.js'); +const isObject = require('../predicate/isObject.js'); +const toPath = require('../util/toPath.js'); + +function updateWith(obj, path, updater, customizer) { + if (obj == null && !isObject.isObject(obj)) { + return obj; + } + const resolvedPath = isKey.isKey(path, obj) + ? [path] + : Array.isArray(path) + ? path + : typeof path === 'string' + ? toPath.toPath(path) + : [path]; + let current = obj; + for (let i = 0; i < resolvedPath.length && current != null; i++) { + const key = toKey.toKey(resolvedPath[i]); + if (isUnsafeProperty.isUnsafeProperty(key)) { + continue; + } + let newValue; + if (i === resolvedPath.length - 1) { + newValue = updater(current[key]); + } + else { + const objValue = current[key]; + const customizerResult = customizer?.(objValue, key, obj); + newValue = + customizerResult !== undefined + ? customizerResult + : isObject.isObject(objValue) + ? objValue + : isIndex.isIndex(resolvedPath[i + 1]) + ? [] + : {}; + } + assignValue.assignValue(current, key, newValue); + current = current[key]; + } + return obj; +} + +exports.updateWith = updateWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..440d89bbb5272e45cda22897b2fa1c0fedb3afd9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/updateWith.mjs @@ -0,0 +1,48 @@ +import { isUnsafeProperty } from '../../_internal/isUnsafeProperty.mjs'; +import { assignValue } from '../_internal/assignValue.mjs'; +import { isIndex } from '../_internal/isIndex.mjs'; +import { isKey } from '../_internal/isKey.mjs'; +import { toKey } from '../_internal/toKey.mjs'; +import { isObject } from '../predicate/isObject.mjs'; +import { toPath } from '../util/toPath.mjs'; + +function updateWith(obj, path, updater, customizer) { + if (obj == null && !isObject(obj)) { + return obj; + } + const resolvedPath = isKey(path, obj) + ? [path] + : Array.isArray(path) + ? path + : typeof path === 'string' + ? toPath(path) + : [path]; + let current = obj; + for (let i = 0; i < resolvedPath.length && current != null; i++) { + const key = toKey(resolvedPath[i]); + if (isUnsafeProperty(key)) { + continue; + } + let newValue; + if (i === resolvedPath.length - 1) { + newValue = updater(current[key]); + } + else { + const objValue = current[key]; + const customizerResult = customizer?.(objValue, key, obj); + newValue = + customizerResult !== undefined + ? customizerResult + : isObject(objValue) + ? objValue + : isIndex(resolvedPath[i + 1]) + ? [] + : {}; + } + assignValue(current, key, newValue); + current = current[key]; + } + return obj; +} + +export { updateWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..aaab0eacaed833ca582eb1080bc824356a63dde9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.d.mts @@ -0,0 +1,37 @@ +/** + * Creates an array of the own enumerable property values of `object`. + * + * @template T + * @param {Record | Record | ArrayLike | null | undefined} object - The object to query. + * @returns {T[]} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * values(obj); // => [1, 2, 3] + */ +declare function values(object: Record | Record | ArrayLike | null | undefined): T[]; +/** + * Creates an array of the own enumerable property values of `object`. + * + * @template T + * @param {T | null | undefined} object - The object to query. + * @returns {Array} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * values(obj); // => [1, 2, 3] + */ +declare function values(object: T | null | undefined): Array; +/** + * Creates an array of the own enumerable property values of `object`. + * + * @param {any} object - The object to query. + * @returns {any[]} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * values(obj); // => [1, 2, 3] + */ +declare function values(object: any): any[]; + +export { values }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..aaab0eacaed833ca582eb1080bc824356a63dde9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.d.ts @@ -0,0 +1,37 @@ +/** + * Creates an array of the own enumerable property values of `object`. + * + * @template T + * @param {Record | Record | ArrayLike | null | undefined} object - The object to query. + * @returns {T[]} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * values(obj); // => [1, 2, 3] + */ +declare function values(object: Record | Record | ArrayLike | null | undefined): T[]; +/** + * Creates an array of the own enumerable property values of `object`. + * + * @template T + * @param {T | null | undefined} object - The object to query. + * @returns {Array} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * values(obj); // => [1, 2, 3] + */ +declare function values(object: T | null | undefined): Array; +/** + * Creates an array of the own enumerable property values of `object`. + * + * @param {any} object - The object to query. + * @returns {any[]} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * values(obj); // => [1, 2, 3] + */ +declare function values(object: any): any[]; + +export { values }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.js new file mode 100644 index 0000000000000000000000000000000000000000..c804f9caa19fdc2cc781469f0071e0a1d5f914e8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function values(object) { + if (object == null) { + return []; + } + return Object.values(object); +} + +exports.values = values; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5aa6d8d47a0c0a7e76dd33fd223a305a97a8fd16 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/values.mjs @@ -0,0 +1,8 @@ +function values(object) { + if (object == null) { + return []; + } + return Object.values(object); +} + +export { values }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0f04d1cfc8ad79ff5d8eb0a21306d96e493c1044 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.d.mts @@ -0,0 +1,26 @@ +/** + * Retrieves the values from an object, including those inherited from its prototype. + * + * @template T + * @param {Record | Record | ArrayLike | null | undefined} object - The object to query. + * @returns {T[]} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * valuesIn(obj); // => [1, 2, 3] + */ +declare function valuesIn(object: Record | Record | ArrayLike | null | undefined): T[]; +/** + * Retrieves the values from an object, including those inherited from its prototype. + * + * @template T + * @param {T | null | undefined} object - The object to query. + * @returns {Array} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * valuesIn(obj); // => [1, 2, 3] + */ +declare function valuesIn(object: T | null | undefined): Array; + +export { valuesIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0f04d1cfc8ad79ff5d8eb0a21306d96e493c1044 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.d.ts @@ -0,0 +1,26 @@ +/** + * Retrieves the values from an object, including those inherited from its prototype. + * + * @template T + * @param {Record | Record | ArrayLike | null | undefined} object - The object to query. + * @returns {T[]} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * valuesIn(obj); // => [1, 2, 3] + */ +declare function valuesIn(object: Record | Record | ArrayLike | null | undefined): T[]; +/** + * Retrieves the values from an object, including those inherited from its prototype. + * + * @template T + * @param {T | null | undefined} object - The object to query. + * @returns {Array} Returns an array of property values. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * valuesIn(obj); // => [1, 2, 3] + */ +declare function valuesIn(object: T | null | undefined): Array; + +export { valuesIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.js new file mode 100644 index 0000000000000000000000000000000000000000..ead6c6391ae2bedbad6655a38a13fe931ee413b0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keysIn = require('./keysIn.js'); + +function valuesIn(object) { + const keys = keysIn.keysIn(object); + const result = new Array(keys.length); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + result[i] = object[key]; + } + return result; +} + +exports.valuesIn = valuesIn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d16e375958cd84c9cc95af8c3564131105d7e2f4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/object/valuesIn.mjs @@ -0,0 +1,13 @@ +import { keysIn } from './keysIn.mjs'; + +function valuesIn(object) { + const keys = keysIn(object); + const result = new Array(keys.length); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + result[i] = object[key]; + } + return result; +} + +export { valuesIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..006cbcd67862daffcdef57da19ab2a959784576f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.d.mts @@ -0,0 +1,24 @@ +import { ConformsPredicateObject } from '../_internal/ConformsPredicateObject.mjs'; + +/** + * Creates a function that invokes the predicate properties of `source` with the corresponding property values of a given object, returning `true` if all predicates return truthy, else `false`. + * + * Note: The created function is equivalent to `conformsTo` with source partially applied. + * + * @param {Record boolean>} source The object of property predicates to conform to. + * @returns {(object: Record) => boolean} Returns the new spec function. + * + * @example + * const isPositive = (n) => n > 0; + * const isEven = (n) => n % 2 === 0; + * const predicates = { a: isPositive, b: isEven }; + * const conform = conforms(predicates); + * + * console.log(conform({ a: 2, b: 4 })); // true + * console.log(conform({ a: -1, b: 4 })); // false + * console.log(conform({ a: 2, b: 3 })); // false + * console.log(conform({ a: 0, b: 2 })); // false + */ +declare function conforms(source: ConformsPredicateObject): (value: T) => boolean; + +export { conforms }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9fc648b24046a5556b69fcb552014ea78a257a21 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.d.ts @@ -0,0 +1,24 @@ +import { ConformsPredicateObject } from '../_internal/ConformsPredicateObject.js'; + +/** + * Creates a function that invokes the predicate properties of `source` with the corresponding property values of a given object, returning `true` if all predicates return truthy, else `false`. + * + * Note: The created function is equivalent to `conformsTo` with source partially applied. + * + * @param {Record boolean>} source The object of property predicates to conform to. + * @returns {(object: Record) => boolean} Returns the new spec function. + * + * @example + * const isPositive = (n) => n > 0; + * const isEven = (n) => n % 2 === 0; + * const predicates = { a: isPositive, b: isEven }; + * const conform = conforms(predicates); + * + * console.log(conform({ a: 2, b: 4 })); // true + * console.log(conform({ a: -1, b: 4 })); // false + * console.log(conform({ a: 2, b: 3 })); // false + * console.log(conform({ a: 0, b: 2 })); // false + */ +declare function conforms(source: ConformsPredicateObject): (value: T) => boolean; + +export { conforms }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.js new file mode 100644 index 0000000000000000000000000000000000000000..20b93289e9e9eead758902b1bc2c9413b30f7647 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const conformsTo = require('./conformsTo.js'); +const cloneDeep = require('../../object/cloneDeep.js'); + +function conforms(source) { + source = cloneDeep.cloneDeep(source); + return function (object) { + return conformsTo.conformsTo(object, source); + }; +} + +exports.conforms = conforms; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7d3bc83f623d06800153f175af347efea263be6e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conforms.mjs @@ -0,0 +1,11 @@ +import { conformsTo } from './conformsTo.mjs'; +import { cloneDeep } from '../../object/cloneDeep.mjs'; + +function conforms(source) { + source = cloneDeep(source); + return function (object) { + return conformsTo(object, source); + }; +} + +export { conforms }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..eefc244202106ccace2c1d91a834a84e0fea2dd9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.d.mts @@ -0,0 +1,32 @@ +import { ConformsPredicateObject } from '../_internal/ConformsPredicateObject.mjs'; + +/** + * Checks if `object` conforms to `source` by invoking the predicate properties of `source` with the corresponding property values of `object`. + * + * Note: This method is equivalent to `conforms` when source is partially applied. + * + * @template T - The type of the target object. + * @param {T} target The object to inspect. + * @param {ConformsPredicateObject} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + * + * @example + * + * const object = { 'a': 1, 'b': 2 }; + * const source = { + * 'a': (n) => n > 0, + * 'b': (n) => n > 1 + * }; + * + * console.log(conformsTo(object, source)); // => true + * + * const source2 = { + * 'a': (n) => n > 1, + * 'b': (n) => n > 1 + * }; + * + * console.log(conformsTo(object, source2)); // => false + */ +declare function conformsTo(target: T, source: ConformsPredicateObject): boolean; + +export { conformsTo }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ecc7871c067b94b1f40242f9f583fcb7f8518278 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.d.ts @@ -0,0 +1,32 @@ +import { ConformsPredicateObject } from '../_internal/ConformsPredicateObject.js'; + +/** + * Checks if `object` conforms to `source` by invoking the predicate properties of `source` with the corresponding property values of `object`. + * + * Note: This method is equivalent to `conforms` when source is partially applied. + * + * @template T - The type of the target object. + * @param {T} target The object to inspect. + * @param {ConformsPredicateObject} source The object of property predicates to conform to. + * @returns {boolean} Returns `true` if `object` conforms, else `false`. + * + * @example + * + * const object = { 'a': 1, 'b': 2 }; + * const source = { + * 'a': (n) => n > 0, + * 'b': (n) => n > 1 + * }; + * + * console.log(conformsTo(object, source)); // => true + * + * const source2 = { + * 'a': (n) => n > 1, + * 'b': (n) => n > 1 + * }; + * + * console.log(conformsTo(object, source2)); // => false + */ +declare function conformsTo(target: T, source: ConformsPredicateObject): boolean; + +export { conformsTo }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.js new file mode 100644 index 0000000000000000000000000000000000000000..45e385163b29100436882d669ccb41d9306601fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function conformsTo(target, source) { + if (source == null) { + return true; + } + if (target == null) { + return Object.keys(source).length === 0; + } + const keys = Object.keys(source); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const predicate = source[key]; + const value = target[key]; + if (value === undefined && !(key in target)) { + return false; + } + if (typeof predicate === 'function' && !predicate(value)) { + return false; + } + } + return true; +} + +exports.conformsTo = conformsTo; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.mjs new file mode 100644 index 0000000000000000000000000000000000000000..126f8c6131ef08bc501e8421a52cf2b0052f7236 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/conformsTo.mjs @@ -0,0 +1,23 @@ +function conformsTo(target, source) { + if (source == null) { + return true; + } + if (target == null) { + return Object.keys(source).length === 0; + } + const keys = Object.keys(source); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const predicate = source[key]; + const value = target[key]; + if (value === undefined && !(key in target)) { + return false; + } + if (typeof predicate === 'function' && !predicate(value)) { + return false; + } + } + return true; +} + +export { conformsTo }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7d3fd2a42644817ee331cd91878caf2a453ce29f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.d.mts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is an arguments object. + * + * This function tests whether the provided value is an arguments object or not. + * It returns `true` if the value is an arguments object, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an arguments object. + * + * @param {any} value - The value to test if it is an arguments object. + * @returns {value is IArguments} `true` if the value is an arguments, `false` otherwise. + * + * @example + * const args = (function() { return arguments; })(); + * const strictArgs = (function() { 'use strict'; return arguments; })(); + * const value = [1, 2, 3]; + * + * console.log(isArguments(args)); // true + * console.log(isArguments(strictArgs)); // true + * console.log(isArguments(value)); // false + */ +declare function isArguments(value?: any): value is IArguments; + +export { isArguments }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7d3fd2a42644817ee331cd91878caf2a453ce29f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.d.ts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is an arguments object. + * + * This function tests whether the provided value is an arguments object or not. + * It returns `true` if the value is an arguments object, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an arguments object. + * + * @param {any} value - The value to test if it is an arguments object. + * @returns {value is IArguments} `true` if the value is an arguments, `false` otherwise. + * + * @example + * const args = (function() { return arguments; })(); + * const strictArgs = (function() { 'use strict'; return arguments; })(); + * const value = [1, 2, 3]; + * + * console.log(isArguments(args)); // true + * console.log(isArguments(strictArgs)); // true + * console.log(isArguments(value)); // false + */ +declare function isArguments(value?: any): value is IArguments; + +export { isArguments }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.js new file mode 100644 index 0000000000000000000000000000000000000000..049cc82ef66fca5d356991ac05b79980ae95ac98 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const getTag = require('../_internal/getTag.js'); + +function isArguments(value) { + return value !== null && typeof value === 'object' && getTag.getTag(value) === '[object Arguments]'; +} + +exports.isArguments = isArguments; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.mjs new file mode 100644 index 0000000000000000000000000000000000000000..610289c0b6a59df0c54c15423811869a3526b2fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArguments.mjs @@ -0,0 +1,7 @@ +import { getTag } from '../_internal/getTag.mjs'; + +function isArguments(value) { + return value !== null && typeof value === 'object' && getTag(value) === '[object Arguments]'; +} + +export { isArguments }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..75274b24744522b0f2e85d89b2b4153e70a5219b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.d.mts @@ -0,0 +1,45 @@ +/** + * Checks if the given value is an array. + * + * This function tests whether the provided value is an array or not. + * It returns `true` if the value is an array, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an array. + * + * @param {any} value - The value to test if it is an array. + * @returns {value is any[]} `true` if the value is an array, `false` otherwise. + * + * @example + * const value1 = [1, 2, 3]; + * const value2 = 'abc'; + * const value3 = () => {}; + * + * console.log(isArray(value1)); // true + * console.log(isArray(value2)); // false + * console.log(isArray(value3)); // false + */ +declare function isArray(value?: any): value is any[]; +/** + * Checks if the given value is an array with generic type support. + * + * This function tests whether the provided value is an array or not. + * It returns `true` if the value is an array, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an array. + * + * @template T - The type of elements in the array. + * @param {any} value - The value to test if it is an array. + * @returns {value is any[]} `true` if the value is an array, `false` otherwise. + * + * @example + * const value1 = [1, 2, 3]; + * const value2 = 'abc'; + * const value3 = () => {}; + * + * console.log(isArray(value1)); // true + * console.log(isArray(value2)); // false + * console.log(isArray(value3)); // false + */ +declare function isArray(value?: any): value is any[]; + +export { isArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..75274b24744522b0f2e85d89b2b4153e70a5219b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.d.ts @@ -0,0 +1,45 @@ +/** + * Checks if the given value is an array. + * + * This function tests whether the provided value is an array or not. + * It returns `true` if the value is an array, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an array. + * + * @param {any} value - The value to test if it is an array. + * @returns {value is any[]} `true` if the value is an array, `false` otherwise. + * + * @example + * const value1 = [1, 2, 3]; + * const value2 = 'abc'; + * const value3 = () => {}; + * + * console.log(isArray(value1)); // true + * console.log(isArray(value2)); // false + * console.log(isArray(value3)); // false + */ +declare function isArray(value?: any): value is any[]; +/** + * Checks if the given value is an array with generic type support. + * + * This function tests whether the provided value is an array or not. + * It returns `true` if the value is an array, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an array. + * + * @template T - The type of elements in the array. + * @param {any} value - The value to test if it is an array. + * @returns {value is any[]} `true` if the value is an array, `false` otherwise. + * + * @example + * const value1 = [1, 2, 3]; + * const value2 = 'abc'; + * const value3 = () => {}; + * + * console.log(isArray(value1)); // true + * console.log(isArray(value2)); // false + * console.log(isArray(value3)); // false + */ +declare function isArray(value?: any): value is any[]; + +export { isArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.js new file mode 100644 index 0000000000000000000000000000000000000000..504f4b31efd29d2ed25d7a52417737418cc44efe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isArray(value) { + return Array.isArray(value); +} + +exports.isArray = isArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.mjs new file mode 100644 index 0000000000000000000000000000000000000000..67f08aa90984839c49947212db5d75e45f5fa179 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArray.mjs @@ -0,0 +1,5 @@ +function isArray(value) { + return Array.isArray(value); +} + +export { isArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..303239eb5e31b9600fc3cabca34c19822d0d2565 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is `ArrayBuffer`. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `ArrayBuffer`. + * + * @param {any} value The value to check if it is a `ArrayBuffer`. + * @returns {value is ArrayBuffer} Returns `true` if `value` is a `ArrayBuffer`, else `false`. + * + * @example + * const value1 = new ArrayBuffer(); + * const value2 = new Array(); + * const value3 = new Map(); + * + * console.log(isArrayBuffer(value1)); // true + * console.log(isArrayBuffer(value2)); // false + * console.log(isArrayBuffer(value3)); // false + */ +declare function isArrayBuffer(value?: any): value is ArrayBuffer; + +export { isArrayBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..303239eb5e31b9600fc3cabca34c19822d0d2565 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is `ArrayBuffer`. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `ArrayBuffer`. + * + * @param {any} value The value to check if it is a `ArrayBuffer`. + * @returns {value is ArrayBuffer} Returns `true` if `value` is a `ArrayBuffer`, else `false`. + * + * @example + * const value1 = new ArrayBuffer(); + * const value2 = new Array(); + * const value3 = new Map(); + * + * console.log(isArrayBuffer(value1)); // true + * console.log(isArrayBuffer(value2)); // false + * console.log(isArrayBuffer(value3)); // false + */ +declare function isArrayBuffer(value?: any): value is ArrayBuffer; + +export { isArrayBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..65c1da1ebff3fe33c19a826a7694656cb01e07e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayBuffer$1 = require('../../predicate/isArrayBuffer.js'); + +function isArrayBuffer(value) { + return isArrayBuffer$1.isArrayBuffer(value); +} + +exports.isArrayBuffer = isArrayBuffer; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.mjs new file mode 100644 index 0000000000000000000000000000000000000000..971c55da1004fdabe4979774a84f81576d9aa605 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayBuffer.mjs @@ -0,0 +1,7 @@ +import { isArrayBuffer as isArrayBuffer$1 } from '../../predicate/isArrayBuffer.mjs'; + +function isArrayBuffer(value) { + return isArrayBuffer$1(value); +} + +export { isArrayBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..316c3ec76cb8fce77715784a6d9f91e9e4bb2a62 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.d.mts @@ -0,0 +1,27 @@ +/** + * Checks if `value` is array-like. This overload is for compatibility with lodash type checking. + * + * @param {T} t The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + */ +declare function isArrayLike(t: T): boolean; +/** + * Checks if `value` is array-like. Functions, null, and undefined are never array-like. + * + * @param {((...args: any[]) => any) | null | undefined} value The value to check. + * @returns {value is never} Returns `false` for functions, null, and undefined. + */ +declare function isArrayLike(value: ((...args: any[]) => any) | null | undefined): value is never; +/** + * Checks if `value` is array-like. + * + * @param {any} value The value to check. + * @returns {value is { length: number }} Returns `true` if `value` is array-like, else `false`. + */ +declare function isArrayLike(value: any): value is { + length: number; +}; + +export { isArrayLike }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..316c3ec76cb8fce77715784a6d9f91e9e4bb2a62 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.d.ts @@ -0,0 +1,27 @@ +/** + * Checks if `value` is array-like. This overload is for compatibility with lodash type checking. + * + * @param {T} t The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + */ +declare function isArrayLike(t: T): boolean; +/** + * Checks if `value` is array-like. Functions, null, and undefined are never array-like. + * + * @param {((...args: any[]) => any) | null | undefined} value The value to check. + * @returns {value is never} Returns `false` for functions, null, and undefined. + */ +declare function isArrayLike(value: ((...args: any[]) => any) | null | undefined): value is never; +/** + * Checks if `value` is array-like. + * + * @param {any} value The value to check. + * @returns {value is { length: number }} Returns `true` if `value` is array-like, else `false`. + */ +declare function isArrayLike(value: any): value is { + length: number; +}; + +export { isArrayLike }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.js new file mode 100644 index 0000000000000000000000000000000000000000..9ee3e9132569fb6bc586874bcc5f3e8b922b6aff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isLength = require('../../predicate/isLength.js'); + +function isArrayLike(value) { + return value != null && typeof value !== 'function' && isLength.isLength(value.length); +} + +exports.isArrayLike = isArrayLike; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.mjs new file mode 100644 index 0000000000000000000000000000000000000000..174da6d437e1cc5101aabb6dbc3d9b03c48e3d20 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.mjs @@ -0,0 +1,7 @@ +import { isLength } from '../../predicate/isLength.mjs'; + +function isArrayLike(value) { + return value != null && typeof value !== 'function' && isLength(value.length); +} + +export { isArrayLike }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fa2751efc4e4e1b41f494b8daeb937b11ffb5b61 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.d.mts @@ -0,0 +1,9 @@ +declare function isArrayLikeObject(value: T): boolean; +declare function isArrayLikeObject(value: ((...args: any[]) => any) | Function | string | boolean | number | null | undefined): value is never; +declare function isArrayLikeObject(value: any): value is object & { + length: number; +}; + +export { isArrayLikeObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fa2751efc4e4e1b41f494b8daeb937b11ffb5b61 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.d.ts @@ -0,0 +1,9 @@ +declare function isArrayLikeObject(value: T): boolean; +declare function isArrayLikeObject(value: ((...args: any[]) => any) | Function | string | boolean | number | null | undefined): value is never; +declare function isArrayLikeObject(value: any): value is object & { + length: number; +}; + +export { isArrayLikeObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.js new file mode 100644 index 0000000000000000000000000000000000000000..a971e951254d88e7d12c9522689ec261b4ec9448 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLike = require('./isArrayLike.js'); +const isObjectLike = require('./isObjectLike.js'); + +function isArrayLikeObject(value) { + return isObjectLike.isObjectLike(value) && isArrayLike.isArrayLike(value); +} + +exports.isArrayLikeObject = isArrayLikeObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..befdee15e55e7a279c26215759da008911de0871 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.mjs @@ -0,0 +1,8 @@ +import { isArrayLike } from './isArrayLike.mjs'; +import { isObjectLike } from './isObjectLike.mjs'; + +function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); +} + +export { isArrayLikeObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f35271a06d925f33960ecd0fb891263ff15df1be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.d.mts @@ -0,0 +1,25 @@ +/** + * Checks if the given value is boolean. + * + * This function tests whether the provided value is strictly `boolean`. + * It returns `true` if the value is `boolean`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `boolean`. + * + * @param {any} value - The Value to test if it is boolean. + * @returns {value is boolean} True if the value is boolean, false otherwise. + * + * @example + * + * const value1 = true; + * const value2 = 0; + * const value3 = 'abc'; + * + * console.log(isBoolean(value1)); // true + * console.log(isBoolean(value2)); // false + * console.log(isBoolean(value3)); // false + * + */ +declare function isBoolean(value?: any): value is boolean; + +export { isBoolean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f35271a06d925f33960ecd0fb891263ff15df1be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.d.ts @@ -0,0 +1,25 @@ +/** + * Checks if the given value is boolean. + * + * This function tests whether the provided value is strictly `boolean`. + * It returns `true` if the value is `boolean`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `boolean`. + * + * @param {any} value - The Value to test if it is boolean. + * @returns {value is boolean} True if the value is boolean, false otherwise. + * + * @example + * + * const value1 = true; + * const value2 = 0; + * const value3 = 'abc'; + * + * console.log(isBoolean(value1)); // true + * console.log(isBoolean(value2)); // false + * console.log(isBoolean(value3)); // false + * + */ +declare function isBoolean(value?: any): value is boolean; + +export { isBoolean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.js new file mode 100644 index 0000000000000000000000000000000000000000..b93d89764e54b562ae242b6e8bd73e6c8fd1338c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isBoolean(value) { + return typeof value === 'boolean' || value instanceof Boolean; +} + +exports.isBoolean = isBoolean; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ac69c94c3be7c997a889515f1edda924e6b729bd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBoolean.mjs @@ -0,0 +1,5 @@ +function isBoolean(value) { + return typeof value === 'boolean' || value instanceof Boolean; +} + +export { isBoolean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2816d564d734dae1678354bb7b5cd0d20af33eda --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.d.mts @@ -0,0 +1,21 @@ +/** + * Checks if the given value is a Buffer instance. + * + * This function tests whether the provided value is an instance of Buffer. + * It returns `true` if the value is a Buffer, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`. + * + * @param {any} x - The value to check if it is a Buffer. + * @returns {boolean} Returns `true` if `x` is a Buffer, else `false`. + * + * @example + * const buffer = Buffer.from("test"); + * console.log(isBuffer(buffer)); // true + * + * const notBuffer = "not a buffer"; + * console.log(isBuffer(notBuffer)); // false + */ +declare function isBuffer(x?: any): boolean; + +export { isBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2816d564d734dae1678354bb7b5cd0d20af33eda --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.d.ts @@ -0,0 +1,21 @@ +/** + * Checks if the given value is a Buffer instance. + * + * This function tests whether the provided value is an instance of Buffer. + * It returns `true` if the value is a Buffer, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`. + * + * @param {any} x - The value to check if it is a Buffer. + * @returns {boolean} Returns `true` if `x` is a Buffer, else `false`. + * + * @example + * const buffer = Buffer.from("test"); + * console.log(isBuffer(buffer)); // true + * + * const notBuffer = "not a buffer"; + * console.log(isBuffer(notBuffer)); // false + */ +declare function isBuffer(x?: any): boolean; + +export { isBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..578c503c1d7462cc30464086a3a33335f886256b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isBuffer$1 = require('../../predicate/isBuffer.js'); + +function isBuffer(x) { + return isBuffer$1.isBuffer(x); +} + +exports.isBuffer = isBuffer; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1112d3126c18b389c163a9916423e8cc4e9b3a6a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isBuffer.mjs @@ -0,0 +1,7 @@ +import { isBuffer as isBuffer$1 } from '../../predicate/isBuffer.mjs'; + +function isBuffer(x) { + return isBuffer$1(x); +} + +export { isBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6ebec7156ab4d5818ea94708d26838de3f40a038 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.d.mts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a Date object. + * + * @param {any} value The value to check. + * @returns {value is Date} Returns `true` if `value` is a Date object, `false` otherwise. + * + * @example + * const value1 = new Date(); + * const value2 = '2024-01-01'; + * + * console.log(isDate(value1)); // true + * console.log(isDate(value2)); // false + */ +declare function isDate(value?: any): value is Date; + +export { isDate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6ebec7156ab4d5818ea94708d26838de3f40a038 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.d.ts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a Date object. + * + * @param {any} value The value to check. + * @returns {value is Date} Returns `true` if `value` is a Date object, `false` otherwise. + * + * @example + * const value1 = new Date(); + * const value2 = '2024-01-01'; + * + * console.log(isDate(value1)); // true + * console.log(isDate(value2)); // false + */ +declare function isDate(value?: any): value is Date; + +export { isDate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.js new file mode 100644 index 0000000000000000000000000000000000000000..ea6e4300ecd28af527c02a6dc504c686022a6bf1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isDate$1 = require('../../predicate/isDate.js'); + +function isDate(value) { + return isDate$1.isDate(value); +} + +exports.isDate = isDate; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f093af4a298f127045bb2b537717eaf207a98d52 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isDate.mjs @@ -0,0 +1,7 @@ +import { isDate as isDate$1 } from '../../predicate/isDate.mjs'; + +function isDate(value) { + return isDate$1(value); +} + +export { isDate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b8e92d73f33b8d327b7fbec24b97192dfa0e9d1a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.d.mts @@ -0,0 +1,13 @@ +/** + * Checks if `value` is likely a DOM element. + * + * @param {any} value The value to check. + * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. + * + * @example + * console.log(isElement(document.body)); // true + * console.log(isElement('')); // false + */ +declare function isElement(value?: any): boolean; + +export { isElement }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b8e92d73f33b8d327b7fbec24b97192dfa0e9d1a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.d.ts @@ -0,0 +1,13 @@ +/** + * Checks if `value` is likely a DOM element. + * + * @param {any} value The value to check. + * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. + * + * @example + * console.log(isElement(document.body)); // true + * console.log(isElement('')); // false + */ +declare function isElement(value?: any): boolean; + +export { isElement }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.js new file mode 100644 index 0000000000000000000000000000000000000000..2c8b178fd91af90c9f18d3db898e6269349a13d0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isObjectLike = require('./isObjectLike.js'); +const isPlainObject = require('./isPlainObject.js'); + +function isElement(value) { + return isObjectLike.isObjectLike(value) && value.nodeType === 1 && !isPlainObject.isPlainObject(value); +} + +exports.isElement = isElement; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2c7cb4ccbd928c4eb5e69486b01cfbe835458176 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isElement.mjs @@ -0,0 +1,8 @@ +import { isObjectLike } from './isObjectLike.mjs'; +import { isPlainObject } from './isPlainObject.mjs'; + +function isElement(value) { + return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value); +} + +export { isElement }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b0f25214378358adfd99c357befe99ae94453819 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.d.mts @@ -0,0 +1,12 @@ +import { EmptyObjectOf } from '../_internal/EmptyObjectOf.mjs'; + +declare function isEmpty(value?: T): boolean; +declare function isEmpty(value: string): value is ''; +declare function isEmpty(value: Map | Set | ArrayLike | null | undefined): boolean; +declare function isEmpty(value: object): boolean; +declare function isEmpty(value: T | null | undefined): value is EmptyObjectOf | null | undefined; +declare function isEmpty(value?: any): boolean; + +export { isEmpty }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..33aee4fc0cf5ffae684fc454b5495177252b9253 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.d.ts @@ -0,0 +1,12 @@ +import { EmptyObjectOf } from '../_internal/EmptyObjectOf.js'; + +declare function isEmpty(value?: T): boolean; +declare function isEmpty(value: string): value is ''; +declare function isEmpty(value: Map | Set | ArrayLike | null | undefined): boolean; +declare function isEmpty(value: object): boolean; +declare function isEmpty(value: T | null | undefined): value is EmptyObjectOf | null | undefined; +declare function isEmpty(value?: any): boolean; + +export { isEmpty }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.js new file mode 100644 index 0000000000000000000000000000000000000000..ed657be23891352552e8688e7be77c3904d6d5b9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArguments = require('./isArguments.js'); +const isArrayLike = require('./isArrayLike.js'); +const isTypedArray = require('./isTypedArray.js'); +const isPrototype = require('../_internal/isPrototype.js'); + +function isEmpty(value) { + if (value == null) { + return true; + } + if (isArrayLike.isArrayLike(value)) { + if (typeof value.splice !== 'function' && + typeof value !== 'string' && + (typeof Buffer === 'undefined' || !Buffer.isBuffer(value)) && + !isTypedArray.isTypedArray(value) && + !isArguments.isArguments(value)) { + return false; + } + return value.length === 0; + } + if (typeof value === 'object') { + if (value instanceof Map || value instanceof Set) { + return value.size === 0; + } + const keys = Object.keys(value); + if (isPrototype.isPrototype(value)) { + return keys.filter(x => x !== 'constructor').length === 0; + } + return keys.length === 0; + } + return true; +} + +exports.isEmpty = isEmpty; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1f6c46326d93521057767ad1ed60509f738cdb4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEmpty.mjs @@ -0,0 +1,33 @@ +import { isArguments } from './isArguments.mjs'; +import { isArrayLike } from './isArrayLike.mjs'; +import { isTypedArray } from './isTypedArray.mjs'; +import { isPrototype } from '../_internal/isPrototype.mjs'; + +function isEmpty(value) { + if (value == null) { + return true; + } + if (isArrayLike(value)) { + if (typeof value.splice !== 'function' && + typeof value !== 'string' && + (typeof Buffer === 'undefined' || !Buffer.isBuffer(value)) && + !isTypedArray(value) && + !isArguments(value)) { + return false; + } + return value.length === 0; + } + if (typeof value === 'object') { + if (value instanceof Map || value instanceof Set) { + return value.size === 0; + } + const keys = Object.keys(value); + if (isPrototype(value)) { + return keys.filter(x => x !== 'constructor').length === 0; + } + return keys.length === 0; + } + return true; +} + +export { isEmpty }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..143d52ddc5701356cb9089d7b1d7440243e32968 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.d.mts @@ -0,0 +1,40 @@ +import { IsEqualCustomizer } from '../_internal/IsEqualCustomizer.mjs'; + +/** + * Compares two values for equality using a custom comparison function. + * + * The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison. + * + * This function also uses the custom equality function to compare values inside objects, + * arrays, maps, sets, and other complex structures, ensuring a deep comparison. + * + * This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases. + * + * The custom comparison function can take up to six parameters: + * - `x`: The value from the first object `a`. + * - `y`: The value from the second object `b`. + * - `property`: The property key used to get `x` and `y`. + * - `xParent`: The parent of the first value `x`. + * - `yParent`: The parent of the second value `y`. + * - `stack`: An internal stack (Map) to handle circular references. + * + * @param {unknown} a - The first value to compare. + * @param {unknown} b - The second value to compare. + * @param {(x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map) => boolean | void} [areValuesEqual=noop] - A function to customize the comparison. + * If it returns a boolean, that result will be used. If it returns undefined, + * the default equality comparison will be used. + * @returns {boolean} `true` if the values are equal according to the customizer, otherwise `false`. + * + * @example + * const customizer = (a, b) => { + * if (typeof a === 'string' && typeof b === 'string') { + * return a.toLowerCase() === b.toLowerCase(); + * } + * }; + * isEqualWith('Hello', 'hello', customizer); // true + * isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true + * isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true + */ +declare function isEqualWith(a: any, b: any, areValuesEqual?: IsEqualCustomizer): boolean; + +export { isEqualWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d0cc8007aa68a8bae9a10eb2d2bcb71680e734aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.d.ts @@ -0,0 +1,40 @@ +import { IsEqualCustomizer } from '../_internal/IsEqualCustomizer.js'; + +/** + * Compares two values for equality using a custom comparison function. + * + * The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison. + * + * This function also uses the custom equality function to compare values inside objects, + * arrays, maps, sets, and other complex structures, ensuring a deep comparison. + * + * This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases. + * + * The custom comparison function can take up to six parameters: + * - `x`: The value from the first object `a`. + * - `y`: The value from the second object `b`. + * - `property`: The property key used to get `x` and `y`. + * - `xParent`: The parent of the first value `x`. + * - `yParent`: The parent of the second value `y`. + * - `stack`: An internal stack (Map) to handle circular references. + * + * @param {unknown} a - The first value to compare. + * @param {unknown} b - The second value to compare. + * @param {(x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map) => boolean | void} [areValuesEqual=noop] - A function to customize the comparison. + * If it returns a boolean, that result will be used. If it returns undefined, + * the default equality comparison will be used. + * @returns {boolean} `true` if the values are equal according to the customizer, otherwise `false`. + * + * @example + * const customizer = (a, b) => { + * if (typeof a === 'string' && typeof b === 'string') { + * return a.toLowerCase() === b.toLowerCase(); + * } + * }; + * isEqualWith('Hello', 'hello', customizer); // true + * isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true + * isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true + */ +declare function isEqualWith(a: any, b: any, areValuesEqual?: IsEqualCustomizer): boolean; + +export { isEqualWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.js new file mode 100644 index 0000000000000000000000000000000000000000..c11735be99efbf2bf9053ca1de88069c9baea5ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const after = require('../../function/after.js'); +const isEqualWith$1 = require('../../predicate/isEqualWith.js'); + +function isEqualWith(a, b, areValuesEqual) { + if (typeof areValuesEqual !== 'function') { + areValuesEqual = () => undefined; + } + return isEqualWith$1.isEqualWith(a, b, (...args) => { + const result = areValuesEqual(...args); + if (result !== undefined) { + return Boolean(result); + } + if (a instanceof Map && b instanceof Map) { + return isEqualWith(Array.from(a), Array.from(b), after.after(2, areValuesEqual)); + } + if (a instanceof Set && b instanceof Set) { + return isEqualWith(Array.from(a), Array.from(b), after.after(2, areValuesEqual)); + } + }); +} + +exports.isEqualWith = isEqualWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b9ee06f0dd1fffc45fdb88421ce4900202096950 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.mjs @@ -0,0 +1,22 @@ +import { after } from '../../function/after.mjs'; +import { isEqualWith as isEqualWith$1 } from '../../predicate/isEqualWith.mjs'; + +function isEqualWith(a, b, areValuesEqual) { + if (typeof areValuesEqual !== 'function') { + areValuesEqual = () => undefined; + } + return isEqualWith$1(a, b, (...args) => { + const result = areValuesEqual(...args); + if (result !== undefined) { + return Boolean(result); + } + if (a instanceof Map && b instanceof Map) { + return isEqualWith(Array.from(a), Array.from(b), after(2, areValuesEqual)); + } + if (a instanceof Set && b instanceof Set) { + return isEqualWith(Array.from(a), Array.from(b), after(2, areValuesEqual)); + } + }); +} + +export { isEqualWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..574b316133f678baca89978279256e102d706f03 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.d.mts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is an Error object. + * + * @param {any} value The value to check. + * @returns {value is Error} Returns `true` if `value` is an Error object, `false` otherwise. + * + * @example + * ```typescript + * console.log(isError(new Error())); // true + * console.log(isError('Error')); // false + * console.log(isError({ name: 'Error', message: '' })); // false + * ``` + */ +declare function isError(value: any): value is Error; + +export { isError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..574b316133f678baca89978279256e102d706f03 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.d.ts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is an Error object. + * + * @param {any} value The value to check. + * @returns {value is Error} Returns `true` if `value` is an Error object, `false` otherwise. + * + * @example + * ```typescript + * console.log(isError(new Error())); // true + * console.log(isError('Error')); // false + * console.log(isError({ name: 'Error', message: '' })); // false + * ``` + */ +declare function isError(value: any): value is Error; + +export { isError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.js new file mode 100644 index 0000000000000000000000000000000000000000..212d81628b17c6917f130b1781af8ea81f5ca336 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const getTag = require('../_internal/getTag.js'); + +function isError(value) { + return getTag.getTag(value) === '[object Error]'; +} + +exports.isError = isError; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.mjs new file mode 100644 index 0000000000000000000000000000000000000000..24c24840cc1a11be3221e7e0f2690a4d98728521 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isError.mjs @@ -0,0 +1,7 @@ +import { getTag } from '../_internal/getTag.mjs'; + +function isError(value) { + return getTag(value) === '[object Error]'; +} + +export { isError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6d24b18b37c427e97518499b1a5f80f6a99c924d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if `value` is a finite number. + * + * @param {any} value The value to check. + * @returns {boolean} Returns `true` if `value` is a finite number, `false` otherwise. + * + * @example + * ```typescript + * const value1 = 100; + * const value2 = Infinity; + * const value3 = '100'; + * + * console.log(isFinite(value1)); // true + * console.log(isFinite(value2)); // false + * console.log(isFinite(value3)); // false + * ``` + */ +declare function isFinite(value?: any): boolean; + +export { isFinite }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6d24b18b37c427e97518499b1a5f80f6a99c924d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if `value` is a finite number. + * + * @param {any} value The value to check. + * @returns {boolean} Returns `true` if `value` is a finite number, `false` otherwise. + * + * @example + * ```typescript + * const value1 = 100; + * const value2 = Infinity; + * const value3 = '100'; + * + * console.log(isFinite(value1)); // true + * console.log(isFinite(value2)); // false + * console.log(isFinite(value3)); // false + * ``` + */ +declare function isFinite(value?: any): boolean; + +export { isFinite }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.js new file mode 100644 index 0000000000000000000000000000000000000000..0c705a7c678d411ed7c963a9eb37860d9559352b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isFinite(value) { + return Number.isFinite(value); +} + +exports.isFinite = isFinite; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.mjs new file mode 100644 index 0000000000000000000000000000000000000000..dda1df0af81f27058b0b1c947f23cc063105b5c8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFinite.mjs @@ -0,0 +1,5 @@ +function isFinite(value) { + return Number.isFinite(value); +} + +export { isFinite }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c89f111c71bc0d4ebdca94b983ddbd6432366f48 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.d.mts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a function. + * + * @param {any} value The value to check. + * @returns {value is (...args: any[]) => any} Returns `true` if `value` is a function, else `false`. + * + * @example + * isFunction(Array.prototype.slice); // true + * isFunction(async function () {}); // true + * isFunction(function* () {}); // true + * isFunction(Proxy); // true + * isFunction(Int8Array); // true + */ +declare function isFunction(value: any): value is (...args: any[]) => any; + +export { isFunction }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c89f111c71bc0d4ebdca94b983ddbd6432366f48 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.d.ts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a function. + * + * @param {any} value The value to check. + * @returns {value is (...args: any[]) => any} Returns `true` if `value` is a function, else `false`. + * + * @example + * isFunction(Array.prototype.slice); // true + * isFunction(async function () {}); // true + * isFunction(function* () {}); // true + * isFunction(Proxy); // true + * isFunction(Int8Array); // true + */ +declare function isFunction(value: any): value is (...args: any[]) => any; + +export { isFunction }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.js new file mode 100644 index 0000000000000000000000000000000000000000..07a19dfd8a6633d6dedb7bd43034c637a533f05f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isFunction(value) { + return typeof value === 'function'; +} + +exports.isFunction = isFunction; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b9a4a2eb82a9c017aec2b54927c2fccedc9e4ba6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isFunction.mjs @@ -0,0 +1,5 @@ +function isFunction(value) { + return typeof value === 'function'; +} + +export { isFunction }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ee133b91971f03908f9e8b83556c26984ca2be11 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.d.mts @@ -0,0 +1,17 @@ +/** + * Checks if `value` is an integer. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `number`. + * + * @param {any} value - The value to check + * @returns {boolean} `true` if `value` is integer, otherwise `false`. + * + * @example + * isInteger(3); // Returns: true + * isInteger(Infinity); // Returns: false + * isInteger('3'); // Returns: false + * isInteger([]); // Returns: false + */ +declare function isInteger(value?: any): boolean; + +export { isInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee133b91971f03908f9e8b83556c26984ca2be11 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.d.ts @@ -0,0 +1,17 @@ +/** + * Checks if `value` is an integer. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `number`. + * + * @param {any} value - The value to check + * @returns {boolean} `true` if `value` is integer, otherwise `false`. + * + * @example + * isInteger(3); // Returns: true + * isInteger(Infinity); // Returns: false + * isInteger('3'); // Returns: false + * isInteger([]); // Returns: false + */ +declare function isInteger(value?: any): boolean; + +export { isInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.js new file mode 100644 index 0000000000000000000000000000000000000000..2843f3b76ae014cddd414fc981311a6a8719dfdb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isInteger(value) { + return Number.isInteger(value); +} + +exports.isInteger = isInteger; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.mjs new file mode 100644 index 0000000000000000000000000000000000000000..89fb4604b704b73bdef193a2c5e8c57eba4f5407 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isInteger.mjs @@ -0,0 +1,5 @@ +function isInteger(value) { + return Number.isInteger(value); +} + +export { isInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..78a60af3571fe73d6a72c2c3fa2df2d7c22f8741 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.d.mts @@ -0,0 +1,24 @@ +/** + * Checks if a given value is a valid length. + * + * A valid length is of type `number`, is a non-negative integer, and is less than or equal to + * JavaScript's maximum safe integer (`Number.MAX_SAFE_INTEGER`). + * It returns `true` if the value is a valid length, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the + * argument to a valid length (`number`). + * + * @param {any} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * + * @example + * isLength(0); // true + * isLength(42); // true + * isLength(-1); // false + * isLength(1.5); // false + * isLength(Number.MAX_SAFE_INTEGER); // true + * isLength(Number.MAX_SAFE_INTEGER + 1); // false + */ +declare function isLength(value?: any): boolean; + +export { isLength }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..78a60af3571fe73d6a72c2c3fa2df2d7c22f8741 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.d.ts @@ -0,0 +1,24 @@ +/** + * Checks if a given value is a valid length. + * + * A valid length is of type `number`, is a non-negative integer, and is less than or equal to + * JavaScript's maximum safe integer (`Number.MAX_SAFE_INTEGER`). + * It returns `true` if the value is a valid length, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the + * argument to a valid length (`number`). + * + * @param {any} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * + * @example + * isLength(0); // true + * isLength(42); // true + * isLength(-1); // false + * isLength(1.5); // false + * isLength(Number.MAX_SAFE_INTEGER); // true + * isLength(Number.MAX_SAFE_INTEGER + 1); // false + */ +declare function isLength(value?: any): boolean; + +export { isLength }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.js new file mode 100644 index 0000000000000000000000000000000000000000..62787d830f3cc71a67ccd175e1730680618b62fc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isLength(value) { + return Number.isSafeInteger(value) && value >= 0; +} + +exports.isLength = isLength; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a4e39989f6e2fc62bd44fd2a1bbe26f1436eed94 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isLength.mjs @@ -0,0 +1,5 @@ +function isLength(value) { + return Number.isSafeInteger(value) && value >= 0; +} + +export { isLength }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..03a43a368f82500743c73fa93a86e0c8c8a65f91 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is `Map`. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Map`. + * + * @param {unknown} value The value to check if it is a `Map`. + * @returns {value is Map} Returns `true` if `value` is a `Map`, else `false`. + * + * @example + * const value1 = new Map(); + * const value2 = new Set(); + * const value3 = new WeakMap(); + * + * console.log(isMap(value1)); // true + * console.log(isMap(value2)); // false + * console.log(isMap(value3)); // false + */ +declare function isMap(value?: any): value is Map; + +export { isMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..03a43a368f82500743c73fa93a86e0c8c8a65f91 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is `Map`. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Map`. + * + * @param {unknown} value The value to check if it is a `Map`. + * @returns {value is Map} Returns `true` if `value` is a `Map`, else `false`. + * + * @example + * const value1 = new Map(); + * const value2 = new Set(); + * const value3 = new WeakMap(); + * + * console.log(isMap(value1)); // true + * console.log(isMap(value2)); // false + * console.log(isMap(value3)); // false + */ +declare function isMap(value?: any): value is Map; + +export { isMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.js new file mode 100644 index 0000000000000000000000000000000000000000..aa42ebd245052622189b6159901513a2a4fba16a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isMap$1 = require('../../predicate/isMap.js'); + +function isMap(value) { + return isMap$1.isMap(value); +} + +exports.isMap = isMap; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b1ad2cd041c2e9c9153fee97f7acafa4ee1d5b56 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMap.mjs @@ -0,0 +1,7 @@ +import { isMap as isMap$1 } from '../../predicate/isMap.mjs'; + +function isMap(value) { + return isMap$1(value); +} + +export { isMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fc5b62a7336ff454ff00ad50f1365d2435c934bf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.d.mts @@ -0,0 +1,31 @@ +/** + * Checks if the target matches the source by comparing their structures and values. + * This function supports deep comparison for objects, arrays, maps, and sets. + * + * @param {object} target - The target value to match against. + * @param {object} source - The source value to match with. + * @returns {boolean} - Returns `true` if the target matches the source, otherwise `false`. + * + * @example + * // Basic usage + * isMatch({ a: 1, b: 2 }, { a: 1 }); // true + * + * @example + * // Matching arrays + * isMatch([1, 2, 3], [1, 2, 3]); // true + * + * @example + * // Matching maps + * const targetMap = new Map([['key1', 'value1'], ['key2', 'value2']]); + * const sourceMap = new Map([['key1', 'value1']]); + * isMatch(targetMap, sourceMap); // true + * + * @example + * // Matching sets + * const targetSet = new Set([1, 2, 3]); + * const sourceSet = new Set([1, 2]); + * isMatch(targetSet, sourceSet); // true + */ +declare function isMatch(target: object, source: object): boolean; + +export { isMatch }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fc5b62a7336ff454ff00ad50f1365d2435c934bf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.d.ts @@ -0,0 +1,31 @@ +/** + * Checks if the target matches the source by comparing their structures and values. + * This function supports deep comparison for objects, arrays, maps, and sets. + * + * @param {object} target - The target value to match against. + * @param {object} source - The source value to match with. + * @returns {boolean} - Returns `true` if the target matches the source, otherwise `false`. + * + * @example + * // Basic usage + * isMatch({ a: 1, b: 2 }, { a: 1 }); // true + * + * @example + * // Matching arrays + * isMatch([1, 2, 3], [1, 2, 3]); // true + * + * @example + * // Matching maps + * const targetMap = new Map([['key1', 'value1'], ['key2', 'value2']]); + * const sourceMap = new Map([['key1', 'value1']]); + * isMatch(targetMap, sourceMap); // true + * + * @example + * // Matching sets + * const targetSet = new Set([1, 2, 3]); + * const sourceSet = new Set([1, 2]); + * isMatch(targetSet, sourceSet); // true + */ +declare function isMatch(target: object, source: object): boolean; + +export { isMatch }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.js new file mode 100644 index 0000000000000000000000000000000000000000..77573c89bac73e28213a68272d6a2115a401a91c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isMatchWith = require('./isMatchWith.js'); + +function isMatch(target, source) { + return isMatchWith.isMatchWith(target, source, () => undefined); +} + +exports.isMatch = isMatch; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.mjs new file mode 100644 index 0000000000000000000000000000000000000000..309d05cb58d351055f1d65ecf37073cdfae44df9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatch.mjs @@ -0,0 +1,7 @@ +import { isMatchWith } from './isMatchWith.mjs'; + +function isMatch(target, source) { + return isMatchWith(target, source, () => undefined); +} + +export { isMatch }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6fb79a92297911a9ea8933fea01e4258e7b5f3ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.d.mts @@ -0,0 +1,29 @@ +import { IsMatchWithCustomizer } from '../_internal/IsMatchWithCustomizer.mjs'; + +/** + * Performs a deep comparison between a target value and a source pattern to determine if they match, + * using a custom comparison function for fine-grained control over the matching logic. + * + * @param {object} target - The value to be tested for matching + * @param {object} source - The pattern/template to match against + * @param {IsMatchWithCustomizer} compare - Custom comparison function for fine-grained control + * @returns {boolean} `true` if the target matches the source pattern, `false` otherwise + * + * @example + * // Basic matching with custom comparator + * const caseInsensitiveCompare = (objVal, srcVal) => { + * if (typeof objVal === 'string' && typeof srcVal === 'string') { + * return objVal.toLowerCase() === srcVal.toLowerCase(); + * } + * return undefined; + * }; + * + * isMatchWith( + * { name: 'JOHN', age: 30 }, + * { name: 'john' }, + * caseInsensitiveCompare + * ); // true + */ +declare function isMatchWith(target: object, source: object, compare: IsMatchWithCustomizer): boolean; + +export { isMatchWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6e8b06c08526754a98c98122be3127fbf22c63a9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.d.ts @@ -0,0 +1,29 @@ +import { IsMatchWithCustomizer } from '../_internal/IsMatchWithCustomizer.js'; + +/** + * Performs a deep comparison between a target value and a source pattern to determine if they match, + * using a custom comparison function for fine-grained control over the matching logic. + * + * @param {object} target - The value to be tested for matching + * @param {object} source - The pattern/template to match against + * @param {IsMatchWithCustomizer} compare - Custom comparison function for fine-grained control + * @returns {boolean} `true` if the target matches the source pattern, `false` otherwise + * + * @example + * // Basic matching with custom comparator + * const caseInsensitiveCompare = (objVal, srcVal) => { + * if (typeof objVal === 'string' && typeof srcVal === 'string') { + * return objVal.toLowerCase() === srcVal.toLowerCase(); + * } + * return undefined; + * }; + * + * isMatchWith( + * { name: 'JOHN', age: 30 }, + * { name: 'john' }, + * caseInsensitiveCompare + * ); // true + */ +declare function isMatchWith(target: object, source: object, compare: IsMatchWithCustomizer): boolean; + +export { isMatchWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.js new file mode 100644 index 0000000000000000000000000000000000000000..c6518010d1fe4a60a47bd926d516a150ef7a0725 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.js @@ -0,0 +1,159 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isMatch = require('./isMatch.js'); +const isObject = require('./isObject.js'); +const isPrimitive = require('../../predicate/isPrimitive.js'); +const eq = require('../util/eq.js'); + +function isMatchWith(target, source, compare) { + if (typeof compare !== 'function') { + return isMatch.isMatch(target, source); + } + return isMatchWithInternal(target, source, function doesMatch(objValue, srcValue, key, object, source, stack) { + const isEqual = compare(objValue, srcValue, key, object, source, stack); + if (isEqual !== undefined) { + return Boolean(isEqual); + } + return isMatchWithInternal(objValue, srcValue, doesMatch, stack); + }, new Map()); +} +function isMatchWithInternal(target, source, compare, stack) { + if (source === target) { + return true; + } + switch (typeof source) { + case 'object': { + return isObjectMatch(target, source, compare, stack); + } + case 'function': { + const sourceKeys = Object.keys(source); + if (sourceKeys.length > 0) { + return isMatchWithInternal(target, { ...source }, compare, stack); + } + return eq.eq(target, source); + } + default: { + if (!isObject.isObject(target)) { + return eq.eq(target, source); + } + if (typeof source === 'string') { + return source === ''; + } + return true; + } + } +} +function isObjectMatch(target, source, compare, stack) { + if (source == null) { + return true; + } + if (Array.isArray(source)) { + return isArrayMatch(target, source, compare, stack); + } + if (source instanceof Map) { + return isMapMatch(target, source, compare, stack); + } + if (source instanceof Set) { + return isSetMatch(target, source, compare, stack); + } + const keys = Object.keys(source); + if (target == null) { + return keys.length === 0; + } + if (keys.length === 0) { + return true; + } + if (stack && stack.has(source)) { + return stack.get(source) === target; + } + if (stack) { + stack.set(source, target); + } + try { + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (!isPrimitive.isPrimitive(target) && !(key in target)) { + return false; + } + if (source[key] === undefined && target[key] !== undefined) { + return false; + } + if (source[key] === null && target[key] !== null) { + return false; + } + const isEqual = compare(target[key], source[key], key, target, source, stack); + if (!isEqual) { + return false; + } + } + return true; + } + finally { + if (stack) { + stack.delete(source); + } + } +} +function isMapMatch(target, source, compare, stack) { + if (source.size === 0) { + return true; + } + if (!(target instanceof Map)) { + return false; + } + for (const [key, sourceValue] of source.entries()) { + const targetValue = target.get(key); + const isEqual = compare(targetValue, sourceValue, key, target, source, stack); + if (isEqual === false) { + return false; + } + } + return true; +} +function isArrayMatch(target, source, compare, stack) { + if (source.length === 0) { + return true; + } + if (!Array.isArray(target)) { + return false; + } + const countedIndex = new Set(); + for (let i = 0; i < source.length; i++) { + const sourceItem = source[i]; + let found = false; + for (let j = 0; j < target.length; j++) { + if (countedIndex.has(j)) { + continue; + } + const targetItem = target[j]; + let matches = false; + const isEqual = compare(targetItem, sourceItem, i, target, source, stack); + if (isEqual) { + matches = true; + } + if (matches) { + countedIndex.add(j); + found = true; + break; + } + } + if (!found) { + return false; + } + } + return true; +} +function isSetMatch(target, source, compare, stack) { + if (source.size === 0) { + return true; + } + if (!(target instanceof Set)) { + return false; + } + return isArrayMatch([...target], [...source], compare, stack); +} + +exports.isMatchWith = isMatchWith; +exports.isSetMatch = isSetMatch; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..cf13ebb792191503047f89e625407422b89d2c77 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.mjs @@ -0,0 +1,154 @@ +import { isMatch } from './isMatch.mjs'; +import { isObject } from './isObject.mjs'; +import { isPrimitive } from '../../predicate/isPrimitive.mjs'; +import { eq } from '../util/eq.mjs'; + +function isMatchWith(target, source, compare) { + if (typeof compare !== 'function') { + return isMatch(target, source); + } + return isMatchWithInternal(target, source, function doesMatch(objValue, srcValue, key, object, source, stack) { + const isEqual = compare(objValue, srcValue, key, object, source, stack); + if (isEqual !== undefined) { + return Boolean(isEqual); + } + return isMatchWithInternal(objValue, srcValue, doesMatch, stack); + }, new Map()); +} +function isMatchWithInternal(target, source, compare, stack) { + if (source === target) { + return true; + } + switch (typeof source) { + case 'object': { + return isObjectMatch(target, source, compare, stack); + } + case 'function': { + const sourceKeys = Object.keys(source); + if (sourceKeys.length > 0) { + return isMatchWithInternal(target, { ...source }, compare, stack); + } + return eq(target, source); + } + default: { + if (!isObject(target)) { + return eq(target, source); + } + if (typeof source === 'string') { + return source === ''; + } + return true; + } + } +} +function isObjectMatch(target, source, compare, stack) { + if (source == null) { + return true; + } + if (Array.isArray(source)) { + return isArrayMatch(target, source, compare, stack); + } + if (source instanceof Map) { + return isMapMatch(target, source, compare, stack); + } + if (source instanceof Set) { + return isSetMatch(target, source, compare, stack); + } + const keys = Object.keys(source); + if (target == null) { + return keys.length === 0; + } + if (keys.length === 0) { + return true; + } + if (stack && stack.has(source)) { + return stack.get(source) === target; + } + if (stack) { + stack.set(source, target); + } + try { + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (!isPrimitive(target) && !(key in target)) { + return false; + } + if (source[key] === undefined && target[key] !== undefined) { + return false; + } + if (source[key] === null && target[key] !== null) { + return false; + } + const isEqual = compare(target[key], source[key], key, target, source, stack); + if (!isEqual) { + return false; + } + } + return true; + } + finally { + if (stack) { + stack.delete(source); + } + } +} +function isMapMatch(target, source, compare, stack) { + if (source.size === 0) { + return true; + } + if (!(target instanceof Map)) { + return false; + } + for (const [key, sourceValue] of source.entries()) { + const targetValue = target.get(key); + const isEqual = compare(targetValue, sourceValue, key, target, source, stack); + if (isEqual === false) { + return false; + } + } + return true; +} +function isArrayMatch(target, source, compare, stack) { + if (source.length === 0) { + return true; + } + if (!Array.isArray(target)) { + return false; + } + const countedIndex = new Set(); + for (let i = 0; i < source.length; i++) { + const sourceItem = source[i]; + let found = false; + for (let j = 0; j < target.length; j++) { + if (countedIndex.has(j)) { + continue; + } + const targetItem = target[j]; + let matches = false; + const isEqual = compare(targetItem, sourceItem, i, target, source, stack); + if (isEqual) { + matches = true; + } + if (matches) { + countedIndex.add(j); + found = true; + break; + } + } + if (!found) { + return false; + } + } + return true; +} +function isSetMatch(target, source, compare, stack) { + if (source.size === 0) { + return true; + } + if (!(target instanceof Set)) { + return false; + } + return isArrayMatch([...target], [...source], compare, stack); +} + +export { isMatchWith, isSetMatch }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..51919f6e62e9176a5bd84f1b8bd634d08b5563cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.d.mts @@ -0,0 +1,15 @@ +/** + * Checks if the value is NaN. + * + * @param {any} value - The value to check. + * @returns {boolean} `true` if the value is NaN, `false` otherwise. + * + * @example + * isNaN(NaN); // true + * isNaN(0); // false + * isNaN('NaN'); // false + * isNaN(undefined); // false + */ +declare function isNaN(value?: any): boolean; + +export { isNaN }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..51919f6e62e9176a5bd84f1b8bd634d08b5563cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.d.ts @@ -0,0 +1,15 @@ +/** + * Checks if the value is NaN. + * + * @param {any} value - The value to check. + * @returns {boolean} `true` if the value is NaN, `false` otherwise. + * + * @example + * isNaN(NaN); // true + * isNaN(0); // false + * isNaN('NaN'); // false + * isNaN(undefined); // false + */ +declare function isNaN(value?: any): boolean; + +export { isNaN }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.js new file mode 100644 index 0000000000000000000000000000000000000000..dba1e66e15b74cdf22b967eef1c98e1d95b3b472 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isNaN(value) { + return Number.isNaN(value); +} + +exports.isNaN = isNaN; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.mjs new file mode 100644 index 0000000000000000000000000000000000000000..67e54c6ad3e223425951fbbfbfc0eeee56aa3113 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNaN.mjs @@ -0,0 +1,5 @@ +function isNaN(value) { + return Number.isNaN(value); +} + +export { isNaN }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5031cf19e5f5412c7a31b05552078972f6ca001e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.d.mts @@ -0,0 +1,18 @@ +/** + * Checks if a given value is a native function. + * + * This function tests whether the provided value is a native function implemented by the JavaScript engine. + * It returns `true` if the value is a native function, and `false` otherwise. + * + * @param {any} value - The value to test for native function. + * @returns {value is (...args: any[]) => any} `true` if the value is a native function, `false` otherwise. + * + * @example + * const value1 = Array.prototype.push; + * const value2 = () => {}; + * const result1 = isNative(value1); // true + * const result2 = isNative(value2); // false + */ +declare function isNative(value: any): value is (...args: any[]) => any; + +export { isNative }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5031cf19e5f5412c7a31b05552078972f6ca001e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.d.ts @@ -0,0 +1,18 @@ +/** + * Checks if a given value is a native function. + * + * This function tests whether the provided value is a native function implemented by the JavaScript engine. + * It returns `true` if the value is a native function, and `false` otherwise. + * + * @param {any} value - The value to test for native function. + * @returns {value is (...args: any[]) => any} `true` if the value is a native function, `false` otherwise. + * + * @example + * const value1 = Array.prototype.push; + * const value2 = () => {}; + * const result1 = isNative(value1); // true + * const result2 = isNative(value2); // false + */ +declare function isNative(value: any): value is (...args: any[]) => any; + +export { isNative }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.js new file mode 100644 index 0000000000000000000000000000000000000000..78948ee71ccc38a0bae5cfe75af2900abd025345 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.js @@ -0,0 +1,21 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const functionToString = Function.prototype.toString; +const REGEXP_SYNTAX_CHARS = /[\\^$.*+?()[\]{}|]/g; +const IS_NATIVE_FUNCTION_REGEXP = RegExp(`^${functionToString + .call(Object.prototype.hasOwnProperty) + .replace(REGEXP_SYNTAX_CHARS, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?')}$`); +function isNative(value) { + if (typeof value !== 'function') { + return false; + } + if (globalThis?.['__core-js_shared__'] != null) { + throw new Error('Unsupported core-js use. Try https://npms.io/search?q=ponyfill.'); + } + return IS_NATIVE_FUNCTION_REGEXP.test(functionToString.call(value)); +} + +exports.isNative = isNative; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fd37c0c83590fae3393424e193de3f3d2bc8276d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNative.mjs @@ -0,0 +1,17 @@ +const functionToString = Function.prototype.toString; +const REGEXP_SYNTAX_CHARS = /[\\^$.*+?()[\]{}|]/g; +const IS_NATIVE_FUNCTION_REGEXP = RegExp(`^${functionToString + .call(Object.prototype.hasOwnProperty) + .replace(REGEXP_SYNTAX_CHARS, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?')}$`); +function isNative(value) { + if (typeof value !== 'function') { + return false; + } + if (globalThis?.['__core-js_shared__'] != null) { + throw new Error('Unsupported core-js use. Try https://npms.io/search?q=ponyfill.'); + } + return IS_NATIVE_FUNCTION_REGEXP.test(functionToString.call(value)); +} + +export { isNative }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0a708f038f0c80956b152d7b2a58b4d170110b9b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.d.mts @@ -0,0 +1,22 @@ +/** + * Checks if a given value is null or undefined. + * + * This function tests whether the provided value is either `null` or `undefined`. + * It returns `true` if the value is `null` or `undefined`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`. + * + * @param {any} x - The value to test for null or undefined. + * @returns {x is null | undefined} `true` if the value is null or undefined, `false` otherwise. + * + * @example + * const value1 = null; + * const value2 = undefined; + * const value3 = 42; + * const result1 = isNil(value1); // true + * const result2 = isNil(value2); // true + * const result3 = isNil(value3); // false + */ +declare function isNil(x: any): x is null | undefined; + +export { isNil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0a708f038f0c80956b152d7b2a58b4d170110b9b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.d.ts @@ -0,0 +1,22 @@ +/** + * Checks if a given value is null or undefined. + * + * This function tests whether the provided value is either `null` or `undefined`. + * It returns `true` if the value is `null` or `undefined`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`. + * + * @param {any} x - The value to test for null or undefined. + * @returns {x is null | undefined} `true` if the value is null or undefined, `false` otherwise. + * + * @example + * const value1 = null; + * const value2 = undefined; + * const value3 = 42; + * const result1 = isNil(value1); // true + * const result2 = isNil(value2); // true + * const result3 = isNil(value3); // false + */ +declare function isNil(x: any): x is null | undefined; + +export { isNil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.js new file mode 100644 index 0000000000000000000000000000000000000000..81ed466830afc4a09e4de7553be1419e15ca5a4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isNil(x) { + return x == null; +} + +exports.isNil = isNil; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.mjs new file mode 100644 index 0000000000000000000000000000000000000000..963a002d35f8596ef94c7b21b52d8121bff7a01e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNil.mjs @@ -0,0 +1,5 @@ +function isNil(x) { + return x == null; +} + +export { isNil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b22051145f7a6a9936266cf20b2dcac636445f0b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.d.mts @@ -0,0 +1,14 @@ +/** + * Checks if `value` is `null`. + * + * @param {any} value - The value to check. + * @returns {value is null} Returns `true` if `value` is `null`, else `false`. + * + * @example + * isNull(null); // true + * isNull(undefined); // false + * isNull(0); // false + */ +declare function isNull(value: any): value is null; + +export { isNull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b22051145f7a6a9936266cf20b2dcac636445f0b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.d.ts @@ -0,0 +1,14 @@ +/** + * Checks if `value` is `null`. + * + * @param {any} value - The value to check. + * @returns {value is null} Returns `true` if `value` is `null`, else `false`. + * + * @example + * isNull(null); // true + * isNull(undefined); // false + * isNull(0); // false + */ +declare function isNull(value: any): value is null; + +export { isNull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.js new file mode 100644 index 0000000000000000000000000000000000000000..8dee9b30b85fc3190d4b1d9666f4be2f48d07a79 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isNull(value) { + return value === null; +} + +exports.isNull = isNull; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a071e9599b902cb94de0a0c603318f7324942875 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNull.mjs @@ -0,0 +1,5 @@ +function isNull(value) { + return value === null; +} + +export { isNull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b608e950930d05be107e3fef80425fbf9ea79b49 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is a number. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `number`. + * + * @param {any} value The value to check if it is a number. + * @returns {value is number} Returns `true` if `value` is a number, else `false`. + * + * @example + * const value1 = 123; + * const value2 = 'abc'; + * const value3 = true; + * + * console.log(isNumber(value1)); // true + * console.log(isNumber(value2)); // false + * console.log(isNumber(value3)); // false + */ +declare function isNumber(value?: any): value is number; + +export { isNumber }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b608e950930d05be107e3fef80425fbf9ea79b49 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is a number. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `number`. + * + * @param {any} value The value to check if it is a number. + * @returns {value is number} Returns `true` if `value` is a number, else `false`. + * + * @example + * const value1 = 123; + * const value2 = 'abc'; + * const value3 = true; + * + * console.log(isNumber(value1)); // true + * console.log(isNumber(value2)); // false + * console.log(isNumber(value3)); // false + */ +declare function isNumber(value?: any): value is number; + +export { isNumber }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.js new file mode 100644 index 0000000000000000000000000000000000000000..ee8c8e1e6d93e4698ea51ec8fb889118c8e44d34 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isNumber(value) { + return typeof value === 'number' || value instanceof Number; +} + +exports.isNumber = isNumber; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a41a1b9019995819d3c96f0d53f348c572170525 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isNumber.mjs @@ -0,0 +1,5 @@ +function isNumber(value) { + return typeof value === 'number' || value instanceof Number; +} + +export { isNumber }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f58fd6ea456a9f0d2c8be6d5f650e43c57423d0e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.d.mts @@ -0,0 +1,26 @@ +/** + * Checks if the given value is an object. An object is a value that is + * not a primitive type (string, number, boolean, symbol, null, or undefined). + * + * This function tests whether the provided value is an object or not. + * It returns `true` if the value is an object, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object value. + * + * @param {any} value - The value to check if it is an object. + * @returns {value is object} `true` if the value is an object, `false` otherwise. + * + * @example + * const value1 = {}; + * const value2 = [1, 2, 3]; + * const value3 = () => {}; + * const value4 = null; + * + * console.log(isObject(value1)); // true + * console.log(isObject(value2)); // true + * console.log(isObject(value3)); // true + * console.log(isObject(value4)); // false + */ +declare function isObject(value?: any): value is object; + +export { isObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f58fd6ea456a9f0d2c8be6d5f650e43c57423d0e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.d.ts @@ -0,0 +1,26 @@ +/** + * Checks if the given value is an object. An object is a value that is + * not a primitive type (string, number, boolean, symbol, null, or undefined). + * + * This function tests whether the provided value is an object or not. + * It returns `true` if the value is an object, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object value. + * + * @param {any} value - The value to check if it is an object. + * @returns {value is object} `true` if the value is an object, `false` otherwise. + * + * @example + * const value1 = {}; + * const value2 = [1, 2, 3]; + * const value3 = () => {}; + * const value4 = null; + * + * console.log(isObject(value1)); // true + * console.log(isObject(value2)); // true + * console.log(isObject(value3)); // true + * console.log(isObject(value4)); // false + */ +declare function isObject(value?: any): value is object; + +export { isObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.js new file mode 100644 index 0000000000000000000000000000000000000000..e07514a3fc5fd5322ff46c62a33c673a8705e4b0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isObject(value) { + return value !== null && (typeof value === 'object' || typeof value === 'function'); +} + +exports.isObject = isObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..92683c214d2d30c061f2e412807898f4e2082ccd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObject.mjs @@ -0,0 +1,5 @@ +function isObject(value) { + return value !== null && (typeof value === 'object' || typeof value === 'function'); +} + +export { isObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fb409f9a06cb1498e71132d31126a4bcc2b7e0f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.d.mts @@ -0,0 +1,26 @@ +/** + * Checks if the given value is object-like. + * + * A value is object-like if its type is object and it is not null. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object-like value. + * + * @param {any} value - The value to test if it is an object-like. + * @returns {boolean} `true` if the value is an object-like, `false` otherwise. + * + * @example + * const value1 = { a: 1 }; + * const value2 = [1, 2, 3]; + * const value3 = 'abc'; + * const value4 = () => {}; + * const value5 = null; + * + * console.log(isObjectLike(value1)); // true + * console.log(isObjectLike(value2)); // true + * console.log(isObjectLike(value3)); // false + * console.log(isObjectLike(value4)); // false + * console.log(isObjectLike(value5)); // false + */ +declare function isObjectLike(value?: any): boolean; + +export { isObjectLike }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fb409f9a06cb1498e71132d31126a4bcc2b7e0f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.d.ts @@ -0,0 +1,26 @@ +/** + * Checks if the given value is object-like. + * + * A value is object-like if its type is object and it is not null. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object-like value. + * + * @param {any} value - The value to test if it is an object-like. + * @returns {boolean} `true` if the value is an object-like, `false` otherwise. + * + * @example + * const value1 = { a: 1 }; + * const value2 = [1, 2, 3]; + * const value3 = 'abc'; + * const value4 = () => {}; + * const value5 = null; + * + * console.log(isObjectLike(value1)); // true + * console.log(isObjectLike(value2)); // true + * console.log(isObjectLike(value3)); // false + * console.log(isObjectLike(value4)); // false + * console.log(isObjectLike(value5)); // false + */ +declare function isObjectLike(value?: any): boolean; + +export { isObjectLike }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.js new file mode 100644 index 0000000000000000000000000000000000000000..ae87209c9223c18b7862e492e0e302dfed0d87fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isObjectLike(value) { + return typeof value === 'object' && value !== null; +} + +exports.isObjectLike = isObjectLike; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.mjs new file mode 100644 index 0000000000000000000000000000000000000000..89d0a067ef6a6275c1bb54cd5bb97bd09103b790 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.mjs @@ -0,0 +1,5 @@ +function isObjectLike(value) { + return typeof value === 'object' && value !== null; +} + +export { isObjectLike }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..76624b793bc435740fb5687b4a4f87e8517df20e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.d.mts @@ -0,0 +1,25 @@ +/** + * Checks if a given value is a plain object. + * + * A plain object is an object created by the `{}` literal, `new Object()`, or + * `Object.create(null)`. + * + * This function also handles objects with custom + * `Symbol.toStringTag` properties. + * + * `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the + * default string description of objects. + * + * @param {any} [object] - The value to check. + * @returns {boolean} - True if the value is a plain object, otherwise false. + * + * @example + * console.log(isPlainObject({})); // true + * console.log(isPlainObject([])); // false + * console.log(isPlainObject(null)); // false + * console.log(isPlainObject(Object.create(null))); // true + * console.log(isPlainObject(new Map())); // false + */ +declare function isPlainObject(object?: any): boolean; + +export { isPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..76624b793bc435740fb5687b4a4f87e8517df20e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.d.ts @@ -0,0 +1,25 @@ +/** + * Checks if a given value is a plain object. + * + * A plain object is an object created by the `{}` literal, `new Object()`, or + * `Object.create(null)`. + * + * This function also handles objects with custom + * `Symbol.toStringTag` properties. + * + * `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the + * default string description of objects. + * + * @param {any} [object] - The value to check. + * @returns {boolean} - True if the value is a plain object, otherwise false. + * + * @example + * console.log(isPlainObject({})); // true + * console.log(isPlainObject([])); // false + * console.log(isPlainObject(null)); // false + * console.log(isPlainObject(Object.create(null))); // true + * console.log(isPlainObject(new Map())); // false + */ +declare function isPlainObject(object?: any): boolean; + +export { isPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.js new file mode 100644 index 0000000000000000000000000000000000000000..8a33dcf404be518f92c2b0e8e4497273e08721cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.js @@ -0,0 +1,33 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isPlainObject(object) { + if (typeof object !== 'object') { + return false; + } + if (object == null) { + return false; + } + if (Object.getPrototypeOf(object) === null) { + return true; + } + if (Object.prototype.toString.call(object) !== '[object Object]') { + const tag = object[Symbol.toStringTag]; + if (tag == null) { + return false; + } + const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable; + if (isTagReadonly) { + return false; + } + return object.toString() === `[object ${tag}]`; + } + let proto = object; + while (Object.getPrototypeOf(proto) !== null) { + proto = Object.getPrototypeOf(proto); + } + return Object.getPrototypeOf(object) === proto; +} + +exports.isPlainObject = isPlainObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9c0e8c1b44cc8f4189505f3669197b349feefb02 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.mjs @@ -0,0 +1,29 @@ +function isPlainObject(object) { + if (typeof object !== 'object') { + return false; + } + if (object == null) { + return false; + } + if (Object.getPrototypeOf(object) === null) { + return true; + } + if (Object.prototype.toString.call(object) !== '[object Object]') { + const tag = object[Symbol.toStringTag]; + if (tag == null) { + return false; + } + const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable; + if (isTagReadonly) { + return false; + } + return object.toString() === `[object ${tag}]`; + } + let proto = object; + while (Object.getPrototypeOf(proto) !== null) { + proto = Object.getPrototypeOf(proto); + } + return Object.getPrototypeOf(object) === proto; +} + +export { isPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5d09337f53f74d5a018ae4d8773279b0757904f1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.d.mts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a RegExp. + * + * @param {any} value The value to check. + * @returns {boolean} Returns `true` if `value` is a RegExp, `false` otherwise. + * + * @example + * const value1 = /abc/; + * const value2 = '/abc/'; + * + * console.log(isRegExp(value1)); // true + * console.log(isRegExp(value2)); // false + */ +declare function isRegExp(value?: any): value is RegExp; + +export { isRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d09337f53f74d5a018ae4d8773279b0757904f1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.d.ts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a RegExp. + * + * @param {any} value The value to check. + * @returns {boolean} Returns `true` if `value` is a RegExp, `false` otherwise. + * + * @example + * const value1 = /abc/; + * const value2 = '/abc/'; + * + * console.log(isRegExp(value1)); // true + * console.log(isRegExp(value2)); // false + */ +declare function isRegExp(value?: any): value is RegExp; + +export { isRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.js new file mode 100644 index 0000000000000000000000000000000000000000..55428b4d8337a853c978ecff7d4d448e0f380f99 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isRegExp$1 = require('../../predicate/isRegExp.js'); + +function isRegExp(value) { + return isRegExp$1.isRegExp(value); +} + +exports.isRegExp = isRegExp; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b98122d4bd1095cf43ef9d675084e485c5e556a0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isRegExp.mjs @@ -0,0 +1,7 @@ +import { isRegExp as isRegExp$1 } from '../../predicate/isRegExp.mjs'; + +function isRegExp(value) { + return isRegExp$1(value); +} + +export { isRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..67727ac1e41cd6e5a7c6cd32d35611ca6226190d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if `value` is a safe integer (between -(2^53 – 1) and (2^53 – 1), inclusive). + * + * A safe integer is an integer that can be precisely represented as a `number` in JavaScript, + * without any other integer being rounded to it. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `number`. + * + * @param {unknown} value - The value to check + * @returns {boolean} `true` if `value` is an integer and between the safe values, otherwise `false` + * + * @example + * isSafeInteger(3); // Returns: true + * isSafeInteger(Number.MIN_SAFE_INTEGER - 1); // Returns: false + * isSafeInteger(1n); // Returns: false + * isSafeInteger('1'); // Returns: false + */ +declare function isSafeInteger(value: any): boolean; + +export { isSafeInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..67727ac1e41cd6e5a7c6cd32d35611ca6226190d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if `value` is a safe integer (between -(2^53 – 1) and (2^53 – 1), inclusive). + * + * A safe integer is an integer that can be precisely represented as a `number` in JavaScript, + * without any other integer being rounded to it. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `number`. + * + * @param {unknown} value - The value to check + * @returns {boolean} `true` if `value` is an integer and between the safe values, otherwise `false` + * + * @example + * isSafeInteger(3); // Returns: true + * isSafeInteger(Number.MIN_SAFE_INTEGER - 1); // Returns: false + * isSafeInteger(1n); // Returns: false + * isSafeInteger('1'); // Returns: false + */ +declare function isSafeInteger(value: any): boolean; + +export { isSafeInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.js new file mode 100644 index 0000000000000000000000000000000000000000..45f626de37dd1a82ec1d2c11c604fbbe75f7ca1a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isSafeInteger(value) { + return Number.isSafeInteger(value); +} + +exports.isSafeInteger = isSafeInteger; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9dec6ff8e220ca008112ad37bd39141191b66dc5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSafeInteger.mjs @@ -0,0 +1,5 @@ +function isSafeInteger(value) { + return Number.isSafeInteger(value); +} + +export { isSafeInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f393c5669020d9fe58ccaba74100f7d25242996b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is `Set`. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Set`. + * + * @param {unknown} value The value to check if it is a `Set`. + * @returns {value is Set} Returns `true` if `value` is a `Set`, else `false`. + * + * @example + * const value1 = new Set(); + * const value2 = new Map(); + * const value3 = new WeakSet(); + * + * console.log(isSet(value1)); // true + * console.log(isSet(value2)); // false + * console.log(isSet(value3)); // false + */ +declare function isSet(value?: any): value is Set; + +export { isSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f393c5669020d9fe58ccaba74100f7d25242996b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is `Set`. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Set`. + * + * @param {unknown} value The value to check if it is a `Set`. + * @returns {value is Set} Returns `true` if `value` is a `Set`, else `false`. + * + * @example + * const value1 = new Set(); + * const value2 = new Map(); + * const value3 = new WeakSet(); + * + * console.log(isSet(value1)); // true + * console.log(isSet(value2)); // false + * console.log(isSet(value3)); // false + */ +declare function isSet(value?: any): value is Set; + +export { isSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.js new file mode 100644 index 0000000000000000000000000000000000000000..dedbbd6289d73f1bd1e7e138f90b5e3188b1276b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isSet$1 = require('../../predicate/isSet.js'); + +function isSet(value) { + return isSet$1.isSet(value); +} + +exports.isSet = isSet; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0880fa594b96ee92763b5757052026df8d15d2e7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSet.mjs @@ -0,0 +1,7 @@ +import { isSet as isSet$1 } from '../../predicate/isSet.mjs'; + +function isSet(value) { + return isSet$1(value); +} + +export { isSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..72deb4cb2b4d04d8b42b88a28abcd99d136e54d6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is string. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`. + * + * @param {unknown} value The value to check if it is string. + * @returns {value is string} Returns `true` if `value` is a string, else `false`. + * + * @example + * const value1 = 'abc'; + * const value2 = 123; + * const value3 = true; + * + * console.log(isString(value1)); // true + * console.log(isString(value2)); // false + * console.log(isString(value3)); // false + */ +declare function isString(value?: any): value is string; + +export { isString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..72deb4cb2b4d04d8b42b88a28abcd99d136e54d6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is string. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`. + * + * @param {unknown} value The value to check if it is string. + * @returns {value is string} Returns `true` if `value` is a string, else `false`. + * + * @example + * const value1 = 'abc'; + * const value2 = 123; + * const value3 = true; + * + * console.log(isString(value1)); // true + * console.log(isString(value2)); // false + * console.log(isString(value3)); // false + */ +declare function isString(value?: any): value is string; + +export { isString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.js new file mode 100644 index 0000000000000000000000000000000000000000..9169bb4e5bb24b4155cf2124950533342c2329f3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isString(value) { + return typeof value === 'string' || value instanceof String; +} + +exports.isString = isString; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.mjs new file mode 100644 index 0000000000000000000000000000000000000000..da0102ef27c31d223692effdfdb43a583de490ae --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isString.mjs @@ -0,0 +1,5 @@ +function isString(value) { + return typeof value === 'string' || value instanceof String; +} + +export { isString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2028ecfb5a807e6fa17c06357a5906a8426fc735 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.d.mts @@ -0,0 +1,17 @@ +/** + * Check whether a value is a symbol. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`. + * + * @param {unknown} value The value to check. + * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`. + * @example + * isSymbol(Symbol.iterator); + * // => true + * + * isSymbol('abc'); + * // => false + */ +declare function isSymbol(value: any): value is symbol; + +export { isSymbol }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2028ecfb5a807e6fa17c06357a5906a8426fc735 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.d.ts @@ -0,0 +1,17 @@ +/** + * Check whether a value is a symbol. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`. + * + * @param {unknown} value The value to check. + * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`. + * @example + * isSymbol(Symbol.iterator); + * // => true + * + * isSymbol('abc'); + * // => false + */ +declare function isSymbol(value: any): value is symbol; + +export { isSymbol }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.js new file mode 100644 index 0000000000000000000000000000000000000000..0bca74fdbf9ac8d395b8e5cd06790efed1691f2a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isSymbol(value) { + return typeof value === 'symbol' || value instanceof Symbol; +} + +exports.isSymbol = isSymbol; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.mjs new file mode 100644 index 0000000000000000000000000000000000000000..aa7cafd67a691d513c8089dc66af2a02bd3ae3e0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isSymbol.mjs @@ -0,0 +1,5 @@ +function isSymbol(value) { + return typeof value === 'symbol' || value instanceof Symbol; +} + +export { isSymbol }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..18b9e0ee365b086eee2d153ba40f0677b4704aa2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.d.mts @@ -0,0 +1,18 @@ +/** + * Checks if a value is a TypedArray. + * @param {any} x The value to check. + * @returns {boolean} Returns true if `x` is a TypedArray, false otherwise. + * + * @example + * const arr = new Uint8Array([1, 2, 3]); + * isTypedArray(arr); // true + * + * const regularArray = [1, 2, 3]; + * isTypedArray(regularArray); // false + * + * const buffer = new ArrayBuffer(16); + * isTypedArray(buffer); // false + */ +declare function isTypedArray(x: any): boolean; + +export { isTypedArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..18b9e0ee365b086eee2d153ba40f0677b4704aa2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.d.ts @@ -0,0 +1,18 @@ +/** + * Checks if a value is a TypedArray. + * @param {any} x The value to check. + * @returns {boolean} Returns true if `x` is a TypedArray, false otherwise. + * + * @example + * const arr = new Uint8Array([1, 2, 3]); + * isTypedArray(arr); // true + * + * const regularArray = [1, 2, 3]; + * isTypedArray(regularArray); // false + * + * const buffer = new ArrayBuffer(16); + * isTypedArray(buffer); // false + */ +declare function isTypedArray(x: any): boolean; + +export { isTypedArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.js new file mode 100644 index 0000000000000000000000000000000000000000..1b29048a9d5eeee855e4f94226cdb7ce8d754a7e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isTypedArray$1 = require('../../predicate/isTypedArray.js'); + +function isTypedArray(x) { + return isTypedArray$1.isTypedArray(x); +} + +exports.isTypedArray = isTypedArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.mjs new file mode 100644 index 0000000000000000000000000000000000000000..30994e720c2d97c078d3d718500b43304424896a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.mjs @@ -0,0 +1,7 @@ +import { isTypedArray as isTypedArray$1 } from '../../predicate/isTypedArray.mjs'; + +function isTypedArray(x) { + return isTypedArray$1(x); +} + +export { isTypedArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8b88d22c51581e19f2fdf8b3732e1d4342d899cb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.d.mts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is undefined. + * + * This function tests whether the provided value is strictly equal to `undefined`. + * It returns `true` if the value is `undefined`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `undefined`. + * + * @param {any} x - The value to test if it is undefined. + * @returns {x is undefined} true if the value is undefined, false otherwise. + * + * @example + * const value1 = undefined; + * const value2 = null; + * const value3 = 42; + * + * console.log(isUndefined(value1)); // true + * console.log(isUndefined(value2)); // false + * console.log(isUndefined(value3)); // false + */ +declare function isUndefined(x: any): x is undefined; + +export { isUndefined }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8b88d22c51581e19f2fdf8b3732e1d4342d899cb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.d.ts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is undefined. + * + * This function tests whether the provided value is strictly equal to `undefined`. + * It returns `true` if the value is `undefined`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `undefined`. + * + * @param {any} x - The value to test if it is undefined. + * @returns {x is undefined} true if the value is undefined, false otherwise. + * + * @example + * const value1 = undefined; + * const value2 = null; + * const value3 = 42; + * + * console.log(isUndefined(value1)); // true + * console.log(isUndefined(value2)); // false + * console.log(isUndefined(value3)); // false + */ +declare function isUndefined(x: any): x is undefined; + +export { isUndefined }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.js new file mode 100644 index 0000000000000000000000000000000000000000..e00c0b836c8ca0935b0685e89a708d26815e3008 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isUndefined$1 = require('../../predicate/isUndefined.js'); + +function isUndefined(x) { + return isUndefined$1.isUndefined(x); +} + +exports.isUndefined = isUndefined; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.mjs new file mode 100644 index 0000000000000000000000000000000000000000..609ad222db22ba43e23a3e2066716455feb6d121 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isUndefined.mjs @@ -0,0 +1,7 @@ +import { isUndefined as isUndefined$1 } from '../../predicate/isUndefined.mjs'; + +function isUndefined(x) { + return isUndefined$1(x); +} + +export { isUndefined }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8b61fedcb73db365fd16eaea50ef2a7ab3f06a5b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.d.mts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is a `WeakMap`. + * + * This function tests whether the provided value is an instance of `WeakMap`. + * It returns `true` if the value is a `WeakMap`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `WeakMap`. + * + * @param {unknown} value - The value to test if it is a `WeakMap`. + * @returns {value is WeakMap} true if the value is a `WeakMap`, false otherwise. + * + * @example + * const value1 = new WeakMap(); + * const value2 = new Map(); + * const value3 = new Set(); + * + * console.log(isWeakMap(value1)); // true + * console.log(isWeakMap(value2)); // false + * console.log(isWeakMap(value3)); // false + */ +declare function isWeakMap(value?: any): value is WeakMap; + +export { isWeakMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8b61fedcb73db365fd16eaea50ef2a7ab3f06a5b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.d.ts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is a `WeakMap`. + * + * This function tests whether the provided value is an instance of `WeakMap`. + * It returns `true` if the value is a `WeakMap`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `WeakMap`. + * + * @param {unknown} value - The value to test if it is a `WeakMap`. + * @returns {value is WeakMap} true if the value is a `WeakMap`, false otherwise. + * + * @example + * const value1 = new WeakMap(); + * const value2 = new Map(); + * const value3 = new Set(); + * + * console.log(isWeakMap(value1)); // true + * console.log(isWeakMap(value2)); // false + * console.log(isWeakMap(value3)); // false + */ +declare function isWeakMap(value?: any): value is WeakMap; + +export { isWeakMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.js new file mode 100644 index 0000000000000000000000000000000000000000..1eb7b6b4de8b7472153442b36fc2824b943bcd4d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isWeakMap$1 = require('../../predicate/isWeakMap.js'); + +function isWeakMap(value) { + return isWeakMap$1.isWeakMap(value); +} + +exports.isWeakMap = isWeakMap; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f6f3e58bc6881a430f4af262a60d166428fd28a5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakMap.mjs @@ -0,0 +1,7 @@ +import { isWeakMap as isWeakMap$1 } from '../../predicate/isWeakMap.mjs'; + +function isWeakMap(value) { + return isWeakMap$1(value); +} + +export { isWeakMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1209380422405f83e210b28bd6e8b7b41da70b90 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.d.mts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is a `WeakSet`. + * + * This function tests whether the provided value is an instance of `WeakSet`. + * It returns `true` if the value is a `WeakSet`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `WeakSet`. + * + * @param {unknown} value - The value to test if it is a `WeakSet`. + * @returns {value is WeakSet} true if the value is a `WeakSet`, false otherwise. + * + * @example + * const value1 = new WeakSet(); + * const value2 = new Map(); + * const value3 = new Set(); + * + * console.log(isWeakSet(value1)); // true + * console.log(isWeakSet(value2)); // false + * console.log(isWeakSet(value3)); // false + */ +declare function isWeakSet(value?: any): value is WeakSet; + +export { isWeakSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1209380422405f83e210b28bd6e8b7b41da70b90 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.d.ts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is a `WeakSet`. + * + * This function tests whether the provided value is an instance of `WeakSet`. + * It returns `true` if the value is a `WeakSet`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `WeakSet`. + * + * @param {unknown} value - The value to test if it is a `WeakSet`. + * @returns {value is WeakSet} true if the value is a `WeakSet`, false otherwise. + * + * @example + * const value1 = new WeakSet(); + * const value2 = new Map(); + * const value3 = new Set(); + * + * console.log(isWeakSet(value1)); // true + * console.log(isWeakSet(value2)); // false + * console.log(isWeakSet(value3)); // false + */ +declare function isWeakSet(value?: any): value is WeakSet; + +export { isWeakSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.js new file mode 100644 index 0000000000000000000000000000000000000000..607aadbb027f3c2b2e9a5e25dbaa677d6d305d9e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isWeakSet$1 = require('../../predicate/isWeakSet.js'); + +function isWeakSet(value) { + return isWeakSet$1.isWeakSet(value); +} + +exports.isWeakSet = isWeakSet; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5b9cd1a3d8742db2b3e85ac70db0d31c564cbc85 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/isWeakSet.mjs @@ -0,0 +1,7 @@ +import { isWeakSet as isWeakSet$1 } from '../../predicate/isWeakSet.mjs'; + +function isWeakSet(value) { + return isWeakSet$1(value); +} + +export { isWeakSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9ede84b734f6ad26ee690d2e1eda0e04fb4de42b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.d.mts @@ -0,0 +1,29 @@ +/** + * Creates a function that performs a deep comparison between a given target and the source object. + * + * @template T + * @param {T} source - The source object to create the matcher from. + * @returns {(value: any) => boolean} Returns a function that takes a target object and returns `true` if the target matches the source, otherwise `false`. + * + * @example + * const matcher = matches({ a: 1, b: 2 }); + * matcher({ a: 1, b: 2, c: 3 }); // true + * matcher({ a: 1, c: 3 }); // false + */ +declare function matches(source: T): (value: any) => boolean; +/** + * Creates a function that performs a deep comparison between a given target and the source object. + * + * @template T + * @template V + * @param {T} source - The source object to create the matcher from. + * @returns {(value: V) => boolean} Returns a function that takes a target object and returns `true` if the target matches the source, otherwise `false`. + * + * @example + * const matcher = matches<{ a: number }, { a: number; b?: number }>({ a: 1 }); + * matcher({ a: 1, b: 2 }); // true + * matcher({ a: 2 }); // false + */ +declare function matches(source: T): (value: V) => boolean; + +export { matches }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9ede84b734f6ad26ee690d2e1eda0e04fb4de42b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.d.ts @@ -0,0 +1,29 @@ +/** + * Creates a function that performs a deep comparison between a given target and the source object. + * + * @template T + * @param {T} source - The source object to create the matcher from. + * @returns {(value: any) => boolean} Returns a function that takes a target object and returns `true` if the target matches the source, otherwise `false`. + * + * @example + * const matcher = matches({ a: 1, b: 2 }); + * matcher({ a: 1, b: 2, c: 3 }); // true + * matcher({ a: 1, c: 3 }); // false + */ +declare function matches(source: T): (value: any) => boolean; +/** + * Creates a function that performs a deep comparison between a given target and the source object. + * + * @template T + * @template V + * @param {T} source - The source object to create the matcher from. + * @returns {(value: V) => boolean} Returns a function that takes a target object and returns `true` if the target matches the source, otherwise `false`. + * + * @example + * const matcher = matches<{ a: number }, { a: number; b?: number }>({ a: 1 }); + * matcher({ a: 1, b: 2 }); // true + * matcher({ a: 2 }); // false + */ +declare function matches(source: T): (value: V) => boolean; + +export { matches }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.js new file mode 100644 index 0000000000000000000000000000000000000000..8aaf7d80dd3f71655fe380a086d39f66f35abbf9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isMatch = require('./isMatch.js'); +const cloneDeep = require('../../object/cloneDeep.js'); + +function matches(source) { + source = cloneDeep.cloneDeep(source); + return (target) => { + return isMatch.isMatch(target, source); + }; +} + +exports.matches = matches; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a27a1706cb61730f0f4e0047313568f78850b2ec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matches.mjs @@ -0,0 +1,11 @@ +import { isMatch } from './isMatch.mjs'; +import { cloneDeep } from '../../object/cloneDeep.mjs'; + +function matches(source) { + source = cloneDeep(source); + return (target) => { + return isMatch(target, source); + }; +} + +export { matches }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6213c6e0fdc565b1da824b90a41b6aa0c6ef7913 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.d.mts @@ -0,0 +1,38 @@ +import { PropertyPath } from '../_internal/PropertyPath.mjs'; + +/** + * Creates a function that checks if a given target object matches a specific property value. + * + * @template T + * @template V + * @param {PropertyPath} path - The property path to check within the target object. + * @param {T} srcValue - The value to compare against the property value in the target object. + * @returns {(value: any) => boolean} Returns a function that takes a target object and returns + * `true` if the property value at the given path in the target object matches the provided value, + * otherwise returns `false`. + * + * @example + * const checkName = matchesProperty('name', 'Alice'); + * console.log(checkName({ name: 'Alice' })); // true + * console.log(checkName({ name: 'Bob' })); // false + */ +declare function matchesProperty(path: PropertyPath, srcValue: T): (value: any) => boolean; +/** + * Creates a function that checks if a given target object matches a specific property value. + * + * @template T + * @template V + * @param {PropertyPath} path - The property path to check within the target object. + * @param {T} srcValue - The value to compare against the property value in the target object. + * @returns {(value: V) => boolean} Returns a function that takes a target object and returns + * `true` if the property value at the given path in the target object matches the provided value, + * otherwise returns `false`. + * + * @example + * const checkNested = matchesProperty(['address', 'city'], 'New York'); + * console.log(checkNested({ address: { city: 'New York' } })); // true + * console.log(checkNested({ address: { city: 'Los Angeles' } })); // false + */ +declare function matchesProperty(path: PropertyPath, srcValue: T): (value: V) => boolean; + +export { matchesProperty }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1ae67f289dcc9bd5dcdb2d327448bdb1484dc95e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.d.ts @@ -0,0 +1,38 @@ +import { PropertyPath } from '../_internal/PropertyPath.js'; + +/** + * Creates a function that checks if a given target object matches a specific property value. + * + * @template T + * @template V + * @param {PropertyPath} path - The property path to check within the target object. + * @param {T} srcValue - The value to compare against the property value in the target object. + * @returns {(value: any) => boolean} Returns a function that takes a target object and returns + * `true` if the property value at the given path in the target object matches the provided value, + * otherwise returns `false`. + * + * @example + * const checkName = matchesProperty('name', 'Alice'); + * console.log(checkName({ name: 'Alice' })); // true + * console.log(checkName({ name: 'Bob' })); // false + */ +declare function matchesProperty(path: PropertyPath, srcValue: T): (value: any) => boolean; +/** + * Creates a function that checks if a given target object matches a specific property value. + * + * @template T + * @template V + * @param {PropertyPath} path - The property path to check within the target object. + * @param {T} srcValue - The value to compare against the property value in the target object. + * @returns {(value: V) => boolean} Returns a function that takes a target object and returns + * `true` if the property value at the given path in the target object matches the provided value, + * otherwise returns `false`. + * + * @example + * const checkNested = matchesProperty(['address', 'city'], 'New York'); + * console.log(checkNested({ address: { city: 'New York' } })); // true + * console.log(checkNested({ address: { city: 'Los Angeles' } })); // false + */ +declare function matchesProperty(path: PropertyPath, srcValue: T): (value: V) => boolean; + +export { matchesProperty }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.js new file mode 100644 index 0000000000000000000000000000000000000000..9d9f99c336ea6adaca9c5cbc524cb60ad12f7414 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isMatch = require('./isMatch.js'); +const toKey = require('../_internal/toKey.js'); +const cloneDeep = require('../object/cloneDeep.js'); +const get = require('../object/get.js'); +const has = require('../object/has.js'); + +function matchesProperty(property, source) { + switch (typeof property) { + case 'object': { + if (Object.is(property?.valueOf(), -0)) { + property = '-0'; + } + break; + } + case 'number': { + property = toKey.toKey(property); + break; + } + } + source = cloneDeep.cloneDeep(source); + return function (target) { + const result = get.get(target, property); + if (result === undefined) { + return has.has(target, property); + } + if (source === undefined) { + return result === undefined; + } + return isMatch.isMatch(result, source); + }; +} + +exports.matchesProperty = matchesProperty; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.mjs new file mode 100644 index 0000000000000000000000000000000000000000..314155570ae5c4748f9063209dc0d4d04214fd5c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.mjs @@ -0,0 +1,33 @@ +import { isMatch } from './isMatch.mjs'; +import { toKey } from '../_internal/toKey.mjs'; +import { cloneDeep } from '../object/cloneDeep.mjs'; +import { get } from '../object/get.mjs'; +import { has } from '../object/has.mjs'; + +function matchesProperty(property, source) { + switch (typeof property) { + case 'object': { + if (Object.is(property?.valueOf(), -0)) { + property = '-0'; + } + break; + } + case 'number': { + property = toKey(property); + break; + } + } + source = cloneDeep(source); + return function (target) { + const result = get(target, property); + if (result === undefined) { + return has(target, property); + } + if (source === undefined) { + return result === undefined; + } + return isMatch(result, source); + }; +} + +export { matchesProperty }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a4a63920818838ddfdf05cea0e37adc375178606 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.d.mts @@ -0,0 +1,18 @@ +/** + * Converts a string to camel case. + * + * Camel case is the naming convention in which the first word is written in lowercase and + * each subsequent word begins with a capital letter, concatenated without any separator characters. + * + * @param {string | object} str - The string that is to be changed to camel case. + * @returns {string} - The converted string to camel case. + * + * @example + * const convertedStr1 = camelCase('camelCase') // returns 'camelCase' + * const convertedStr2 = camelCase('some whitespace') // returns 'someWhitespace' + * const convertedStr3 = camelCase('hyphen-text') // returns 'hyphenText' + * const convertedStr4 = camelCase('HTTPRequest') // returns 'httpRequest' + */ +declare function camelCase(str?: string): string; + +export { camelCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a4a63920818838ddfdf05cea0e37adc375178606 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.d.ts @@ -0,0 +1,18 @@ +/** + * Converts a string to camel case. + * + * Camel case is the naming convention in which the first word is written in lowercase and + * each subsequent word begins with a capital letter, concatenated without any separator characters. + * + * @param {string | object} str - The string that is to be changed to camel case. + * @returns {string} - The converted string to camel case. + * + * @example + * const convertedStr1 = camelCase('camelCase') // returns 'camelCase' + * const convertedStr2 = camelCase('some whitespace') // returns 'someWhitespace' + * const convertedStr3 = camelCase('hyphen-text') // returns 'hyphenText' + * const convertedStr4 = camelCase('HTTPRequest') // returns 'httpRequest' + */ +declare function camelCase(str?: string): string; + +export { camelCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.js new file mode 100644 index 0000000000000000000000000000000000000000..ddaa5849a03b1b072396eaf8e65ebf6d46cc0aed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const camelCase$1 = require('../../string/camelCase.js'); +const normalizeForCase = require('../_internal/normalizeForCase.js'); + +function camelCase(str) { + return camelCase$1.camelCase(normalizeForCase.normalizeForCase(str)); +} + +exports.camelCase = camelCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..81c5059944c5e399618549cf9614dff1979ab7c1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/camelCase.mjs @@ -0,0 +1,8 @@ +import { camelCase as camelCase$1 } from '../../string/camelCase.mjs'; +import { normalizeForCase } from '../_internal/normalizeForCase.mjs'; + +function camelCase(str) { + return camelCase$1(normalizeForCase(str)); +} + +export { camelCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..612a54c7287fb7d95d8458e2ca125ecd0422b6cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.d.mts @@ -0,0 +1,14 @@ +/** + * Converts the first character of string to upper case and the remaining to lower case. + * + * @param {string} string - The string to capitalize. + * @returns {string} - The capitalized string. + * + * @example + * const convertedStr1 = capitalize('fred') // returns 'Fred' + * const convertedStr2 = capitalize('FRED') // returns 'Fred' + * const convertedStr3 = capitalize('') // returns '' + */ +declare function capitalize(str?: T): string extends T ? string : Capitalize>; + +export { capitalize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..612a54c7287fb7d95d8458e2ca125ecd0422b6cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.d.ts @@ -0,0 +1,14 @@ +/** + * Converts the first character of string to upper case and the remaining to lower case. + * + * @param {string} string - The string to capitalize. + * @returns {string} - The capitalized string. + * + * @example + * const convertedStr1 = capitalize('fred') // returns 'Fred' + * const convertedStr2 = capitalize('FRED') // returns 'Fred' + * const convertedStr3 = capitalize('') // returns '' + */ +declare function capitalize(str?: T): string extends T ? string : Capitalize>; + +export { capitalize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.js new file mode 100644 index 0000000000000000000000000000000000000000..354c9f807a61604c998294f43aeb3eee176d781d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const capitalize$1 = require('../../string/capitalize.js'); +const toString = require('../util/toString.js'); + +function capitalize(str) { + return capitalize$1.capitalize(toString.toString(str)); +} + +exports.capitalize = capitalize; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.mjs new file mode 100644 index 0000000000000000000000000000000000000000..63d6b9940842d067b3d5c8cdaf994a967aa2ad50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/capitalize.mjs @@ -0,0 +1,8 @@ +import { capitalize as capitalize$1 } from '../../string/capitalize.mjs'; +import { toString } from '../util/toString.mjs'; + +function capitalize(str) { + return capitalize$1(toString(str)); +} + +export { capitalize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..056ab7bad98f07d4028b4632a7187bba4d532d4e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.d.mts @@ -0,0 +1,22 @@ +/** + * Converts a string by replacing special characters and diacritical marks with their ASCII equivalents. + * For example, "Crème brûlée" becomes "Creme brulee". + * + * @param {string} str - The input string to be deburred. + * @returns {string} - The deburred string with special characters replaced by their ASCII equivalents. + * + * @example + * // Basic usage: + * deburr('Æthelred') // returns 'Aethelred' + * + * @example + * // Handling diacritical marks: + * deburr('München') // returns 'Munchen' + * + * @example + * // Special characters: + * deburr('Crème brûlée') // returns 'Creme brulee' + */ +declare function deburr(str?: string): string; + +export { deburr }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..056ab7bad98f07d4028b4632a7187bba4d532d4e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.d.ts @@ -0,0 +1,22 @@ +/** + * Converts a string by replacing special characters and diacritical marks with their ASCII equivalents. + * For example, "Crème brûlée" becomes "Creme brulee". + * + * @param {string} str - The input string to be deburred. + * @returns {string} - The deburred string with special characters replaced by their ASCII equivalents. + * + * @example + * // Basic usage: + * deburr('Æthelred') // returns 'Aethelred' + * + * @example + * // Handling diacritical marks: + * deburr('München') // returns 'Munchen' + * + * @example + * // Special characters: + * deburr('Crème brûlée') // returns 'Creme brulee' + */ +declare function deburr(str?: string): string; + +export { deburr }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.js new file mode 100644 index 0000000000000000000000000000000000000000..272148cbcdb58130ae9d334d5d7b7fc56702f45d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const deburr$1 = require('../../string/deburr.js'); +const toString = require('../util/toString.js'); + +function deburr(str) { + return deburr$1.deburr(toString.toString(str)); +} + +exports.deburr = deburr; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8abdbe4eef22497d1fa0fac003ad905955d77d6a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/deburr.mjs @@ -0,0 +1,8 @@ +import { deburr as deburr$1 } from '../../string/deburr.mjs'; +import { toString } from '../util/toString.mjs'; + +function deburr(str) { + return deburr$1(toString(str)); +} + +export { deburr }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..961aca1dd32d380656035120ed67d544a83ef71f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if a string contains another string at the end of the string. + * + * Checks if one string endsWith another string. Optional position parameter to offset searching before a certain index. + * + * @param {string} str - The string that might contain the target string. + * @param {string} target - The string to search for. + * @param {number} position - An optional position from the start to search up to this index + * @returns {boolean} - True if the str string ends with the target string. + * + * @example + * const isPrefix = endsWith('fooBar', 'foo') // returns true + * const isPrefix = endsWith('fooBar', 'bar') // returns false + * const isPrefix = endsWith('fooBar', 'abc') // returns false + * const isPrefix = endsWith('fooBar', 'foo', 3) // returns true + * const isPrefix = endsWith('fooBar', 'abc', 5) // returns false + */ +declare function endsWith(str?: string, target?: string, position?: number): boolean; + +export { endsWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..961aca1dd32d380656035120ed67d544a83ef71f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if a string contains another string at the end of the string. + * + * Checks if one string endsWith another string. Optional position parameter to offset searching before a certain index. + * + * @param {string} str - The string that might contain the target string. + * @param {string} target - The string to search for. + * @param {number} position - An optional position from the start to search up to this index + * @returns {boolean} - True if the str string ends with the target string. + * + * @example + * const isPrefix = endsWith('fooBar', 'foo') // returns true + * const isPrefix = endsWith('fooBar', 'bar') // returns false + * const isPrefix = endsWith('fooBar', 'abc') // returns false + * const isPrefix = endsWith('fooBar', 'foo', 3) // returns true + * const isPrefix = endsWith('fooBar', 'abc', 5) // returns false + */ +declare function endsWith(str?: string, target?: string, position?: number): boolean; + +export { endsWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.js new file mode 100644 index 0000000000000000000000000000000000000000..6eecf3df66bd3b300485b54aacc57fc0d7e769c9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function endsWith(str, target, position) { + if (str == null || target == null) { + return false; + } + if (position == null) { + position = str.length; + } + return str.endsWith(target, position); +} + +exports.endsWith = endsWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..661bf5bb9d9df635bf115b30f514596643a7419e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/endsWith.mjs @@ -0,0 +1,11 @@ +function endsWith(str, target, position) { + if (str == null || target == null) { + return false; + } + if (position == null) { + position = str.length; + } + return str.endsWith(target, position); +} + +export { endsWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..be0a0b1c304cb0a8b564eb7998c33f9ff1fec00e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.d.mts @@ -0,0 +1,16 @@ +/** + * Converts the characters "&", "<", ">", '"', and "'" in `str` to their corresponding HTML entities. + * For example, "<" becomes "<". + * + * @param {string} str The string to escape. + * @returns {string} Returns the escaped string. + * + * @example + * escape('This is a
element.'); // returns 'This is a <div> element.' + * escape('This is a "quote"'); // returns 'This is a "quote"' + * escape("This is a 'quote'"); // returns 'This is a 'quote'' + * escape('This is a & symbol'); // returns 'This is a & symbol' + */ +declare function escape(string?: string): string; + +export { escape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..be0a0b1c304cb0a8b564eb7998c33f9ff1fec00e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.d.ts @@ -0,0 +1,16 @@ +/** + * Converts the characters "&", "<", ">", '"', and "'" in `str` to their corresponding HTML entities. + * For example, "<" becomes "<". + * + * @param {string} str The string to escape. + * @returns {string} Returns the escaped string. + * + * @example + * escape('This is a
element.'); // returns 'This is a <div> element.' + * escape('This is a "quote"'); // returns 'This is a "quote"' + * escape("This is a 'quote'"); // returns 'This is a 'quote'' + * escape('This is a & symbol'); // returns 'This is a & symbol' + */ +declare function escape(string?: string): string; + +export { escape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.js new file mode 100644 index 0000000000000000000000000000000000000000..5b6a8070b33008fdc1363630983830702dbf8a26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const escape$1 = require('../../string/escape.js'); +const toString = require('../util/toString.js'); + +function escape(string) { + return escape$1.escape(toString.toString(string)); +} + +exports.escape = escape; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d811eb8505ca381df18a591e3612659456c992e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escape.mjs @@ -0,0 +1,8 @@ +import { escape as escape$1 } from '../../string/escape.mjs'; +import { toString } from '../util/toString.mjs'; + +function escape(string) { + return escape$1(toString(string)); +} + +export { escape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..afcd3dac2b0d6e026171b90bca9192a8fb844aad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.d.mts @@ -0,0 +1,14 @@ +/** + * Escapes the RegExp special characters "^", "$", "\\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", and "|" in `str`. + * + * @param {string} str The string to escape. + * @returns {string} Returns the escaped string. + * + * @example + * import { escapeRegExp } from 'es-toolkit/string'; + * + * escapeRegExp('[es-toolkit](https://es-toolkit.dev/)'); // returns '\[es-toolkit\]\(https://es-toolkit\.dev/\)' + */ +declare function escapeRegExp(str?: string): string; + +export { escapeRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..afcd3dac2b0d6e026171b90bca9192a8fb844aad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.d.ts @@ -0,0 +1,14 @@ +/** + * Escapes the RegExp special characters "^", "$", "\\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", and "|" in `str`. + * + * @param {string} str The string to escape. + * @returns {string} Returns the escaped string. + * + * @example + * import { escapeRegExp } from 'es-toolkit/string'; + * + * escapeRegExp('[es-toolkit](https://es-toolkit.dev/)'); // returns '\[es-toolkit\]\(https://es-toolkit\.dev/\)' + */ +declare function escapeRegExp(str?: string): string; + +export { escapeRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.js new file mode 100644 index 0000000000000000000000000000000000000000..1b144aeb8590c9ed8143d9d5eadb1338fb109a4d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const escapeRegExp$1 = require('../../string/escapeRegExp.js'); +const toString = require('../util/toString.js'); + +function escapeRegExp(str) { + return escapeRegExp$1.escapeRegExp(toString.toString(str)); +} + +exports.escapeRegExp = escapeRegExp; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.mjs new file mode 100644 index 0000000000000000000000000000000000000000..030f4f4208da252949cabb4086ba4dbe2f6fad74 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/escapeRegExp.mjs @@ -0,0 +1,8 @@ +import { escapeRegExp as escapeRegExp$1 } from '../../string/escapeRegExp.mjs'; +import { toString } from '../util/toString.mjs'; + +function escapeRegExp(str) { + return escapeRegExp$1(toString(str)); +} + +export { escapeRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..aad91b3a76ee5d5ff5e5ddd600d8e6746590bccf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.d.mts @@ -0,0 +1,17 @@ +/** + * Converts a string to kebab case. + * + * Kebab case is the naming convention in which each word is written in lowercase and separated by a dash (-) character. + * + * @param {string | object} str - The string that is to be changed to kebab case. + * @returns {string} - The converted string to kebab case. + * + * @example + * const convertedStr1 = kebabCase('camelCase') // returns 'camel-case' + * const convertedStr2 = kebabCase('some whitespace') // returns 'some-whitespace' + * const convertedStr3 = kebabCase('hyphen-text') // returns 'hyphen-text' + * const convertedStr4 = kebabCase('HTTPRequest') // returns 'http-request' + */ +declare function kebabCase(str?: string): string; + +export { kebabCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..aad91b3a76ee5d5ff5e5ddd600d8e6746590bccf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.d.ts @@ -0,0 +1,17 @@ +/** + * Converts a string to kebab case. + * + * Kebab case is the naming convention in which each word is written in lowercase and separated by a dash (-) character. + * + * @param {string | object} str - The string that is to be changed to kebab case. + * @returns {string} - The converted string to kebab case. + * + * @example + * const convertedStr1 = kebabCase('camelCase') // returns 'camel-case' + * const convertedStr2 = kebabCase('some whitespace') // returns 'some-whitespace' + * const convertedStr3 = kebabCase('hyphen-text') // returns 'hyphen-text' + * const convertedStr4 = kebabCase('HTTPRequest') // returns 'http-request' + */ +declare function kebabCase(str?: string): string; + +export { kebabCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.js new file mode 100644 index 0000000000000000000000000000000000000000..45884fd31f7e2004965946b22cf69712b3fd2c3f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const kebabCase$1 = require('../../string/kebabCase.js'); +const normalizeForCase = require('../_internal/normalizeForCase.js'); + +function kebabCase(str) { + return kebabCase$1.kebabCase(normalizeForCase.normalizeForCase(str)); +} + +exports.kebabCase = kebabCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b9a6f6279e5ef95fb0cf0e2c05472338c387ffe6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/kebabCase.mjs @@ -0,0 +1,8 @@ +import { kebabCase as kebabCase$1 } from '../../string/kebabCase.mjs'; +import { normalizeForCase } from '../_internal/normalizeForCase.mjs'; + +function kebabCase(str) { + return kebabCase$1(normalizeForCase(str)); +} + +export { kebabCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d01040823b900f36390f3c7d5775b5692ad69379 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.d.mts @@ -0,0 +1,17 @@ +/** + * Converts a string to lower case. + * + * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character. + * + * @param {string | object} str - The string that is to be changed to lower case. + * @returns {string} - The converted string to lower case. + * + * @example + * const convertedStr1 = lowerCase('camelCase') // returns 'camel case' + * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace' + * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text' + * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request' + */ +declare function lowerCase(str?: string): string; + +export { lowerCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d01040823b900f36390f3c7d5775b5692ad69379 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.d.ts @@ -0,0 +1,17 @@ +/** + * Converts a string to lower case. + * + * Lower case is the naming convention in which each word is written in lowercase and separated by an space ( ) character. + * + * @param {string | object} str - The string that is to be changed to lower case. + * @returns {string} - The converted string to lower case. + * + * @example + * const convertedStr1 = lowerCase('camelCase') // returns 'camel case' + * const convertedStr2 = lowerCase('some whitespace') // returns 'some whitespace' + * const convertedStr3 = lowerCase('hyphen-text') // returns 'hyphen text' + * const convertedStr4 = lowerCase('HTTPRequest') // returns 'http request' + */ +declare function lowerCase(str?: string): string; + +export { lowerCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.js new file mode 100644 index 0000000000000000000000000000000000000000..76c2eb74d906e39fd2b04d4c9ae0e67b0a3fd9ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const lowerCase$1 = require('../../string/lowerCase.js'); +const normalizeForCase = require('../_internal/normalizeForCase.js'); + +function lowerCase(str) { + return lowerCase$1.lowerCase(normalizeForCase.normalizeForCase(str)); +} + +exports.lowerCase = lowerCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d0b1535d4a8e022cc98a3f38bb3ad980f84f79a9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerCase.mjs @@ -0,0 +1,8 @@ +import { lowerCase as lowerCase$1 } from '../../string/lowerCase.mjs'; +import { normalizeForCase } from '../_internal/normalizeForCase.mjs'; + +function lowerCase(str) { + return lowerCase$1(normalizeForCase(str)); +} + +export { lowerCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..566875f1acc1492e0cea07458c9d1326ae237fc5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.d.mts @@ -0,0 +1,14 @@ +/** + * Converts the first character of string to lower case. + * + * @param {string} str - The string that is to be changed + * @returns {string} - The converted string. + * + * @example + * const convertedStr1 = lowerCase('fred') // returns 'fred' + * const convertedStr2 = lowerCase('Fred') // returns 'fred' + * const convertedStr3 = lowerCase('FRED') // returns 'fRED' + */ +declare function lowerFirst(str?: T): Uncapitalize; + +export { lowerFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..566875f1acc1492e0cea07458c9d1326ae237fc5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.d.ts @@ -0,0 +1,14 @@ +/** + * Converts the first character of string to lower case. + * + * @param {string} str - The string that is to be changed + * @returns {string} - The converted string. + * + * @example + * const convertedStr1 = lowerCase('fred') // returns 'fred' + * const convertedStr2 = lowerCase('Fred') // returns 'fred' + * const convertedStr3 = lowerCase('FRED') // returns 'fRED' + */ +declare function lowerFirst(str?: T): Uncapitalize; + +export { lowerFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.js new file mode 100644 index 0000000000000000000000000000000000000000..110c7bc42db17bb43f6e0d49ae5a4e16bf3e5c30 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const lowerFirst$1 = require('../../string/lowerFirst.js'); +const toString = require('../util/toString.js'); + +function lowerFirst(str) { + return lowerFirst$1.lowerFirst(toString.toString(str)); +} + +exports.lowerFirst = lowerFirst; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a88520553366778ad51e4fccb73e320a3a9748ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/lowerFirst.mjs @@ -0,0 +1,8 @@ +import { lowerFirst as lowerFirst$1 } from '../../string/lowerFirst.mjs'; +import { toString } from '../util/toString.mjs'; + +function lowerFirst(str) { + return lowerFirst$1(toString(str)); +} + +export { lowerFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..47fda5d48777be57f0426ca14b8c7c1b3872e351 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.d.mts @@ -0,0 +1,19 @@ +/** + * Pads string on the left and right sides if it's shorter than length. Padding characters are truncated if they can't be evenly divided by length. + * If the length is less than or equal to the original string's length, or if the padding character is an empty string, the original string is returned unchanged. + * + * @param {string} str - The string to pad. + * @param {number} [length] - The length of the resulting string once padded. + * @param {string} [chars] - The character(s) to use for padding. + * @returns {string} - The padded string, or the original string if padding is not required. + * + * @example + * const result1 = pad('abc', 8); // result will be ' abc ' + * const result2 = pad('abc', 8, '_-'); // result will be '_-abc_-_' + * const result3 = pad('abc', 3); // result will be 'abc' + * const result4 = pad('abc', 2); // result will be 'abc' + * + */ +declare function pad(str?: string, length?: number, chars?: string): string; + +export { pad }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..47fda5d48777be57f0426ca14b8c7c1b3872e351 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.d.ts @@ -0,0 +1,19 @@ +/** + * Pads string on the left and right sides if it's shorter than length. Padding characters are truncated if they can't be evenly divided by length. + * If the length is less than or equal to the original string's length, or if the padding character is an empty string, the original string is returned unchanged. + * + * @param {string} str - The string to pad. + * @param {number} [length] - The length of the resulting string once padded. + * @param {string} [chars] - The character(s) to use for padding. + * @returns {string} - The padded string, or the original string if padding is not required. + * + * @example + * const result1 = pad('abc', 8); // result will be ' abc ' + * const result2 = pad('abc', 8, '_-'); // result will be '_-abc_-_' + * const result3 = pad('abc', 3); // result will be 'abc' + * const result4 = pad('abc', 2); // result will be 'abc' + * + */ +declare function pad(str?: string, length?: number, chars?: string): string; + +export { pad }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.js new file mode 100644 index 0000000000000000000000000000000000000000..a926bab12e76b895bdbc47fb00a5e544c2901692 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const pad$1 = require('../../string/pad.js'); +const toString = require('../util/toString.js'); + +function pad(str, length, chars) { + return pad$1.pad(toString.toString(str), length, chars); +} + +exports.pad = pad; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1d7cfecf1ae452e99d80ca92a4f55210c32bdc9f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/pad.mjs @@ -0,0 +1,8 @@ +import { pad as pad$1 } from '../../string/pad.mjs'; +import { toString } from '../util/toString.mjs'; + +function pad(str, length, chars) { + return pad$1(toString(str), length, chars); +} + +export { pad }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c0e7509a35a2c653f0b81a4fa3491fac9d536541 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.d.mts @@ -0,0 +1,20 @@ +/** + * Pads the end of a string with a given character until it reaches the specified length. + * + * If the length is less than or equal to the original string's length, or if the padding character is an empty string, + * the original string is returned unchanged. + * + * @param {string} str - The string to pad. + * @param {number} [length] - The length of the resulting string once padded. + * @param {string} [chars] - The character(s) to use for padding. + * @returns {string} - The padded string, or the original string if padding is not required. + * + * @example + * const result1 = padEnd('abc', 6); // result will be 'abc ' + * const result2 = padEnd('abc', 6, '_-'); // result will be 'abc_-_' + * const result3 = padEnd('abc', 3); // result will be 'abc' + * const result4 = padEnd('abc', 2); // result will be 'abc' + */ +declare function padEnd(str?: string, length?: number, chars?: string): string; + +export { padEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c0e7509a35a2c653f0b81a4fa3491fac9d536541 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.d.ts @@ -0,0 +1,20 @@ +/** + * Pads the end of a string with a given character until it reaches the specified length. + * + * If the length is less than or equal to the original string's length, or if the padding character is an empty string, + * the original string is returned unchanged. + * + * @param {string} str - The string to pad. + * @param {number} [length] - The length of the resulting string once padded. + * @param {string} [chars] - The character(s) to use for padding. + * @returns {string} - The padded string, or the original string if padding is not required. + * + * @example + * const result1 = padEnd('abc', 6); // result will be 'abc ' + * const result2 = padEnd('abc', 6, '_-'); // result will be 'abc_-_' + * const result3 = padEnd('abc', 3); // result will be 'abc' + * const result4 = padEnd('abc', 2); // result will be 'abc' + */ +declare function padEnd(str?: string, length?: number, chars?: string): string; + +export { padEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.js new file mode 100644 index 0000000000000000000000000000000000000000..8c1f9bf7ac42d106f987944fb0d7736e05ae3242 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toString = require('../util/toString.js'); + +function padEnd(str, length = 0, chars = ' ') { + return toString.toString(str).padEnd(length, chars); +} + +exports.padEnd = padEnd; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7156646e9ecfcc365b3b635e8ced9694e4ea7c9d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padEnd.mjs @@ -0,0 +1,7 @@ +import { toString } from '../util/toString.mjs'; + +function padEnd(str, length = 0, chars = ' ') { + return toString(str).padEnd(length, chars); +} + +export { padEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5c8e06b5d009e39a2c93a73c175c338100ffab32 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.d.mts @@ -0,0 +1,20 @@ +/** + * Pads the start of a string with a given character until it reaches the specified length. + * + * If the length is less than or equal to the original string's length, or if the padding character is an empty string, + * the original string is returned unchanged. + * + * @param {string} str - The string to pad. + * @param {number} [length] - The length of the resulting string once padded. + * @param {string} [chars] - The character(s) to use for padding. + * @returns {string} - The padded string, or the original string if padding is not required. + * + * @example + * const result1 = padStart('abc', 6); // result will be ' abc' + * const result2 = padStart('abc', 6, '_-'); // result will be '_-_abc' + * const result3 = padStart('abc', 3); // result will be 'abc' + * const result4 = padStart('abc', 2); // result will be 'abc' + */ +declare function padStart(str?: string, length?: number, chars?: string): string; + +export { padStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5c8e06b5d009e39a2c93a73c175c338100ffab32 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.d.ts @@ -0,0 +1,20 @@ +/** + * Pads the start of a string with a given character until it reaches the specified length. + * + * If the length is less than or equal to the original string's length, or if the padding character is an empty string, + * the original string is returned unchanged. + * + * @param {string} str - The string to pad. + * @param {number} [length] - The length of the resulting string once padded. + * @param {string} [chars] - The character(s) to use for padding. + * @returns {string} - The padded string, or the original string if padding is not required. + * + * @example + * const result1 = padStart('abc', 6); // result will be ' abc' + * const result2 = padStart('abc', 6, '_-'); // result will be '_-_abc' + * const result3 = padStart('abc', 3); // result will be 'abc' + * const result4 = padStart('abc', 2); // result will be 'abc' + */ +declare function padStart(str?: string, length?: number, chars?: string): string; + +export { padStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.js new file mode 100644 index 0000000000000000000000000000000000000000..ab43bfae61005eba7ab773e5ed15ab57759c20ae --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toString = require('../util/toString.js'); + +function padStart(str, length = 0, chars = ' ') { + return toString.toString(str).padStart(length, chars); +} + +exports.padStart = padStart; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7e0259151a4ff351e8ba824336c4e9332f41b1a7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/padStart.mjs @@ -0,0 +1,7 @@ +import { toString } from '../util/toString.mjs'; + +function padStart(str, length = 0, chars = ' ') { + return toString(str).padStart(length, chars); +} + +export { padStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..3016ec8c4b7108769a62110536005877d20b5077 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.d.mts @@ -0,0 +1,17 @@ +/** + * Repeats the given string n times. + * + * If n is less than 1, an empty string is returned, or if the string is an empty string, + * the original string is returned unchanged. + * + * @param {string} str - The string to repeat. + * @param {number} n - The number of times to repeat the string. + * @returns {string} - The repeated string, or an empty string if n is less than 1. + * + * @example + * repeat('abc', 0); // '' + * repeat('abc', 2); // 'abcabc' + */ +declare function repeat(str?: string, n?: number): string; + +export { repeat }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3016ec8c4b7108769a62110536005877d20b5077 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.d.ts @@ -0,0 +1,17 @@ +/** + * Repeats the given string n times. + * + * If n is less than 1, an empty string is returned, or if the string is an empty string, + * the original string is returned unchanged. + * + * @param {string} str - The string to repeat. + * @param {number} n - The number of times to repeat the string. + * @returns {string} - The repeated string, or an empty string if n is less than 1. + * + * @example + * repeat('abc', 0); // '' + * repeat('abc', 2); // 'abcabc' + */ +declare function repeat(str?: string, n?: number): string; + +export { repeat }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.js new file mode 100644 index 0000000000000000000000000000000000000000..ba91fa8e9b39a87d918a0ba4bdef7967cde7490d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isIterateeCall = require('../_internal/isIterateeCall.js'); +const toInteger = require('../util/toInteger.js'); +const toString = require('../util/toString.js'); + +function repeat(str, n, guard) { + if (guard ? isIterateeCall.isIterateeCall(str, n, guard) : n === undefined) { + n = 1; + } + else { + n = toInteger.toInteger(n); + } + return toString.toString(str).repeat(n); +} + +exports.repeat = repeat; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.mjs new file mode 100644 index 0000000000000000000000000000000000000000..de62fd415b54ee9a867b7f23aa8be119900d5b4a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/repeat.mjs @@ -0,0 +1,15 @@ +import { isIterateeCall } from '../_internal/isIterateeCall.mjs'; +import { toInteger } from '../util/toInteger.mjs'; +import { toString } from '../util/toString.mjs'; + +function repeat(str, n, guard) { + if (guard ? isIterateeCall(str, n, guard) : n === undefined) { + n = 1; + } + else { + n = toInteger(n); + } + return toString(str).repeat(n); +} + +export { repeat }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9f4809feabdf808191fa58bd682d76dc4044f542 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.d.mts @@ -0,0 +1,5 @@ +type ReplaceFunction = (match: string, ...args: any[]) => string; +declare function replace(string: string, pattern: RegExp | string, replacement: ReplaceFunction | string): string; +declare function replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string; + +export { replace }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f4809feabdf808191fa58bd682d76dc4044f542 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.d.ts @@ -0,0 +1,5 @@ +type ReplaceFunction = (match: string, ...args: any[]) => string; +declare function replace(string: string, pattern: RegExp | string, replacement: ReplaceFunction | string): string; +declare function replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string; + +export { replace }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.js new file mode 100644 index 0000000000000000000000000000000000000000..cc075c2ea10ca25d9ae7848885cf52b602ca0a54 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toString = require('../util/toString.js'); + +function replace(target, pattern, replacement) { + if (arguments.length < 3) { + return toString.toString(target); + } + return toString.toString(target).replace(pattern, replacement); +} + +exports.replace = replace; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1df5399946b055923ae4141570c7b3b04e2aa67d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/replace.mjs @@ -0,0 +1,10 @@ +import { toString } from '../util/toString.mjs'; + +function replace(target, pattern, replacement) { + if (arguments.length < 3) { + return toString(target); + } + return toString(target).replace(pattern, replacement); +} + +export { replace }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..edab133de6f72acde7802a66d35faba1928dbf6d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.d.mts @@ -0,0 +1,17 @@ +/** + * Converts a string to snake case. + * + * Snake case is the naming convention in which each word is written in lowercase and separated by an underscore (_) character. + * + * @param {string | object} str - The string that is to be changed to snake case. + * @returns {string} - The converted string to snake case. + * + * @example + * const convertedStr1 = snakeCase('camelCase') // returns 'camel_case' + * const convertedStr2 = snakeCase('some whitespace') // returns 'some_whitespace' + * const convertedStr3 = snakeCase('hyphen-text') // returns 'hyphen_text' + * const convertedStr4 = snakeCase('HTTPRequest') // returns 'http_request' + */ +declare function snakeCase(str?: string): string; + +export { snakeCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..edab133de6f72acde7802a66d35faba1928dbf6d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.d.ts @@ -0,0 +1,17 @@ +/** + * Converts a string to snake case. + * + * Snake case is the naming convention in which each word is written in lowercase and separated by an underscore (_) character. + * + * @param {string | object} str - The string that is to be changed to snake case. + * @returns {string} - The converted string to snake case. + * + * @example + * const convertedStr1 = snakeCase('camelCase') // returns 'camel_case' + * const convertedStr2 = snakeCase('some whitespace') // returns 'some_whitespace' + * const convertedStr3 = snakeCase('hyphen-text') // returns 'hyphen_text' + * const convertedStr4 = snakeCase('HTTPRequest') // returns 'http_request' + */ +declare function snakeCase(str?: string): string; + +export { snakeCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.js new file mode 100644 index 0000000000000000000000000000000000000000..acb6d989c00b19324c6d097ba69e9bbdcaaf00ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const snakeCase$1 = require('../../string/snakeCase.js'); +const normalizeForCase = require('../_internal/normalizeForCase.js'); + +function snakeCase(str) { + return snakeCase$1.snakeCase(normalizeForCase.normalizeForCase(str)); +} + +exports.snakeCase = snakeCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..37de21ee4918a929d3edd9bf11b572f9a862e68c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/snakeCase.mjs @@ -0,0 +1,8 @@ +import { snakeCase as snakeCase$1 } from '../../string/snakeCase.mjs'; +import { normalizeForCase } from '../_internal/normalizeForCase.mjs'; + +function snakeCase(str) { + return snakeCase$1(normalizeForCase(str)); +} + +export { snakeCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a24a95fcc1579c4d8faf4f9f916a22eb6008319d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.d.mts @@ -0,0 +1,36 @@ +/** + * Splits the input string by the specified `separator` + * and returns a new array containing the split segments. + * + * @param {string | null | undefined} [string=''] The string to split. + * @param {RegExp|string} [separator] The separator pattern to split by. + * @param {number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * + * @example + * split('a-b-c', '-'); + * // => ['a', 'b', 'c'] + * + * split('a-b-c', '-', 2); + * // => ['a', 'b'] + */ +declare function split(string: string | null | undefined, separator?: RegExp | string, limit?: number): string[]; +/** + * Splits the input string by the specified `separator` + * and returns a new array containing the split segments. + * + * @param {string | null | undefined} [string=''] The string to split. + * @param {RegExp|string} [separator] The separator pattern to split by. + * @param {number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * + * @example + * split('a-b-c', '-'); + * // => ['a', 'b', 'c'] + * + * split('a-b-c', '-', 2); + * // => ['a', 'b'] + */ +declare function split(string: string | null | undefined, index: string | number, guard: object): string[]; + +export { split }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a24a95fcc1579c4d8faf4f9f916a22eb6008319d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.d.ts @@ -0,0 +1,36 @@ +/** + * Splits the input string by the specified `separator` + * and returns a new array containing the split segments. + * + * @param {string | null | undefined} [string=''] The string to split. + * @param {RegExp|string} [separator] The separator pattern to split by. + * @param {number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * + * @example + * split('a-b-c', '-'); + * // => ['a', 'b', 'c'] + * + * split('a-b-c', '-', 2); + * // => ['a', 'b'] + */ +declare function split(string: string | null | undefined, separator?: RegExp | string, limit?: number): string[]; +/** + * Splits the input string by the specified `separator` + * and returns a new array containing the split segments. + * + * @param {string | null | undefined} [string=''] The string to split. + * @param {RegExp|string} [separator] The separator pattern to split by. + * @param {number} [limit] The length to truncate results to. + * @returns {Array} Returns the string segments. + * + * @example + * split('a-b-c', '-'); + * // => ['a', 'b', 'c'] + * + * split('a-b-c', '-', 2); + * // => ['a', 'b'] + */ +declare function split(string: string | null | undefined, index: string | number, guard: object): string[]; + +export { split }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.js new file mode 100644 index 0000000000000000000000000000000000000000..06d9e9165037985572beb654eeca4d2b113cb44d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toString = require('../util/toString.js'); + +function split(string, separator, limit) { + return toString.toString(string).split(separator, limit); +} + +exports.split = split; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5dd06cdb551a1e773bafb5ec280856c98d007e16 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/split.mjs @@ -0,0 +1,7 @@ +import { toString } from '../util/toString.mjs'; + +function split(string, separator, limit) { + return toString(string).split(separator, limit); +} + +export { split }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e393aa25d3a5e45f956cd339abc2c09739376185 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.d.mts @@ -0,0 +1,16 @@ +/** + * Converts the first character of each word in a string to uppercase and the remaining characters to lowercase. + * + * Start case is the naming convention in which each word is written with an initial capital letter. + * @param {string | object} str - The string to convert. + * @returns {string} The converted string. + * + * @example + * const result1 = startCase('hello world'); // result will be 'Hello World' + * const result2 = startCase('HELLO WORLD'); // result will be 'HELLO WORLD' + * const result3 = startCase('hello-world'); // result will be 'Hello World' + * const result4 = startCase('hello_world'); // result will be 'Hello World' + */ +declare function startCase(str?: string): string; + +export { startCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e393aa25d3a5e45f956cd339abc2c09739376185 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.d.ts @@ -0,0 +1,16 @@ +/** + * Converts the first character of each word in a string to uppercase and the remaining characters to lowercase. + * + * Start case is the naming convention in which each word is written with an initial capital letter. + * @param {string | object} str - The string to convert. + * @returns {string} The converted string. + * + * @example + * const result1 = startCase('hello world'); // result will be 'Hello World' + * const result2 = startCase('HELLO WORLD'); // result will be 'HELLO WORLD' + * const result3 = startCase('hello-world'); // result will be 'Hello World' + * const result4 = startCase('hello_world'); // result will be 'Hello World' + */ +declare function startCase(str?: string): string; + +export { startCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.js new file mode 100644 index 0000000000000000000000000000000000000000..9bf0f1953883af3bdacd4722bea723bb6b165ba5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const words = require('../../string/words.js'); +const normalizeForCase = require('../_internal/normalizeForCase.js'); + +function startCase(str) { + const words$1 = words.words(normalizeForCase.normalizeForCase(str).trim()); + let result = ''; + for (let i = 0; i < words$1.length; i++) { + const word = words$1[i]; + if (result) { + result += ' '; + } + if (word === word.toUpperCase()) { + result += word; + } + else { + result += word[0].toUpperCase() + word.slice(1).toLowerCase(); + } + } + return result; +} + +exports.startCase = startCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6cea5a2c76af54a69aec061aa00a22c947125493 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startCase.mjs @@ -0,0 +1,22 @@ +import { words } from '../../string/words.mjs'; +import { normalizeForCase } from '../_internal/normalizeForCase.mjs'; + +function startCase(str) { + const words$1 = words(normalizeForCase(str).trim()); + let result = ''; + for (let i = 0; i < words$1.length; i++) { + const word = words$1[i]; + if (result) { + result += ' '; + } + if (word === word.toUpperCase()) { + result += word; + } + else { + result += word[0].toUpperCase() + word.slice(1).toLowerCase(); + } + } + return result; +} + +export { startCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..63b61de79c1916cabb8b85a0a4c4e142b98a5a20 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if a string contains another string at the beginning of the string. + * + * Checks if one string startsWith another string. Optional position parameter to start searching from a certain index. + * + * @param {string} str - The string that might contain the target string. + * @param {string} target - The string to search for. + * @param {number} position - An optional offset to start searching in the str string + * @returns {boolean} - True if the str string starts with the target string. + * + * @example + * const isPrefix = startsWith('fooBar', 'foo') // returns true + * const isPrefix = startsWith('fooBar', 'bar') // returns false + * const isPrefix = startsWith('fooBar', 'abc') // returns false + * const isPrefix = startsWith('fooBar', 'Bar', 2) // returns true + * const isPrefix = startsWith('fooBar', 'Bar', 5) // returns false + */ +declare function startsWith(str?: string, target?: string, position?: number): boolean; + +export { startsWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..63b61de79c1916cabb8b85a0a4c4e142b98a5a20 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if a string contains another string at the beginning of the string. + * + * Checks if one string startsWith another string. Optional position parameter to start searching from a certain index. + * + * @param {string} str - The string that might contain the target string. + * @param {string} target - The string to search for. + * @param {number} position - An optional offset to start searching in the str string + * @returns {boolean} - True if the str string starts with the target string. + * + * @example + * const isPrefix = startsWith('fooBar', 'foo') // returns true + * const isPrefix = startsWith('fooBar', 'bar') // returns false + * const isPrefix = startsWith('fooBar', 'abc') // returns false + * const isPrefix = startsWith('fooBar', 'Bar', 2) // returns true + * const isPrefix = startsWith('fooBar', 'Bar', 5) // returns false + */ +declare function startsWith(str?: string, target?: string, position?: number): boolean; + +export { startsWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.js new file mode 100644 index 0000000000000000000000000000000000000000..0e541906007fee2c7141d5980e52628f2d5dc59e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function startsWith(str, target, position) { + if (str == null || target == null) { + return false; + } + if (position == null) { + position = 0; + } + return str.startsWith(target, position); +} + +exports.startsWith = startsWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..558fa9e4b28ac0c5b9020734a9d7d6b16f78c39c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/startsWith.mjs @@ -0,0 +1,11 @@ +function startsWith(str, target, position) { + if (str == null || target == null) { + return false; + } + if (position == null) { + position = 0; + } + return str.startsWith(target, position); +} + +export { startsWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..89955f205fd62eee49c9ed428aadb7a7f9a6442f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.d.mts @@ -0,0 +1,29 @@ +import { escape } from './escape.mjs'; + +declare const templateSettings: { + escape: RegExp; + evaluate: RegExp; + interpolate: RegExp; + variable: string; + imports: { + _: { + escape: typeof escape; + template: typeof template; + }; + }; +}; +interface TemplateOptions { + escape?: RegExp | null | undefined; + evaluate?: RegExp | null | undefined; + interpolate?: RegExp | null | undefined; + variable?: string | undefined; + imports?: Record | undefined; + sourceURL?: string; +} +interface TemplateExecutor { + (data?: object): string; + source: string; +} +declare function template(string?: string, options?: TemplateOptions): TemplateExecutor; + +export { template, templateSettings }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a718e12022dccedea8d6ef3ea5dcae6750f4d9ce --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.d.ts @@ -0,0 +1,29 @@ +import { escape } from './escape.js'; + +declare const templateSettings: { + escape: RegExp; + evaluate: RegExp; + interpolate: RegExp; + variable: string; + imports: { + _: { + escape: typeof escape; + template: typeof template; + }; + }; +}; +interface TemplateOptions { + escape?: RegExp | null | undefined; + evaluate?: RegExp | null | undefined; + interpolate?: RegExp | null | undefined; + variable?: string | undefined; + imports?: Record | undefined; + sourceURL?: string; +} +interface TemplateExecutor { + (data?: object): string; + source: string; +} +declare function template(string?: string, options?: TemplateOptions): TemplateExecutor; + +export { template, templateSettings }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.js new file mode 100644 index 0000000000000000000000000000000000000000..812f60791fb777dd6ddf10cada534eed26721713 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.js @@ -0,0 +1,91 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const escape = require('./escape.js'); +const attempt = require('../function/attempt.js'); +const defaults = require('../object/defaults.js'); +const toString = require('../util/toString.js'); + +const esTemplateRegExp = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; +const unEscapedRegExp = /['\n\r\u2028\u2029\\]/g; +const noMatchExp = /($^)/; +const escapeMap = new Map([ + ['\\', '\\'], + ["'", "'"], + ['\n', 'n'], + ['\r', 'r'], + ['\u2028', 'u2028'], + ['\u2029', 'u2029'], +]); +function escapeString(match) { + return `\\${escapeMap.get(match)}`; +} +const templateSettings = { + escape: /<%-([\s\S]+?)%>/g, + evaluate: /<%([\s\S]+?)%>/g, + interpolate: /<%=([\s\S]+?)%>/g, + variable: '', + imports: { + _: { + escape: escape.escape, + template, + }, + }, +}; +function template(string, options, guard) { + string = toString.toString(string); + if (guard) { + options = templateSettings; + } + options = defaults.defaults({ ...options }, templateSettings); + const delimitersRegExp = new RegExp([ + options.escape?.source ?? noMatchExp.source, + options.interpolate?.source ?? noMatchExp.source, + options.interpolate ? esTemplateRegExp.source : noMatchExp.source, + options.evaluate?.source ?? noMatchExp.source, + '$', + ].join('|'), 'g'); + let lastIndex = 0; + let isEvaluated = false; + let source = `__p += ''`; + for (const match of string.matchAll(delimitersRegExp)) { + const [fullMatch, escapeValue, interpolateValue, esTemplateValue, evaluateValue] = match; + const { index } = match; + source += ` + '${string.slice(lastIndex, index).replace(unEscapedRegExp, escapeString)}'`; + if (escapeValue) { + source += ` + _.escape(${escapeValue})`; + } + if (interpolateValue) { + source += ` + ((${interpolateValue}) == null ? '' : ${interpolateValue})`; + } + else if (esTemplateValue) { + source += ` + ((${esTemplateValue}) == null ? '' : ${esTemplateValue})`; + } + if (evaluateValue) { + source += `;\n${evaluateValue};\n __p += ''`; + isEvaluated = true; + } + lastIndex = index + fullMatch.length; + } + const imports = defaults.defaults({ ...options.imports }, templateSettings.imports); + const importsKeys = Object.keys(imports); + const importValues = Object.values(imports); + const sourceURL = `//# sourceURL=${options.sourceURL ? String(options.sourceURL).replace(/[\r\n]/g, ' ') : `es-toolkit.templateSource[${Date.now()}]`}\n`; + const compiledFunction = `function(${options.variable || 'obj'}) { + let __p = ''; + ${options.variable ? '' : 'if (obj == null) { obj = {}; }'} + ${isEvaluated ? `function print() { __p += Array.prototype.join.call(arguments, ''); }` : ''} + ${options.variable ? source : `with(obj) {\n${source}\n}`} + return __p; + }`; + const result = attempt.attempt(() => new Function(...importsKeys, `${sourceURL}return ${compiledFunction}`)(...importValues)); + result.source = compiledFunction; + if (result instanceof Error) { + throw result; + } + return result; +} + +exports.template = template; +exports.templateSettings = templateSettings; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5cada1dc0c16ecb304418777b798c261cf9e055f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/template.mjs @@ -0,0 +1,86 @@ +import { escape } from './escape.mjs'; +import { attempt } from '../function/attempt.mjs'; +import { defaults } from '../object/defaults.mjs'; +import { toString } from '../util/toString.mjs'; + +const esTemplateRegExp = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; +const unEscapedRegExp = /['\n\r\u2028\u2029\\]/g; +const noMatchExp = /($^)/; +const escapeMap = new Map([ + ['\\', '\\'], + ["'", "'"], + ['\n', 'n'], + ['\r', 'r'], + ['\u2028', 'u2028'], + ['\u2029', 'u2029'], +]); +function escapeString(match) { + return `\\${escapeMap.get(match)}`; +} +const templateSettings = { + escape: /<%-([\s\S]+?)%>/g, + evaluate: /<%([\s\S]+?)%>/g, + interpolate: /<%=([\s\S]+?)%>/g, + variable: '', + imports: { + _: { + escape, + template, + }, + }, +}; +function template(string, options, guard) { + string = toString(string); + if (guard) { + options = templateSettings; + } + options = defaults({ ...options }, templateSettings); + const delimitersRegExp = new RegExp([ + options.escape?.source ?? noMatchExp.source, + options.interpolate?.source ?? noMatchExp.source, + options.interpolate ? esTemplateRegExp.source : noMatchExp.source, + options.evaluate?.source ?? noMatchExp.source, + '$', + ].join('|'), 'g'); + let lastIndex = 0; + let isEvaluated = false; + let source = `__p += ''`; + for (const match of string.matchAll(delimitersRegExp)) { + const [fullMatch, escapeValue, interpolateValue, esTemplateValue, evaluateValue] = match; + const { index } = match; + source += ` + '${string.slice(lastIndex, index).replace(unEscapedRegExp, escapeString)}'`; + if (escapeValue) { + source += ` + _.escape(${escapeValue})`; + } + if (interpolateValue) { + source += ` + ((${interpolateValue}) == null ? '' : ${interpolateValue})`; + } + else if (esTemplateValue) { + source += ` + ((${esTemplateValue}) == null ? '' : ${esTemplateValue})`; + } + if (evaluateValue) { + source += `;\n${evaluateValue};\n __p += ''`; + isEvaluated = true; + } + lastIndex = index + fullMatch.length; + } + const imports = defaults({ ...options.imports }, templateSettings.imports); + const importsKeys = Object.keys(imports); + const importValues = Object.values(imports); + const sourceURL = `//# sourceURL=${options.sourceURL ? String(options.sourceURL).replace(/[\r\n]/g, ' ') : `es-toolkit.templateSource[${Date.now()}]`}\n`; + const compiledFunction = `function(${options.variable || 'obj'}) { + let __p = ''; + ${options.variable ? '' : 'if (obj == null) { obj = {}; }'} + ${isEvaluated ? `function print() { __p += Array.prototype.join.call(arguments, ''); }` : ''} + ${options.variable ? source : `with(obj) {\n${source}\n}`} + return __p; + }`; + const result = attempt(() => new Function(...importsKeys, `${sourceURL}return ${compiledFunction}`)(...importValues)); + result.source = compiledFunction; + if (result instanceof Error) { + throw result; + } + return result; +} + +export { template, templateSettings }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1e96b20a3a3e6faba6b8d2b83486f7517c58338b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.d.mts @@ -0,0 +1,20 @@ +/** + * Converts the given value to a string and transforms it to lower case. + * The function can handle various input types by first converting them to strings. + * + * @param {unknown} [value=''] The value to convert. + * @returns {string} Returns the lower cased string. + * @example + * + * toLower('--FOO-BAR--'); + * // => '--foo-bar--' + * + * toLower(null); + * // => '' + * + * toLower([1, 2, 3]); + * // => '1,2,3' + */ +declare function toLower(value?: T): Lowercase; + +export { toLower }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1e96b20a3a3e6faba6b8d2b83486f7517c58338b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.d.ts @@ -0,0 +1,20 @@ +/** + * Converts the given value to a string and transforms it to lower case. + * The function can handle various input types by first converting them to strings. + * + * @param {unknown} [value=''] The value to convert. + * @returns {string} Returns the lower cased string. + * @example + * + * toLower('--FOO-BAR--'); + * // => '--foo-bar--' + * + * toLower(null); + * // => '' + * + * toLower([1, 2, 3]); + * // => '1,2,3' + */ +declare function toLower(value?: T): Lowercase; + +export { toLower }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.js new file mode 100644 index 0000000000000000000000000000000000000000..a6eb3c0af6fdee3bbeff7db515267e2521d443be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toString = require('../util/toString.js'); + +function toLower(value) { + return toString.toString(value).toLowerCase(); +} + +exports.toLower = toLower; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0e08ae49b28f9879ffdc6cc968c423209fdf6089 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toLower.mjs @@ -0,0 +1,7 @@ +import { toString } from '../util/toString.mjs'; + +function toLower(value) { + return toString(value).toLowerCase(); +} + +export { toLower }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..196f562117a45fcc3a1e7d30f93fe0b38dddcd7e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.d.mts @@ -0,0 +1,20 @@ +/** + * Converts `string`, as a whole, to upper case just like + * [String#toUpperCase](https://mdn.io/toUpperCase). + * + * @param {unknown} [value=''] The value to convert. + * @returns {string} Returns the upper cased string. + * @example + * + * toUpper('--foo-bar--'); + * // => '--FOO-BAR--' + * + * toUpper(null); + * // => '' + * + * toUpper([1, 2, 3]); + * // => '1,2,3' + */ +declare function toUpper(value?: T): Uppercase; + +export { toUpper }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..196f562117a45fcc3a1e7d30f93fe0b38dddcd7e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.d.ts @@ -0,0 +1,20 @@ +/** + * Converts `string`, as a whole, to upper case just like + * [String#toUpperCase](https://mdn.io/toUpperCase). + * + * @param {unknown} [value=''] The value to convert. + * @returns {string} Returns the upper cased string. + * @example + * + * toUpper('--foo-bar--'); + * // => '--FOO-BAR--' + * + * toUpper(null); + * // => '' + * + * toUpper([1, 2, 3]); + * // => '1,2,3' + */ +declare function toUpper(value?: T): Uppercase; + +export { toUpper }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.js new file mode 100644 index 0000000000000000000000000000000000000000..c39f2cfb8bd5cd95160fa2e44a2244a0dad7c6d5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toString = require('../util/toString.js'); + +function toUpper(value) { + return toString.toString(value).toUpperCase(); +} + +exports.toUpper = toUpper; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7f2a7f6b148ef8b7e311ed2a606030dcb7c4e810 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/toUpper.mjs @@ -0,0 +1,7 @@ +import { toString } from '../util/toString.mjs'; + +function toUpper(value) { + return toString(value).toUpperCase(); +} + +export { toUpper }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f81c0bb92eab22c64c09be40d9cea6c8269563d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.d.mts @@ -0,0 +1,28 @@ +/** + * Removes leading and trailing whitespace or specified characters from a string. + * + * @param {string} str - The string from which leading and trailing characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`. + * @returns {string} - The resulting string after the specified leading and trailing characters have been removed. + * + * @example + * trim(" hello "); // "hello" + * trim("--hello--", "-"); // "hello" + * trim("##hello##", ["#", "o"]); // "hell" + */ +declare function trim(string?: string, chars?: string): string; +/** + * Removes leading and trailing whitespace or specified characters from a string. + * + * @param {string} str - The string from which leading and trailing characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`. + * @returns {string} - The resulting string after the specified leading and trailing characters have been removed. + * + * @example + * trim(" hello "); // "hello" + * trim("--hello--", "-"); // "hello" + * trim("##hello##", ["#", "o"]); // "hell" + */ +declare function trim(string: string, index: string | number, guard: object): string; + +export { trim }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f81c0bb92eab22c64c09be40d9cea6c8269563d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.d.ts @@ -0,0 +1,28 @@ +/** + * Removes leading and trailing whitespace or specified characters from a string. + * + * @param {string} str - The string from which leading and trailing characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`. + * @returns {string} - The resulting string after the specified leading and trailing characters have been removed. + * + * @example + * trim(" hello "); // "hello" + * trim("--hello--", "-"); // "hello" + * trim("##hello##", ["#", "o"]); // "hell" + */ +declare function trim(string?: string, chars?: string): string; +/** + * Removes leading and trailing whitespace or specified characters from a string. + * + * @param {string} str - The string from which leading and trailing characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`. + * @returns {string} - The resulting string after the specified leading and trailing characters have been removed. + * + * @example + * trim(" hello "); // "hello" + * trim("--hello--", "-"); // "hello" + * trim("##hello##", ["#", "o"]); // "hell" + */ +declare function trim(string: string, index: string | number, guard: object): string; + +export { trim }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.js new file mode 100644 index 0000000000000000000000000000000000000000..8892d6f03c5e52925e45d095d9d143381e6b9cb6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.js @@ -0,0 +1,29 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const trim$1 = require('../../string/trim.js'); + +function trim(str, chars, guard) { + if (str == null) { + return ''; + } + if (guard != null || chars == null) { + return str.toString().trim(); + } + switch (typeof chars) { + case 'object': { + if (Array.isArray(chars)) { + return trim$1.trim(str, chars.flatMap(x => x.toString().split(''))); + } + else { + return trim$1.trim(str, chars.toString().split('')); + } + } + default: { + return trim$1.trim(str, chars.toString().split('')); + } + } +} + +exports.trim = trim; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.mjs new file mode 100644 index 0000000000000000000000000000000000000000..977a786a131337afe2b9eec53e676a03a66e502f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trim.mjs @@ -0,0 +1,25 @@ +import { trim as trim$1 } from '../../string/trim.mjs'; + +function trim(str, chars, guard) { + if (str == null) { + return ''; + } + if (guard != null || chars == null) { + return str.toString().trim(); + } + switch (typeof chars) { + case 'object': { + if (Array.isArray(chars)) { + return trim$1(str, chars.flatMap(x => x.toString().split(''))); + } + else { + return trim$1(str, chars.toString().split('')); + } + } + default: { + return trim$1(str, chars.toString().split('')); + } + } +} + +export { trim }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..22bb90ba3e47404d363d6d3a402157f40accc96a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.d.mts @@ -0,0 +1,30 @@ +/** + * Removes trailing whitespace or specified characters from a string. + * + * @param {string} string - The string to trim. + * @param {string} chars - The characters to trim from the end of the string. + * @returns {string} Returns the trimmed string. + * + * @example + * trimEnd(' abc '); + * // => ' abc' + * + * trimEnd('-_-abc-_-', '_-'); + * // => '-_-abc' + */ +declare function trimEnd(string?: string, chars?: string): string; +/** + * Removes trailing whitespace or specified characters from a string. + * + * @param {string} string - The string to trim. + * @param {string | number} index - The index parameter (used with guard). + * @param {object} guard - Enables use as an iteratee for methods like `map`. + * @returns {string} Returns the trimmed string. + * + * @example + * trimEnd(' abc ', 0, {}); + * // => ' abc' + */ +declare function trimEnd(string: string, index: string | number, guard: object): string; + +export { trimEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..22bb90ba3e47404d363d6d3a402157f40accc96a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.d.ts @@ -0,0 +1,30 @@ +/** + * Removes trailing whitespace or specified characters from a string. + * + * @param {string} string - The string to trim. + * @param {string} chars - The characters to trim from the end of the string. + * @returns {string} Returns the trimmed string. + * + * @example + * trimEnd(' abc '); + * // => ' abc' + * + * trimEnd('-_-abc-_-', '_-'); + * // => '-_-abc' + */ +declare function trimEnd(string?: string, chars?: string): string; +/** + * Removes trailing whitespace or specified characters from a string. + * + * @param {string} string - The string to trim. + * @param {string | number} index - The index parameter (used with guard). + * @param {object} guard - Enables use as an iteratee for methods like `map`. + * @returns {string} Returns the trimmed string. + * + * @example + * trimEnd(' abc ', 0, {}); + * // => ' abc' + */ +declare function trimEnd(string: string, index: string | number, guard: object): string; + +export { trimEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.js new file mode 100644 index 0000000000000000000000000000000000000000..61dee2cd89424234d97d306804c0bf3c7363f407 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const trimEnd$1 = require('../../string/trimEnd.js'); + +function trimEnd(str, chars, guard) { + if (str == null) { + return ''; + } + if (guard != null || chars == null) { + return str.toString().trimEnd(); + } + return trimEnd$1.trimEnd(str, chars.toString().split('')); +} + +exports.trimEnd = trimEnd; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6a444c3d543cee84e87507e35ef35b080f111006 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimEnd.mjs @@ -0,0 +1,13 @@ +import { trimEnd as trimEnd$1 } from '../../string/trimEnd.mjs'; + +function trimEnd(str, chars, guard) { + if (str == null) { + return ''; + } + if (guard != null || chars == null) { + return str.toString().trimEnd(); + } + return trimEnd$1(str, chars.toString().split('')); +} + +export { trimEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..aa300a47b63035a6ba83a73ba78db1981d080afb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.d.mts @@ -0,0 +1,30 @@ +/** + * Removes leading whitespace or specified characters from a string. + * + * @param {string} string - The string to trim. + * @param {string} chars - The characters to trim from the start of the string. + * @returns {string} Returns the trimmed string. + * + * @example + * trimStart(' abc '); + * // => 'abc ' + * + * trimStart('-_-abc-_-', '_-'); + * // => 'abc-_-' + */ +declare function trimStart(string?: string, chars?: string): string; +/** + * Removes leading whitespace or specified characters from a string. + * + * @param {string} string - The string to trim. + * @param {string | number} index - The index parameter (used with guard). + * @param {object} guard - Enables use as an iteratee for methods like `map`. + * @returns {string} Returns the trimmed string. + * + * @example + * trimStart(' abc ', 0, {}); + * // => 'abc ' + */ +declare function trimStart(string: string, index: string | number, guard: object): string; + +export { trimStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..aa300a47b63035a6ba83a73ba78db1981d080afb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.d.ts @@ -0,0 +1,30 @@ +/** + * Removes leading whitespace or specified characters from a string. + * + * @param {string} string - The string to trim. + * @param {string} chars - The characters to trim from the start of the string. + * @returns {string} Returns the trimmed string. + * + * @example + * trimStart(' abc '); + * // => 'abc ' + * + * trimStart('-_-abc-_-', '_-'); + * // => 'abc-_-' + */ +declare function trimStart(string?: string, chars?: string): string; +/** + * Removes leading whitespace or specified characters from a string. + * + * @param {string} string - The string to trim. + * @param {string | number} index - The index parameter (used with guard). + * @param {object} guard - Enables use as an iteratee for methods like `map`. + * @returns {string} Returns the trimmed string. + * + * @example + * trimStart(' abc ', 0, {}); + * // => 'abc ' + */ +declare function trimStart(string: string, index: string | number, guard: object): string; + +export { trimStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.js new file mode 100644 index 0000000000000000000000000000000000000000..e088a7d4e73ad25b749e348f7708cb942380c81f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const trimStart$1 = require('../../string/trimStart.js'); + +function trimStart(str, chars, guard) { + if (str == null) { + return ''; + } + if (guard != null || chars == null) { + return str.toString().trimStart(); + } + return trimStart$1.trimStart(str, chars.toString().split('')); +} + +exports.trimStart = trimStart; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.mjs new file mode 100644 index 0000000000000000000000000000000000000000..15460c007a7de585ac7983ecf8d240a8f7a7e9cb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/trimStart.mjs @@ -0,0 +1,13 @@ +import { trimStart as trimStart$1 } from '../../string/trimStart.mjs'; + +function trimStart(str, chars, guard) { + if (str == null) { + return ''; + } + if (guard != null || chars == null) { + return str.toString().trimStart(); + } + return trimStart$1(str, chars.toString().split('')); +} + +export { trimStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..62647a851bdd5f4b72d0b82a8901257e0cc6f78c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.d.mts @@ -0,0 +1,34 @@ +type TruncateOptions = { + length?: number; + separator?: string | RegExp; + omission?: string; +}; +/** + * This regex might more completely detect unicode, but it is slower and this project + * desires to mimic the behavior of lodash. + */ +/** + * Truncates `string` if it's longer than the given maximum string length. + * The last characters of the truncated string are replaced with the omission + * string which defaults to "...". + * + * @param {string} [string=''] The string to truncate. + * @param {Object} [options={}] The options object. + * @param {number} [options.length=30] The maximum string length. + * @param {string} [options.omission='...'] The string to indicate text is omitted. + * @param {RegExp|string} [options.separator] The separator pattern to truncate to. + * + * @example + * const test = 'hi-diddly-ho there, neighborino'; + * const truncatedStr1 = truncate(test) // returns 'hi-diddly-ho there, neighbo...' + * const truncatedStr2 = truncate(test, { length: 24, separator: ' ' }) // returns 'hi-diddly-ho there,...' + * const truncatedStr3 = truncate(test, { length: 24, separator: /,? +/ }) // returns 'hi-diddly-ho there...' + * const truncatedStr4 = truncate(test, { omission: ' [...]' }) // returns 'hi-diddly-ho there, neig [...]' + * const truncatedStr5 = truncate('ABC', { length: 3 }) // returns 'ABC' + * const truncatedStr6 = truncate('ABC', { length: 2 }) // returns '...' + * const truncatedStr7 = truncate('¥§✈✉🤓', { length: 5 }) // returns '¥§✈✉🤓' + * const truncatedStr8 = truncate('¥§✈✉🤓', { length: 4, omission: '…' }) // returns '¥§✈…' + */ +declare function truncate(string?: string, options?: TruncateOptions): string; + +export { truncate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..62647a851bdd5f4b72d0b82a8901257e0cc6f78c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.d.ts @@ -0,0 +1,34 @@ +type TruncateOptions = { + length?: number; + separator?: string | RegExp; + omission?: string; +}; +/** + * This regex might more completely detect unicode, but it is slower and this project + * desires to mimic the behavior of lodash. + */ +/** + * Truncates `string` if it's longer than the given maximum string length. + * The last characters of the truncated string are replaced with the omission + * string which defaults to "...". + * + * @param {string} [string=''] The string to truncate. + * @param {Object} [options={}] The options object. + * @param {number} [options.length=30] The maximum string length. + * @param {string} [options.omission='...'] The string to indicate text is omitted. + * @param {RegExp|string} [options.separator] The separator pattern to truncate to. + * + * @example + * const test = 'hi-diddly-ho there, neighborino'; + * const truncatedStr1 = truncate(test) // returns 'hi-diddly-ho there, neighbo...' + * const truncatedStr2 = truncate(test, { length: 24, separator: ' ' }) // returns 'hi-diddly-ho there,...' + * const truncatedStr3 = truncate(test, { length: 24, separator: /,? +/ }) // returns 'hi-diddly-ho there...' + * const truncatedStr4 = truncate(test, { omission: ' [...]' }) // returns 'hi-diddly-ho there, neig [...]' + * const truncatedStr5 = truncate('ABC', { length: 3 }) // returns 'ABC' + * const truncatedStr6 = truncate('ABC', { length: 2 }) // returns '...' + * const truncatedStr7 = truncate('¥§✈✉🤓', { length: 5 }) // returns '¥§✈✉🤓' + * const truncatedStr8 = truncate('¥§✈✉🤓', { length: 4, omission: '…' }) // returns '¥§✈…' + */ +declare function truncate(string?: string, options?: TruncateOptions): string; + +export { truncate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.js new file mode 100644 index 0000000000000000000000000000000000000000..e8461d5325ee75cb42fdb5d3c8ee0124f3252930 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.js @@ -0,0 +1,52 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isObject = require('../predicate/isObject.js'); + +const regexMultiByte = /[\u200d\ud800-\udfff\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff\ufe0e\ufe0f]/; +function truncate(string, options) { + string = string != null ? `${string}` : ''; + let length = 30; + let omission = '...'; + if (isObject.isObject(options)) { + length = parseLength(options.length); + omission = 'omission' in options ? `${options.omission}` : '...'; + } + let i = string.length; + const lengthOmission = Array.from(omission).length; + const lengthBase = Math.max(length - lengthOmission, 0); + let strArray = undefined; + const unicode = regexMultiByte.test(string); + if (unicode) { + strArray = Array.from(string); + i = strArray.length; + } + if (length >= i) { + return string; + } + if (i <= lengthOmission) { + return omission; + } + let base = strArray === undefined ? string.slice(0, lengthBase) : strArray?.slice(0, lengthBase).join(''); + const separator = options?.separator; + if (!separator) { + base += omission; + return base; + } + const search = separator instanceof RegExp ? separator.source : separator; + const flags = 'u' + (separator instanceof RegExp ? separator.flags.replace('u', '') : ''); + const withoutSeparator = new RegExp(`(?.*(?:(?!${search}).))(?:${search})`, flags).exec(base); + return (!withoutSeparator?.groups ? base : withoutSeparator.groups.result) + omission; +} +function parseLength(length) { + if (length == null) { + return 30; + } + if (length <= 0) { + return 0; + } + return length; +} + +exports.truncate = truncate; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.mjs new file mode 100644 index 0000000000000000000000000000000000000000..22450eca7b5f7002d4dfaf78eb1399ef6da10b7b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/truncate.mjs @@ -0,0 +1,48 @@ +import { isObject } from '../predicate/isObject.mjs'; + +const regexMultiByte = /[\u200d\ud800-\udfff\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff\ufe0e\ufe0f]/; +function truncate(string, options) { + string = string != null ? `${string}` : ''; + let length = 30; + let omission = '...'; + if (isObject(options)) { + length = parseLength(options.length); + omission = 'omission' in options ? `${options.omission}` : '...'; + } + let i = string.length; + const lengthOmission = Array.from(omission).length; + const lengthBase = Math.max(length - lengthOmission, 0); + let strArray = undefined; + const unicode = regexMultiByte.test(string); + if (unicode) { + strArray = Array.from(string); + i = strArray.length; + } + if (length >= i) { + return string; + } + if (i <= lengthOmission) { + return omission; + } + let base = strArray === undefined ? string.slice(0, lengthBase) : strArray?.slice(0, lengthBase).join(''); + const separator = options?.separator; + if (!separator) { + base += omission; + return base; + } + const search = separator instanceof RegExp ? separator.source : separator; + const flags = 'u' + (separator instanceof RegExp ? separator.flags.replace('u', '') : ''); + const withoutSeparator = new RegExp(`(?.*(?:(?!${search}).))(?:${search})`, flags).exec(base); + return (!withoutSeparator?.groups ? base : withoutSeparator.groups.result) + omission; +} +function parseLength(length) { + if (length == null) { + return 30; + } + if (length <= 0) { + return 0; + } + return length; +} + +export { truncate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..605328f469fa64b19d195e7d08db951842a0e67c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.d.mts @@ -0,0 +1,16 @@ +/** + * Converts the HTML entities `&`, `<`, `>`, `"`, and `'` in `str` to their corresponding characters. + * It is the inverse of `escape`. + * + * @param {string} str The string to unescape. + * @returns {string} Returns the unescaped string. + * + * @example + * unescape('This is a <div> element.'); // returns 'This is a
element.' + * unescape('This is a "quote"'); // returns 'This is a "quote"' + * unescape('This is a 'quote''); // returns 'This is a 'quote'' + * unescape('This is a & symbol'); // returns 'This is a & symbol' + */ +declare function unescape(str?: string): string; + +export { unescape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..605328f469fa64b19d195e7d08db951842a0e67c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.d.ts @@ -0,0 +1,16 @@ +/** + * Converts the HTML entities `&`, `<`, `>`, `"`, and `'` in `str` to their corresponding characters. + * It is the inverse of `escape`. + * + * @param {string} str The string to unescape. + * @returns {string} Returns the unescaped string. + * + * @example + * unescape('This is a <div> element.'); // returns 'This is a
element.' + * unescape('This is a "quote"'); // returns 'This is a "quote"' + * unescape('This is a 'quote''); // returns 'This is a 'quote'' + * unescape('This is a & symbol'); // returns 'This is a & symbol' + */ +declare function unescape(str?: string): string; + +export { unescape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.js new file mode 100644 index 0000000000000000000000000000000000000000..b93656ff5e35c19579576d252ee7cfcb7749c0fc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const unescape$1 = require('../../string/unescape.js'); +const toString = require('../util/toString.js'); + +function unescape(str) { + return unescape$1.unescape(toString.toString(str)); +} + +exports.unescape = unescape; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c3e46cc134c539ef727ee6f9aff919982f895756 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/unescape.mjs @@ -0,0 +1,8 @@ +import { unescape as unescape$1 } from '../../string/unescape.mjs'; +import { toString } from '../util/toString.mjs'; + +function unescape(str) { + return unescape$1(toString(str)); +} + +export { unescape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..819519a7dba5380da24a11cd8597ebd5a2fc8cc7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.d.mts @@ -0,0 +1,17 @@ +/** + * Converts a string to upper case. + * + * Upper case is the naming convention in which each word is written in uppercase and separated by an space ( ) character. + * + * @param {string | object} str - The string that is to be changed to upper case. + * @returns {string} - The converted string to upper case. + * + * @example + * const convertedStr1 = upperCase('camelCase') // returns 'CAMEL CASE' + * const convertedStr2 = upperCase('some whitespace') // returns 'SOME WHITESPACE' + * const convertedStr3 = upperCase('hyphen-text') // returns 'HYPHEN TEXT' + * const convertedStr4 = upperCase('HTTPRequest') // returns 'HTTP REQUEST' + */ +declare function upperCase(str?: string): string; + +export { upperCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..819519a7dba5380da24a11cd8597ebd5a2fc8cc7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.d.ts @@ -0,0 +1,17 @@ +/** + * Converts a string to upper case. + * + * Upper case is the naming convention in which each word is written in uppercase and separated by an space ( ) character. + * + * @param {string | object} str - The string that is to be changed to upper case. + * @returns {string} - The converted string to upper case. + * + * @example + * const convertedStr1 = upperCase('camelCase') // returns 'CAMEL CASE' + * const convertedStr2 = upperCase('some whitespace') // returns 'SOME WHITESPACE' + * const convertedStr3 = upperCase('hyphen-text') // returns 'HYPHEN TEXT' + * const convertedStr4 = upperCase('HTTPRequest') // returns 'HTTP REQUEST' + */ +declare function upperCase(str?: string): string; + +export { upperCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.js new file mode 100644 index 0000000000000000000000000000000000000000..65430fca24bfe447e30e1ffdffe90bd6c55128be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const upperCase$1 = require('../../string/upperCase.js'); +const normalizeForCase = require('../_internal/normalizeForCase.js'); + +function upperCase(str) { + return upperCase$1.upperCase(normalizeForCase.normalizeForCase(str)); +} + +exports.upperCase = upperCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6b5063ce7869a74c345c327f0501911775c03713 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperCase.mjs @@ -0,0 +1,8 @@ +import { upperCase as upperCase$1 } from '../../string/upperCase.mjs'; +import { normalizeForCase } from '../_internal/normalizeForCase.mjs'; + +function upperCase(str) { + return upperCase$1(normalizeForCase(str)); +} + +export { upperCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..847eebe8f012dd8c8813a0aa7c45909567d4e755 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.d.mts @@ -0,0 +1,14 @@ +/** + * Converts the first character of string to upper case. + * + * @param {string} str - The string that is to be changed + * @returns {string} - The converted string. + * + * @example + * const convertedStr1 = upperFirst('fred') // returns 'Fred' + * const convertedStr2 = upperFirst('Fred') // returns 'Fred' + * const convertedStr3 = upperFirst('FRED') // returns 'FRED' + */ +declare function upperFirst(str?: T): Capitalize; + +export { upperFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..847eebe8f012dd8c8813a0aa7c45909567d4e755 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.d.ts @@ -0,0 +1,14 @@ +/** + * Converts the first character of string to upper case. + * + * @param {string} str - The string that is to be changed + * @returns {string} - The converted string. + * + * @example + * const convertedStr1 = upperFirst('fred') // returns 'Fred' + * const convertedStr2 = upperFirst('Fred') // returns 'Fred' + * const convertedStr3 = upperFirst('FRED') // returns 'FRED' + */ +declare function upperFirst(str?: T): Capitalize; + +export { upperFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.js new file mode 100644 index 0000000000000000000000000000000000000000..abc1cb204e414bdb09ee4459a074d11e61c8d5ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const upperFirst$1 = require('../../string/upperFirst.js'); +const toString = require('../util/toString.js'); + +function upperFirst(str) { + return upperFirst$1.upperFirst(toString.toString(str)); +} + +exports.upperFirst = upperFirst; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1dcc41a126815e9a6cb33a279e1c10df613a27ef --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/upperFirst.mjs @@ -0,0 +1,8 @@ +import { upperFirst as upperFirst$1 } from '../../string/upperFirst.mjs'; +import { toString } from '../util/toString.mjs'; + +function upperFirst(str) { + return upperFirst$1(toString(str)); +} + +export { upperFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..afb5c5f23e29d9853de9cfdd263373bc34d4d597 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.d.mts @@ -0,0 +1,27 @@ +/** + * Splits `string` into an array of its words. + * + * @param {string | object} str - The string or object that is to be split into words. + * @param {RegExp | string} [pattern] - The pattern to match words. + * @returns {string[]} - Returns the words of `string`. + * + * @example + * const wordsArray1 = words('fred, barney, & pebbles'); + * // => ['fred', 'barney', 'pebbles'] + * + */ +declare function words(string?: string, pattern?: string | RegExp): string[]; +/** + * Splits `string` into an array of its words. + * + * @param {string | object} str - The string or object that is to be split into words. + * @param {RegExp | string} [pattern] - The pattern to match words. + * @returns {string[]} - Returns the words of `string`. + * + * @example + * const wordsArray1 = words('fred, barney, & pebbles'); + * // => ['fred', 'barney', 'pebbles'] + */ +declare function words(string: string, index: string | number, guard: object): string[]; + +export { words }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..afb5c5f23e29d9853de9cfdd263373bc34d4d597 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.d.ts @@ -0,0 +1,27 @@ +/** + * Splits `string` into an array of its words. + * + * @param {string | object} str - The string or object that is to be split into words. + * @param {RegExp | string} [pattern] - The pattern to match words. + * @returns {string[]} - Returns the words of `string`. + * + * @example + * const wordsArray1 = words('fred, barney, & pebbles'); + * // => ['fred', 'barney', 'pebbles'] + * + */ +declare function words(string?: string, pattern?: string | RegExp): string[]; +/** + * Splits `string` into an array of its words. + * + * @param {string | object} str - The string or object that is to be split into words. + * @param {RegExp | string} [pattern] - The pattern to match words. + * @returns {string[]} - Returns the words of `string`. + * + * @example + * const wordsArray1 = words('fred, barney, & pebbles'); + * // => ['fred', 'barney', 'pebbles'] + */ +declare function words(string: string, index: string | number, guard: object): string[]; + +export { words }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.js new file mode 100644 index 0000000000000000000000000000000000000000..8d39521b15213e7e1de27231bfc62e47b4402419 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toString = require('../util/toString.js'); + +const rNonCharLatin = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\xd7\\xf7'; +const rUnicodeUpper = '\\p{Lu}'; +const rUnicodeLower = '\\p{Ll}'; +const rMisc = '(?:[\\p{Lm}\\p{Lo}]\\p{M}*)'; +const rNumber = '\\d'; +const rUnicodeOptContrLower = "(?:['\u2019](?:d|ll|m|re|s|t|ve))?"; +const rUnicodeOptContrUpper = "(?:['\u2019](?:D|LL|M|RE|S|T|VE))?"; +const rUnicodeBreak = `[\\p{Z}\\p{P}${rNonCharLatin}]`; +const rUnicodeMiscUpper = `(?:${rUnicodeUpper}|${rMisc})`; +const rUnicodeMiscLower = `(?:${rUnicodeLower}|${rMisc})`; +const rUnicodeWord = RegExp([ + `${rUnicodeUpper}?${rUnicodeLower}+${rUnicodeOptContrLower}(?=${rUnicodeBreak}|${rUnicodeUpper}|$)`, + `${rUnicodeMiscUpper}+${rUnicodeOptContrUpper}(?=${rUnicodeBreak}|${rUnicodeUpper}${rUnicodeMiscLower}|$)`, + `${rUnicodeUpper}?${rUnicodeMiscLower}+${rUnicodeOptContrLower}`, + `${rUnicodeUpper}+${rUnicodeOptContrUpper}`, + `${rNumber}*(?:1ST|2ND|3RD|(?![123])${rNumber}TH)(?=\\b|[a-z_])`, + `${rNumber}*(?:1st|2nd|3rd|(?![123])${rNumber}th)(?=\\b|[A-Z_])`, + `${rNumber}+`, + '\\p{Emoji_Presentation}', + '\\p{Extended_Pictographic}', +].join('|'), 'gu'); +function words(str, pattern = rUnicodeWord, guard) { + const input = toString.toString(str); + if (guard) { + pattern = rUnicodeWord; + } + if (typeof pattern === 'number') { + pattern = pattern.toString(); + } + const words = Array.from(input.match(pattern) ?? []); + return words.filter(x => x !== ''); +} + +exports.words = words; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.mjs new file mode 100644 index 0000000000000000000000000000000000000000..03b6372fbb68f7fd01caf6274e57f86727657802 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/string/words.mjs @@ -0,0 +1,36 @@ +import { toString } from '../util/toString.mjs'; + +const rNonCharLatin = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\xd7\\xf7'; +const rUnicodeUpper = '\\p{Lu}'; +const rUnicodeLower = '\\p{Ll}'; +const rMisc = '(?:[\\p{Lm}\\p{Lo}]\\p{M}*)'; +const rNumber = '\\d'; +const rUnicodeOptContrLower = "(?:['\u2019](?:d|ll|m|re|s|t|ve))?"; +const rUnicodeOptContrUpper = "(?:['\u2019](?:D|LL|M|RE|S|T|VE))?"; +const rUnicodeBreak = `[\\p{Z}\\p{P}${rNonCharLatin}]`; +const rUnicodeMiscUpper = `(?:${rUnicodeUpper}|${rMisc})`; +const rUnicodeMiscLower = `(?:${rUnicodeLower}|${rMisc})`; +const rUnicodeWord = RegExp([ + `${rUnicodeUpper}?${rUnicodeLower}+${rUnicodeOptContrLower}(?=${rUnicodeBreak}|${rUnicodeUpper}|$)`, + `${rUnicodeMiscUpper}+${rUnicodeOptContrUpper}(?=${rUnicodeBreak}|${rUnicodeUpper}${rUnicodeMiscLower}|$)`, + `${rUnicodeUpper}?${rUnicodeMiscLower}+${rUnicodeOptContrLower}`, + `${rUnicodeUpper}+${rUnicodeOptContrUpper}`, + `${rNumber}*(?:1ST|2ND|3RD|(?![123])${rNumber}TH)(?=\\b|[a-z_])`, + `${rNumber}*(?:1st|2nd|3rd|(?![123])${rNumber}th)(?=\\b|[A-Z_])`, + `${rNumber}+`, + '\\p{Emoji_Presentation}', + '\\p{Extended_Pictographic}', +].join('|'), 'gu'); +function words(str, pattern = rUnicodeWord, guard) { + const input = toString(str); + if (guard) { + pattern = rUnicodeWord; + } + if (typeof pattern === 'number') { + pattern = pattern.toString(); + } + const words = Array.from(input.match(pattern) ?? []); + return words.filter(x => x !== ''); +} + +export { words }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..82b7ee11a1c0b6e93d77ae68f194bc2f98c9235f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.d.mts @@ -0,0 +1,31 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Binds methods of an object to the object itself, overwriting the existing method. + * Method names may be specified as individual arguments or as arrays of method names. + * + * @template T - The type of the object. + * @param {T} object - The object to bind methods to. + * @param {Array>} [methodNames] - The method names to bind, specified individually or in arrays. + * @returns {T} - Returns the object. + * + * @example + * const view = { + * 'label': 'docs', + * 'click': function() { + * console.log('clicked ' + this.label); + * } + * }; + * + * bindAll(view, ['click']); + * jQuery(element).on('click', view.click); + * // => Logs 'clicked docs' when clicked. + * + * @example + * // Using individual method names + * bindAll(view, 'click'); + * // => Same as above + */ +declare function bindAll(object: T, ...methodNames: Array>): T; + +export { bindAll }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e66ed5e79d3a1f61c7386ba786e8f750bb84a76b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.d.ts @@ -0,0 +1,31 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Binds methods of an object to the object itself, overwriting the existing method. + * Method names may be specified as individual arguments or as arrays of method names. + * + * @template T - The type of the object. + * @param {T} object - The object to bind methods to. + * @param {Array>} [methodNames] - The method names to bind, specified individually or in arrays. + * @returns {T} - Returns the object. + * + * @example + * const view = { + * 'label': 'docs', + * 'click': function() { + * console.log('clicked ' + this.label); + * } + * }; + * + * bindAll(view, ['click']); + * jQuery(element).on('click', view.click); + * // => Logs 'clicked docs' when clicked. + * + * @example + * // Using individual method names + * bindAll(view, 'click'); + * // => Same as above + */ +declare function bindAll(object: T, ...methodNames: Array>): T; + +export { bindAll }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.js new file mode 100644 index 0000000000000000000000000000000000000000..c22eb25556440142f3c2fd0c503886f56d6830b5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.js @@ -0,0 +1,47 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isFunction = require('../../predicate/isFunction.js'); +const isArray = require('../predicate/isArray.js'); +const isObject = require('../predicate/isObject.js'); +const toString = require('./toString.js'); + +function bindAll(object, ...methodNames) { + if (object == null) { + return object; + } + if (!isObject.isObject(object)) { + return object; + } + if (isArray.isArray(object) && methodNames.length === 0) { + return object; + } + const methods = []; + for (let i = 0; i < methodNames.length; i++) { + const name = methodNames[i]; + if (isArray.isArray(name)) { + methods.push(...name); + } + else if (name && typeof name === 'object' && 'length' in name) { + methods.push(...Array.from(name)); + } + else { + methods.push(name); + } + } + if (methods.length === 0) { + return object; + } + for (let i = 0; i < methods.length; i++) { + const key = methods[i]; + const stringKey = toString.toString(key); + const func = object[stringKey]; + if (isFunction.isFunction(func)) { + object[stringKey] = func.bind(object); + } + } + return object; +} + +exports.bindAll = bindAll; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.mjs new file mode 100644 index 0000000000000000000000000000000000000000..dd2ce5d3d4ebd06aa41e5d54d7d11709de3ecf8c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/bindAll.mjs @@ -0,0 +1,43 @@ +import { isFunction } from '../../predicate/isFunction.mjs'; +import { isArray } from '../predicate/isArray.mjs'; +import { isObject } from '../predicate/isObject.mjs'; +import { toString } from './toString.mjs'; + +function bindAll(object, ...methodNames) { + if (object == null) { + return object; + } + if (!isObject(object)) { + return object; + } + if (isArray(object) && methodNames.length === 0) { + return object; + } + const methods = []; + for (let i = 0; i < methodNames.length; i++) { + const name = methodNames[i]; + if (isArray(name)) { + methods.push(...name); + } + else if (name && typeof name === 'object' && 'length' in name) { + methods.push(...Array.from(name)); + } + else { + methods.push(name); + } + } + if (methods.length === 0) { + return object; + } + for (let i = 0; i < methods.length; i++) { + const key = methods[i]; + const stringKey = toString(key); + const func = object[stringKey]; + if (isFunction(func)) { + object[stringKey] = func.bind(object); + } + } + return object; +} + +export { bindAll }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..704a49180d9f0e4e24a40013eeb85b04bb2d811a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.d.mts @@ -0,0 +1,58 @@ +/** + * Creates a function that checks conditions one by one and runs the matching function. + * + * Each pair consists of a condition (predicate) and a function to run. + * The function goes through each condition in order until it finds one that's true. + * When it finds a true condition, it runs the corresponding function and returns its result. + * If none of the conditions are true, it returns undefined. + * + * @param {Array} pairs - Array of pairs. Each pair consists of a predicate function and a function to run. + * @returns {(...args: any[]) => unknown} A new composite function that checks conditions and runs the matching function. + * @example + * + * const func = cond([ + * [matches({ a: 1 }), constant('matches A')], + * [conforms({ b: isNumber }), constant('matches B')], + * [stubTrue, constant('no match')] + * ]); + * + * func({ a: 1, b: 2 }); + * // => 'matches A' + * + * func({ a: 0, b: 1 }); + * // => 'matches B' + * + * func({ a: '1', b: '2' }); + * // => 'no match' + */ +declare function cond(pairs: Array<[truthy: () => boolean, falsey: () => R]>): () => R; +/** + * Creates a function that checks conditions one by one and runs the matching function. + * + * Each pair consists of a condition (predicate) and a function to run. + * The function goes through each condition in order until it finds one that's true. + * When it finds a true condition, it runs the corresponding function and returns its result. + * If none of the conditions are true, it returns undefined. + * + * @param {Array} pairs - Array of pairs. Each pair consists of a predicate function and a function to run. + * @returns {(...args: any[]) => unknown} A new composite function that checks conditions and runs the matching function. + * @example + * + * const func = cond([ + * [matches({ a: 1 }), constant('matches A')], + * [conforms({ b: isNumber }), constant('matches B')], + * [stubTrue, constant('no match')] + * ]); + * + * func({ a: 1, b: 2 }); + * // => 'matches A' + * + * func({ a: 0, b: 1 }); + * // => 'matches B' + * + * func({ a: '1', b: '2' }); + * // => 'no match' + */ +declare function cond(pairs: Array<[truthy: (val: T) => boolean, falsey: (val: T) => R]>): (val: T) => R; + +export { cond }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..704a49180d9f0e4e24a40013eeb85b04bb2d811a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.d.ts @@ -0,0 +1,58 @@ +/** + * Creates a function that checks conditions one by one and runs the matching function. + * + * Each pair consists of a condition (predicate) and a function to run. + * The function goes through each condition in order until it finds one that's true. + * When it finds a true condition, it runs the corresponding function and returns its result. + * If none of the conditions are true, it returns undefined. + * + * @param {Array} pairs - Array of pairs. Each pair consists of a predicate function and a function to run. + * @returns {(...args: any[]) => unknown} A new composite function that checks conditions and runs the matching function. + * @example + * + * const func = cond([ + * [matches({ a: 1 }), constant('matches A')], + * [conforms({ b: isNumber }), constant('matches B')], + * [stubTrue, constant('no match')] + * ]); + * + * func({ a: 1, b: 2 }); + * // => 'matches A' + * + * func({ a: 0, b: 1 }); + * // => 'matches B' + * + * func({ a: '1', b: '2' }); + * // => 'no match' + */ +declare function cond(pairs: Array<[truthy: () => boolean, falsey: () => R]>): () => R; +/** + * Creates a function that checks conditions one by one and runs the matching function. + * + * Each pair consists of a condition (predicate) and a function to run. + * The function goes through each condition in order until it finds one that's true. + * When it finds a true condition, it runs the corresponding function and returns its result. + * If none of the conditions are true, it returns undefined. + * + * @param {Array} pairs - Array of pairs. Each pair consists of a predicate function and a function to run. + * @returns {(...args: any[]) => unknown} A new composite function that checks conditions and runs the matching function. + * @example + * + * const func = cond([ + * [matches({ a: 1 }), constant('matches A')], + * [conforms({ b: isNumber }), constant('matches B')], + * [stubTrue, constant('no match')] + * ]); + * + * func({ a: 1, b: 2 }); + * // => 'matches A' + * + * func({ a: 0, b: 1 }); + * // => 'matches B' + * + * func({ a: '1', b: '2' }); + * // => 'no match' + */ +declare function cond(pairs: Array<[truthy: (val: T) => boolean, falsey: (val: T) => R]>): (val: T) => R; + +export { cond }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.js new file mode 100644 index 0000000000000000000000000000000000000000..2a57895f57dc33ad69616f8083ed9e9aaf252322 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const iteratee = require('./iteratee.js'); +const isFunction = require('../../predicate/isFunction.js'); + +function cond(pairs) { + const length = pairs.length; + const processedPairs = pairs.map(pair => { + const predicate = pair[0]; + const func = pair[1]; + if (!isFunction.isFunction(func)) { + throw new TypeError('Expected a function'); + } + return [iteratee.iteratee(predicate), func]; + }); + return function (...args) { + for (let i = 0; i < length; i++) { + const pair = processedPairs[i]; + const predicate = pair[0]; + const func = pair[1]; + if (predicate.apply(this, args)) { + return func.apply(this, args); + } + } + }; +} + +exports.cond = cond; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2ebd641e95e90894a24fc3c7d3a6d44c5e2333dd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/cond.mjs @@ -0,0 +1,26 @@ +import { iteratee } from './iteratee.mjs'; +import { isFunction } from '../../predicate/isFunction.mjs'; + +function cond(pairs) { + const length = pairs.length; + const processedPairs = pairs.map(pair => { + const predicate = pair[0]; + const func = pair[1]; + if (!isFunction(func)) { + throw new TypeError('Expected a function'); + } + return [iteratee(predicate), func]; + }); + return function (...args) { + for (let i = 0; i < length; i++) { + const pair = processedPairs[i]; + const predicate = pair[0]; + const func = pair[1]; + if (predicate.apply(this, args)) { + return func.apply(this, args); + } + } + }; +} + +export { cond }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bb2e4694886339dc1d947c8f63b73ac8eb40d493 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.d.mts @@ -0,0 +1,10 @@ +/** + * Creates a new function that always returns `value`. + * + * @template T - The type of the value to return. + * @param {T} value - The value to return from the new function. + * @returns {() => T} Returns the new constant function. + */ +declare function constant(value: T): () => T; + +export { constant }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bb2e4694886339dc1d947c8f63b73ac8eb40d493 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.d.ts @@ -0,0 +1,10 @@ +/** + * Creates a new function that always returns `value`. + * + * @template T - The type of the value to return. + * @param {T} value - The value to return from the new function. + * @returns {() => T} Returns the new constant function. + */ +declare function constant(value: T): () => T; + +export { constant }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.js new file mode 100644 index 0000000000000000000000000000000000000000..e467b264d13404f6b0cddae512a044bd2781eac4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function constant(value) { + return () => value; +} + +exports.constant = constant; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5be2843db1d84e5f14f87a73db2397232f9d3663 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/constant.mjs @@ -0,0 +1,5 @@ +function constant(value) { + return () => value; +} + +export { constant }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..51267a6d7fdc9f84a71918dd0016a5b2ab3e4dd7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.d.mts @@ -0,0 +1,21 @@ +/** + * Returns the default value for `null`, `undefined`, and `NaN`. + * + * @template T - The type of the value parameter + * @param {T | null | undefined} value - The value to check. + * @param {T} defaultValue - The default value to return if the first value is null, undefined, or NaN. + * @returns {T} Returns either the first value or the default value. + */ +declare function defaultTo(value: T | null | undefined, defaultValue: T): T; +/** + * Returns the default value for `null`, `undefined`, and `NaN`. + * + * @template T - The type of the value parameter + * @template D - The type of the defaultValue parameter + * @param {T | null | undefined} value - The value to check. + * @param {D} defaultValue - The default value to return if the first value is null, undefined, or NaN. + * @returns {T | D} Returns either the first value or the default value. + */ +declare function defaultTo(value: T | null | undefined, defaultValue: D): T | D; + +export { defaultTo }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..51267a6d7fdc9f84a71918dd0016a5b2ab3e4dd7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.d.ts @@ -0,0 +1,21 @@ +/** + * Returns the default value for `null`, `undefined`, and `NaN`. + * + * @template T - The type of the value parameter + * @param {T | null | undefined} value - The value to check. + * @param {T} defaultValue - The default value to return if the first value is null, undefined, or NaN. + * @returns {T} Returns either the first value or the default value. + */ +declare function defaultTo(value: T | null | undefined, defaultValue: T): T; +/** + * Returns the default value for `null`, `undefined`, and `NaN`. + * + * @template T - The type of the value parameter + * @template D - The type of the defaultValue parameter + * @param {T | null | undefined} value - The value to check. + * @param {D} defaultValue - The default value to return if the first value is null, undefined, or NaN. + * @returns {T | D} Returns either the first value or the default value. + */ +declare function defaultTo(value: T | null | undefined, defaultValue: D): T | D; + +export { defaultTo }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.js new file mode 100644 index 0000000000000000000000000000000000000000..cbbba680d23e40b46dcdbeb19375ace759a60698 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function defaultTo(value, defaultValue) { + if (value == null || Number.isNaN(value)) { + return defaultValue; + } + return value; +} + +exports.defaultTo = defaultTo; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d18e909a96eedca6f8aa1ef510e11c148bc08c79 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/defaultTo.mjs @@ -0,0 +1,8 @@ +function defaultTo(value, defaultValue) { + if (value == null || Number.isNaN(value)) { + return defaultValue; + } + return value; +} + +export { defaultTo }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..04c8b985baa87ff30c1c9fe558004a86983269c2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.d.mts @@ -0,0 +1,16 @@ +/** + * Performs a `SameValueZero` comparison between two values to determine if they are equivalent. + * + * @param {any} value - The value to compare. + * @param {any} other - The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * + * @example + * eq(1, 1); // true + * eq(0, -0); // true + * eq(NaN, NaN); // true + * eq('a', Object('a')); // false + */ +declare function eq(value: any, other: any): boolean; + +export { eq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..04c8b985baa87ff30c1c9fe558004a86983269c2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.d.ts @@ -0,0 +1,16 @@ +/** + * Performs a `SameValueZero` comparison between two values to determine if they are equivalent. + * + * @param {any} value - The value to compare. + * @param {any} other - The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * + * @example + * eq(1, 1); // true + * eq(0, -0); // true + * eq(NaN, NaN); // true + * eq('a', Object('a')); // false + */ +declare function eq(value: any, other: any): boolean; + +export { eq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.js new file mode 100644 index 0000000000000000000000000000000000000000..9e9cf763bbdbc18161d5c5a41e7e1f32e9d3d0bd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function eq(value, other) { + return value === other || (Number.isNaN(value) && Number.isNaN(other)); +} + +exports.eq = eq; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6406eb54b6da3890d9c9db25d168baa867ef7e4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/eq.mjs @@ -0,0 +1,5 @@ +function eq(value, other) { + return value === other || (Number.isNaN(value) && Number.isNaN(other)); +} + +export { eq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a79fcbbacda85956dedd8e7ed3c40b9271bc73d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.d.mts @@ -0,0 +1,15 @@ +/** + * Checks if value is greater than other. + * + * @param {any} value The value to compare. + * @param {any} other The other value to compare. + * @returns {boolean} Returns `true` if value is greater than other, else `false`. + * + * @example + * gt(3, 1); // true + * gt(3, 3); // false + * gt(1, 3); // false + */ +declare function gt(value: any, other: any): boolean; + +export { gt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a79fcbbacda85956dedd8e7ed3c40b9271bc73d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.d.ts @@ -0,0 +1,15 @@ +/** + * Checks if value is greater than other. + * + * @param {any} value The value to compare. + * @param {any} other The other value to compare. + * @returns {boolean} Returns `true` if value is greater than other, else `false`. + * + * @example + * gt(3, 1); // true + * gt(3, 3); // false + * gt(1, 3); // false + */ +declare function gt(value: any, other: any): boolean; + +export { gt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.js new file mode 100644 index 0000000000000000000000000000000000000000..90bcf329aa05849cdd6505a5474457b9665fffa6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('./toNumber.js'); + +function gt(value, other) { + if (typeof value === 'string' && typeof other === 'string') { + return value > other; + } + return toNumber.toNumber(value) > toNumber.toNumber(other); +} + +exports.gt = gt; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e185b7b379f92ad091a7e41948722f8e8a33cf1f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gt.mjs @@ -0,0 +1,10 @@ +import { toNumber } from './toNumber.mjs'; + +function gt(value, other) { + if (typeof value === 'string' && typeof other === 'string') { + return value > other; + } + return toNumber(value) > toNumber(other); +} + +export { gt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6a4c0bb669d952a3dc988eb30ab8a98d594ff8bb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.d.mts @@ -0,0 +1,15 @@ +/** + * Checks if value is greater than or equal to other. + * + * @param {any} value The value to compare. + * @param {any} other The other value to compare. + * @returns {boolean} Returns `true` if value is greater than or equal to other, else `false`. + * + * @example + * gte(3, 1); // => true + * gte(3, 3); // => true + * gte(1, 3); // => false + */ +declare function gte(value: any, other: any): boolean; + +export { gte }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6a4c0bb669d952a3dc988eb30ab8a98d594ff8bb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.d.ts @@ -0,0 +1,15 @@ +/** + * Checks if value is greater than or equal to other. + * + * @param {any} value The value to compare. + * @param {any} other The other value to compare. + * @returns {boolean} Returns `true` if value is greater than or equal to other, else `false`. + * + * @example + * gte(3, 1); // => true + * gte(3, 3); // => true + * gte(1, 3); // => false + */ +declare function gte(value: any, other: any): boolean; + +export { gte }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.js new file mode 100644 index 0000000000000000000000000000000000000000..d108666cda4b186aafffe4468df6c29dc8e14050 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('./toNumber.js'); + +function gte(value, other) { + if (typeof value === 'string' && typeof other === 'string') { + return value >= other; + } + return toNumber.toNumber(value) >= toNumber.toNumber(other); +} + +exports.gte = gte; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.mjs new file mode 100644 index 0000000000000000000000000000000000000000..66fcf9296186f5c06be9bd6d12199c9b1394e5b8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/gte.mjs @@ -0,0 +1,10 @@ +import { toNumber } from './toNumber.mjs'; + +function gte(value, other) { + if (typeof value === 'string' && typeof other === 'string') { + return value >= other; + } + return toNumber(value) >= toNumber(other); +} + +export { gte }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..108c727ca79349f46c46472f3bd8f17de58fea24 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.d.mts @@ -0,0 +1,23 @@ +/** + * Invokes the method at `path` of `object` with the given arguments. + * + * @param {unknown} object - The object to query. + * @param {PropertyKey | PropertyKey[]} path - The path of the method to invoke. + * @param {any[]} args - The arguments to invoke the method with. + * @returns {any} - Returns the result of the invoked method. + * + * @example + * const object = { + * a: { + * b: function (x, y) { + * return x + y; + * } + * } + * }; + * + * invoke(object, 'a.b', [1, 2]); // => 3 + * invoke(object, ['a', 'b'], [1, 2]); // => 3 + */ +declare function invoke(object: any, path: PropertyKey | readonly PropertyKey[], ...args: any[]): any; + +export { invoke }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..108c727ca79349f46c46472f3bd8f17de58fea24 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.d.ts @@ -0,0 +1,23 @@ +/** + * Invokes the method at `path` of `object` with the given arguments. + * + * @param {unknown} object - The object to query. + * @param {PropertyKey | PropertyKey[]} path - The path of the method to invoke. + * @param {any[]} args - The arguments to invoke the method with. + * @returns {any} - Returns the result of the invoked method. + * + * @example + * const object = { + * a: { + * b: function (x, y) { + * return x + y; + * } + * } + * }; + * + * invoke(object, 'a.b', [1, 2]); // => 3 + * invoke(object, ['a', 'b'], [1, 2]); // => 3 + */ +declare function invoke(object: any, path: PropertyKey | readonly PropertyKey[], ...args: any[]): any; + +export { invoke }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.js new file mode 100644 index 0000000000000000000000000000000000000000..7593c1e17f35adbe26a47ec3f534cee665bb55ac --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.js @@ -0,0 +1,53 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toPath = require('./toPath.js'); +const toKey = require('../_internal/toKey.js'); +const last = require('../array/last.js'); +const get = require('../object/get.js'); + +function invoke(object, path, ...args) { + args = args.flat(1); + if (object == null) { + return; + } + switch (typeof path) { + case 'string': { + if (typeof object === 'object' && Object.hasOwn(object, path)) { + return invokeImpl(object, [path], args); + } + return invokeImpl(object, toPath.toPath(path), args); + } + case 'number': + case 'symbol': { + return invokeImpl(object, [path], args); + } + default: { + if (Array.isArray(path)) { + return invokeImpl(object, path, args); + } + else { + return invokeImpl(object, [path], args); + } + } + } +} +function invokeImpl(object, path, args) { + const parent = get.get(object, path.slice(0, -1), object); + if (parent == null) { + return undefined; + } + let lastKey = last.last(path); + const lastValue = lastKey?.valueOf(); + if (typeof lastValue === 'number') { + lastKey = toKey.toKey(lastValue); + } + else { + lastKey = String(lastKey); + } + const func = get.get(parent, lastKey); + return func?.apply(parent, args); +} + +exports.invoke = invoke; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.mjs new file mode 100644 index 0000000000000000000000000000000000000000..73e88093dffc784bfa3755ef627939701f1ee7bb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/invoke.mjs @@ -0,0 +1,49 @@ +import { toPath } from './toPath.mjs'; +import { toKey } from '../_internal/toKey.mjs'; +import { last } from '../array/last.mjs'; +import { get } from '../object/get.mjs'; + +function invoke(object, path, ...args) { + args = args.flat(1); + if (object == null) { + return; + } + switch (typeof path) { + case 'string': { + if (typeof object === 'object' && Object.hasOwn(object, path)) { + return invokeImpl(object, [path], args); + } + return invokeImpl(object, toPath(path), args); + } + case 'number': + case 'symbol': { + return invokeImpl(object, [path], args); + } + default: { + if (Array.isArray(path)) { + return invokeImpl(object, path, args); + } + else { + return invokeImpl(object, [path], args); + } + } + } +} +function invokeImpl(object, path, args) { + const parent = get(object, path.slice(0, -1), object); + if (parent == null) { + return undefined; + } + let lastKey = last(path); + const lastValue = lastKey?.valueOf(); + if (typeof lastValue === 'number') { + lastKey = toKey(lastValue); + } + else { + lastKey = String(lastKey); + } + const func = get(parent, lastKey); + return func?.apply(parent, args); +} + +export { invoke }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a754958329a433dc60efcce5ec5b4fc2e62b701c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.d.mts @@ -0,0 +1,33 @@ +/** + * Returns the provided function as-is when it is a function type. + * + * @template F - The function type + * @param {F} func - The function to return + * @returns {F} Returns the provided function unchanged + * + * @example + * const fn = (x: number) => x * 2; + * const iterateeFn = iteratee(fn); + * iterateeFn(4); // => 8 + */ +declare function iteratee any>(func: F): F; +/** + * Creates an iteratee function based on the provided property key or object. + * If given a property key, returns a function that gets that property from objects. + * If given an object, returns a function that matches objects against the provided one. + * + * @param {PropertyKey | object} func - The value to convert to an iteratee + * @returns {Function} Returns the iteratee function + * + * @example + * // With property key + * const getLength = iteratee('length'); + * getLength([1,2,3]); // => 3 + * + * // With object + * const matchObj = iteratee({ x: 1, y: 2 }); + * matchObj({ x: 1, y: 2, z: 3 }); // => true + */ +declare function iteratee(func: PropertyKey | object): (...args: any[]) => any; + +export { iteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a754958329a433dc60efcce5ec5b4fc2e62b701c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.d.ts @@ -0,0 +1,33 @@ +/** + * Returns the provided function as-is when it is a function type. + * + * @template F - The function type + * @param {F} func - The function to return + * @returns {F} Returns the provided function unchanged + * + * @example + * const fn = (x: number) => x * 2; + * const iterateeFn = iteratee(fn); + * iterateeFn(4); // => 8 + */ +declare function iteratee any>(func: F): F; +/** + * Creates an iteratee function based on the provided property key or object. + * If given a property key, returns a function that gets that property from objects. + * If given an object, returns a function that matches objects against the provided one. + * + * @param {PropertyKey | object} func - The value to convert to an iteratee + * @returns {Function} Returns the iteratee function + * + * @example + * // With property key + * const getLength = iteratee('length'); + * getLength([1,2,3]); // => 3 + * + * // With object + * const matchObj = iteratee({ x: 1, y: 2 }); + * matchObj({ x: 1, y: 2, z: 3 }); // => true + */ +declare function iteratee(func: PropertyKey | object): (...args: any[]) => any; + +export { iteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.js new file mode 100644 index 0000000000000000000000000000000000000000..2454d6bda92f72165a501900b67f53c1fa722859 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.js @@ -0,0 +1,32 @@ +'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 iteratee(value) { + if (value == null) { + return identity.identity; + } + switch (typeof value) { + case 'function': { + return value; + } + case 'object': { + if (Array.isArray(value) && value.length === 2) { + return matchesProperty.matchesProperty(value[0], value[1]); + } + return matches.matches(value); + } + case 'string': + case 'symbol': + case 'number': { + return property.property(value); + } + } +} + +exports.iteratee = iteratee; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.mjs new file mode 100644 index 0000000000000000000000000000000000000000..53720afaabdaa6fbb6fdff72c11176bd346134d2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/iteratee.mjs @@ -0,0 +1,28 @@ +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 iteratee(value) { + if (value == null) { + return identity; + } + switch (typeof value) { + case 'function': { + return value; + } + case 'object': { + if (Array.isArray(value) && value.length === 2) { + return matchesProperty(value[0], value[1]); + } + return matches(value); + } + case 'string': + case 'symbol': + case 'number': { + return property(value); + } + } +} + +export { iteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8db3bbdff5a7cdf44099d0e9636208ef928347ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.d.mts @@ -0,0 +1,15 @@ +/** + * Checks if value is less than other. + * + * @param {any} value The value to compare. + * @param {any} other The other value to compare. + * @returns {boolean} Returns `true` if value is less than other, else `false`. + * + * @example + * lt(1, 3); // true + * lt(3, 3); // false + * lt(3, 1); // false + */ +declare function lt(value: any, other: any): boolean; + +export { lt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8db3bbdff5a7cdf44099d0e9636208ef928347ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.d.ts @@ -0,0 +1,15 @@ +/** + * Checks if value is less than other. + * + * @param {any} value The value to compare. + * @param {any} other The other value to compare. + * @returns {boolean} Returns `true` if value is less than other, else `false`. + * + * @example + * lt(1, 3); // true + * lt(3, 3); // false + * lt(3, 1); // false + */ +declare function lt(value: any, other: any): boolean; + +export { lt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.js new file mode 100644 index 0000000000000000000000000000000000000000..7ca9970187e44d8b894a9fe4db4307e0e7ae41db --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('./toNumber.js'); + +function lt(value, other) { + if (typeof value === 'string' && typeof other === 'string') { + return value < other; + } + return toNumber.toNumber(value) < toNumber.toNumber(other); +} + +exports.lt = lt; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fb898ff3bc0d1281ec2ebf4ab636b3f1b0c8bbf2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lt.mjs @@ -0,0 +1,10 @@ +import { toNumber } from './toNumber.mjs'; + +function lt(value, other) { + if (typeof value === 'string' && typeof other === 'string') { + return value < other; + } + return toNumber(value) < toNumber(other); +} + +export { lt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f5942cad75d49810ab715709258552ecfdb99407 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.d.mts @@ -0,0 +1,15 @@ +/** + * Checks if value is less than or equal to other. + * + * @param {any} value The value to compare. + * @param {any} other The other value to compare. + * @returns {boolean} Returns `true` if value is less than or equal to other, else `false`. + * + * @example + * lte(1, 3); // => true + * lte(3, 3); // => true + * lte(3, 1); // => false + */ +declare function lte(value: any, other: any): boolean; + +export { lte }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f5942cad75d49810ab715709258552ecfdb99407 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.d.ts @@ -0,0 +1,15 @@ +/** + * Checks if value is less than or equal to other. + * + * @param {any} value The value to compare. + * @param {any} other The other value to compare. + * @returns {boolean} Returns `true` if value is less than or equal to other, else `false`. + * + * @example + * lte(1, 3); // => true + * lte(3, 3); // => true + * lte(3, 1); // => false + */ +declare function lte(value: any, other: any): boolean; + +export { lte }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.js new file mode 100644 index 0000000000000000000000000000000000000000..b2e10c69a6521379132c6d1a7f973137f041cbcb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('./toNumber.js'); + +function lte(value, other) { + if (typeof value === 'string' && typeof other === 'string') { + return value <= other; + } + return toNumber.toNumber(value) <= toNumber.toNumber(other); +} + +exports.lte = lte; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d0c1622ab3e8c86a19be376e30455c3bae55c964 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/lte.mjs @@ -0,0 +1,10 @@ +import { toNumber } from './toNumber.mjs'; + +function lte(value, other) { + if (typeof value === 'string' && typeof other === 'string') { + return value <= other; + } + return toNumber(value) <= toNumber(other); +} + +export { lte }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e24e5ba0c0b3461be3dd6aeff3967b13450600da --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.d.mts @@ -0,0 +1,22 @@ +/** + * Creates a function that invokes the method at `path` of a given object with the provided arguments. + * + * @param {PropertyKey | PropertyKey[]} path - The path of the method to invoke. + * @param {...any} args - The arguments to invoke the method with. + * @returns {(object?: unknown) => any} - Returns a new function that takes an object and invokes the method at `path` with `args`. + * + * @example + * const object = { + * a: { + * b: function (x, y) { + * return x + y; + * } + * } + * }; + * + * const add = method('a.b', 1, 2); + * console.log(add(object)); // => 3 + */ +declare function method(path: PropertyKey | readonly PropertyKey[], ...args: any[]): (object: any) => any; + +export { method }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e24e5ba0c0b3461be3dd6aeff3967b13450600da --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.d.ts @@ -0,0 +1,22 @@ +/** + * Creates a function that invokes the method at `path` of a given object with the provided arguments. + * + * @param {PropertyKey | PropertyKey[]} path - The path of the method to invoke. + * @param {...any} args - The arguments to invoke the method with. + * @returns {(object?: unknown) => any} - Returns a new function that takes an object and invokes the method at `path` with `args`. + * + * @example + * const object = { + * a: { + * b: function (x, y) { + * return x + y; + * } + * } + * }; + * + * const add = method('a.b', 1, 2); + * console.log(add(object)); // => 3 + */ +declare function method(path: PropertyKey | readonly PropertyKey[], ...args: any[]): (object: any) => any; + +export { method }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.js new file mode 100644 index 0000000000000000000000000000000000000000..c3e9f9bb8340e8d2f3cca026eba60edabcae2623 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const invoke = require('./invoke.js'); + +function method(path, ...args) { + return function (object) { + return invoke.invoke(object, path, args); + }; +} + +exports.method = method; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d28474acd4ed87ee77ed7334783f2d6dcc929ae4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/method.mjs @@ -0,0 +1,9 @@ +import { invoke } from './invoke.mjs'; + +function method(path, ...args) { + return function (object) { + return invoke(object, path, args); + }; +} + +export { method }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1c027baf25e9e2536ea64e2b1b7e030dfb9937ff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.d.mts @@ -0,0 +1,22 @@ +/** + * Creates a function that invokes the method at a given path of `object` with the provided arguments. + * + * @param {object} object - The object to query. + * @param {...any} args - The arguments to invoke the method with. + * @returns {(path: PropertyKey | PropertyKey[]) => any} - Returns a new function that takes a path and invokes the method at `path` with `args`. + * + * @example + * const object = { + * a: { + * b: function (x, y) { + * return x + y; + * } + * } + * }; + * + * const add = methodOf(object, 1, 2); + * console.log(add('a.b')); // => 3 + */ +declare function methodOf(object: object, ...args: any[]): (path: PropertyKey | readonly PropertyKey[]) => any; + +export { methodOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1c027baf25e9e2536ea64e2b1b7e030dfb9937ff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.d.ts @@ -0,0 +1,22 @@ +/** + * Creates a function that invokes the method at a given path of `object` with the provided arguments. + * + * @param {object} object - The object to query. + * @param {...any} args - The arguments to invoke the method with. + * @returns {(path: PropertyKey | PropertyKey[]) => any} - Returns a new function that takes a path and invokes the method at `path` with `args`. + * + * @example + * const object = { + * a: { + * b: function (x, y) { + * return x + y; + * } + * } + * }; + * + * const add = methodOf(object, 1, 2); + * console.log(add('a.b')); // => 3 + */ +declare function methodOf(object: object, ...args: any[]): (path: PropertyKey | readonly PropertyKey[]) => any; + +export { methodOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.js new file mode 100644 index 0000000000000000000000000000000000000000..ad9db7e82a9a4ce71cba0d9618fe9d8d6ba1d635 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const invoke = require('./invoke.js'); + +function methodOf(object, ...args) { + return function (path) { + return invoke.invoke(object, path, args); + }; +} + +exports.methodOf = methodOf; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.mjs new file mode 100644 index 0000000000000000000000000000000000000000..970c778f6a9df7380a3aab8712ca7535784d7e5f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/methodOf.mjs @@ -0,0 +1,9 @@ +import { invoke } from './invoke.mjs'; + +function methodOf(object, ...args) { + return function (path) { + return invoke(object, path, args); + }; +} + +export { methodOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..3643b520dd6bb65b02b84f38f3e198a58bbab66d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.d.mts @@ -0,0 +1,18 @@ +/** + * Returns the number of milliseconds elapsed since January 1, 1970 00:00:00 UTC. + * + * @returns {number} The current time in milliseconds. + * + * @example + * const currentTime = now(); + * console.log(currentTime); // Outputs the current time in milliseconds + * + * @example + * const startTime = now(); + * // Some time-consuming operation + * const endTime = now(); + * console.log(`Operation took ${endTime - startTime} milliseconds`); + */ +declare function now(): number; + +export { now }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3643b520dd6bb65b02b84f38f3e198a58bbab66d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.d.ts @@ -0,0 +1,18 @@ +/** + * Returns the number of milliseconds elapsed since January 1, 1970 00:00:00 UTC. + * + * @returns {number} The current time in milliseconds. + * + * @example + * const currentTime = now(); + * console.log(currentTime); // Outputs the current time in milliseconds + * + * @example + * const startTime = now(); + * // Some time-consuming operation + * const endTime = now(); + * console.log(`Operation took ${endTime - startTime} milliseconds`); + */ +declare function now(): number; + +export { now }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.js new file mode 100644 index 0000000000000000000000000000000000000000..956be19bae50c5cf0a0df126632978a3e11dadea --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function now() { + return Date.now(); +} + +exports.now = now; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.mjs new file mode 100644 index 0000000000000000000000000000000000000000..eee7673bb3554b97beea288e0fa6cf14d48dc655 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/now.mjs @@ -0,0 +1,5 @@ +function now() { + return Date.now(); +} + +export { now }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..769a0dd5ea60cda61f454238ad6f386fee407fa6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.d.mts @@ -0,0 +1,29 @@ +/** + * Creates a function that invokes given functions and returns their results as an array. + * + * @param {Array} iteratees - The iteratees to invoke. + * @returns {(...args: any[]) => unknown[]} Returns the new function. + * + * @example + * const func = over([Math.max, Math.min]); + * const func2 = over(Math.max, Math.min); // same as above + * func(1, 2, 3, 4); + * // => [4, 1] + * func2(1, 2, 3, 4); + * // => [4, 1] + * + * const func = over(['a', 'b']); + * func({ a: 1, b: 2 }); + * // => [1, 2] + * + * const func = over([{ a: 1 }, { b: 2 }]); + * func({ a: 1, b: 2 }); + * // => [true, false] + * + * const func = over([['a', 1], ['b', 2]]); + * func({ a: 1, b: 2 }); + * // => [true, true] + */ +declare function over(...iteratees: Array<((...args: any[]) => T) | ReadonlyArray<(...args: any[]) => T>>): (...args: any[]) => T[]; + +export { over }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..769a0dd5ea60cda61f454238ad6f386fee407fa6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.d.ts @@ -0,0 +1,29 @@ +/** + * Creates a function that invokes given functions and returns their results as an array. + * + * @param {Array} iteratees - The iteratees to invoke. + * @returns {(...args: any[]) => unknown[]} Returns the new function. + * + * @example + * const func = over([Math.max, Math.min]); + * const func2 = over(Math.max, Math.min); // same as above + * func(1, 2, 3, 4); + * // => [4, 1] + * func2(1, 2, 3, 4); + * // => [4, 1] + * + * const func = over(['a', 'b']); + * func({ a: 1, b: 2 }); + * // => [1, 2] + * + * const func = over([{ a: 1 }, { b: 2 }]); + * func({ a: 1, b: 2 }); + * // => [true, false] + * + * const func = over([['a', 1], ['b', 2]]); + * func({ a: 1, b: 2 }); + * // => [true, true] + */ +declare function over(...iteratees: Array<((...args: any[]) => T) | ReadonlyArray<(...args: any[]) => T>>): (...args: any[]) => T[]; + +export { over }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.js new file mode 100644 index 0000000000000000000000000000000000000000..8c7bc70987e324bb2bdaaf3062f76fc4b5e3c98e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const iteratee = require('./iteratee.js'); + +function over(...iteratees) { + if (iteratees.length === 1 && Array.isArray(iteratees[0])) { + iteratees = iteratees[0]; + } + const funcs = iteratees.map(item => iteratee.iteratee(item)); + return function (...args) { + return funcs.map(func => func.apply(this, args)); + }; +} + +exports.over = over; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8150c7bb9f75d35400c101b3377c87337b739502 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/over.mjs @@ -0,0 +1,13 @@ +import { iteratee } from './iteratee.mjs'; + +function over(...iteratees) { + if (iteratees.length === 1 && Array.isArray(iteratees[0])) { + iteratees = iteratees[0]; + } + const funcs = iteratees.map(item => iteratee(item)); + return function (...args) { + return funcs.map(func => func.apply(this, args)); + }; +} + +export { over }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..32426cc01b67ec1c423a06555b16c712e93af478 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.d.mts @@ -0,0 +1,67 @@ +/** + * Creates a predicate function that checks if a value satisfies all of the given predicates. + * + * @template T - The type of the value to be checked. + * @template U - The first possible type that the value could match. + * @template V - The second possible type that the value could match. + * + * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`. + * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`. + * + * @returns {(value: T) => value is U & V} A function that takes a value and returns `true` if all predicates return truthy. + * + * @example + * const func = overEvery( + * (value) => typeof value === 'string', + * (value) => value === 'hello' + * ); + * + * func("hello"); // true + * func("world"); // false + * func(42); // false + */ +declare function overEvery(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U & V; +/** + * Creates a function that checks if all of the given predicates return truthy for the provided values. + * + * @template T - The type of the values to be checked. + * + * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates - + * A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of + * type `T` and returns a boolean indicating whether the condition is satisfied for those values. + * + * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if all of the + * predicates return truthy for the provided values, and `false` otherwise. + * + * @example + * const func = overEvery( + * (value) => typeof value === 'string', + * (value) => value.length > 3 + * ); + * + * func("hello"); // true + * func("hi"); // false + * func(42); // false + * + * @example + * const func = overEvery([ + * (value) => value.a > 0, + * (value) => value.b > 0 + * ]); + * + * func({ a: 1, b: 2 }); // true + * func({ a: 0, b: 2 }); // false + * + * @example + * const func = overEvery( + * (a, b) => typeof a === 'string' && typeof b === 'string', + * (a, b) => a.length > 3 && b.length > 3 + * ); + * + * func("hello", "world"); // true + * func("hi", "world"); // false + * func(1, 10); // false + */ +declare function overEvery(...predicates: Array<((...args: T[]) => boolean) | ReadonlyArray<(...args: T[]) => boolean>>): (...args: T[]) => boolean; + +export { overEvery }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..32426cc01b67ec1c423a06555b16c712e93af478 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.d.ts @@ -0,0 +1,67 @@ +/** + * Creates a predicate function that checks if a value satisfies all of the given predicates. + * + * @template T - The type of the value to be checked. + * @template U - The first possible type that the value could match. + * @template V - The second possible type that the value could match. + * + * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`. + * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`. + * + * @returns {(value: T) => value is U & V} A function that takes a value and returns `true` if all predicates return truthy. + * + * @example + * const func = overEvery( + * (value) => typeof value === 'string', + * (value) => value === 'hello' + * ); + * + * func("hello"); // true + * func("world"); // false + * func(42); // false + */ +declare function overEvery(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U & V; +/** + * Creates a function that checks if all of the given predicates return truthy for the provided values. + * + * @template T - The type of the values to be checked. + * + * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates - + * A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of + * type `T` and returns a boolean indicating whether the condition is satisfied for those values. + * + * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if all of the + * predicates return truthy for the provided values, and `false` otherwise. + * + * @example + * const func = overEvery( + * (value) => typeof value === 'string', + * (value) => value.length > 3 + * ); + * + * func("hello"); // true + * func("hi"); // false + * func(42); // false + * + * @example + * const func = overEvery([ + * (value) => value.a > 0, + * (value) => value.b > 0 + * ]); + * + * func({ a: 1, b: 2 }); // true + * func({ a: 0, b: 2 }); // false + * + * @example + * const func = overEvery( + * (a, b) => typeof a === 'string' && typeof b === 'string', + * (a, b) => a.length > 3 && b.length > 3 + * ); + * + * func("hello", "world"); // true + * func("hi", "world"); // false + * func(1, 10); // false + */ +declare function overEvery(...predicates: Array<((...args: T[]) => boolean) | ReadonlyArray<(...args: T[]) => boolean>>): (...args: T[]) => boolean; + +export { overEvery }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.js new file mode 100644 index 0000000000000000000000000000000000000000..5084a3f00a9f5c6e0cef3f730cfc380cd5034c38 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const iteratee = require('./iteratee.js'); + +function overEvery(...predicates) { + return function (...values) { + for (let i = 0; i < predicates.length; ++i) { + const predicate = predicates[i]; + if (!Array.isArray(predicate)) { + if (!iteratee.iteratee(predicate).apply(this, values)) { + return false; + } + continue; + } + for (let j = 0; j < predicate.length; ++j) { + if (!iteratee.iteratee(predicate[j]).apply(this, values)) { + return false; + } + } + } + return true; + }; +} + +exports.overEvery = overEvery; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8c8f31f85b636473f4b3eb14da3641574f5e9a34 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overEvery.mjs @@ -0,0 +1,23 @@ +import { iteratee } from './iteratee.mjs'; + +function overEvery(...predicates) { + return function (...values) { + for (let i = 0; i < predicates.length; ++i) { + const predicate = predicates[i]; + if (!Array.isArray(predicate)) { + if (!iteratee(predicate).apply(this, values)) { + return false; + } + continue; + } + for (let j = 0; j < predicate.length; ++j) { + if (!iteratee(predicate[j]).apply(this, values)) { + return false; + } + } + } + return true; + }; +} + +export { overEvery }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0c98b2ebecdb83ca0bc8a91373001eda4ae267af --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.d.mts @@ -0,0 +1,69 @@ +/** + * Creates a predicate function that checks if a value satisfies at least one of the given predicates. + * + * @template T - The type of the value to be checked. + * @template U - The first possible type that the value could match. + * @template V - The second possible type that the value could match. + * + * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`. + * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`. + * + * @returns {(value: T) => value is U | V} A function that takes a value and returns `true` if any predicates return truthy. + * + * @example + * const func = overSome( + * (value) => typeof value === 'string', + * (value) => typeof value === 'number' + * ); + * + * func("hello"); // true + * func(42); // true + * func([]); // false + */ +declare function overSome(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U | V; +/** + * Creates a function that checks if any of the given predicates return truthy for the provided values. + * + * @template T - The type of the values to be checked. + * + * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates - + * A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of + * type `T` and returns a boolean indicating whether the condition is satisfied for those values. + * + * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if any of the + * predicates return truthy for the provided values, and `false` otherwise. + * + * @example + * const func = overSome( + * (value) => typeof value === 'string', + * (value) => typeof value === 'number', + * (value) => typeof value === 'symbol' + * ); + * + * func("hello"); // true + * func(42); // true + * func(Symbol()); // true + * func([]); // false + * + * @example + * const func = overSome([ + * (value) => value.a > 0, + * (value) => value.b > 0 + * ]); + * + * func({ a: 0, b: 2 }); // true + * func({ a: 0, b: 0 }); // false + * + * @example + * const func = overSome( + * (a, b) => typeof a === 'string' && typeof b === 'string', + * (a, b) => a > 0 && b > 0 + * ); + * + * func("hello", "world"); // true + * func(1, 10); // true + * func(0, 2); // false + */ +declare function overSome(...predicates: Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>): (...values: T[]) => boolean; + +export { overSome }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0c98b2ebecdb83ca0bc8a91373001eda4ae267af --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.d.ts @@ -0,0 +1,69 @@ +/** + * Creates a predicate function that checks if a value satisfies at least one of the given predicates. + * + * @template T - The type of the value to be checked. + * @template U - The first possible type that the value could match. + * @template V - The second possible type that the value could match. + * + * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`. + * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`. + * + * @returns {(value: T) => value is U | V} A function that takes a value and returns `true` if any predicates return truthy. + * + * @example + * const func = overSome( + * (value) => typeof value === 'string', + * (value) => typeof value === 'number' + * ); + * + * func("hello"); // true + * func(42); // true + * func([]); // false + */ +declare function overSome(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U | V; +/** + * Creates a function that checks if any of the given predicates return truthy for the provided values. + * + * @template T - The type of the values to be checked. + * + * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates - + * A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of + * type `T` and returns a boolean indicating whether the condition is satisfied for those values. + * + * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if any of the + * predicates return truthy for the provided values, and `false` otherwise. + * + * @example + * const func = overSome( + * (value) => typeof value === 'string', + * (value) => typeof value === 'number', + * (value) => typeof value === 'symbol' + * ); + * + * func("hello"); // true + * func(42); // true + * func(Symbol()); // true + * func([]); // false + * + * @example + * const func = overSome([ + * (value) => value.a > 0, + * (value) => value.b > 0 + * ]); + * + * func({ a: 0, b: 2 }); // true + * func({ a: 0, b: 0 }); // false + * + * @example + * const func = overSome( + * (a, b) => typeof a === 'string' && typeof b === 'string', + * (a, b) => a > 0 && b > 0 + * ); + * + * func("hello", "world"); // true + * func(1, 10); // true + * func(0, 2); // false + */ +declare function overSome(...predicates: Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>): (...values: T[]) => boolean; + +export { overSome }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.js new file mode 100644 index 0000000000000000000000000000000000000000..816d00718cd52a2adf78b744f3e76664dac7a75a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const iteratee = require('./iteratee.js'); + +function overSome(...predicates) { + return function (...values) { + for (let i = 0; i < predicates.length; ++i) { + const predicate = predicates[i]; + if (!Array.isArray(predicate)) { + if (iteratee.iteratee(predicate).apply(this, values)) { + return true; + } + continue; + } + for (let j = 0; j < predicate.length; ++j) { + if (iteratee.iteratee(predicate[j]).apply(this, values)) { + return true; + } + } + } + return false; + }; +} + +exports.overSome = overSome; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d534088e9043d9fd0477335d8c3321659843448c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/overSome.mjs @@ -0,0 +1,23 @@ +import { iteratee } from './iteratee.mjs'; + +function overSome(...predicates) { + return function (...values) { + for (let i = 0; i < predicates.length; ++i) { + const predicate = predicates[i]; + if (!Array.isArray(predicate)) { + if (iteratee(predicate).apply(this, values)) { + return true; + } + continue; + } + for (let j = 0; j < predicate.length; ++j) { + if (iteratee(predicate[j]).apply(this, values)) { + return true; + } + } + } + return false; + }; +} + +export { overSome }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0bc9321bf78034cf84b10207ee979677f1556d28 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.d.mts @@ -0,0 +1,10 @@ +/** + * Returns a new empty array. + * + * @returns {Array} A new empty array. + * @example + * stubArray() // Returns [] + */ +declare function stubArray(): any[]; + +export { stubArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0bc9321bf78034cf84b10207ee979677f1556d28 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.d.ts @@ -0,0 +1,10 @@ +/** + * Returns a new empty array. + * + * @returns {Array} A new empty array. + * @example + * stubArray() // Returns [] + */ +declare function stubArray(): any[]; + +export { stubArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.js new file mode 100644 index 0000000000000000000000000000000000000000..e9ffbcba7a28efe51dedd92d3a6a1911bae3992f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function stubArray() { + return []; +} + +exports.stubArray = stubArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.mjs new file mode 100644 index 0000000000000000000000000000000000000000..15532e89fa742aec8f1754d302a984da796533ce --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubArray.mjs @@ -0,0 +1,5 @@ +function stubArray() { + return []; +} + +export { stubArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..59c63dd825e2beabb80eb3e5da6e3b0c6209e778 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.d.mts @@ -0,0 +1,18 @@ +/** + * Returns false. + * + * @returns {boolean} false. + * @example + * stubFalse() // Returns false + */ +declare function stubFalse(): false; +/** + * Returns false. + * + * @returns {boolean} false. + * @example + * stubFalse() // Returns false + */ +declare function stubFalse(): false; + +export { stubFalse }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..59c63dd825e2beabb80eb3e5da6e3b0c6209e778 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.d.ts @@ -0,0 +1,18 @@ +/** + * Returns false. + * + * @returns {boolean} false. + * @example + * stubFalse() // Returns false + */ +declare function stubFalse(): false; +/** + * Returns false. + * + * @returns {boolean} false. + * @example + * stubFalse() // Returns false + */ +declare function stubFalse(): false; + +export { stubFalse }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.js new file mode 100644 index 0000000000000000000000000000000000000000..c638e70b857eb5eabe4bfac8421ed6d1271ff73e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function stubFalse() { + return false; +} + +exports.stubFalse = stubFalse; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.mjs new file mode 100644 index 0000000000000000000000000000000000000000..bde8cb615510ae8de992881f5f3135e956f4c02d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubFalse.mjs @@ -0,0 +1,5 @@ +function stubFalse() { + return false; +} + +export { stubFalse }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..81a816aed33d957adc14cdbaf41409110153880c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.d.mts @@ -0,0 +1,10 @@ +/** + * Returns an empty object. + * + * @returns {Object} An empty object. + * @example + * stubObject() // Returns {} + */ +declare function stubObject(): any; + +export { stubObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..81a816aed33d957adc14cdbaf41409110153880c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.d.ts @@ -0,0 +1,10 @@ +/** + * Returns an empty object. + * + * @returns {Object} An empty object. + * @example + * stubObject() // Returns {} + */ +declare function stubObject(): any; + +export { stubObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.js new file mode 100644 index 0000000000000000000000000000000000000000..44254ca64e79cccfa0acecfaddefad141a1cfd73 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function stubObject() { + return {}; +} + +exports.stubObject = stubObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ee94fef8247d3025fcf87a6fb7672b5dd37453c7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubObject.mjs @@ -0,0 +1,5 @@ +function stubObject() { + return {}; +} + +export { stubObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..246f39dd9d00cb513f0670083e00c0fd204173de --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.d.mts @@ -0,0 +1,10 @@ +/** + * Returns an empty string. + * + * @returns {string} An empty string. + * @example + * stubString() // Returns '' + */ +declare function stubString(): string; + +export { stubString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..246f39dd9d00cb513f0670083e00c0fd204173de --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.d.ts @@ -0,0 +1,10 @@ +/** + * Returns an empty string. + * + * @returns {string} An empty string. + * @example + * stubString() // Returns '' + */ +declare function stubString(): string; + +export { stubString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.js new file mode 100644 index 0000000000000000000000000000000000000000..81c7738db0b790661e42944b891a74659cd1b9fc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function stubString() { + return ''; +} + +exports.stubString = stubString; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d3444ede55789c8ec3e2081d656681eacde2b90c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubString.mjs @@ -0,0 +1,5 @@ +function stubString() { + return ''; +} + +export { stubString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..42d6a873ff45fef07e4ada2ce49cee659afaf90e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.d.mts @@ -0,0 +1,18 @@ +/** + * Returns true. + * + * @returns {boolean} true. + * @example + * stubTrue() // Returns true + */ +declare function stubTrue(): true; +/** + * Returns true. + * + * @returns {boolean} true. + * @example + * stubTrue() // Returns true + */ +declare function stubTrue(): true; + +export { stubTrue }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..42d6a873ff45fef07e4ada2ce49cee659afaf90e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.d.ts @@ -0,0 +1,18 @@ +/** + * Returns true. + * + * @returns {boolean} true. + * @example + * stubTrue() // Returns true + */ +declare function stubTrue(): true; +/** + * Returns true. + * + * @returns {boolean} true. + * @example + * stubTrue() // Returns true + */ +declare function stubTrue(): true; + +export { stubTrue }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.js new file mode 100644 index 0000000000000000000000000000000000000000..c53b48d8eb6dff8d6fed1a12413d9b5da2369f39 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function stubTrue() { + return true; +} + +exports.stubTrue = stubTrue; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ef6bfff17f61340d7c3bbcbe84f994fa0c29451a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/stubTrue.mjs @@ -0,0 +1,5 @@ +function stubTrue() { + return true; +} + +export { stubTrue }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..507e11074ff8ae69e04f433d1fcdfc48ff719087 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.d.mts @@ -0,0 +1,23 @@ +/** + * Invokes the iteratee function n times, returning an array of the results. + * + * @template T The return type of the iteratee function. + * @param {number} n - The number of times to invoke iteratee. + * @param {(num: number) => T} iteratee - The function to invoke for each index. + * @returns {T[]} An array containing the results of invoking iteratee n times. + * @example + * times(3, (i) => i * 2); // => [0, 2, 4] + * times(2, () => 'es-toolkit'); // => ['es-toolkit', 'es-toolkit'] + */ +declare function times(n: number, iteratee: (num: number) => T): T[]; +/** + * Invokes the default iteratee function n times, returning an array of indices. + * + * @param {number} n - The number of times to invoke the default iteratee. + * @returns {number[]} An array containing indices from 0 to n-1. + * @example + * times(3); // => [0, 1, 2] + */ +declare function times(n: number): number[]; + +export { times }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..507e11074ff8ae69e04f433d1fcdfc48ff719087 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.d.ts @@ -0,0 +1,23 @@ +/** + * Invokes the iteratee function n times, returning an array of the results. + * + * @template T The return type of the iteratee function. + * @param {number} n - The number of times to invoke iteratee. + * @param {(num: number) => T} iteratee - The function to invoke for each index. + * @returns {T[]} An array containing the results of invoking iteratee n times. + * @example + * times(3, (i) => i * 2); // => [0, 2, 4] + * times(2, () => 'es-toolkit'); // => ['es-toolkit', 'es-toolkit'] + */ +declare function times(n: number, iteratee: (num: number) => T): T[]; +/** + * Invokes the default iteratee function n times, returning an array of indices. + * + * @param {number} n - The number of times to invoke the default iteratee. + * @returns {number[]} An array containing indices from 0 to n-1. + * @example + * times(3); // => [0, 1, 2] + */ +declare function times(n: number): number[]; + +export { times }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.js new file mode 100644 index 0000000000000000000000000000000000000000..5c6a555dd35aa2abeb4d8e60ac33bdf9b4fb813f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('./toInteger.js'); + +function times(n, getValue) { + n = toInteger.toInteger(n); + if (n < 1 || !Number.isSafeInteger(n)) { + return []; + } + const result = new Array(n); + for (let i = 0; i < n; i++) { + result[i] = typeof getValue === 'function' ? getValue(i) : i; + } + return result; +} + +exports.times = times; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a142337ef59ed14a325c6cfa2421fac608da8993 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/times.mjs @@ -0,0 +1,15 @@ +import { toInteger } from './toInteger.mjs'; + +function times(n, getValue) { + n = toInteger(n); + if (n < 1 || !Number.isSafeInteger(n)) { + return []; + } + const result = new Array(n); + for (let i = 0; i < n; i++) { + result[i] = typeof getValue === 'function' ? getValue(i) : i; + } + return result; +} + +export { times }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e05e88212de65314e4ff22a03ef48291221a9141 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.d.mts @@ -0,0 +1,35 @@ +/** + * Converts a record or null/undefined to an array of its values. + * + * @template T + * @param {Record | Record | null | undefined} value - The record or null/undefined to convert. + * @returns {T[]} Returns an array of the record's values or an empty array if null/undefined. + * + * @example + * toArray({ 'a': 1, 'b': 2 }) // => returns [1, 2] + * toArray(null) // => returns [] + */ +declare function toArray(value: Record | Record | null | undefined): T[]; +/** + * Converts a value to an array of its values. + * + * @template T + * @param {T} value - The value to convert. + * @returns {Array} Returns an array of the value's values. + * + * @example + * toArray({ x: 10, y: 20 }) // => returns [10, 20] + * toArray('abc') // => returns ['a', 'b', 'c'] + */ +declare function toArray(value: T): Array; +/** + * Converts an undefined value to an empty array. + * + * @returns {any[]} Returns an empty array. + * + * @example + * toArray() // => returns [] + */ +declare function toArray(): any[]; + +export { toArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e05e88212de65314e4ff22a03ef48291221a9141 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.d.ts @@ -0,0 +1,35 @@ +/** + * Converts a record or null/undefined to an array of its values. + * + * @template T + * @param {Record | Record | null | undefined} value - The record or null/undefined to convert. + * @returns {T[]} Returns an array of the record's values or an empty array if null/undefined. + * + * @example + * toArray({ 'a': 1, 'b': 2 }) // => returns [1, 2] + * toArray(null) // => returns [] + */ +declare function toArray(value: Record | Record | null | undefined): T[]; +/** + * Converts a value to an array of its values. + * + * @template T + * @param {T} value - The value to convert. + * @returns {Array} Returns an array of the value's values. + * + * @example + * toArray({ x: 10, y: 20 }) // => returns [10, 20] + * toArray('abc') // => returns ['a', 'b', 'c'] + */ +declare function toArray(value: T): Array; +/** + * Converts an undefined value to an empty array. + * + * @returns {any[]} Returns an empty array. + * + * @example + * toArray() // => returns [] + */ +declare function toArray(): any[]; + +export { toArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.js new file mode 100644 index 0000000000000000000000000000000000000000..6c66539cfc784a1ee358508e39298f2c11c15f1d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.js @@ -0,0 +1,21 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLike = require('../predicate/isArrayLike.js'); +const isMap = require('../predicate/isMap.js'); + +function toArray(value) { + if (value == null) { + return []; + } + if (isArrayLike.isArrayLike(value) || isMap.isMap(value)) { + return Array.from(value); + } + if (typeof value === 'object') { + return Object.values(value); + } + return []; +} + +exports.toArray = toArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5be29b7513a50ac9f99a52fafe41a01e24c6bd0b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toArray.mjs @@ -0,0 +1,17 @@ +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isMap } from '../predicate/isMap.mjs'; + +function toArray(value) { + if (value == null) { + return []; + } + if (isArrayLike(value) || isMap(value)) { + return Array.from(value); + } + if (typeof value === 'object') { + return Object.values(value); + } + return []; +} + +export { toArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0674486a432a713dad235f7093efa4c8a69fd8a8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.d.mts @@ -0,0 +1,17 @@ +/** + * Converts `value` to a finite number. + * + * @param {unknown} value - The value to convert. + * @returns {number} Returns the number. + * + * @example + * toNumber(3.2); // => 3.2 + * toNumber(Number.MIN_VALUE); // => 5e-324 + * toNumber(Infinity); // => 1.7976931348623157e+308 + * toNumber('3.2'); // => 3.2 + * toNumber(Symbol.iterator); // => 0 + * toNumber(NaN); // => 0 + */ +declare function toFinite(value: any): number; + +export { toFinite }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0674486a432a713dad235f7093efa4c8a69fd8a8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.d.ts @@ -0,0 +1,17 @@ +/** + * Converts `value` to a finite number. + * + * @param {unknown} value - The value to convert. + * @returns {number} Returns the number. + * + * @example + * toNumber(3.2); // => 3.2 + * toNumber(Number.MIN_VALUE); // => 5e-324 + * toNumber(Infinity); // => 1.7976931348623157e+308 + * toNumber('3.2'); // => 3.2 + * toNumber(Symbol.iterator); // => 0 + * toNumber(NaN); // => 0 + */ +declare function toFinite(value: any): number; + +export { toFinite }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.js new file mode 100644 index 0000000000000000000000000000000000000000..311dd5e754df63e6d0fdda9cc6264318d9b0be82 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toNumber = require('./toNumber.js'); + +function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber.toNumber(value); + if (value === Infinity || value === -Infinity) { + const sign = value < 0 ? -1 : 1; + return sign * Number.MAX_VALUE; + } + return value === value ? value : 0; +} + +exports.toFinite = toFinite; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b4ad37744f2b562b11e663becfeed7ef736dbce3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toFinite.mjs @@ -0,0 +1,15 @@ +import { toNumber } from './toNumber.mjs'; + +function toFinite(value) { + if (!value) { + return value === 0 ? value : 0; + } + value = toNumber(value); + if (value === Infinity || value === -Infinity) { + const sign = value < 0 ? -1 : 1; + return sign * Number.MAX_VALUE; + } + return value === value ? value : 0; +} + +export { toFinite }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ddbebb27af69865e38afa305b874e9a6429dda9b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.d.mts @@ -0,0 +1,20 @@ +/** + * Converts `value` to an integer. + * + * This function first converts `value` to a finite number. If the result has any decimal places, + * they are removed by rounding down to the nearest whole number. + * + * @param {unknown} value - The value to convert. + * @returns {number} Returns the number. + * + * @example + * toInteger(3.2); // => 3 + * toInteger(Number.MIN_VALUE); // => 0 + * toInteger(Infinity); // => 1.7976931348623157e+308 + * toInteger('3.2'); // => 3 + * toInteger(Symbol.iterator); // => 0 + * toInteger(NaN); // => 0 + */ +declare function toInteger(value: any): number; + +export { toInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ddbebb27af69865e38afa305b874e9a6429dda9b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.d.ts @@ -0,0 +1,20 @@ +/** + * Converts `value` to an integer. + * + * This function first converts `value` to a finite number. If the result has any decimal places, + * they are removed by rounding down to the nearest whole number. + * + * @param {unknown} value - The value to convert. + * @returns {number} Returns the number. + * + * @example + * toInteger(3.2); // => 3 + * toInteger(Number.MIN_VALUE); // => 0 + * toInteger(Infinity); // => 1.7976931348623157e+308 + * toInteger('3.2'); // => 3 + * toInteger(Symbol.iterator); // => 0 + * toInteger(NaN); // => 0 + */ +declare function toInteger(value: any): number; + +export { toInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.js new file mode 100644 index 0000000000000000000000000000000000000000..60254e39bb689b347a01c18947c6d93271d45d6e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toFinite = require('./toFinite.js'); + +function toInteger(value) { + const finite = toFinite.toFinite(value); + const remainder = finite % 1; + return remainder ? finite - remainder : finite; +} + +exports.toInteger = toInteger; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8c9e8f9feef6c801e6a34023164f1ed4024fc281 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toInteger.mjs @@ -0,0 +1,9 @@ +import { toFinite } from './toFinite.mjs'; + +function toInteger(value) { + const finite = toFinite(value); + const remainder = finite % 1; + return remainder ? finite - remainder : finite; +} + +export { toInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..151a0bc678245cf2d5b47458b3c3a2197ece3368 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.d.mts @@ -0,0 +1,18 @@ +/** + * Converts the value to a valid index. A valid index is an integer that is greater than or equal to `0` and less than or equal to `2^32 - 1`. + * + * It converts the given value to a number and floors it to an integer. If the value is less than `0`, it returns `0`. If the value exceeds `2^32 - 1`, it returns `2^32 - 1`. + * + * @param {unknown} value - The value to convert to a valid index. + * @returns {number} The converted value. + * + * @example + * toLength(3.2) // => 3 + * toLength(-1) // => 0 + * toLength(1.9) // => 1 + * toLength('42') // => 42 + * toLength(null) // => 0 + */ +declare function toLength(value: any): number; + +export { toLength }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..151a0bc678245cf2d5b47458b3c3a2197ece3368 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.d.ts @@ -0,0 +1,18 @@ +/** + * Converts the value to a valid index. A valid index is an integer that is greater than or equal to `0` and less than or equal to `2^32 - 1`. + * + * It converts the given value to a number and floors it to an integer. If the value is less than `0`, it returns `0`. If the value exceeds `2^32 - 1`, it returns `2^32 - 1`. + * + * @param {unknown} value - The value to convert to a valid index. + * @returns {number} The converted value. + * + * @example + * toLength(3.2) // => 3 + * toLength(-1) // => 0 + * toLength(1.9) // => 1 + * toLength('42') // => 42 + * toLength(null) // => 0 + */ +declare function toLength(value: any): number; + +export { toLength }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.js new file mode 100644 index 0000000000000000000000000000000000000000..572300b390747c23e1a92d43c3697dd9466b43c7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const MAX_ARRAY_LENGTH = require('../_internal/MAX_ARRAY_LENGTH.js'); +const clamp = require('../math/clamp.js'); + +function toLength(value) { + if (value == null) { + return 0; + } + const length = Math.floor(Number(value)); + return clamp.clamp(length, 0, MAX_ARRAY_LENGTH.MAX_ARRAY_LENGTH); +} + +exports.toLength = toLength; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.mjs new file mode 100644 index 0000000000000000000000000000000000000000..dcf2ab194d05567509261a2ed45d04a6f6731bfb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toLength.mjs @@ -0,0 +1,12 @@ +import { MAX_ARRAY_LENGTH } from '../_internal/MAX_ARRAY_LENGTH.mjs'; +import { clamp } from '../math/clamp.mjs'; + +function toLength(value) { + if (value == null) { + return 0; + } + const length = Math.floor(Number(value)); + return clamp(length, 0, MAX_ARRAY_LENGTH); +} + +export { toLength }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5d09041b854be51b91bafe0b0ff4987dbd316d5c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.d.mts @@ -0,0 +1,19 @@ +/** + * Converts `value` to a number. + * + * Unlike `Number()`, this function returns `NaN` for symbols. + * + * @param {unknown} value - The value to convert. + * @returns {number} Returns the number. + * + * @example + * toNumber(3.2); // => 3.2 + * toNumber(Number.MIN_VALUE); // => 5e-324 + * toNumber(Infinity); // => Infinity + * toNumber('3.2'); // => 3.2 + * toNumber(Symbol.iterator); // => NaN + * toNumber(NaN); // => NaN + */ +declare function toNumber(value: any): number; + +export { toNumber }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d09041b854be51b91bafe0b0ff4987dbd316d5c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.d.ts @@ -0,0 +1,19 @@ +/** + * Converts `value` to a number. + * + * Unlike `Number()`, this function returns `NaN` for symbols. + * + * @param {unknown} value - The value to convert. + * @returns {number} Returns the number. + * + * @example + * toNumber(3.2); // => 3.2 + * toNumber(Number.MIN_VALUE); // => 5e-324 + * toNumber(Infinity); // => Infinity + * toNumber('3.2'); // => 3.2 + * toNumber(Symbol.iterator); // => NaN + * toNumber(NaN); // => NaN + */ +declare function toNumber(value: any): number; + +export { toNumber }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.js new file mode 100644 index 0000000000000000000000000000000000000000..6b5d8955330c8e921f2b7f078c81c83bca7587ec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isSymbol = require('../predicate/isSymbol.js'); + +function toNumber(value) { + if (isSymbol.isSymbol(value)) { + return NaN; + } + return Number(value); +} + +exports.toNumber = toNumber; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e3aa8f4ba975a9ce26ebf232be90cc5d6c1367bc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toNumber.mjs @@ -0,0 +1,10 @@ +import { isSymbol } from '../predicate/isSymbol.mjs'; + +function toNumber(value) { + if (isSymbol(value)) { + return NaN; + } + return Number(value); +} + +export { toNumber }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ac344886a3a09a3dfccb8a4dd7a6a772dfb1adc8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.d.mts @@ -0,0 +1,20 @@ +/** + * Converts a deep key string into an array of path segments. + * + * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path. + * + * @param {any} deepKey - The deep key string to convert. + * @returns {string[]} An array of strings, each representing a segment of the path. + * + * Examples: + * + * toPath('a.b.c') // Returns ['a', 'b', 'c'] + * toPath('a[b][c]') // Returns ['a', 'b', 'c'] + * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c'] + * toPath('a["b.c"].d') // Returns ['a', 'b.c', 'd'] + * toPath('') // Returns [] + * toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h'] + */ +declare function toPath(deepKey: any): string[]; + +export { toPath }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ac344886a3a09a3dfccb8a4dd7a6a772dfb1adc8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.d.ts @@ -0,0 +1,20 @@ +/** + * Converts a deep key string into an array of path segments. + * + * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path. + * + * @param {any} deepKey - The deep key string to convert. + * @returns {string[]} An array of strings, each representing a segment of the path. + * + * Examples: + * + * toPath('a.b.c') // Returns ['a', 'b', 'c'] + * toPath('a[b][c]') // Returns ['a', 'b', 'c'] + * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c'] + * toPath('a["b.c"].d') // Returns ['a', 'b.c', 'd'] + * toPath('') // Returns [] + * toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h'] + */ +declare function toPath(deepKey: any): string[]; + +export { toPath }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.js new file mode 100644 index 0000000000000000000000000000000000000000..338fa4195e3050bad442a842620dc6c1d61bb620 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function toPath(deepKey) { + const result = []; + const length = deepKey.length; + if (length === 0) { + return result; + } + let index = 0; + let key = ''; + let quoteChar = ''; + let bracket = false; + if (deepKey.charCodeAt(0) === 46) { + result.push(''); + index++; + } + while (index < length) { + const char = deepKey[index]; + if (quoteChar) { + if (char === '\\' && index + 1 < length) { + index++; + key += deepKey[index]; + } + else if (char === quoteChar) { + quoteChar = ''; + } + else { + key += char; + } + } + else if (bracket) { + if (char === '"' || char === "'") { + quoteChar = char; + } + else if (char === ']') { + bracket = false; + result.push(key); + key = ''; + } + else { + key += char; + } + } + else { + if (char === '[') { + bracket = true; + if (key) { + result.push(key); + key = ''; + } + } + else if (char === '.') { + if (key) { + result.push(key); + key = ''; + } + } + else { + key += char; + } + } + index++; + } + if (key) { + result.push(key); + } + return result; +} + +exports.toPath = toPath; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3a7870613faecceff6adf9eff4cdba5dbb64cc7c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPath.mjs @@ -0,0 +1,68 @@ +function toPath(deepKey) { + const result = []; + const length = deepKey.length; + if (length === 0) { + return result; + } + let index = 0; + let key = ''; + let quoteChar = ''; + let bracket = false; + if (deepKey.charCodeAt(0) === 46) { + result.push(''); + index++; + } + while (index < length) { + const char = deepKey[index]; + if (quoteChar) { + if (char === '\\' && index + 1 < length) { + index++; + key += deepKey[index]; + } + else if (char === quoteChar) { + quoteChar = ''; + } + else { + key += char; + } + } + else if (bracket) { + if (char === '"' || char === "'") { + quoteChar = char; + } + else if (char === ']') { + bracket = false; + result.push(key); + key = ''; + } + else { + key += char; + } + } + else { + if (char === '[') { + bracket = true; + if (key) { + result.push(key); + key = ''; + } + } + else if (char === '.') { + if (key) { + result.push(key); + key = ''; + } + } + else { + key += char; + } + } + index++; + } + if (key) { + result.push(key); + } + return result; +} + +export { toPath }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d9b25dc91de5a55369c5b141cc2670a1712cbad7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.d.mts @@ -0,0 +1,16 @@ +/** + * Converts value to a plain object flattening inherited enumerable string keyed properties of value to own properties of the plain object. + * + * @param {any} value The value to convert. + * @returns {any} Returns the converted plain object. + * + * @example + * function Foo() { + * this.b = 2; + * } + * Foo.prototype.c = 3; + * toPlainObject(new Foo()); // { b: 2, c: 3 } + */ +declare function toPlainObject(value?: any): any; + +export { toPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d9b25dc91de5a55369c5b141cc2670a1712cbad7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.d.ts @@ -0,0 +1,16 @@ +/** + * Converts value to a plain object flattening inherited enumerable string keyed properties of value to own properties of the plain object. + * + * @param {any} value The value to convert. + * @returns {any} Returns the converted plain object. + * + * @example + * function Foo() { + * this.b = 2; + * } + * Foo.prototype.c = 3; + * toPlainObject(new Foo()); // { b: 2, c: 3 } + */ +declare function toPlainObject(value?: any): any; + +export { toPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.js new file mode 100644 index 0000000000000000000000000000000000000000..7c90706145b0ba705c44d79e6e732a4797d26208 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.js @@ -0,0 +1,28 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const keysIn = require('../object/keysIn.js'); + +function toPlainObject(value) { + const plainObject = {}; + const valueKeys = keysIn.keysIn(value); + for (let i = 0; i < valueKeys.length; i++) { + const key = valueKeys[i]; + const objValue = value[key]; + if (key === '__proto__') { + Object.defineProperty(plainObject, key, { + configurable: true, + enumerable: true, + value: objValue, + writable: true, + }); + } + else { + plainObject[key] = objValue; + } + } + return plainObject; +} + +exports.toPlainObject = toPlainObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4d82b6e46b5968e4d7125f48a4231a03a65f4c56 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toPlainObject.mjs @@ -0,0 +1,24 @@ +import { keysIn } from '../object/keysIn.mjs'; + +function toPlainObject(value) { + const plainObject = {}; + const valueKeys = keysIn(value); + for (let i = 0; i < valueKeys.length; i++) { + const key = valueKeys[i]; + const objValue = value[key]; + if (key === '__proto__') { + Object.defineProperty(plainObject, key, { + configurable: true, + enumerable: true, + value: objValue, + writable: true, + }); + } + else { + plainObject[key] = objValue; + } + } + return plainObject; +} + +export { toPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ed157a1676253c5f8033b38644b3e10ac463023f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.d.mts @@ -0,0 +1,20 @@ +/** + * Converts `value` to a safe integer. + * + * A safe integer can be compared and represented correctly. + * + * @param {any} value - The value to convert. + * @returns {number} Returns the value converted to a safe integer. + * + * @example + * toSafeInteger(3.2); // => 3 + * toSafeInteger(Number.MAX_VALUE); // => 9007199254740991 + * toSafeInteger(Infinity); // => 9007199254740991 + * toSafeInteger('3.2'); // => 3 + * toSafeInteger(NaN); // => 0 + * toSafeInteger(null); // => 0 + * toSafeInteger(-Infinity); // => -9007199254740991 + */ +declare function toSafeInteger(value: any): number; + +export { toSafeInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ed157a1676253c5f8033b38644b3e10ac463023f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.d.ts @@ -0,0 +1,20 @@ +/** + * Converts `value` to a safe integer. + * + * A safe integer can be compared and represented correctly. + * + * @param {any} value - The value to convert. + * @returns {number} Returns the value converted to a safe integer. + * + * @example + * toSafeInteger(3.2); // => 3 + * toSafeInteger(Number.MAX_VALUE); // => 9007199254740991 + * toSafeInteger(Infinity); // => 9007199254740991 + * toSafeInteger('3.2'); // => 3 + * toSafeInteger(NaN); // => 0 + * toSafeInteger(null); // => 0 + * toSafeInteger(-Infinity); // => -9007199254740991 + */ +declare function toSafeInteger(value: any): number; + +export { toSafeInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.js new file mode 100644 index 0000000000000000000000000000000000000000..d5d53e5c522520ba629d353206f13a7d9d8cd3b7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('./toInteger.js'); +const MAX_SAFE_INTEGER = require('../_internal/MAX_SAFE_INTEGER.js'); +const clamp = require('../math/clamp.js'); + +function toSafeInteger(value) { + if (value == null) { + return 0; + } + return clamp.clamp(toInteger.toInteger(value), -MAX_SAFE_INTEGER.MAX_SAFE_INTEGER, MAX_SAFE_INTEGER.MAX_SAFE_INTEGER); +} + +exports.toSafeInteger = toSafeInteger; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2d565da8cabb2d43cd08d1b2ba751af65aa43f9b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toSafeInteger.mjs @@ -0,0 +1,12 @@ +import { toInteger } from './toInteger.mjs'; +import { MAX_SAFE_INTEGER } from '../_internal/MAX_SAFE_INTEGER.mjs'; +import { clamp } from '../math/clamp.mjs'; + +function toSafeInteger(value) { + if (value == null) { + return 0; + } + return clamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER); +} + +export { toSafeInteger }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4b1fb4277c4748aa153d3da6a8d9ae2f9ebee27f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.d.mts @@ -0,0 +1,19 @@ +/** + * Converts `value` to a string. + * + * An empty string is returned for `null` and `undefined` values. + * The sign of `-0` is preserved. + * + * @param {any} value - The value to convert. + * @returns {string} Returns the converted string. + * + * @example + * toString(null) // returns '' + * toString(undefined) // returns '' + * toString(-0) // returns '-0' + * toString([1, 2, -0]) // returns '1,2,-0' + * toString([Symbol('a'), Symbol('b')]) // returns 'Symbol(a),Symbol(b)' + */ +declare function toString(value: any): string; + +export { toString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4b1fb4277c4748aa153d3da6a8d9ae2f9ebee27f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.d.ts @@ -0,0 +1,19 @@ +/** + * Converts `value` to a string. + * + * An empty string is returned for `null` and `undefined` values. + * The sign of `-0` is preserved. + * + * @param {any} value - The value to convert. + * @returns {string} Returns the converted string. + * + * @example + * toString(null) // returns '' + * toString(undefined) // returns '' + * toString(-0) // returns '-0' + * toString([1, 2, -0]) // returns '1,2,-0' + * toString([Symbol('a'), Symbol('b')]) // returns 'Symbol(a),Symbol(b)' + */ +declare function toString(value: any): string; + +export { toString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.js new file mode 100644 index 0000000000000000000000000000000000000000..e1f93a00325de19e53923332994f8b9d669c2d27 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function toString(value) { + if (value == null) { + return ''; + } + if (typeof value === 'string') { + return value; + } + if (Array.isArray(value)) { + return value.map(toString).join(','); + } + const result = String(value); + if (result === '0' && Object.is(Number(value), -0)) { + return '-0'; + } + return result; +} + +exports.toString = toString; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2987074b1bab3ab234b0d535e1e2f7802d598bbc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/toString.mjs @@ -0,0 +1,18 @@ +function toString(value) { + if (value == null) { + return ''; + } + if (typeof value === 'string') { + return value; + } + if (Array.isArray(value)) { + return value.map(toString).join(','); + } + const result = String(value); + if (result === '0' && Object.is(Number(value), -0)) { + return '-0'; + } + return result; +} + +export { toString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..626eec24e872762cb82cdc30f0bea6983a5681fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.d.mts @@ -0,0 +1,25 @@ +/** + * Generates a unique identifier, optionally prefixed with a given string. + * + * @param {string} [prefix] - An optional string to prefix the unique identifier. + * If not provided or not a string, only the unique + * numeric identifier is returned. + * @returns {string} A string containing the unique identifier, with the optional + * prefix if provided. + * + * @example + * // Generate a unique ID with a prefix + * uniqueId('user_'); // => 'user_1' + * + * @example + * // Generate a unique ID without a prefix + * uniqueId(); // => '2' + * + * @example + * // Subsequent calls increment the internal counter + * uniqueId('item_'); // => 'item_3' + * uniqueId(); // => '4' + */ +declare function uniqueId(prefix?: string): string; + +export { uniqueId }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..626eec24e872762cb82cdc30f0bea6983a5681fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.d.ts @@ -0,0 +1,25 @@ +/** + * Generates a unique identifier, optionally prefixed with a given string. + * + * @param {string} [prefix] - An optional string to prefix the unique identifier. + * If not provided or not a string, only the unique + * numeric identifier is returned. + * @returns {string} A string containing the unique identifier, with the optional + * prefix if provided. + * + * @example + * // Generate a unique ID with a prefix + * uniqueId('user_'); // => 'user_1' + * + * @example + * // Generate a unique ID without a prefix + * uniqueId(); // => '2' + * + * @example + * // Subsequent calls increment the internal counter + * uniqueId('item_'); // => 'item_3' + * uniqueId(); // => '4' + */ +declare function uniqueId(prefix?: string): string; + +export { uniqueId }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.js new file mode 100644 index 0000000000000000000000000000000000000000..3f70ce9d639be08503d5b95904a696467cd8938f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +let idCounter = 0; +function uniqueId(prefix = '') { + const id = ++idCounter; + return `${prefix}${id}`; +} + +exports.uniqueId = uniqueId; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3c01fbbd84fa208a31549ef768fdb8c195636d53 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/util/uniqueId.mjs @@ -0,0 +1,7 @@ +let idCounter = 0; +function uniqueId(prefix = '') { + const id = ++idCounter; + return `${prefix}${id}`; +} + +export { uniqueId }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/dist/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ad236c492050394ade5d7d3d1749e5bcfcc8542b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/dist/index.js @@ -0,0 +1,22 @@ +const { dirname, resolve } = require('path'); +const { readdir, stat } = require('fs'); +const { promisify } = require('util'); + +const toStats = promisify(stat); +const toRead = promisify(readdir); + +module.exports = async function (start, callback) { + let dir = resolve('.', start); + let tmp, stats = await toStats(dir); + + if (!stats.isDirectory()) { + dir = dirname(dir); + } + + while (true) { + tmp = await callback(dir, await toRead(dir)); + if (tmp) return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) break; + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/dist/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/dist/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..bf95be03425c909cd4aaef11fdb7ac6fe31e2dd3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/dist/index.mjs @@ -0,0 +1,22 @@ +import { dirname, resolve } from 'path'; +import { readdir, stat } from 'fs'; +import { promisify } from 'util'; + +const toStats = promisify(stat); +const toRead = promisify(readdir); + +export default async function (start, callback) { + let dir = resolve('.', start); + let tmp, stats = await toStats(dir); + + if (!stats.isDirectory()) { + dir = dirname(dir); + } + + while (true) { + tmp = await callback(dir, await toRead(dir)); + if (tmp) return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) break; + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c023d37b286d1f16630ed054d492c027184dffc0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.d.mts @@ -0,0 +1,9 @@ +export type Callback = ( + directory: string, + files: string[], +) => string | false | void; + +export default function ( + directory: string, + callback: Callback, +): string | void; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9d5b5890c38169867e93a5dd6d3e9ed829370243 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.d.ts @@ -0,0 +1,13 @@ +declare namespace escalade { + export type Callback = ( + directory: string, + files: string[], + ) => string | false | void; +} + +declare function escalade( + directory: string, + callback: escalade.Callback, +): string | void; + +export = escalade; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.js new file mode 100644 index 0000000000000000000000000000000000000000..902cc46cd9a80b10aa787e067ff1936ada95505d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.js @@ -0,0 +1,18 @@ +const { dirname, resolve } = require('path'); +const { readdirSync, statSync } = require('fs'); + +module.exports = function (start, callback) { + let dir = resolve('.', start); + let tmp, stats = statSync(dir); + + if (!stats.isDirectory()) { + dir = dirname(dir); + } + + while (true) { + tmp = callback(dir, readdirSync(dir)); + if (tmp) return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) break; + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3cdc5bd1fee04733ea106fd6cdde40ec094880cb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/escalade/sync/index.mjs @@ -0,0 +1,18 @@ +import { dirname, resolve } from 'path'; +import { readdirSync, statSync } from 'fs'; + +export default function (start, callback) { + let dir = resolve('.', start); + let tmp, stats = statSync(dir); + + if (!stats.isDirectory()) { + dir = dirname(dir); + } + + while (true) { + tmp = callback(dir, readdirSync(dir)); + if (tmp) return resolve(dir, tmp); + dir = dirname(tmp = dir); + if (tmp === dir) break; + } +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.cjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.cjs new file mode 100644 index 0000000000000000000000000000000000000000..9dce6430d4263c1751640d00bff417e0509b8c09 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.cjs @@ -0,0 +1,178 @@ +'use strict'; + +const eslint = require('eslint'); +const semver = require('semver'); +const convertConfig = require('./shared/eslint-compat-utils.503aeaae.cjs'); +const getUnsupported = require('./shared/eslint-compat-utils.cb53cf36.cjs'); +require('module'); + +function _interopNamespaceCompat(e) { + if (e && typeof e === 'object' && 'default' in e) return e; + const n = Object.create(null); + if (e) { + for (const k in e) { + n[k] = e[k]; + } + } + n.default = e; + return n; +} + +const eslint__namespace = /*#__PURE__*/_interopNamespaceCompat(eslint); +const semver__namespace = /*#__PURE__*/_interopNamespaceCompat(semver); + +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +let cacheESLint, cacheLegacyESLint; +function getESLint() { + return cacheESLint != null ? cacheESLint : cacheESLint = getESLintInternal(); + function getESLintInternal() { + if (semver__namespace.gte(eslint__namespace.Linter.version, "9.0.0-0")) { + return eslint__namespace.ESLint; + } + return getUnsupported.getUnsupported().FlatESLint || (eslint__namespace.ESLint ? getESLintClassFromLegacyESLint(eslint__namespace.ESLint) : getESLintClassFromLegacyESLint(getLegacyESLintClassFromCLIEngine())); + } +} +function getLegacyESLint() { + return cacheLegacyESLint != null ? cacheLegacyESLint : cacheLegacyESLint = getLegacyESLintInternal(); + function getLegacyESLintInternal() { + return getUnsupported.getUnsupported().LegacyESLint || eslint__namespace.ESLint || getLegacyESLintClassFromCLIEngine(); + } +} +function getESLintClassFromLegacyESLint(legacyESLintClass) { + return class ESLintFromLegacyESLint extends legacyESLintClass { + static get version() { + return legacyESLintClass.version; + } + constructor(options) { + super(adjustOptions(options)); + } + }; + function adjustOptions(options) { + const { + baseConfig: originalBaseConfig, + overrideConfig: originalOverrideConfig, + overrideConfigFile, + ...newOptions + } = options || {}; + if (originalBaseConfig) { + const [baseConfig, plugins] = convertConfig$1(originalBaseConfig); + newOptions.baseConfig = baseConfig; + if (plugins) { + newOptions.plugins = plugins; + } + } + if (originalOverrideConfig) { + const [overrideConfig, plugins] = convertConfig$1(originalOverrideConfig); + newOptions.overrideConfig = overrideConfig; + if (plugins) { + newOptions.plugins = plugins; + } + } + if (overrideConfigFile) { + if (overrideConfigFile === true) { + newOptions.useEslintrc = false; + } else { + newOptions.overrideConfigFile = overrideConfigFile; + } + } + return newOptions; + } + function convertConfig$1(config) { + const pluginDefs = {}; + const newConfigs = []; + for (const configItem of Array.isArray(config) ? config : [config]) { + const { plugins, ...otherConfig } = configItem; + if (typeof otherConfig.processor !== "string") + delete otherConfig.processor; + const newConfig = { + files: ["**/*.*", "*.*", "**/*", "*"], + ...convertConfig.convertConfigToRc(otherConfig) + }; + if (plugins) { + newConfig.plugins = Object.keys(plugins); + } + Object.assign(pluginDefs, plugins); + newConfigs.push(newConfig); + } + return [{ overrides: newConfigs }, pluginDefs]; + } +} +function getLegacyESLintClassFromCLIEngine() { + const CLIEngine = eslint__namespace.CLIEngine; + class LegacyESLintFromCLIEngine { + constructor(options) { + __publicField(this, "engine"); + const { + overrideConfig: { + plugins, + globals, + rules, + overrides, + ...overrideConfig + } = { + plugins: [], + globals: {}, + rules: {}, + overrides: [] + }, + fix, + reportUnusedDisableDirectives, + plugins: pluginsMap, + ...otherOptions + } = options || {}; + const cliEngineOptions = { + baseConfig: { + ...overrides ? { + overrides + } : {} + }, + fix: Boolean(fix), + reportUnusedDisableDirectives: reportUnusedDisableDirectives ? reportUnusedDisableDirectives !== "off" : void 0, + ...otherOptions, + globals: globals ? Object.keys(globals).filter((n) => globals[n]) : void 0, + plugins: plugins || [], + rules: rules ? Object.fromEntries( + Object.entries(rules).flatMap( + ([ruleId, opt]) => opt ? [[ruleId, opt]] : [] + ) + ) : void 0, + ...overrideConfig + }; + this.engine = new CLIEngine(cliEngineOptions); + for (const [name, plugin] of Object.entries(pluginsMap || {})) { + this.engine.addPlugin(name, plugin); + } + } + static get version() { + return CLIEngine.version; + } + // eslint-disable-next-line @typescript-eslint/require-await -- ignore + async lintText(...params) { + var _a; + const result = this.engine.executeOnText(params[0], (_a = params[1]) == null ? void 0 : _a.filePath); + return result.results; + } + // eslint-disable-next-line @typescript-eslint/require-await -- ignore + async lintFiles(...params) { + const result = this.engine.executeOnFiles( + Array.isArray(params[0]) ? params[0] : [params[0]] + ); + return result.results; + } + // eslint-disable-next-line @typescript-eslint/require-await -- ignore + static async outputFixes(...params) { + return CLIEngine.outputFixes({ + results: params[0] + }); + } + } + return LegacyESLintFromCLIEngine; +} + +exports.getESLint = getESLint; +exports.getLegacyESLint = getLegacyESLint; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.cts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..2df1729f7b61cd4bef464d6b8f59917990df77f3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.cts @@ -0,0 +1,12 @@ +import * as eslint from 'eslint'; + +/** + * Get ESLint class + */ +declare function getESLint(): typeof eslint.ESLint; +/** + * Get LegacyESLint class + */ +declare function getLegacyESLint(): typeof eslint.ESLint; + +export { getESLint, getLegacyESLint }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2df1729f7b61cd4bef464d6b8f59917990df77f3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.mts @@ -0,0 +1,12 @@ +import * as eslint from 'eslint'; + +/** + * Get ESLint class + */ +declare function getESLint(): typeof eslint.ESLint; +/** + * Get LegacyESLint class + */ +declare function getLegacyESLint(): typeof eslint.ESLint; + +export { getESLint, getLegacyESLint }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2df1729f7b61cd4bef464d6b8f59917990df77f3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.d.ts @@ -0,0 +1,12 @@ +import * as eslint from 'eslint'; + +/** + * Get ESLint class + */ +declare function getESLint(): typeof eslint.ESLint; +/** + * Get LegacyESLint class + */ +declare function getLegacyESLint(): typeof eslint.ESLint; + +export { getESLint, getLegacyESLint }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5742df357b5e4dd59bb0bc1aca9ec3552d81e41d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/eslint.mjs @@ -0,0 +1,160 @@ +import * as eslint from 'eslint'; +import * as semver from 'semver'; +import { c as convertConfigToRc } from './shared/eslint-compat-utils.1a5060cf.mjs'; +import { g as getUnsupported } from './shared/eslint-compat-utils.3ecba7ac.mjs'; +import 'module'; + +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +let cacheESLint, cacheLegacyESLint; +function getESLint() { + return cacheESLint != null ? cacheESLint : cacheESLint = getESLintInternal(); + function getESLintInternal() { + if (semver.gte(eslint.Linter.version, "9.0.0-0")) { + return eslint.ESLint; + } + return getUnsupported().FlatESLint || (eslint.ESLint ? getESLintClassFromLegacyESLint(eslint.ESLint) : getESLintClassFromLegacyESLint(getLegacyESLintClassFromCLIEngine())); + } +} +function getLegacyESLint() { + return cacheLegacyESLint != null ? cacheLegacyESLint : cacheLegacyESLint = getLegacyESLintInternal(); + function getLegacyESLintInternal() { + return getUnsupported().LegacyESLint || eslint.ESLint || getLegacyESLintClassFromCLIEngine(); + } +} +function getESLintClassFromLegacyESLint(legacyESLintClass) { + return class ESLintFromLegacyESLint extends legacyESLintClass { + static get version() { + return legacyESLintClass.version; + } + constructor(options) { + super(adjustOptions(options)); + } + }; + function adjustOptions(options) { + const { + baseConfig: originalBaseConfig, + overrideConfig: originalOverrideConfig, + overrideConfigFile, + ...newOptions + } = options || {}; + if (originalBaseConfig) { + const [baseConfig, plugins] = convertConfig(originalBaseConfig); + newOptions.baseConfig = baseConfig; + if (plugins) { + newOptions.plugins = plugins; + } + } + if (originalOverrideConfig) { + const [overrideConfig, plugins] = convertConfig(originalOverrideConfig); + newOptions.overrideConfig = overrideConfig; + if (plugins) { + newOptions.plugins = plugins; + } + } + if (overrideConfigFile) { + if (overrideConfigFile === true) { + newOptions.useEslintrc = false; + } else { + newOptions.overrideConfigFile = overrideConfigFile; + } + } + return newOptions; + } + function convertConfig(config) { + const pluginDefs = {}; + const newConfigs = []; + for (const configItem of Array.isArray(config) ? config : [config]) { + const { plugins, ...otherConfig } = configItem; + if (typeof otherConfig.processor !== "string") + delete otherConfig.processor; + const newConfig = { + files: ["**/*.*", "*.*", "**/*", "*"], + ...convertConfigToRc(otherConfig) + }; + if (plugins) { + newConfig.plugins = Object.keys(plugins); + } + Object.assign(pluginDefs, plugins); + newConfigs.push(newConfig); + } + return [{ overrides: newConfigs }, pluginDefs]; + } +} +function getLegacyESLintClassFromCLIEngine() { + const CLIEngine = eslint.CLIEngine; + class LegacyESLintFromCLIEngine { + constructor(options) { + __publicField(this, "engine"); + const { + overrideConfig: { + plugins, + globals, + rules, + overrides, + ...overrideConfig + } = { + plugins: [], + globals: {}, + rules: {}, + overrides: [] + }, + fix, + reportUnusedDisableDirectives, + plugins: pluginsMap, + ...otherOptions + } = options || {}; + const cliEngineOptions = { + baseConfig: { + ...overrides ? { + overrides + } : {} + }, + fix: Boolean(fix), + reportUnusedDisableDirectives: reportUnusedDisableDirectives ? reportUnusedDisableDirectives !== "off" : void 0, + ...otherOptions, + globals: globals ? Object.keys(globals).filter((n) => globals[n]) : void 0, + plugins: plugins || [], + rules: rules ? Object.fromEntries( + Object.entries(rules).flatMap( + ([ruleId, opt]) => opt ? [[ruleId, opt]] : [] + ) + ) : void 0, + ...overrideConfig + }; + this.engine = new CLIEngine(cliEngineOptions); + for (const [name, plugin] of Object.entries(pluginsMap || {})) { + this.engine.addPlugin(name, plugin); + } + } + static get version() { + return CLIEngine.version; + } + // eslint-disable-next-line @typescript-eslint/require-await -- ignore + async lintText(...params) { + var _a; + const result = this.engine.executeOnText(params[0], (_a = params[1]) == null ? void 0 : _a.filePath); + return result.results; + } + // eslint-disable-next-line @typescript-eslint/require-await -- ignore + async lintFiles(...params) { + const result = this.engine.executeOnFiles( + Array.isArray(params[0]) ? params[0] : [params[0]] + ); + return result.results; + } + // eslint-disable-next-line @typescript-eslint/require-await -- ignore + static async outputFixes(...params) { + return CLIEngine.outputFixes({ + results: params[0] + }); + } + } + return LegacyESLintFromCLIEngine; +} + +export { getESLint, getLegacyESLint }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.cjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..70c0039dcf3ac4761383f0ec8ed24539be0f0767 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.cjs @@ -0,0 +1,126 @@ +'use strict'; + +const path = require('path'); +const fs = require('fs'); + +function applyPolyfills(object, polyfill) { + return new Proxy(object, { + get(_target, p) { + var _a; + return (_a = object[p]) != null ? _a : polyfill[p]; + } + }); +} + +function getParent(node) { + return node.parent; +} + +const cache = /* @__PURE__ */ new WeakMap(); +function getSourceCode(context) { + const original = context.sourceCode || context.getSourceCode(); + const cached = cache.get(original); + if (cached) { + return cached; + } + const sourceCode = applyPolyfills(original, { + getScope(node) { + const inner = node.type !== "Program"; + for (let n = node; n; n = getParent(n)) { + const scope = original.scopeManager.acquire(n, inner); + if (scope) { + if (scope.type === "function-expression-name") { + return scope.childScopes[0]; + } + return scope; + } + } + return original.scopeManager.scopes[0]; + }, + markVariableAsUsed(name, refNode = original.ast) { + const currentScope = sourceCode.getScope(refNode); + if (currentScope === context.getScope()) { + return context.markVariableAsUsed(name); + } + let initialScope = currentScope; + if (currentScope.type === "global" && currentScope.childScopes.length > 0 && currentScope.childScopes[0].block === original.ast) { + initialScope = currentScope.childScopes[0]; + } + for (let scope = initialScope; scope; scope = scope.upper) { + const variable = scope.variables.find( + (scopeVar) => scopeVar.name === name + ); + if (variable) { + variable.eslintUsed = true; + return true; + } + } + return false; + }, + getAncestors(node) { + const result = []; + for (let ancestor = getParent(node); ancestor; ancestor = ancestor.parent) { + result.unshift(ancestor); + } + return result; + }, + getDeclaredVariables(node) { + return original.scopeManager.getDeclaredVariables(node); + }, + isSpaceBetween(first, second) { + if (first.range[0] <= second.range[1] && second.range[0] <= first.range[1]) { + return false; + } + const [startingNodeOrToken, endingNodeOrToken] = first.range[1] <= second.range[0] ? [first, second] : [second, first]; + const tokens = sourceCode.getTokensBetween(first, second, { + includeComments: true + }); + let startIndex = startingNodeOrToken.range[1]; + for (const token of tokens) { + if (startIndex !== token.range[0]) { + return true; + } + startIndex = token.range[1]; + } + return startIndex !== endingNodeOrToken.range[0]; + } + }); + cache.set(original, sourceCode); + return sourceCode; +} + +function getCwd(context) { + var _a, _b, _c; + return (_c = (_b = context.cwd) != null ? _b : (_a = context.getCwd) == null ? void 0 : _a.call(context)) != null ? _c : ( + // getCwd is added in v6.6.0 + process.cwd() + ); +} + +function getFilename(context) { + var _a; + return (_a = context.filename) != null ? _a : context.getFilename(); +} + +function getPhysicalFilename(context) { + var _a, _b; + const physicalFilename = (_b = context.physicalFilename) != null ? _b : (_a = context.getPhysicalFilename) == null ? void 0 : _a.call(context); + if (physicalFilename != null) { + return physicalFilename; + } + const filename = getFilename(context); + let target = filename; + while (/^\d+_/u.test(path.basename(target)) && !fs.existsSync(target)) { + const next = path.dirname(target); + if (next === target || !path.extname(next)) { + break; + } + target = next; + } + return target; +} + +exports.getCwd = getCwd; +exports.getFilename = getFilename; +exports.getPhysicalFilename = getPhysicalFilename; +exports.getSourceCode = getSourceCode; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.cts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..993098a077cc06c6ec6dec30c3f2436a45eb3cf3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.cts @@ -0,0 +1,28 @@ +import { Rule, SourceCode } from 'eslint'; + +/** + * Returns an extended instance of `context.sourceCode` or the result of `context.getSourceCode()`. + * Extended instances can use new APIs such as `getScope(node)` even with old ESLint. + */ +declare function getSourceCode(context: Rule.RuleContext): SourceCode; + +/** + * Gets the value of `context.cwd`, but for older ESLint it returns the result of `context.getCwd()`. + * Versions older than v6.6.0 return a value from the result of `process.cwd()`. + */ +declare function getCwd(context: Rule.RuleContext): string; + +/** + * Gets the value of `context.filename`, but for older ESLint it returns the result of `context.getFilename()`. + */ +declare function getFilename(context: Rule.RuleContext): string; + +/** + * Gets the value of `context.physicalFilename`, + * but for older ESLint it returns the result of `context.getPhysicalFilename()`. + * Versions older than v7.28.0 return a value guessed from the result of `context.getFilename()`, + * but it may be incorrect. + */ +declare function getPhysicalFilename(context: Rule.RuleContext): string; + +export { getCwd, getFilename, getPhysicalFilename, getSourceCode }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..993098a077cc06c6ec6dec30c3f2436a45eb3cf3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.mts @@ -0,0 +1,28 @@ +import { Rule, SourceCode } from 'eslint'; + +/** + * Returns an extended instance of `context.sourceCode` or the result of `context.getSourceCode()`. + * Extended instances can use new APIs such as `getScope(node)` even with old ESLint. + */ +declare function getSourceCode(context: Rule.RuleContext): SourceCode; + +/** + * Gets the value of `context.cwd`, but for older ESLint it returns the result of `context.getCwd()`. + * Versions older than v6.6.0 return a value from the result of `process.cwd()`. + */ +declare function getCwd(context: Rule.RuleContext): string; + +/** + * Gets the value of `context.filename`, but for older ESLint it returns the result of `context.getFilename()`. + */ +declare function getFilename(context: Rule.RuleContext): string; + +/** + * Gets the value of `context.physicalFilename`, + * but for older ESLint it returns the result of `context.getPhysicalFilename()`. + * Versions older than v7.28.0 return a value guessed from the result of `context.getFilename()`, + * but it may be incorrect. + */ +declare function getPhysicalFilename(context: Rule.RuleContext): string; + +export { getCwd, getFilename, getPhysicalFilename, getSourceCode }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..993098a077cc06c6ec6dec30c3f2436a45eb3cf3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.d.ts @@ -0,0 +1,28 @@ +import { Rule, SourceCode } from 'eslint'; + +/** + * Returns an extended instance of `context.sourceCode` or the result of `context.getSourceCode()`. + * Extended instances can use new APIs such as `getScope(node)` even with old ESLint. + */ +declare function getSourceCode(context: Rule.RuleContext): SourceCode; + +/** + * Gets the value of `context.cwd`, but for older ESLint it returns the result of `context.getCwd()`. + * Versions older than v6.6.0 return a value from the result of `process.cwd()`. + */ +declare function getCwd(context: Rule.RuleContext): string; + +/** + * Gets the value of `context.filename`, but for older ESLint it returns the result of `context.getFilename()`. + */ +declare function getFilename(context: Rule.RuleContext): string; + +/** + * Gets the value of `context.physicalFilename`, + * but for older ESLint it returns the result of `context.getPhysicalFilename()`. + * Versions older than v7.28.0 return a value guessed from the result of `context.getFilename()`, + * but it may be incorrect. + */ +declare function getPhysicalFilename(context: Rule.RuleContext): string; + +export { getCwd, getFilename, getPhysicalFilename, getSourceCode }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a8563dcb1000b7e3a0cfb1a358e2d4895e66aea7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/index.mjs @@ -0,0 +1,121 @@ +import { basename, dirname, extname } from 'path'; +import { existsSync } from 'fs'; + +function applyPolyfills(object, polyfill) { + return new Proxy(object, { + get(_target, p) { + var _a; + return (_a = object[p]) != null ? _a : polyfill[p]; + } + }); +} + +function getParent(node) { + return node.parent; +} + +const cache = /* @__PURE__ */ new WeakMap(); +function getSourceCode(context) { + const original = context.sourceCode || context.getSourceCode(); + const cached = cache.get(original); + if (cached) { + return cached; + } + const sourceCode = applyPolyfills(original, { + getScope(node) { + const inner = node.type !== "Program"; + for (let n = node; n; n = getParent(n)) { + const scope = original.scopeManager.acquire(n, inner); + if (scope) { + if (scope.type === "function-expression-name") { + return scope.childScopes[0]; + } + return scope; + } + } + return original.scopeManager.scopes[0]; + }, + markVariableAsUsed(name, refNode = original.ast) { + const currentScope = sourceCode.getScope(refNode); + if (currentScope === context.getScope()) { + return context.markVariableAsUsed(name); + } + let initialScope = currentScope; + if (currentScope.type === "global" && currentScope.childScopes.length > 0 && currentScope.childScopes[0].block === original.ast) { + initialScope = currentScope.childScopes[0]; + } + for (let scope = initialScope; scope; scope = scope.upper) { + const variable = scope.variables.find( + (scopeVar) => scopeVar.name === name + ); + if (variable) { + variable.eslintUsed = true; + return true; + } + } + return false; + }, + getAncestors(node) { + const result = []; + for (let ancestor = getParent(node); ancestor; ancestor = ancestor.parent) { + result.unshift(ancestor); + } + return result; + }, + getDeclaredVariables(node) { + return original.scopeManager.getDeclaredVariables(node); + }, + isSpaceBetween(first, second) { + if (first.range[0] <= second.range[1] && second.range[0] <= first.range[1]) { + return false; + } + const [startingNodeOrToken, endingNodeOrToken] = first.range[1] <= second.range[0] ? [first, second] : [second, first]; + const tokens = sourceCode.getTokensBetween(first, second, { + includeComments: true + }); + let startIndex = startingNodeOrToken.range[1]; + for (const token of tokens) { + if (startIndex !== token.range[0]) { + return true; + } + startIndex = token.range[1]; + } + return startIndex !== endingNodeOrToken.range[0]; + } + }); + cache.set(original, sourceCode); + return sourceCode; +} + +function getCwd(context) { + var _a, _b, _c; + return (_c = (_b = context.cwd) != null ? _b : (_a = context.getCwd) == null ? void 0 : _a.call(context)) != null ? _c : ( + // getCwd is added in v6.6.0 + process.cwd() + ); +} + +function getFilename(context) { + var _a; + return (_a = context.filename) != null ? _a : context.getFilename(); +} + +function getPhysicalFilename(context) { + var _a, _b; + const physicalFilename = (_b = context.physicalFilename) != null ? _b : (_a = context.getPhysicalFilename) == null ? void 0 : _a.call(context); + if (physicalFilename != null) { + return physicalFilename; + } + const filename = getFilename(context); + let target = filename; + while (/^\d+_/u.test(basename(target)) && !existsSync(target)) { + const next = dirname(target); + if (next === target || !extname(next)) { + break; + } + target = next; + } + return target; +} + +export { getCwd, getFilename, getPhysicalFilename, getSourceCode }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.cjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.cjs new file mode 100644 index 0000000000000000000000000000000000000000..a0ec95d19f7cc592b63a3a78c414a4030710188f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.cjs @@ -0,0 +1,48 @@ +'use strict'; + +const eslint = require('eslint'); +const semver = require('semver'); +const convertConfig = require('./shared/eslint-compat-utils.503aeaae.cjs'); +const convertOption = require('./shared/eslint-compat-utils.808b5669.cjs'); +require('module'); + +function _interopNamespaceCompat(e) { + if (e && typeof e === 'object' && 'default' in e) return e; + const n = Object.create(null); + if (e) { + for (const k in e) { + n[k] = e[k]; + } + } + n.default = e; + return n; +} + +const eslint__namespace = /*#__PURE__*/_interopNamespaceCompat(eslint); +const semver__namespace = /*#__PURE__*/_interopNamespaceCompat(semver); + +let cacheLinter; +function getLinter() { + return cacheLinter != null ? cacheLinter : cacheLinter = getLinterInternal(); + function getLinterInternal() { + if (semver__namespace.gte(eslint__namespace.Linter.version, "9.0.0-0")) { + return eslint__namespace.Linter; + } + return getLinterClassFromLegacyLinter(); + } +} +function getLinterClassFromLegacyLinter() { + return class LinterFromLegacyLinter extends eslint__namespace.Linter { + static get version() { + return eslint__namespace.Linter.version; + } + verify(code, config, option) { + const { processor, ...otherConfig } = config || {}; + const newConfig = convertConfig.convertConfigToRc(otherConfig, this); + const newOption = convertOption.convertOptionToLegacy(processor, option, config || {}); + return super.verify(code, newConfig, newOption); + } + }; +} + +exports.getLinter = getLinter; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.cts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..900e4594f11428f58fdacb5fc6e3fef3d1f649b9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.cts @@ -0,0 +1,8 @@ +import * as eslint from 'eslint'; + +/** + * Get Linter class + */ +declare function getLinter(): typeof eslint.Linter; + +export { getLinter }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..900e4594f11428f58fdacb5fc6e3fef3d1f649b9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.mts @@ -0,0 +1,8 @@ +import * as eslint from 'eslint'; + +/** + * Get Linter class + */ +declare function getLinter(): typeof eslint.Linter; + +export { getLinter }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..900e4594f11428f58fdacb5fc6e3fef3d1f649b9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.d.ts @@ -0,0 +1,8 @@ +import * as eslint from 'eslint'; + +/** + * Get Linter class + */ +declare function getLinter(): typeof eslint.Linter; + +export { getLinter }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8c62505617dee311986d0ac972d677809777e4cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/linter.mjs @@ -0,0 +1,31 @@ +import * as eslint from 'eslint'; +import * as semver from 'semver'; +import { c as convertConfigToRc } from './shared/eslint-compat-utils.1a5060cf.mjs'; +import { c as convertOptionToLegacy } from './shared/eslint-compat-utils.cb6790c2.mjs'; +import 'module'; + +let cacheLinter; +function getLinter() { + return cacheLinter != null ? cacheLinter : cacheLinter = getLinterInternal(); + function getLinterInternal() { + if (semver.gte(eslint.Linter.version, "9.0.0-0")) { + return eslint.Linter; + } + return getLinterClassFromLegacyLinter(); + } +} +function getLinterClassFromLegacyLinter() { + return class LinterFromLegacyLinter extends eslint.Linter { + static get version() { + return eslint.Linter.version; + } + verify(code, config, option) { + const { processor, ...otherConfig } = config || {}; + const newConfig = convertConfigToRc(otherConfig, this); + const newOption = convertOptionToLegacy(processor, option, config || {}); + return super.verify(code, newConfig, newOption); + } + }; +} + +export { getLinter }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.cjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.cjs new file mode 100644 index 0000000000000000000000000000000000000000..3b9dd4fa6866af64f3463cbfcfede038a29d09fe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.cjs @@ -0,0 +1,110 @@ +'use strict'; + +const eslint = require('eslint'); +const semver = require('semver'); +const convertConfig = require('./shared/eslint-compat-utils.503aeaae.cjs'); +const getUnsupported = require('./shared/eslint-compat-utils.cb53cf36.cjs'); +const convertOption = require('./shared/eslint-compat-utils.808b5669.cjs'); +require('module'); + +function _interopNamespaceCompat(e) { + if (e && typeof e === 'object' && 'default' in e) return e; + const n = Object.create(null); + if (e) { + for (const k in e) { + n[k] = e[k]; + } + } + n.default = e; + return n; +} + +const eslint__namespace = /*#__PURE__*/_interopNamespaceCompat(eslint); +const semver__namespace = /*#__PURE__*/_interopNamespaceCompat(semver); + +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +let cacheRuleTester; +let cachePrefix = ""; +function getRuleTester() { + return cacheRuleTester != null ? cacheRuleTester : cacheRuleTester = getRuleTesterInternal(); + function getRuleTesterInternal() { + if (semver__namespace.gte(eslint__namespace.Linter.version, "9.0.0-0")) { + cachePrefix = "rule-to-test/"; + return eslint__namespace.RuleTester; + } + const flatRuleTester = getUnsupported.getUnsupported().FlatRuleTester; + if (flatRuleTester) { + cachePrefix = "rule-to-test/"; + return patchForV8FlatRuleTester(flatRuleTester); + } + return getRuleTesterClassFromLegacyRuleTester(); + } +} +function getRuleIdPrefix() { + getRuleTester(); + return cachePrefix; +} +function patchForV8FlatRuleTester(flatRuleTester) { + return class RuleTesterWithPatch extends flatRuleTester { + constructor(options) { + super(patchConfig(options)); + } + }; + function patchConfig(config) { + return { + files: ["**/*.*"], + ...config + }; + } +} +function getRuleTesterClassFromLegacyRuleTester() { + return class RuleTesterForV8 extends eslint__namespace.RuleTester { + constructor(options) { + var _a; + const defineRules = []; + const { processor, ...others } = options; + super( + convertConfig.convertConfigToRc(others, { + defineRule(...args) { + defineRules.push(args); + } + }) + ); + __publicField(this, "defaultProcessor"); + for (const args of defineRules) { + (_a = this.linter) == null ? void 0 : _a.defineRule(...args); + } + this.defaultProcessor = processor; + } + run(name, rule, tests) { + super.run(name, rule, { + valid: (tests.valid || []).map( + (test) => typeof test === "string" ? test : convert(test, this.defaultProcessor) + ), + invalid: (tests.invalid || []).map( + (test) => convert(test, this.defaultProcessor) + ) + }); + } + }; + function convert(config, defaultProcessor) { + const { processor: configProcessor, ...otherConfig } = config; + const processor = configProcessor || defaultProcessor; + const converted = convertConfig.convertConfigToRc(otherConfig); + if (!processor) { + return converted; + } + return { + ...converted, + filename: convertOption.convertOptionToLegacy(processor, config.filename, config) + }; + } +} + +exports.getRuleIdPrefix = getRuleIdPrefix; +exports.getRuleTester = getRuleTester; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.cts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..e2db6f5d38116e937492b9f9aaa971680331197d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.cts @@ -0,0 +1,12 @@ +import * as eslint from 'eslint'; + +/** + * Get RuleTester class + */ +declare function getRuleTester(): typeof eslint.RuleTester; +/** + * Get the prefix of the ruleId used in the rule tester. + */ +declare function getRuleIdPrefix(): string; + +export { getRuleIdPrefix, getRuleTester }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e2db6f5d38116e937492b9f9aaa971680331197d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.mts @@ -0,0 +1,12 @@ +import * as eslint from 'eslint'; + +/** + * Get RuleTester class + */ +declare function getRuleTester(): typeof eslint.RuleTester; +/** + * Get the prefix of the ruleId used in the rule tester. + */ +declare function getRuleIdPrefix(): string; + +export { getRuleIdPrefix, getRuleTester }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e2db6f5d38116e937492b9f9aaa971680331197d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.d.ts @@ -0,0 +1,12 @@ +import * as eslint from 'eslint'; + +/** + * Get RuleTester class + */ +declare function getRuleTester(): typeof eslint.RuleTester; +/** + * Get the prefix of the ruleId used in the rule tester. + */ +declare function getRuleIdPrefix(): string; + +export { getRuleIdPrefix, getRuleTester }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ef12823054ed0873a28b35a14c476f1c402403f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/rule-tester.mjs @@ -0,0 +1,92 @@ +import * as eslint from 'eslint'; +import * as semver from 'semver'; +import { c as convertConfigToRc } from './shared/eslint-compat-utils.1a5060cf.mjs'; +import { g as getUnsupported } from './shared/eslint-compat-utils.3ecba7ac.mjs'; +import { c as convertOptionToLegacy } from './shared/eslint-compat-utils.cb6790c2.mjs'; +import 'module'; + +var __defProp = Object.defineProperty; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __publicField = (obj, key, value) => { + __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); + return value; +}; +let cacheRuleTester; +let cachePrefix = ""; +function getRuleTester() { + return cacheRuleTester != null ? cacheRuleTester : cacheRuleTester = getRuleTesterInternal(); + function getRuleTesterInternal() { + if (semver.gte(eslint.Linter.version, "9.0.0-0")) { + cachePrefix = "rule-to-test/"; + return eslint.RuleTester; + } + const flatRuleTester = getUnsupported().FlatRuleTester; + if (flatRuleTester) { + cachePrefix = "rule-to-test/"; + return patchForV8FlatRuleTester(flatRuleTester); + } + return getRuleTesterClassFromLegacyRuleTester(); + } +} +function getRuleIdPrefix() { + getRuleTester(); + return cachePrefix; +} +function patchForV8FlatRuleTester(flatRuleTester) { + return class RuleTesterWithPatch extends flatRuleTester { + constructor(options) { + super(patchConfig(options)); + } + }; + function patchConfig(config) { + return { + files: ["**/*.*"], + ...config + }; + } +} +function getRuleTesterClassFromLegacyRuleTester() { + return class RuleTesterForV8 extends eslint.RuleTester { + constructor(options) { + var _a; + const defineRules = []; + const { processor, ...others } = options; + super( + convertConfigToRc(others, { + defineRule(...args) { + defineRules.push(args); + } + }) + ); + __publicField(this, "defaultProcessor"); + for (const args of defineRules) { + (_a = this.linter) == null ? void 0 : _a.defineRule(...args); + } + this.defaultProcessor = processor; + } + run(name, rule, tests) { + super.run(name, rule, { + valid: (tests.valid || []).map( + (test) => typeof test === "string" ? test : convert(test, this.defaultProcessor) + ), + invalid: (tests.invalid || []).map( + (test) => convert(test, this.defaultProcessor) + ) + }); + } + }; + function convert(config, defaultProcessor) { + const { processor: configProcessor, ...otherConfig } = config; + const processor = configProcessor || defaultProcessor; + const converted = convertConfigToRc(otherConfig); + if (!processor) { + return converted; + } + return { + ...converted, + filename: convertOptionToLegacy(processor, config.filename, config) + }; + } +} + +export { getRuleIdPrefix, getRuleTester }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.1a5060cf.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.1a5060cf.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0b3ca3d1e6bb4d9e5bf358ce248205df38c776ea --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.1a5060cf.mjs @@ -0,0 +1,193 @@ +import * as eslint from 'eslint'; +import * as semver from 'semver'; +import { createRequire } from 'module'; + +function safeRequire(name) { + try { + return createRequire(`${process.cwd()}/__placeholder__.js`)(name); + } catch { + return void 0; + } +} +function safeRequireResolve(name) { + try { + return createRequire(`${process.cwd()}/__placeholder__.js`).resolve(name); + } catch { + return name; + } +} + +const builtInGlobals = /* @__PURE__ */ new Map([ + [ + 3, + Object.entries({ + Array: false, + Boolean: false, + constructor: false, + Date: false, + decodeURI: false, + decodeURIComponent: false, + encodeURI: false, + encodeURIComponent: false, + Error: false, + escape: false, + eval: false, + EvalError: false, + Function: false, + hasOwnProperty: false, + Infinity: false, + isFinite: false, + isNaN: false, + isPrototypeOf: false, + Math: false, + NaN: false, + Number: false, + Object: false, + parseFloat: false, + parseInt: false, + propertyIsEnumerable: false, + RangeError: false, + ReferenceError: false, + RegExp: false, + String: false, + SyntaxError: false, + toLocaleString: false, + toString: false, + TypeError: false, + undefined: false, + unescape: false, + URIError: false, + valueOf: false + }) + ], + [ + 5, + Object.entries({ + JSON: false + }) + ], + [ + 2015, + Object.entries({ + ArrayBuffer: false, + DataView: false, + Float32Array: false, + Float64Array: false, + Int16Array: false, + Int32Array: false, + Int8Array: false, + Intl: false, + Map: false, + Promise: false, + Proxy: false, + Reflect: false, + Set: false, + Symbol: false, + Uint16Array: false, + Uint32Array: false, + Uint8Array: false, + Uint8ClampedArray: false, + WeakMap: false, + WeakSet: false + }) + ], + [ + 2017, + Object.entries({ + Atomics: false, + SharedArrayBuffer: false + }) + ], + [ + 2020, + Object.entries({ + BigInt: false, + BigInt64Array: false, + BigUint64Array: false, + globalThis: false + }) + ], + [ + 2021, + Object.entries({ + AggregateError: false, + FinalizationRegistry: false, + WeakRef: false + }) + ] +]); +function convertConfigToRc(config, linter) { + var _a, _b; + if (Array.isArray(config)) { + throw new Error("Array config is not supported."); + } + const { + languageOptions: originalLanguageOptions, + plugins, + ...newConfig + } = config; + if (originalLanguageOptions) { + const { + parser, + globals, + parserOptions, + ecmaVersion, + sourceType, + ...languageOptions + } = originalLanguageOptions; + newConfig.parserOptions = { + ...!ecmaVersion || ecmaVersion === "latest" ? { ecmaVersion: getLatestEcmaVersion() } : { ecmaVersion }, + ...sourceType ? { sourceType } : { sourceType: "module" }, + ...languageOptions, + ...parserOptions, + ...newConfig.parserOptions + }; + const resolvedEcmaVersion = newConfig.parserOptions.ecmaVersion; + newConfig.globals = { + ...Object.fromEntries( + [...builtInGlobals.entries()].flatMap( + ([version, editionGlobals]) => resolvedEcmaVersion < version ? [] : editionGlobals + ) + ), + ...newConfig.globals + }; + if (globals) { + newConfig.globals = { + ...globals, + ...newConfig.globals + }; + } + if (parser && !newConfig.parser) { + const parserName = getParserName(parser); + newConfig.parser = parserName; + (_a = linter == null ? void 0 : linter.defineParser) == null ? void 0 : _a.call(linter, parserName, parser); + } + } + if (plugins) { + for (const [pluginName, plugin] of Object.entries(plugins)) { + for (const [ruleName, rule] of Object.entries(plugin.rules || {})) { + (_b = linter == null ? void 0 : linter.defineRule) == null ? void 0 : _b.call(linter, `${pluginName}/${ruleName}`, rule); + } + } + } + newConfig.env = { + es6: true, + ...newConfig.env + }; + return newConfig; +} +function getParserName(parser) { + var _a; + const name = ((_a = parser.meta) == null ? void 0 : _a.name) || parser.name; + if (name === "typescript-eslint/parser") { + return safeRequireResolve("@typescript-eslint/parser"); + } else if (name == null && parser === safeRequire("@typescript-eslint/parser")) + return safeRequireResolve("@typescript-eslint/parser"); + return safeRequireResolve(name); +} +function getLatestEcmaVersion() { + const eslintVersion = eslint.Linter.version; + return semver.gte(eslintVersion, "8.0.0") ? "latest" : semver.gte(eslintVersion, "7.8.0") ? 2021 : semver.gte(eslintVersion, "6.2.0") ? 2020 : semver.gte(eslintVersion, "5.0.0") ? 2019 : 2018; +} + +export { convertConfigToRc as c }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.3ecba7ac.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.3ecba7ac.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a6cc607b01043327f0b858b73e865acdc2d4e93c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.3ecba7ac.mjs @@ -0,0 +1,9 @@ +function getUnsupported() { + try { + return require("eslint/use-at-your-own-risk"); + } catch { + return {}; + } +} + +export { getUnsupported as g }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.503aeaae.cjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.503aeaae.cjs new file mode 100644 index 0000000000000000000000000000000000000000..ceef3fd6efe363c61bb51f2c029e34e62cd0b2c0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.503aeaae.cjs @@ -0,0 +1,210 @@ +'use strict'; + +const eslint = require('eslint'); +const semver = require('semver'); +const module$1 = require('module'); + +function _interopNamespaceCompat(e) { + if (e && typeof e === 'object' && 'default' in e) return e; + const n = Object.create(null); + if (e) { + for (const k in e) { + n[k] = e[k]; + } + } + n.default = e; + return n; +} + +const eslint__namespace = /*#__PURE__*/_interopNamespaceCompat(eslint); +const semver__namespace = /*#__PURE__*/_interopNamespaceCompat(semver); + +function safeRequire(name) { + try { + return module$1.createRequire(`${process.cwd()}/__placeholder__.js`)(name); + } catch { + return void 0; + } +} +function safeRequireResolve(name) { + try { + return module$1.createRequire(`${process.cwd()}/__placeholder__.js`).resolve(name); + } catch { + return name; + } +} + +const builtInGlobals = /* @__PURE__ */ new Map([ + [ + 3, + Object.entries({ + Array: false, + Boolean: false, + constructor: false, + Date: false, + decodeURI: false, + decodeURIComponent: false, + encodeURI: false, + encodeURIComponent: false, + Error: false, + escape: false, + eval: false, + EvalError: false, + Function: false, + hasOwnProperty: false, + Infinity: false, + isFinite: false, + isNaN: false, + isPrototypeOf: false, + Math: false, + NaN: false, + Number: false, + Object: false, + parseFloat: false, + parseInt: false, + propertyIsEnumerable: false, + RangeError: false, + ReferenceError: false, + RegExp: false, + String: false, + SyntaxError: false, + toLocaleString: false, + toString: false, + TypeError: false, + undefined: false, + unescape: false, + URIError: false, + valueOf: false + }) + ], + [ + 5, + Object.entries({ + JSON: false + }) + ], + [ + 2015, + Object.entries({ + ArrayBuffer: false, + DataView: false, + Float32Array: false, + Float64Array: false, + Int16Array: false, + Int32Array: false, + Int8Array: false, + Intl: false, + Map: false, + Promise: false, + Proxy: false, + Reflect: false, + Set: false, + Symbol: false, + Uint16Array: false, + Uint32Array: false, + Uint8Array: false, + Uint8ClampedArray: false, + WeakMap: false, + WeakSet: false + }) + ], + [ + 2017, + Object.entries({ + Atomics: false, + SharedArrayBuffer: false + }) + ], + [ + 2020, + Object.entries({ + BigInt: false, + BigInt64Array: false, + BigUint64Array: false, + globalThis: false + }) + ], + [ + 2021, + Object.entries({ + AggregateError: false, + FinalizationRegistry: false, + WeakRef: false + }) + ] +]); +function convertConfigToRc(config, linter) { + var _a, _b; + if (Array.isArray(config)) { + throw new Error("Array config is not supported."); + } + const { + languageOptions: originalLanguageOptions, + plugins, + ...newConfig + } = config; + if (originalLanguageOptions) { + const { + parser, + globals, + parserOptions, + ecmaVersion, + sourceType, + ...languageOptions + } = originalLanguageOptions; + newConfig.parserOptions = { + ...!ecmaVersion || ecmaVersion === "latest" ? { ecmaVersion: getLatestEcmaVersion() } : { ecmaVersion }, + ...sourceType ? { sourceType } : { sourceType: "module" }, + ...languageOptions, + ...parserOptions, + ...newConfig.parserOptions + }; + const resolvedEcmaVersion = newConfig.parserOptions.ecmaVersion; + newConfig.globals = { + ...Object.fromEntries( + [...builtInGlobals.entries()].flatMap( + ([version, editionGlobals]) => resolvedEcmaVersion < version ? [] : editionGlobals + ) + ), + ...newConfig.globals + }; + if (globals) { + newConfig.globals = { + ...globals, + ...newConfig.globals + }; + } + if (parser && !newConfig.parser) { + const parserName = getParserName(parser); + newConfig.parser = parserName; + (_a = linter == null ? void 0 : linter.defineParser) == null ? void 0 : _a.call(linter, parserName, parser); + } + } + if (plugins) { + for (const [pluginName, plugin] of Object.entries(plugins)) { + for (const [ruleName, rule] of Object.entries(plugin.rules || {})) { + (_b = linter == null ? void 0 : linter.defineRule) == null ? void 0 : _b.call(linter, `${pluginName}/${ruleName}`, rule); + } + } + } + newConfig.env = { + es6: true, + ...newConfig.env + }; + return newConfig; +} +function getParserName(parser) { + var _a; + const name = ((_a = parser.meta) == null ? void 0 : _a.name) || parser.name; + if (name === "typescript-eslint/parser") { + return safeRequireResolve("@typescript-eslint/parser"); + } else if (name == null && parser === safeRequire("@typescript-eslint/parser")) + return safeRequireResolve("@typescript-eslint/parser"); + return safeRequireResolve(name); +} +function getLatestEcmaVersion() { + const eslintVersion = eslint__namespace.Linter.version; + return semver__namespace.gte(eslintVersion, "8.0.0") ? "latest" : semver__namespace.gte(eslintVersion, "7.8.0") ? 2021 : semver__namespace.gte(eslintVersion, "6.2.0") ? 2020 : semver__namespace.gte(eslintVersion, "5.0.0") ? 2019 : 2018; +} + +exports.convertConfigToRc = convertConfigToRc; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.808b5669.cjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.808b5669.cjs new file mode 100644 index 0000000000000000000000000000000000000000..471e0cf553149385e627f8071182ceb57b2babd8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.808b5669.cjs @@ -0,0 +1,54 @@ +'use strict'; + +function convertOptionToLegacy(processor, verifyOption, config) { + var _a; + if (processor == null) + return verifyOption; + if (typeof processor === "string") { + return convertOptionToLegacy( + findProcessor(processor, config), + verifyOption, + config + ); + } + const filename = (_a = typeof verifyOption === "string" ? verifyOption : verifyOption == null ? void 0 : verifyOption.filename) != null ? _a : ""; + const preprocess = function(code) { + var _a2; + const result = (_a2 = processor.preprocess) == null ? void 0 : _a2.call(processor, code, filename); + return result ? result : [code]; + }; + const postprocess = function(messages) { + var _a2; + const result = (_a2 = processor.postprocess) == null ? void 0 : _a2.call(processor, messages, filename); + return result ? result : messages[0]; + }; + if (verifyOption == null) { + return { preprocess, postprocess }; + } + if (typeof verifyOption === "string") { + return { filename: verifyOption, preprocess, postprocess }; + } + return { ...verifyOption, preprocess, postprocess }; +} +function findProcessor(processor, config) { + var _a, _b; + let pluginName, processorName; + const splitted = processor.split("/")[0]; + if (splitted.length === 2) { + pluginName = splitted[0]; + processorName = splitted[1]; + } else if (splitted.length === 3 && splitted[0].startsWith("@")) { + pluginName = `${splitted[0]}/${splitted[1]}`; + processorName = splitted[2]; + } else { + throw new Error(`Could not resolve processor: ${processor}`); + } + const plugin = (_a = config.plugins) == null ? void 0 : _a[pluginName]; + const resolved = (_b = plugin == null ? void 0 : plugin.processors) == null ? void 0 : _b[processorName]; + if (!resolved) { + throw new Error(`Could not resolve processor: ${processor}`); + } + return resolved; +} + +exports.convertOptionToLegacy = convertOptionToLegacy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.cb53cf36.cjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.cb53cf36.cjs new file mode 100644 index 0000000000000000000000000000000000000000..e9d6b9698f25d168be48e204959a96456a543f4e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.cb53cf36.cjs @@ -0,0 +1,11 @@ +'use strict'; + +function getUnsupported() { + try { + return require("eslint/use-at-your-own-risk"); + } catch { + return {}; + } +} + +exports.getUnsupported = getUnsupported; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.cb6790c2.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.cb6790c2.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4d8c01051a2b4313fafaba3f338252b9ed6b2831 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-compat-utils/dist/shared/eslint-compat-utils.cb6790c2.mjs @@ -0,0 +1,52 @@ +function convertOptionToLegacy(processor, verifyOption, config) { + var _a; + if (processor == null) + return verifyOption; + if (typeof processor === "string") { + return convertOptionToLegacy( + findProcessor(processor, config), + verifyOption, + config + ); + } + const filename = (_a = typeof verifyOption === "string" ? verifyOption : verifyOption == null ? void 0 : verifyOption.filename) != null ? _a : ""; + const preprocess = function(code) { + var _a2; + const result = (_a2 = processor.preprocess) == null ? void 0 : _a2.call(processor, code, filename); + return result ? result : [code]; + }; + const postprocess = function(messages) { + var _a2; + const result = (_a2 = processor.postprocess) == null ? void 0 : _a2.call(processor, messages, filename); + return result ? result : messages[0]; + }; + if (verifyOption == null) { + return { preprocess, postprocess }; + } + if (typeof verifyOption === "string") { + return { filename: verifyOption, preprocess, postprocess }; + } + return { ...verifyOption, preprocess, postprocess }; +} +function findProcessor(processor, config) { + var _a, _b; + let pluginName, processorName; + const splitted = processor.split("/")[0]; + if (splitted.length === 2) { + pluginName = splitted[0]; + processorName = splitted[1]; + } else if (splitted.length === 3 && splitted[0].startsWith("@")) { + pluginName = `${splitted[0]}/${splitted[1]}`; + processorName = splitted[2]; + } else { + throw new Error(`Could not resolve processor: ${processor}`); + } + const plugin = (_a = config.plugins) == null ? void 0 : _a[pluginName]; + const resolved = (_b = plugin == null ? void 0 : plugin.processors) == null ? void 0 : _b[processorName]; + if (!resolved) { + throw new Error(`Could not resolve processor: ${processor}`); + } + return resolved; +} + +export { convertOptionToLegacy as c }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..305eef8b915ff1a92b6da385861e70c3909e104e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/index.js @@ -0,0 +1,330 @@ +/** + * DON'T EDIT THIS FILE. + * This file was generated automatically by 'scripts/update-lib-index.js'. + */ +"use strict" + +const { printWarningOfDeprecatedConfig } = require("./utils") +const { version, name } = require("../package.json") + +module.exports = { + meta: { version, name }, + configs: { + "flat/no-new-in-es5": require("./configs/flat/no-new-in-es5"), + "flat/no-new-in-es2015": require("./configs/flat/no-new-in-es2015"), + "flat/no-new-in-es2015-intl-api": require("./configs/flat/no-new-in-es2015-intl-api"), + "flat/no-new-in-es2016": require("./configs/flat/no-new-in-es2016"), + "flat/no-new-in-es2016-intl-api": require("./configs/flat/no-new-in-es2016-intl-api"), + "flat/no-new-in-es2017": require("./configs/flat/no-new-in-es2017"), + "flat/no-new-in-es2017-intl-api": require("./configs/flat/no-new-in-es2017-intl-api"), + "flat/no-new-in-es2018": require("./configs/flat/no-new-in-es2018"), + "flat/no-new-in-es2018-intl-api": require("./configs/flat/no-new-in-es2018-intl-api"), + "flat/no-new-in-es2019": require("./configs/flat/no-new-in-es2019"), + "flat/no-new-in-es2019-intl-api": require("./configs/flat/no-new-in-es2019-intl-api"), + "flat/no-new-in-es2020": require("./configs/flat/no-new-in-es2020"), + "flat/no-new-in-es2020-intl-api": require("./configs/flat/no-new-in-es2020-intl-api"), + "flat/no-new-in-es2021": require("./configs/flat/no-new-in-es2021"), + "flat/no-new-in-es2021-intl-api": require("./configs/flat/no-new-in-es2021-intl-api"), + "flat/no-new-in-es2022": require("./configs/flat/no-new-in-es2022"), + "flat/no-new-in-es2022-intl-api": require("./configs/flat/no-new-in-es2022-intl-api"), + "flat/no-new-in-es2023": require("./configs/flat/no-new-in-es2023"), + "flat/no-new-in-es2023-intl-api": require("./configs/flat/no-new-in-es2023-intl-api"), + "flat/no-new-in-esnext": require("./configs/flat/no-new-in-esnext"), + "flat/no-new-in-esnext-intl-api": require("./configs/flat/no-new-in-esnext-intl-api"), + "flat/no-set-methods": require("./configs/flat/no-set-methods"), + "flat/restrict-to-es-intl-api-1st-edition": require("./configs/flat/restrict-to-es-intl-api-1st-edition"), + "flat/restrict-to-es3": require("./configs/flat/restrict-to-es3"), + "flat/restrict-to-es5": require("./configs/flat/restrict-to-es5"), + "flat/restrict-to-es2015": require("./configs/flat/restrict-to-es2015"), + "flat/restrict-to-es2015-intl-api": require("./configs/flat/restrict-to-es2015-intl-api"), + "flat/restrict-to-es2016": require("./configs/flat/restrict-to-es2016"), + "flat/restrict-to-es2016-intl-api": require("./configs/flat/restrict-to-es2016-intl-api"), + "flat/restrict-to-es2017": require("./configs/flat/restrict-to-es2017"), + "flat/restrict-to-es2017-intl-api": require("./configs/flat/restrict-to-es2017-intl-api"), + "flat/restrict-to-es2018": require("./configs/flat/restrict-to-es2018"), + "flat/restrict-to-es2018-intl-api": require("./configs/flat/restrict-to-es2018-intl-api"), + "flat/restrict-to-es2019": require("./configs/flat/restrict-to-es2019"), + "flat/restrict-to-es2019-intl-api": require("./configs/flat/restrict-to-es2019-intl-api"), + "flat/restrict-to-es2020": require("./configs/flat/restrict-to-es2020"), + "flat/restrict-to-es2020-intl-api": require("./configs/flat/restrict-to-es2020-intl-api"), + "flat/restrict-to-es2021": require("./configs/flat/restrict-to-es2021"), + "flat/restrict-to-es2021-intl-api": require("./configs/flat/restrict-to-es2021-intl-api"), + "flat/restrict-to-es2022": require("./configs/flat/restrict-to-es2022"), + "flat/restrict-to-es2022-intl-api": require("./configs/flat/restrict-to-es2022-intl-api"), + "no-new-in-es5": require("./configs/no-new-in-es5"), + "no-new-in-es2015": require("./configs/no-new-in-es2015"), + "no-new-in-es2015-intl-api": require("./configs/no-new-in-es2015-intl-api"), + "no-new-in-es2016": require("./configs/no-new-in-es2016"), + "no-new-in-es2016-intl-api": require("./configs/no-new-in-es2016-intl-api"), + "no-new-in-es2017": require("./configs/no-new-in-es2017"), + "no-new-in-es2017-intl-api": require("./configs/no-new-in-es2017-intl-api"), + "no-new-in-es2018": require("./configs/no-new-in-es2018"), + "no-new-in-es2018-intl-api": require("./configs/no-new-in-es2018-intl-api"), + "no-new-in-es2019": require("./configs/no-new-in-es2019"), + "no-new-in-es2019-intl-api": require("./configs/no-new-in-es2019-intl-api"), + "no-new-in-es2020": require("./configs/no-new-in-es2020"), + "no-new-in-es2020-intl-api": require("./configs/no-new-in-es2020-intl-api"), + "no-new-in-es2021": require("./configs/no-new-in-es2021"), + "no-new-in-es2021-intl-api": require("./configs/no-new-in-es2021-intl-api"), + "no-new-in-es2022": require("./configs/no-new-in-es2022"), + "no-new-in-es2022-intl-api": require("./configs/no-new-in-es2022-intl-api"), + "no-new-in-es2023": require("./configs/no-new-in-es2023"), + "no-new-in-es2023-intl-api": require("./configs/no-new-in-es2023-intl-api"), + "no-new-in-esnext": require("./configs/no-new-in-esnext"), + "no-new-in-esnext-intl-api": require("./configs/no-new-in-esnext-intl-api"), + "no-set-methods": require("./configs/no-set-methods"), + "restrict-to-es-intl-api-1st-edition": require("./configs/restrict-to-es-intl-api-1st-edition"), + "restrict-to-es3": require("./configs/restrict-to-es3"), + "restrict-to-es5": require("./configs/restrict-to-es5"), + "restrict-to-es2015": require("./configs/restrict-to-es2015"), + "restrict-to-es2015-intl-api": require("./configs/restrict-to-es2015-intl-api"), + "restrict-to-es2016": require("./configs/restrict-to-es2016"), + "restrict-to-es2016-intl-api": require("./configs/restrict-to-es2016-intl-api"), + "restrict-to-es2017": require("./configs/restrict-to-es2017"), + "restrict-to-es2017-intl-api": require("./configs/restrict-to-es2017-intl-api"), + "restrict-to-es2018": require("./configs/restrict-to-es2018"), + "restrict-to-es2018-intl-api": require("./configs/restrict-to-es2018-intl-api"), + "restrict-to-es2019": require("./configs/restrict-to-es2019"), + "restrict-to-es2019-intl-api": require("./configs/restrict-to-es2019-intl-api"), + "restrict-to-es2020": require("./configs/restrict-to-es2020"), + "restrict-to-es2020-intl-api": require("./configs/restrict-to-es2020-intl-api"), + "restrict-to-es2021": require("./configs/restrict-to-es2021"), + "restrict-to-es2021-intl-api": require("./configs/restrict-to-es2021-intl-api"), + "restrict-to-es2022": require("./configs/restrict-to-es2022"), + "restrict-to-es2022-intl-api": require("./configs/restrict-to-es2022-intl-api"), + get "no-5"() { + printWarningOfDeprecatedConfig("no-5") + return this["no-new-in-es5"] + }, + get "no-2015"() { + printWarningOfDeprecatedConfig("no-2015") + return this["no-new-in-es2015"] + }, + get "no-2016"() { + printWarningOfDeprecatedConfig("no-2016") + return this["no-new-in-es2016"] + }, + get "no-2017"() { + printWarningOfDeprecatedConfig("no-2017") + return this["no-new-in-es2017"] + }, + get "no-2018"() { + printWarningOfDeprecatedConfig("no-2018") + return this["no-new-in-es2018"] + }, + get "no-2019"() { + printWarningOfDeprecatedConfig("no-2019") + return this["no-new-in-es2019"] + }, + }, + rules: { + "no-accessor-properties": require("./rules/no-accessor-properties"), + "no-arbitrary-module-namespace-names": require("./rules/no-arbitrary-module-namespace-names"), + "no-array-from": require("./rules/no-array-from"), + "no-array-isarray": require("./rules/no-array-isarray"), + "no-array-of": require("./rules/no-array-of"), + "no-array-prototype-copywithin": require("./rules/no-array-prototype-copywithin"), + "no-array-prototype-entries": require("./rules/no-array-prototype-entries"), + "no-array-prototype-every": require("./rules/no-array-prototype-every"), + "no-array-prototype-fill": require("./rules/no-array-prototype-fill"), + "no-array-prototype-filter": require("./rules/no-array-prototype-filter"), + "no-array-prototype-find": require("./rules/no-array-prototype-find"), + "no-array-prototype-findindex": require("./rules/no-array-prototype-findindex"), + "no-array-prototype-findlast-findlastindex": require("./rules/no-array-prototype-findlast-findlastindex"), + "no-array-prototype-flat": require("./rules/no-array-prototype-flat"), + "no-array-prototype-foreach": require("./rules/no-array-prototype-foreach"), + "no-array-prototype-includes": require("./rules/no-array-prototype-includes"), + "no-array-prototype-indexof": require("./rules/no-array-prototype-indexof"), + "no-array-prototype-keys": require("./rules/no-array-prototype-keys"), + "no-array-prototype-lastindexof": require("./rules/no-array-prototype-lastindexof"), + "no-array-prototype-map": require("./rules/no-array-prototype-map"), + "no-array-prototype-reduce": require("./rules/no-array-prototype-reduce"), + "no-array-prototype-reduceright": require("./rules/no-array-prototype-reduceright"), + "no-array-prototype-some": require("./rules/no-array-prototype-some"), + "no-array-prototype-toreversed": require("./rules/no-array-prototype-toreversed"), + "no-array-prototype-tosorted": require("./rules/no-array-prototype-tosorted"), + "no-array-prototype-tospliced": require("./rules/no-array-prototype-tospliced"), + "no-array-prototype-values": require("./rules/no-array-prototype-values"), + "no-array-prototype-with": require("./rules/no-array-prototype-with"), + "no-array-string-prototype-at": require("./rules/no-array-string-prototype-at"), + "no-arraybuffer-prototype-transfer": require("./rules/no-arraybuffer-prototype-transfer"), + "no-arrow-functions": require("./rules/no-arrow-functions"), + "no-async-functions": require("./rules/no-async-functions"), + "no-async-iteration": require("./rules/no-async-iteration"), + "no-atomics": require("./rules/no-atomics"), + "no-atomics-waitasync": require("./rules/no-atomics-waitasync"), + "no-bigint": require("./rules/no-bigint"), + "no-binary-numeric-literals": require("./rules/no-binary-numeric-literals"), + "no-block-scoped-functions": require("./rules/no-block-scoped-functions"), + "no-block-scoped-variables": require("./rules/no-block-scoped-variables"), + "no-class-fields": require("./rules/no-class-fields"), + "no-class-static-block": require("./rules/no-class-static-block"), + "no-classes": require("./rules/no-classes"), + "no-computed-properties": require("./rules/no-computed-properties"), + "no-date-now": require("./rules/no-date-now"), + "no-date-prototype-getyear-setyear": require("./rules/no-date-prototype-getyear-setyear"), + "no-date-prototype-togmtstring": require("./rules/no-date-prototype-togmtstring"), + "no-default-parameters": require("./rules/no-default-parameters"), + "no-destructuring": require("./rules/no-destructuring"), + "no-dynamic-import": require("./rules/no-dynamic-import"), + "no-error-cause": require("./rules/no-error-cause"), + "no-escape-unescape": require("./rules/no-escape-unescape"), + "no-exponential-operators": require("./rules/no-exponential-operators"), + "no-export-ns-from": require("./rules/no-export-ns-from"), + "no-for-of-loops": require("./rules/no-for-of-loops"), + "no-function-declarations-in-if-statement-clauses-without-block": require("./rules/no-function-declarations-in-if-statement-clauses-without-block"), + "no-function-prototype-bind": require("./rules/no-function-prototype-bind"), + "no-generators": require("./rules/no-generators"), + "no-global-this": require("./rules/no-global-this"), + "no-hashbang": require("./rules/no-hashbang"), + "no-import-meta": require("./rules/no-import-meta"), + "no-initializers-in-for-in": require("./rules/no-initializers-in-for-in"), + "no-intl-datetimeformat-prototype-formatrange": require("./rules/no-intl-datetimeformat-prototype-formatrange"), + "no-intl-datetimeformat-prototype-formattoparts": require("./rules/no-intl-datetimeformat-prototype-formattoparts"), + "no-intl-displaynames": require("./rules/no-intl-displaynames"), + "no-intl-getcanonicallocales": require("./rules/no-intl-getcanonicallocales"), + "no-intl-listformat": require("./rules/no-intl-listformat"), + "no-intl-locale": require("./rules/no-intl-locale"), + "no-intl-numberformat-prototype-formatrange": require("./rules/no-intl-numberformat-prototype-formatrange"), + "no-intl-numberformat-prototype-formatrangetoparts": require("./rules/no-intl-numberformat-prototype-formatrangetoparts"), + "no-intl-numberformat-prototype-formattoparts": require("./rules/no-intl-numberformat-prototype-formattoparts"), + "no-intl-pluralrules": require("./rules/no-intl-pluralrules"), + "no-intl-pluralrules-prototype-selectrange": require("./rules/no-intl-pluralrules-prototype-selectrange"), + "no-intl-relativetimeformat": require("./rules/no-intl-relativetimeformat"), + "no-intl-segmenter": require("./rules/no-intl-segmenter"), + "no-intl-supportedvaluesof": require("./rules/no-intl-supportedvaluesof"), + "no-json": require("./rules/no-json"), + "no-json-superset": require("./rules/no-json-superset"), + "no-keyword-properties": require("./rules/no-keyword-properties"), + "no-labelled-function-declarations": require("./rules/no-labelled-function-declarations"), + "no-legacy-object-prototype-accessor-methods": require("./rules/no-legacy-object-prototype-accessor-methods"), + "no-logical-assignment-operators": require("./rules/no-logical-assignment-operators"), + "no-malformed-template-literals": require("./rules/no-malformed-template-literals"), + "no-map": require("./rules/no-map"), + "no-math-acosh": require("./rules/no-math-acosh"), + "no-math-asinh": require("./rules/no-math-asinh"), + "no-math-atanh": require("./rules/no-math-atanh"), + "no-math-cbrt": require("./rules/no-math-cbrt"), + "no-math-clz32": require("./rules/no-math-clz32"), + "no-math-cosh": require("./rules/no-math-cosh"), + "no-math-expm1": require("./rules/no-math-expm1"), + "no-math-fround": require("./rules/no-math-fround"), + "no-math-hypot": require("./rules/no-math-hypot"), + "no-math-imul": require("./rules/no-math-imul"), + "no-math-log1p": require("./rules/no-math-log1p"), + "no-math-log2": require("./rules/no-math-log2"), + "no-math-log10": require("./rules/no-math-log10"), + "no-math-sign": require("./rules/no-math-sign"), + "no-math-sinh": require("./rules/no-math-sinh"), + "no-math-tanh": require("./rules/no-math-tanh"), + "no-math-trunc": require("./rules/no-math-trunc"), + "no-modules": require("./rules/no-modules"), + "no-new-target": require("./rules/no-new-target"), + "no-nullish-coalescing-operators": require("./rules/no-nullish-coalescing-operators"), + "no-number-epsilon": require("./rules/no-number-epsilon"), + "no-number-isfinite": require("./rules/no-number-isfinite"), + "no-number-isinteger": require("./rules/no-number-isinteger"), + "no-number-isnan": require("./rules/no-number-isnan"), + "no-number-issafeinteger": require("./rules/no-number-issafeinteger"), + "no-number-maxsafeinteger": require("./rules/no-number-maxsafeinteger"), + "no-number-minsafeinteger": require("./rules/no-number-minsafeinteger"), + "no-number-parsefloat": require("./rules/no-number-parsefloat"), + "no-number-parseint": require("./rules/no-number-parseint"), + "no-numeric-separators": require("./rules/no-numeric-separators"), + "no-object-assign": require("./rules/no-object-assign"), + "no-object-create": require("./rules/no-object-create"), + "no-object-defineproperties": require("./rules/no-object-defineproperties"), + "no-object-defineproperty": require("./rules/no-object-defineproperty"), + "no-object-entries": require("./rules/no-object-entries"), + "no-object-freeze": require("./rules/no-object-freeze"), + "no-object-fromentries": require("./rules/no-object-fromentries"), + "no-object-getownpropertydescriptor": require("./rules/no-object-getownpropertydescriptor"), + "no-object-getownpropertydescriptors": require("./rules/no-object-getownpropertydescriptors"), + "no-object-getownpropertynames": require("./rules/no-object-getownpropertynames"), + "no-object-getownpropertysymbols": require("./rules/no-object-getownpropertysymbols"), + "no-object-getprototypeof": require("./rules/no-object-getprototypeof"), + "no-object-hasown": require("./rules/no-object-hasown"), + "no-object-is": require("./rules/no-object-is"), + "no-object-isextensible": require("./rules/no-object-isextensible"), + "no-object-isfrozen": require("./rules/no-object-isfrozen"), + "no-object-issealed": require("./rules/no-object-issealed"), + "no-object-keys": require("./rules/no-object-keys"), + "no-object-map-groupby": require("./rules/no-object-map-groupby"), + "no-object-preventextensions": require("./rules/no-object-preventextensions"), + "no-object-seal": require("./rules/no-object-seal"), + "no-object-setprototypeof": require("./rules/no-object-setprototypeof"), + "no-object-super-properties": require("./rules/no-object-super-properties"), + "no-object-values": require("./rules/no-object-values"), + "no-octal-numeric-literals": require("./rules/no-octal-numeric-literals"), + "no-optional-catch-binding": require("./rules/no-optional-catch-binding"), + "no-optional-chaining": require("./rules/no-optional-chaining"), + "no-private-in": require("./rules/no-private-in"), + "no-promise": require("./rules/no-promise"), + "no-promise-all-settled": require("./rules/no-promise-all-settled"), + "no-promise-any": require("./rules/no-promise-any"), + "no-promise-prototype-finally": require("./rules/no-promise-prototype-finally"), + "no-promise-withresolvers": require("./rules/no-promise-withresolvers"), + "no-property-shorthands": require("./rules/no-property-shorthands"), + "no-proxy": require("./rules/no-proxy"), + "no-reflect": require("./rules/no-reflect"), + "no-regexp-d-flag": require("./rules/no-regexp-d-flag"), + "no-regexp-duplicate-named-capturing-groups": require("./rules/no-regexp-duplicate-named-capturing-groups"), + "no-regexp-lookbehind-assertions": require("./rules/no-regexp-lookbehind-assertions"), + "no-regexp-named-capture-groups": require("./rules/no-regexp-named-capture-groups"), + "no-regexp-prototype-compile": require("./rules/no-regexp-prototype-compile"), + "no-regexp-prototype-flags": require("./rules/no-regexp-prototype-flags"), + "no-regexp-s-flag": require("./rules/no-regexp-s-flag"), + "no-regexp-u-flag": require("./rules/no-regexp-u-flag"), + "no-regexp-unicode-property-escapes": require("./rules/no-regexp-unicode-property-escapes"), + "no-regexp-unicode-property-escapes-2019": require("./rules/no-regexp-unicode-property-escapes-2019"), + "no-regexp-unicode-property-escapes-2020": require("./rules/no-regexp-unicode-property-escapes-2020"), + "no-regexp-unicode-property-escapes-2021": require("./rules/no-regexp-unicode-property-escapes-2021"), + "no-regexp-unicode-property-escapes-2022": require("./rules/no-regexp-unicode-property-escapes-2022"), + "no-regexp-unicode-property-escapes-2023": require("./rules/no-regexp-unicode-property-escapes-2023"), + "no-regexp-v-flag": require("./rules/no-regexp-v-flag"), + "no-regexp-y-flag": require("./rules/no-regexp-y-flag"), + "no-resizable-and-growable-arraybuffers": require("./rules/no-resizable-and-growable-arraybuffers"), + "no-rest-parameters": require("./rules/no-rest-parameters"), + "no-rest-spread-properties": require("./rules/no-rest-spread-properties"), + "no-set": require("./rules/no-set"), + "no-set-prototype-difference": require("./rules/no-set-prototype-difference"), + "no-set-prototype-intersection": require("./rules/no-set-prototype-intersection"), + "no-set-prototype-isdisjointfrom": require("./rules/no-set-prototype-isdisjointfrom"), + "no-set-prototype-issubsetof": require("./rules/no-set-prototype-issubsetof"), + "no-set-prototype-issupersetof": require("./rules/no-set-prototype-issupersetof"), + "no-set-prototype-symmetricdifference": require("./rules/no-set-prototype-symmetricdifference"), + "no-set-prototype-union": require("./rules/no-set-prototype-union"), + "no-shadow-catch-param": require("./rules/no-shadow-catch-param"), + "no-shared-array-buffer": require("./rules/no-shared-array-buffer"), + "no-spread-elements": require("./rules/no-spread-elements"), + "no-string-create-html-methods": require("./rules/no-string-create-html-methods"), + "no-string-fromcodepoint": require("./rules/no-string-fromcodepoint"), + "no-string-prototype-codepointat": require("./rules/no-string-prototype-codepointat"), + "no-string-prototype-endswith": require("./rules/no-string-prototype-endswith"), + "no-string-prototype-includes": require("./rules/no-string-prototype-includes"), + "no-string-prototype-iswellformed-towellformed": require("./rules/no-string-prototype-iswellformed-towellformed"), + "no-string-prototype-matchall": require("./rules/no-string-prototype-matchall"), + "no-string-prototype-normalize": require("./rules/no-string-prototype-normalize"), + "no-string-prototype-padstart-padend": require("./rules/no-string-prototype-padstart-padend"), + "no-string-prototype-repeat": require("./rules/no-string-prototype-repeat"), + "no-string-prototype-replaceall": require("./rules/no-string-prototype-replaceall"), + "no-string-prototype-startswith": require("./rules/no-string-prototype-startswith"), + "no-string-prototype-substr": require("./rules/no-string-prototype-substr"), + "no-string-prototype-trim": require("./rules/no-string-prototype-trim"), + "no-string-prototype-trimleft-trimright": require("./rules/no-string-prototype-trimleft-trimright"), + "no-string-prototype-trimstart-trimend": require("./rules/no-string-prototype-trimstart-trimend"), + "no-string-raw": require("./rules/no-string-raw"), + "no-subclassing-builtins": require("./rules/no-subclassing-builtins"), + "no-symbol": require("./rules/no-symbol"), + "no-symbol-prototype-description": require("./rules/no-symbol-prototype-description"), + "no-template-literals": require("./rules/no-template-literals"), + "no-top-level-await": require("./rules/no-top-level-await"), + "no-trailing-commas": require("./rules/no-trailing-commas"), + "no-trailing-function-commas": require("./rules/no-trailing-function-commas"), + "no-typed-arrays": require("./rules/no-typed-arrays"), + "no-unicode-codepoint-escapes": require("./rules/no-unicode-codepoint-escapes"), + "no-weak-map": require("./rules/no-weak-map"), + "no-weak-set": require("./rules/no-weak-set"), + "no-weakrefs": require("./rules/no-weakrefs"), + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-accessor-properties.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-accessor-properties.js new file mode 100644 index 0000000000000000000000000000000000000000..062548915223015d5ef5d61dc1b4769fe0671163 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-accessor-properties.js @@ -0,0 +1,31 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +module.exports = { + meta: { + docs: { + description: "disallow accessor properties.", + category: "ES5", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-accessor-properties.html", + }, + fixable: null, + messages: { + forbidden: "ES5 accessor properties are forbidden.", + }, + schema: [], + type: "problem", + }, + create(context) { + return { + "Property[kind='get'], Property[kind='set'], MethodDefinition[kind='get'], MethodDefinition[kind='set']"( + node, + ) { + context.report({ node, messageId: "forbidden" }) + }, + } + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-arbitrary-module-namespace-names.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-arbitrary-module-namespace-names.js new file mode 100644 index 0000000000000000000000000000000000000000..8500c9412744f4e444c22bb59afde3c446c2ceaa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-arbitrary-module-namespace-names.js @@ -0,0 +1,34 @@ +/** + * @author Yosuke Ota + * See LICENSE file in root directory for full license. + */ +"use strict" + +module.exports = { + meta: { + docs: { + description: "disallow arbitrary module namespace names.", + category: "ES2022", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-arbitrary-module-namespace-names.html", + }, + fixable: null, + messages: { + forbidden: "ES2022 arbitrary module namespace names are forbidden.", + }, + schema: [], + type: "problem", + }, + create(context) { + return { + "ExportAllDeclaration > Literal.exported, ExportSpecifier > Literal.local, ExportSpecifier > Literal.exported, ImportSpecifier > Literal.imported"( + node, + ) { + context.report({ + node, + messageId: "forbidden", + }) + }, + } + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-from.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-from.js new file mode 100644 index 0000000000000000000000000000000000000000..f6dfe0cfbb2722761c58ac521909031aa0d66ff1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-from.js @@ -0,0 +1,46 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { READ, ReferenceTracker } = require("@eslint-community/eslint-utils") +const { getSourceCode } = require("eslint-compat-utils") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.from` method.", + category: "ES2015", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-from.html", + }, + fixable: null, + messages: { + forbidden: "ES2015 '{{name}}' method is forbidden.", + }, + schema: [], + type: "problem", + }, + create(context) { + return { + "Program:exit"(program) { + const sourceCode = getSourceCode(context) + const tracker = new ReferenceTracker( + sourceCode.getScope(program), + ) + for (const { node, path } of tracker.iterateGlobalReferences({ + Array: { + from: { [READ]: true }, + }, + })) { + context.report({ + node, + messageId: "forbidden", + data: { name: path.join(".") }, + }) + } + }, + } + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-isarray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-isarray.js new file mode 100644 index 0000000000000000000000000000000000000000..6c3d766eb8185b1d9420c27291f2e36a3b2b508c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-isarray.js @@ -0,0 +1,46 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { READ, ReferenceTracker } = require("@eslint-community/eslint-utils") +const { getSourceCode } = require("eslint-compat-utils") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.isArray` method.", + category: "ES5", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-isarray.html", + }, + fixable: null, + messages: { + forbidden: "ES5 '{{name}}' method is forbidden.", + }, + schema: [], + type: "problem", + }, + create(context) { + return { + "Program:exit"(program) { + const sourceCode = getSourceCode(context) + const tracker = new ReferenceTracker( + sourceCode.getScope(program), + ) + for (const { node, path } of tracker.iterateGlobalReferences({ + Array: { + isArray: { [READ]: true }, + }, + })) { + context.report({ + node, + messageId: "forbidden", + data: { name: path.join(".") }, + }) + } + }, + } + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-of.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-of.js new file mode 100644 index 0000000000000000000000000000000000000000..bad6cf6bd03b0d9b89e814e4854b361b6289d22c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-of.js @@ -0,0 +1,46 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { READ, ReferenceTracker } = require("@eslint-community/eslint-utils") +const { getSourceCode } = require("eslint-compat-utils") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.of` method.", + category: "ES2015", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-of.html", + }, + fixable: null, + messages: { + forbidden: "ES2015 '{{name}}' method is forbidden.", + }, + schema: [], + type: "problem", + }, + create(context) { + return { + "Program:exit"(program) { + const sourceCode = getSourceCode(context) + const tracker = new ReferenceTracker( + sourceCode.getScope(program), + ) + for (const { node, path } of tracker.iterateGlobalReferences({ + Array: { + of: { [READ]: true }, + }, + })) { + context.report({ + node, + messageId: "forbidden", + data: { name: path.join(".") }, + }) + } + }, + } + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-copywithin.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-copywithin.js new file mode 100644 index 0000000000000000000000000000000000000000..9ad67a12b29b88d32f1cf2c53347c4bad754eefb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-copywithin.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.copyWithin` method.", + category: "ES2015", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-copywithin.html", + }, + fixable: null, + messages: { + forbidden: "ES2015 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["copyWithin"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-entries.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-entries.js new file mode 100644 index 0000000000000000000000000000000000000000..de040128b05d4979d9cc1c9446622b668b871bbb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-entries.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.entries` method.", + category: "ES2015", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-entries.html", + }, + fixable: null, + messages: { + forbidden: "ES2015 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["entries"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-every.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-every.js new file mode 100644 index 0000000000000000000000000000000000000000..3223f8eb4402034849279a814586047addb0381d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-every.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.every` method.", + category: "ES5", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-every.html", + }, + fixable: null, + messages: { + forbidden: "ES5 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["every"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-fill.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-fill.js new file mode 100644 index 0000000000000000000000000000000000000000..bc8bb086226c790373fe970d056db246535be23b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-fill.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.fill` method.", + category: "ES2015", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-fill.html", + }, + fixable: null, + messages: { + forbidden: "ES2015 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["fill"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-filter.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-filter.js new file mode 100644 index 0000000000000000000000000000000000000000..1819499bc5c8a90d4cf7966ee39f9f34802d578f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-filter.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.filter` method.", + category: "ES5", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-filter.html", + }, + fixable: null, + messages: { + forbidden: "ES5 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["filter"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-find.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-find.js new file mode 100644 index 0000000000000000000000000000000000000000..f1556175be0eb80fec0691498d76e656e80fd3f1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-find.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.find` method.", + category: "ES2015", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-find.html", + }, + fixable: null, + messages: { + forbidden: "ES2015 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["find"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-findindex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-findindex.js new file mode 100644 index 0000000000000000000000000000000000000000..4ef2a9ab4bfb47f28dda7626c6db8dca81f6f2c9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-findindex.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.findIndex` method.", + category: "ES2015", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-findindex.html", + }, + fixable: null, + messages: { + forbidden: "ES2015 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["findIndex"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-findlast-findlastindex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-findlast-findlastindex.js new file mode 100644 index 0000000000000000000000000000000000000000..6ece30d6beec18a2db137b0a9ce2896607431949 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-findlast-findlastindex.js @@ -0,0 +1,47 @@ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: + "disallow the `Array.prototype.{findLast,findLastIndex}` methods.", + category: "ES2023", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-findlast-findlastindex.html", + }, + fixable: null, + messages: { + forbidden: "ES2023 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["findLast", "findLastIndex"], + Int8Array: ["findLast", "findLastIndex"], + Uint8Array: ["findLast", "findLastIndex"], + Uint8ClampedArray: ["findLast", "findLastIndex"], + Int16Array: ["findLast", "findLastIndex"], + Uint16Array: ["findLast", "findLastIndex"], + Int32Array: ["findLast", "findLastIndex"], + Uint32Array: ["findLast", "findLastIndex"], + Float32Array: ["findLast", "findLastIndex"], + Float64Array: ["findLast", "findLastIndex"], + BigInt64Array: ["findLast", "findLastIndex"], + BigUint64Array: ["findLast", "findLastIndex"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-flat.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-flat.js new file mode 100644 index 0000000000000000000000000000000000000000..9b300c9bc594e2d21f7b012f445bdb228220f03e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-flat.js @@ -0,0 +1,40 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: + "disallow the `Array.prototype.{flat,flatMap}` method.", + category: "ES2019", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-flat.html", + }, + fixable: null, + messages: { + forbidden: "ES2019 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["flat", "flatMap"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-foreach.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-foreach.js new file mode 100644 index 0000000000000000000000000000000000000000..3e8b07e59a0f359d6ece09ae000fd9d54051bab1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-foreach.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.forEach` method.", + category: "ES5", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-foreach.html", + }, + fixable: null, + messages: { + forbidden: "ES5 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["forEach"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-includes.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-includes.js new file mode 100644 index 0000000000000000000000000000000000000000..a185f8dc965635a79cc2a2ba55a98f1e143ebead --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-includes.js @@ -0,0 +1,50 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.includes` method.", + category: "ES2016", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-includes.html", + }, + fixable: null, + messages: { + forbidden: "ES2016 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["includes"], + Int8Array: ["includes"], + Uint8Array: ["includes"], + Uint8ClampedArray: ["includes"], + Int16Array: ["includes"], + Uint16Array: ["includes"], + Int32Array: ["includes"], + Uint32Array: ["includes"], + Float32Array: ["includes"], + Float64Array: ["includes"], + BigInt64Array: ["includes"], + BigUint64Array: ["includes"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-indexof.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-indexof.js new file mode 100644 index 0000000000000000000000000000000000000000..ac51a41cb6b846355b090ecadf36f291883887c3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-indexof.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.indexOf` method.", + category: "ES5", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-indexof.html", + }, + fixable: null, + messages: { + forbidden: "ES5 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["indexOf"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-keys.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-keys.js new file mode 100644 index 0000000000000000000000000000000000000000..cbb003c124bf990dbccde6c2e814fede05d5a66e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-keys.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.keys` method.", + category: "ES2015", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-keys.html", + }, + fixable: null, + messages: { + forbidden: "ES2015 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["keys"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-lastindexof.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-lastindexof.js new file mode 100644 index 0000000000000000000000000000000000000000..02a54ba8149c4d2cca670d97ae65c0f0f6eadeee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-lastindexof.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.lastIndexOf` method.", + category: "ES5", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-lastindexof.html", + }, + fixable: null, + messages: { + forbidden: "ES5 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["lastIndexOf"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-map.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-map.js new file mode 100644 index 0000000000000000000000000000000000000000..22e2700e8c8a10d8a7ab7d19537235478cd982e6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/rules/no-array-prototype-map.js @@ -0,0 +1,39 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + definePrototypeMethodHandler, +} = require("../util/define-prototype-method-handler") + +module.exports = { + meta: { + docs: { + description: "disallow the `Array.prototype.map` method.", + category: "ES5", + recommended: false, + url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-array-prototype-map.html", + }, + fixable: null, + messages: { + forbidden: "ES5 '{{name}}' method is forbidden.", + }, + schema: [ + { + type: "object", + properties: { + aggressive: { type: "boolean" }, + }, + additionalProperties: false, + }, + ], + type: "problem", + }, + create(context) { + return definePrototypeMethodHandler(context, { + Array: ["map"], + }) + }, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/define-regexp-handler.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/define-regexp-handler.js new file mode 100644 index 0000000000000000000000000000000000000000..c3446e54c299a947b6460fe0a70ce9767d93acd4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/define-regexp-handler.js @@ -0,0 +1,109 @@ +"use strict" + +const { RegExpValidator } = require("@eslint-community/regexpp") +const { getRegExpCalls } = require("../utils") +const { getSourceCode } = require("eslint-compat-utils") + +const allVisitorBuilder = new WeakMap() + +/** + * @typedef {RegExpValidator.Options & {onExit:()=>void}} RuleValidator + */ +/** + * Define handlers to regexp nodes. + * @param {RuleContext} context The rule context. + * @param {(node: Node) => RuleValidator} visitorBuilder The regexp node visitor builder. + * @returns {Record void>} The defined handlers. + */ +function defineRegExpHandler(context, visitorBuilder) { + const sourceCode = getSourceCode(context) + const programNode = sourceCode.ast + + let handler = {} + let builders = allVisitorBuilder.get(programNode) + if (!builders) { + builders = [] + allVisitorBuilder.set(programNode, builders) + handler = { + "Literal[regex]"(node) { + const { pattern, flags } = node.regex + visitRegExp(builders, node, pattern || "", flags || "") + }, + + "Program:exit"() { + allVisitorBuilder.delete(programNode) + + const scope = sourceCode.getScope(programNode) + for (const { node, pattern, flags } of getRegExpCalls(scope)) { + visitRegExp(builders, node, pattern || "", flags || "") + } + }, + } + } + + builders.push(visitorBuilder) + + return handler +} + +module.exports = { defineRegExpHandler } + +/** + * Visit a given regular expression. + * @param {((node: Node) => RuleValidator)[]} visitorBuilders The array of validator options builders. + * @param {Node} node The AST node to report. + * @param {string} pattern The pattern part of a RegExp. + * @param {string} flags The flags part of a RegExp. + * @returns {void} + */ +function visitRegExp(visitorBuilders, node, pattern, flags) { + try { + const visitors = visitorBuilders.map((r) => r(node, { pattern, flags })) + const composedVisitor = composeRegExpVisitors(visitors) + + new RegExpValidator(composedVisitor).validatePattern( + pattern, + 0, + pattern.length, + flags.includes("u"), + ) + + if (typeof composedVisitor.onExit === "function") { + composedVisitor.onExit() + } + } catch (error) { + //istanbul ignore else + if (error.message.startsWith("Invalid regular expression:")) { + return + } + //istanbul ignore next + throw error + } +} + +/** + * Returns a single visitor handler that executes all the given visitors. + * @param {RuleValidator[]} visitors + * @returns {RuleValidator} + */ +function composeRegExpVisitors(visitors) { + const result = {} + + for (const visitor of visitors) { + const entries = Object.entries(visitor) + + for (const [key, fn] of entries) { + const orig = result[key] + if (orig) { + result[key] = (...args) => { + orig(...args) + fn(...args) + } + } else { + result[key] = fn + } + } + } + + return result +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/optional-require.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/optional-require.js new file mode 100644 index 0000000000000000000000000000000000000000..127d8e663739019ea2f773c3c4ad18b9fb67e3a2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/optional-require.js @@ -0,0 +1,19 @@ +"use strict" + +/** + * Load a module optionally. + * @param {Function} originalRequire The original `require` function. + * @param {string} id The module specifier. + */ +function optionalRequire(originalRequire, id) { + try { + return originalRequire(id) + } catch (error) { + if (error && error.code === "MODULE_NOT_FOUND") { + return undefined + } + throw error + } +} + +module.exports = { optionalRequire } diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/unicode-properties.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/unicode-properties.js new file mode 100644 index 0000000000000000000000000000000000000000..f7c2a9c7c5ce1b2c0d00b90ddf417b43d611061b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/util/unicode-properties.js @@ -0,0 +1,112 @@ +/* This file was generated with ECMAScript specifications. */ +"use strict" + +class DataSet { + constructor( + raw2018, + raw2019, + raw2020, + raw2021, + raw2022, + raw2023, + raw2024, + raw2025, + ) { + this._raw2018 = raw2018 + this._raw2019 = raw2019 + this._raw2020 = raw2020 + this._raw2021 = raw2021 + this._raw2022 = raw2022 + this._raw2023 = raw2023 + this._raw2024 = raw2024 + this._raw2025 = raw2025 + } + + get es2018() { + return ( + this._set2018 || (this._set2018 = new Set(this._raw2018.split(" "))) + ) + } + + get es2019() { + return ( + this._set2019 || (this._set2019 = new Set(this._raw2019.split(" "))) + ) + } + + get es2020() { + return ( + this._set2020 || (this._set2020 = new Set(this._raw2020.split(" "))) + ) + } + + get es2021() { + return ( + this._set2021 || (this._set2021 = new Set(this._raw2021.split(" "))) + ) + } + + get es2022() { + return ( + this._set2022 || (this._set2022 = new Set(this._raw2022.split(" "))) + ) + } + + get es2023() { + return ( + this._set2023 || (this._set2023 = new Set(this._raw2023.split(" "))) + ) + } + + get es2024() { + return ( + this._set2024 || (this._set2024 = new Set(this._raw2024.split(" "))) + ) + } + + get es2025() { + return ( + this._set2025 || (this._set2025 = new Set(this._raw2025.split(" "))) + ) + } +} + +const gcNameSet = new Set(["General_Category", "gc"]) +const scNameSet = new Set(["Script", "Script_Extensions", "sc", "scx"]) +const gcValueSets = new DataSet( + "C Cased_Letter Cc Cf Close_Punctuation Cn Co Combining_Mark Connector_Punctuation Control Cs Currency_Symbol Dash_Punctuation Decimal_Number Enclosing_Mark Final_Punctuation Format Initial_Punctuation L LC Letter Letter_Number Line_Separator Ll Lm Lo Lowercase_Letter Lt Lu M Mark Math_Symbol Mc Me Mn Modifier_Letter Modifier_Symbol N Nd Nl No Nonspacing_Mark Number Open_Punctuation Other Other_Letter Other_Number Other_Punctuation Other_Symbol P Paragraph_Separator Pc Pd Pe Pf Pi Po Private_Use Ps Punctuation S Sc Separator Sk Sm So Space_Separator Spacing_Mark Surrogate Symbol Titlecase_Letter Unassigned Uppercase_Letter Z Zl Zp Zs cntrl digit punct", + "", + "", + "", + "", + "", + "", + "", +) +const scValueSets = new DataSet( + "Adlam Adlm Aghb Ahom Anatolian_Hieroglyphs Arab Arabic Armenian Armi Armn Avestan Avst Bali Balinese Bamu Bamum Bass Bassa_Vah Batak Batk Beng Bengali Bhaiksuki Bhks Bopo Bopomofo Brah Brahmi Brai Braille Bugi Buginese Buhd Buhid Cakm Canadian_Aboriginal Cans Cari Carian Caucasian_Albanian Chakma Cham Cher Cherokee Common Copt Coptic Cprt Cuneiform Cypriot Cyrillic Cyrl Deseret Deva Devanagari Dsrt Dupl Duployan Egyp Egyptian_Hieroglyphs Elba Elbasan Ethi Ethiopic Geor Georgian Glag Glagolitic Gonm Goth Gothic Gran Grantha Greek Grek Gujarati Gujr Gurmukhi Guru Han Hang Hangul Hani Hano Hanunoo Hatr Hatran Hebr Hebrew Hira Hiragana Hluw Hmng Hung Imperial_Aramaic Inherited Inscriptional_Pahlavi Inscriptional_Parthian Ital Java Javanese Kaithi Kali Kana Kannada Katakana Kayah_Li Khar Kharoshthi Khmer Khmr Khoj Khojki Khudawadi Knda Kthi Lana Lao Laoo Latin Latn Lepc Lepcha Limb Limbu Lina Linb Linear_A Linear_B Lisu Lyci Lycian Lydi Lydian Mahajani Mahj Malayalam Mand Mandaic Mani Manichaean Marc Marchen Masaram_Gondi Meetei_Mayek Mend Mende_Kikakui Merc Mero Meroitic_Cursive Meroitic_Hieroglyphs Miao Mlym Modi Mong Mongolian Mro Mroo Mtei Mult Multani Myanmar Mymr Nabataean Narb Nbat New_Tai_Lue Newa Nko Nkoo Nshu Nushu Ogam Ogham Ol_Chiki Olck Old_Hungarian Old_Italic Old_North_Arabian Old_Permic Old_Persian Old_South_Arabian Old_Turkic Oriya Orkh Orya Osage Osge Osma Osmanya Pahawh_Hmong Palm Palmyrene Pau_Cin_Hau Pauc Perm Phag Phags_Pa Phli Phlp Phnx Phoenician Plrd Prti Psalter_Pahlavi Qaac Qaai Rejang Rjng Runic Runr Samaritan Samr Sarb Saur Saurashtra Sgnw Sharada Shavian Shaw Shrd Sidd Siddham SignWriting Sind Sinh Sinhala Sora Sora_Sompeng Soyo Soyombo Sund Sundanese Sylo Syloti_Nagri Syrc Syriac Tagalog Tagb Tagbanwa Tai_Le Tai_Tham Tai_Viet Takr Takri Tale Talu Tamil Taml Tang Tangut Tavt Telu Telugu Tfng Tglg Thaa Thaana Thai Tibetan Tibt Tifinagh Tirh Tirhuta Ugar Ugaritic Vai Vaii Wara Warang_Citi Xpeo Xsux Yi Yiii Zanabazar_Square Zanb Zinh Zyyy", + "Dogr Dogra Gong Gunjala_Gondi Hanifi_Rohingya Maka Makasar Medefaidrin Medf Old_Sogdian Rohg Sogd Sogdian Sogo", + "Elym Elymaic Hmnp Nand Nandinagari Nyiakeng_Puachue_Hmong Wancho Wcho", + "Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi", + "Cpmn Cypro_Minoan Old_Uyghur Ougr Tangsa Tnsa Toto Vith Vithkuqi", + "Hrkt Katakana_Or_Hiragana Kawi Nag_Mundari Nagm Unknown Zzzz", + "", + "", +) +const binPropertySets = new DataSet( + "AHex ASCII ASCII_Hex_Digit Alpha Alphabetic Any Assigned Bidi_C Bidi_Control Bidi_M Bidi_Mirrored CI CWCF CWCM CWKCF CWL CWT CWU Case_Ignorable Cased Changes_When_Casefolded Changes_When_Casemapped Changes_When_Lowercased Changes_When_NFKC_Casefolded Changes_When_Titlecased Changes_When_Uppercased DI Dash Default_Ignorable_Code_Point Dep Deprecated Dia Diacritic Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Ext Extender Gr_Base Gr_Ext Grapheme_Base Grapheme_Extend Hex Hex_Digit IDC IDS IDSB IDST IDS_Binary_Operator IDS_Trinary_Operator ID_Continue ID_Start Ideo Ideographic Join_C Join_Control LOE Logical_Order_Exception Lower Lowercase Math NChar Noncharacter_Code_Point Pat_Syn Pat_WS Pattern_Syntax Pattern_White_Space QMark Quotation_Mark RI Radical Regional_Indicator SD STerm Sentence_Terminal Soft_Dotted Term Terminal_Punctuation UIdeo Unified_Ideograph Upper Uppercase VS Variation_Selector White_Space XIDC XIDS XID_Continue XID_Start space", + "Extended_Pictographic", + "", + "EBase EComp EMod EPres ExtPict", + "", + "", + "", + "", +) +module.exports = { + gcNameSet, + scNameSet, + gcValueSets, + scValueSets, + binPropertySets, +} diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/utils.js b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..19d0627e9d42714cddcebca17456bd19e025f4a0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/eslint-plugin-es-x/lib/utils.js @@ -0,0 +1,70 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict" + +const { + CALL, + CONSTRUCT, + PatternMatcher, + ReferenceTracker, + getStringIfConstant, +} = require("@eslint-community/eslint-utils") + +module.exports = { + /** + * Define generator to search pattern. + * The iterator generated by the generator returns the start and end index of the match. + * @param {RegExp} pattern Base pattern + * @returns {function(string):IterableIterator} generator + */ + definePatternSearchGenerator(pattern) { + const matcher = new PatternMatcher(pattern) + return matcher.execAll.bind(matcher) + }, + + /** + * Check whether a given token is a comma token or not. + * @param {Token} token The token to check. + * @returns {boolean} `true` if the token is a comma token. + */ + isCommaToken(token) { + return ( + token != null && token.type === "Punctuator" && token.value === "," + ) + }, + + /** + * Iterate the calls of the `RegExp` global variable. + * @param {Scope} globalScope The global scope object. + * @returns {IterableIterator<{node:Node,pattern:(string|null),flags:(string|null)}>} The iterator of `CallExpression` or `NewExpression` for `RegExp`. + */ + *getRegExpCalls(globalScope) { + const tracker = new ReferenceTracker(globalScope) + for (const { node } of tracker.iterateGlobalReferences({ + RegExp: { [CALL]: true, [CONSTRUCT]: true }, + })) { + const [patternNode, flagsNode] = node.arguments + yield { + node, + pattern: getStringIfConstant(patternNode, globalScope), + flags: getStringIfConstant(flagsNode, globalScope), + } + } + }, + + printWarningOfDeprecatedConfig(configId) { + if (!process) { + return + } + const newConfigId = configId.replace("no-", "no-new-in-es") + process.emitWarning( + `"plugin:es-x/${configId}" has been deprecated in favor of "plugin:es-x/${newConfigId}".`, + { + type: "DeprecationWarning", + code: "ESLINT_PLUGIN_ES_LEGACY_CONFIG", + }, + ) + }, +}