diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ed9c632658f29e20c8cb54f02211f403491290ad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.d.mts @@ -0,0 +1,19 @@ +/** + * Flattens an array up to the specified depth. + * + * @template T - The type of elements within the array. + * @template D - The depth to which the array should be flattened. + * @param {T[]} arr - The array to flatten. + * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1. + * @returns {Array>} A new array that has been flattened. + * + * @example + * const arr = flatten([1, [2, 3], [4, [5, 6]]], 1); + * // Returns: [1, 2, 3, 4, [5, 6]] + * + * const arr = flatten([1, [2, 3], [4, [5, 6]]], 2); + * // Returns: [1, 2, 3, 4, 5, 6] + */ +declare function flatten(arr: readonly T[], depth?: D): Array>; + +export { flatten }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ed9c632658f29e20c8cb54f02211f403491290ad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.d.ts @@ -0,0 +1,19 @@ +/** + * Flattens an array up to the specified depth. + * + * @template T - The type of elements within the array. + * @template D - The depth to which the array should be flattened. + * @param {T[]} arr - The array to flatten. + * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1. + * @returns {Array>} A new array that has been flattened. + * + * @example + * const arr = flatten([1, [2, 3], [4, [5, 6]]], 1); + * // Returns: [1, 2, 3, 4, [5, 6]] + * + * const arr = flatten([1, [2, 3], [4, [5, 6]]], 2); + * // Returns: [1, 2, 3, 4, 5, 6] + */ +declare function flatten(arr: readonly T[], depth?: D): Array>; + +export { flatten }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.js new file mode 100644 index 0000000000000000000000000000000000000000..363f9b525036014070e744aa62969b8f8ca3d773 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function flatten(arr, depth = 1) { + const result = []; + const flooredDepth = Math.floor(depth); + const recursive = (arr, currentDepth) => { + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (Array.isArray(item) && currentDepth < flooredDepth) { + recursive(item, currentDepth + 1); + } + else { + result.push(item); + } + } + }; + recursive(arr, 0); + return result; +} + +exports.flatten = flatten; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9f9389190635e49f385b64f9c1a9aed1f57da461 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flatten.mjs @@ -0,0 +1,19 @@ +function flatten(arr, depth = 1) { + const result = []; + const flooredDepth = Math.floor(depth); + const recursive = (arr, currentDepth) => { + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (Array.isArray(item) && currentDepth < flooredDepth) { + recursive(item, currentDepth + 1); + } + else { + result.push(item); + } + } + }; + recursive(arr, 0); + return result; +} + +export { flatten }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b41a0e70856158f069688667b164b0337d2089ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.d.mts @@ -0,0 +1,25 @@ +/** + * Utility type for recursively unpacking nested array types to extract the type of the innermost element + * + * @example + * ExtractNestedArrayType<(number | (number | number[])[])[]> + * // number + * + * ExtractNestedArrayType<(boolean | (string | number[])[])[]> + * // string | number | boolean + */ +type ExtractNestedArrayType = T extends ReadonlyArray ? ExtractNestedArrayType : T; +/** + * Flattens all depths of a nested array. + * + * @template T - The type of elements within the array. + * @param {T[]} arr - The array to flatten. + * @returns {Array>} A new array that has been flattened. + * + * @example + * const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]); + * // Returns: [1, 2, 3, 4, 5, 6] + */ +declare function flattenDeep(arr: readonly T[]): Array>; + +export { type ExtractNestedArrayType, flattenDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b41a0e70856158f069688667b164b0337d2089ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.d.ts @@ -0,0 +1,25 @@ +/** + * Utility type for recursively unpacking nested array types to extract the type of the innermost element + * + * @example + * ExtractNestedArrayType<(number | (number | number[])[])[]> + * // number + * + * ExtractNestedArrayType<(boolean | (string | number[])[])[]> + * // string | number | boolean + */ +type ExtractNestedArrayType = T extends ReadonlyArray ? ExtractNestedArrayType : T; +/** + * Flattens all depths of a nested array. + * + * @template T - The type of elements within the array. + * @param {T[]} arr - The array to flatten. + * @returns {Array>} A new array that has been flattened. + * + * @example + * const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]); + * // Returns: [1, 2, 3, 4, 5, 6] + */ +declare function flattenDeep(arr: readonly T[]): Array>; + +export { type ExtractNestedArrayType, flattenDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.js new file mode 100644 index 0000000000000000000000000000000000000000..4067e75738dcc3a7b2a8e5ecb59c4ff16ded6559 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('./flatten.js'); + +function flattenDeep(arr) { + return flatten.flatten(arr, Infinity); +} + +exports.flattenDeep = flattenDeep; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fc98092b5408a346f46fac3d5e9e9e9dc2954cd2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/flattenDeep.mjs @@ -0,0 +1,7 @@ +import { flatten } from './flatten.mjs'; + +function flattenDeep(arr) { + return flatten(arr, Infinity); +} + +export { flattenDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f3ccbf74084db0c5df6bde880b04cd51a673cb41 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.d.mts @@ -0,0 +1,48 @@ +/** + * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to iterate over. + * @param {(value: T, index: number, arr: T[]) => void} callback - The function invoked per iteration. + * The callback function receives three arguments: + * - 'value': The current element being processed in the array. + * - 'index': The index of the current element being processed in the array. + * - 'arr': The array 'forEachRight' was called upon. + * + * @example + * const array = [1, 2, 3]; + * const result: number[] = []; + * + * // Use the forEachRight function to iterate through the array and add each element to the result array. + * forEachRight(array, (value) => { + * result.push(value); + * }) + * + * console.log(result) // Output: [3, 2, 1] + */ +declare function forEachRight(arr: T[], callback: (value: T, index: number, arr: T[]) => void): void; +/** + * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to iterate over. + * @param {(value: T, index: number, arr: T[]) => void} callback - The function invoked per iteration. + * The callback function receives three arguments: + * - 'value': The current element being processed in the array. + * - 'index': The index of the current element being processed in the array. + * - 'arr': The array 'forEachRight' was called upon. + * + * @example + * const array = [1, 2, 3]; + * const result: number[] = []; + * + * // Use the forEachRight function to iterate through the array and add each element to the result array. + * forEachRight(array, (value) => { + * result.push(value); + * }) + * + * console.log(result) // Output: [3, 2, 1] + */ +declare function forEachRight(arr: readonly T[], callback: (value: T, index: number, arr: readonly T[]) => void): void; + +export { forEachRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f3ccbf74084db0c5df6bde880b04cd51a673cb41 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.d.ts @@ -0,0 +1,48 @@ +/** + * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to iterate over. + * @param {(value: T, index: number, arr: T[]) => void} callback - The function invoked per iteration. + * The callback function receives three arguments: + * - 'value': The current element being processed in the array. + * - 'index': The index of the current element being processed in the array. + * - 'arr': The array 'forEachRight' was called upon. + * + * @example + * const array = [1, 2, 3]; + * const result: number[] = []; + * + * // Use the forEachRight function to iterate through the array and add each element to the result array. + * forEachRight(array, (value) => { + * result.push(value); + * }) + * + * console.log(result) // Output: [3, 2, 1] + */ +declare function forEachRight(arr: T[], callback: (value: T, index: number, arr: T[]) => void): void; +/** + * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to iterate over. + * @param {(value: T, index: number, arr: T[]) => void} callback - The function invoked per iteration. + * The callback function receives three arguments: + * - 'value': The current element being processed in the array. + * - 'index': The index of the current element being processed in the array. + * - 'arr': The array 'forEachRight' was called upon. + * + * @example + * const array = [1, 2, 3]; + * const result: number[] = []; + * + * // Use the forEachRight function to iterate through the array and add each element to the result array. + * forEachRight(array, (value) => { + * result.push(value); + * }) + * + * console.log(result) // Output: [3, 2, 1] + */ +declare function forEachRight(arr: readonly T[], callback: (value: T, index: number, arr: readonly T[]) => void): void; + +export { forEachRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.js new file mode 100644 index 0000000000000000000000000000000000000000..2e3386fc29fc1bf7ecc6343bb97af27b355b6475 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function forEachRight(arr, callback) { + for (let i = arr.length - 1; i >= 0; i--) { + const element = arr[i]; + callback(element, i, arr); + } +} + +exports.forEachRight = forEachRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f5d71768ae67d63c693f0f5cc565d1becb56253f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/forEachRight.mjs @@ -0,0 +1,8 @@ +function forEachRight(arr, callback) { + for (let i = arr.length - 1; i >= 0; i--) { + const element = arr[i]; + callback(element, i, arr); + } +} + +export { forEachRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6b878d159a0217da0855aae9b2e6d9a9d254e6aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.d.mts @@ -0,0 +1,35 @@ +/** + * Groups the elements of an array based on a provided key-generating function. + * + * This function takes an array and a function that generates a key from each element. It returns + * an object where the keys are the generated keys and the values are arrays of elements that share + * the same key. + * + * @template T - The type of elements in the array. + * @template K - The type of keys. + * @param {T[]} arr - The array to group. + * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element. + * @returns {Record} An object where each key is associated with an array of elements that + * share that key. + * + * @example + * const array = [ + * { category: 'fruit', name: 'apple' }, + * { category: 'fruit', name: 'banana' }, + * { category: 'vegetable', name: 'carrot' } + * ]; + * const result = groupBy(array, item => item.category); + * // result will be: + * // { + * // fruit: [ + * // { category: 'fruit', name: 'apple' }, + * // { category: 'fruit', name: 'banana' } + * // ], + * // vegetable: [ + * // { category: 'vegetable', name: 'carrot' } + * // ] + * // } + */ +declare function groupBy(arr: readonly T[], getKeyFromItem: (item: T) => K): Record; + +export { groupBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b878d159a0217da0855aae9b2e6d9a9d254e6aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.d.ts @@ -0,0 +1,35 @@ +/** + * Groups the elements of an array based on a provided key-generating function. + * + * This function takes an array and a function that generates a key from each element. It returns + * an object where the keys are the generated keys and the values are arrays of elements that share + * the same key. + * + * @template T - The type of elements in the array. + * @template K - The type of keys. + * @param {T[]} arr - The array to group. + * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element. + * @returns {Record} An object where each key is associated with an array of elements that + * share that key. + * + * @example + * const array = [ + * { category: 'fruit', name: 'apple' }, + * { category: 'fruit', name: 'banana' }, + * { category: 'vegetable', name: 'carrot' } + * ]; + * const result = groupBy(array, item => item.category); + * // result will be: + * // { + * // fruit: [ + * // { category: 'fruit', name: 'apple' }, + * // { category: 'fruit', name: 'banana' } + * // ], + * // vegetable: [ + * // { category: 'vegetable', name: 'carrot' } + * // ] + * // } + */ +declare function groupBy(arr: readonly T[], getKeyFromItem: (item: T) => K): Record; + +export { groupBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.js new file mode 100644 index 0000000000000000000000000000000000000000..7a3fd79cd2c333d82f8684e5397b947c5775a1b8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function groupBy(arr, getKeyFromItem) { + const result = {}; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + const key = getKeyFromItem(item); + if (!Object.hasOwn(result, key)) { + result[key] = []; + } + result[key].push(item); + } + return result; +} + +exports.groupBy = groupBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6f20e2383e41ba8fa367f0cf736baa2b36305c4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/groupBy.mjs @@ -0,0 +1,14 @@ +function groupBy(arr, getKeyFromItem) { + const result = {}; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + const key = getKeyFromItem(item); + if (!Object.hasOwn(result, key)) { + result[key] = []; + } + result[key].push(item); + } + return result; +} + +export { groupBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8479a8142bf5eb4c8294a8a1b292e05757ef0fc8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.d.mts @@ -0,0 +1,34 @@ +/** + * Returns the first element of an array. + * + * This function takes an array and returns the first element of the array. + * If the array is empty, the function returns `undefined`. + * + * @template T - The type of elements in the array. + * @param {[T, ...T[]]} arr - A non-empty array from which to get the first element. + * @returns {T} The first element of the array. + * + * @example + * const arr = [1, 2, 3]; + * const firstElement = head(arr); + * // firstElement will be 1 + */ +declare function head(arr: readonly [T, ...T[]]): T; +/** + * Returns the first element of an array or `undefined` if the array is empty. + * + * This function takes an array and returns the first element of the array. + * If the array is empty, the function returns `undefined`. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array from which to get the first element. + * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty. + * + * @example + * const emptyArr: number[] = []; + * const noElement = head(emptyArr); + * // noElement will be undefined + */ +declare function head(arr: readonly T[]): T | undefined; + +export { head }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8479a8142bf5eb4c8294a8a1b292e05757ef0fc8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.d.ts @@ -0,0 +1,34 @@ +/** + * Returns the first element of an array. + * + * This function takes an array and returns the first element of the array. + * If the array is empty, the function returns `undefined`. + * + * @template T - The type of elements in the array. + * @param {[T, ...T[]]} arr - A non-empty array from which to get the first element. + * @returns {T} The first element of the array. + * + * @example + * const arr = [1, 2, 3]; + * const firstElement = head(arr); + * // firstElement will be 1 + */ +declare function head(arr: readonly [T, ...T[]]): T; +/** + * Returns the first element of an array or `undefined` if the array is empty. + * + * This function takes an array and returns the first element of the array. + * If the array is empty, the function returns `undefined`. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array from which to get the first element. + * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty. + * + * @example + * const emptyArr: number[] = []; + * const noElement = head(emptyArr); + * // noElement will be undefined + */ +declare function head(arr: readonly T[]): T | undefined; + +export { head }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.js new file mode 100644 index 0000000000000000000000000000000000000000..4b0cfa25afac41a628dc435fdc1f98540b30e649 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function head(arr) { + return arr[0]; +} + +exports.head = head; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d99ca36435704b896b005f5d4e077e4e5f4aa235 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/head.mjs @@ -0,0 +1,5 @@ +function head(arr) { + return arr[0]; +} + +export { head }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f56ab128cfdb2553a953060d4e70526f7405e7eb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.d.mts @@ -0,0 +1,60 @@ +export { at } from './at.mjs'; +export { chunk } from './chunk.mjs'; +export { compact } from './compact.mjs'; +export { countBy } from './countBy.mjs'; +export { difference } from './difference.mjs'; +export { differenceBy } from './differenceBy.mjs'; +export { differenceWith } from './differenceWith.mjs'; +export { drop } from './drop.mjs'; +export { dropRight } from './dropRight.mjs'; +export { dropRightWhile } from './dropRightWhile.mjs'; +export { dropWhile } from './dropWhile.mjs'; +export { fill } from './fill.mjs'; +export { flatMap } from './flatMap.mjs'; +export { flatMapDeep } from './flatMapDeep.mjs'; +export { flatten } from './flatten.mjs'; +export { flattenDeep } from './flattenDeep.mjs'; +export { forEachRight } from './forEachRight.mjs'; +export { groupBy } from './groupBy.mjs'; +export { head } from './head.mjs'; +export { initial } from './initial.mjs'; +export { intersection } from './intersection.mjs'; +export { intersectionBy } from './intersectionBy.mjs'; +export { intersectionWith } from './intersectionWith.mjs'; +export { isSubset } from './isSubset.mjs'; +export { isSubsetWith } from './isSubsetWith.mjs'; +export { keyBy } from './keyBy.mjs'; +export { last } from './last.mjs'; +export { maxBy } from './maxBy.mjs'; +export { minBy } from './minBy.mjs'; +export { orderBy } from './orderBy.mjs'; +export { partition } from './partition.mjs'; +export { pull } from './pull.mjs'; +export { pullAt } from './pullAt.mjs'; +export { remove } from './remove.mjs'; +export { sample } from './sample.mjs'; +export { sampleSize } from './sampleSize.mjs'; +export { shuffle } from './shuffle.mjs'; +export { sortBy } from './sortBy.mjs'; +export { tail } from './tail.mjs'; +export { take } from './take.mjs'; +export { takeRight } from './takeRight.mjs'; +export { takeRightWhile } from './takeRightWhile.mjs'; +export { takeWhile } from './takeWhile.mjs'; +export { toFilled } from './toFilled.mjs'; +export { union } from './union.mjs'; +export { unionBy } from './unionBy.mjs'; +export { unionWith } from './unionWith.mjs'; +export { uniq } from './uniq.mjs'; +export { uniqBy } from './uniqBy.mjs'; +export { uniqWith } from './uniqWith.mjs'; +export { unzip } from './unzip.mjs'; +export { unzipWith } from './unzipWith.mjs'; +export { windowed } from './windowed.mjs'; +export { without } from './without.mjs'; +export { xor } from './xor.mjs'; +export { xorBy } from './xorBy.mjs'; +export { xorWith } from './xorWith.mjs'; +export { zip } from './zip.mjs'; +export { zipObject } from './zipObject.mjs'; +export { zipWith } from './zipWith.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2ca9cf581dbe820db1311a80d39102b5231bf948 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.d.ts @@ -0,0 +1,60 @@ +export { at } from './at.js'; +export { chunk } from './chunk.js'; +export { compact } from './compact.js'; +export { countBy } from './countBy.js'; +export { difference } from './difference.js'; +export { differenceBy } from './differenceBy.js'; +export { differenceWith } from './differenceWith.js'; +export { drop } from './drop.js'; +export { dropRight } from './dropRight.js'; +export { dropRightWhile } from './dropRightWhile.js'; +export { dropWhile } from './dropWhile.js'; +export { fill } from './fill.js'; +export { flatMap } from './flatMap.js'; +export { flatMapDeep } from './flatMapDeep.js'; +export { flatten } from './flatten.js'; +export { flattenDeep } from './flattenDeep.js'; +export { forEachRight } from './forEachRight.js'; +export { groupBy } from './groupBy.js'; +export { head } from './head.js'; +export { initial } from './initial.js'; +export { intersection } from './intersection.js'; +export { intersectionBy } from './intersectionBy.js'; +export { intersectionWith } from './intersectionWith.js'; +export { isSubset } from './isSubset.js'; +export { isSubsetWith } from './isSubsetWith.js'; +export { keyBy } from './keyBy.js'; +export { last } from './last.js'; +export { maxBy } from './maxBy.js'; +export { minBy } from './minBy.js'; +export { orderBy } from './orderBy.js'; +export { partition } from './partition.js'; +export { pull } from './pull.js'; +export { pullAt } from './pullAt.js'; +export { remove } from './remove.js'; +export { sample } from './sample.js'; +export { sampleSize } from './sampleSize.js'; +export { shuffle } from './shuffle.js'; +export { sortBy } from './sortBy.js'; +export { tail } from './tail.js'; +export { take } from './take.js'; +export { takeRight } from './takeRight.js'; +export { takeRightWhile } from './takeRightWhile.js'; +export { takeWhile } from './takeWhile.js'; +export { toFilled } from './toFilled.js'; +export { union } from './union.js'; +export { unionBy } from './unionBy.js'; +export { unionWith } from './unionWith.js'; +export { uniq } from './uniq.js'; +export { uniqBy } from './uniqBy.js'; +export { uniqWith } from './uniqWith.js'; +export { unzip } from './unzip.js'; +export { unzipWith } from './unzipWith.js'; +export { windowed } from './windowed.js'; +export { without } from './without.js'; +export { xor } from './xor.js'; +export { xorBy } from './xorBy.js'; +export { xorWith } from './xorWith.js'; +export { zip } from './zip.js'; +export { zipObject } from './zipObject.js'; +export { zipWith } from './zipWith.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e32a0b83d3bed235a97f8975735e6a1d90e6b572 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.js @@ -0,0 +1,127 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const at = require('./at.js'); +const chunk = require('./chunk.js'); +const compact = require('./compact.js'); +const countBy = require('./countBy.js'); +const difference = require('./difference.js'); +const differenceBy = require('./differenceBy.js'); +const differenceWith = require('./differenceWith.js'); +const drop = require('./drop.js'); +const dropRight = require('./dropRight.js'); +const dropRightWhile = require('./dropRightWhile.js'); +const dropWhile = require('./dropWhile.js'); +const fill = require('./fill.js'); +const flatMap = require('./flatMap.js'); +const flatMapDeep = require('./flatMapDeep.js'); +const flatten = require('./flatten.js'); +const flattenDeep = require('./flattenDeep.js'); +const forEachRight = require('./forEachRight.js'); +const groupBy = require('./groupBy.js'); +const head = require('./head.js'); +const initial = require('./initial.js'); +const intersection = require('./intersection.js'); +const intersectionBy = require('./intersectionBy.js'); +const intersectionWith = require('./intersectionWith.js'); +const isSubset = require('./isSubset.js'); +const isSubsetWith = require('./isSubsetWith.js'); +const keyBy = require('./keyBy.js'); +const last = require('./last.js'); +const maxBy = require('./maxBy.js'); +const minBy = require('./minBy.js'); +const orderBy = require('./orderBy.js'); +const partition = require('./partition.js'); +const pull = require('./pull.js'); +const pullAt = require('./pullAt.js'); +const remove = require('./remove.js'); +const sample = require('./sample.js'); +const sampleSize = require('./sampleSize.js'); +const shuffle = require('./shuffle.js'); +const sortBy = require('./sortBy.js'); +const tail = require('./tail.js'); +const take = require('./take.js'); +const takeRight = require('./takeRight.js'); +const takeRightWhile = require('./takeRightWhile.js'); +const takeWhile = require('./takeWhile.js'); +const toFilled = require('./toFilled.js'); +const union = require('./union.js'); +const unionBy = require('./unionBy.js'); +const unionWith = require('./unionWith.js'); +const uniq = require('./uniq.js'); +const uniqBy = require('./uniqBy.js'); +const uniqWith = require('./uniqWith.js'); +const unzip = require('./unzip.js'); +const unzipWith = require('./unzipWith.js'); +const windowed = require('./windowed.js'); +const without = require('./without.js'); +const xor = require('./xor.js'); +const xorBy = require('./xorBy.js'); +const xorWith = require('./xorWith.js'); +const zip = require('./zip.js'); +const zipObject = require('./zipObject.js'); +const zipWith = require('./zipWith.js'); + + + +exports.at = at.at; +exports.chunk = chunk.chunk; +exports.compact = compact.compact; +exports.countBy = countBy.countBy; +exports.difference = difference.difference; +exports.differenceBy = differenceBy.differenceBy; +exports.differenceWith = differenceWith.differenceWith; +exports.drop = drop.drop; +exports.dropRight = dropRight.dropRight; +exports.dropRightWhile = dropRightWhile.dropRightWhile; +exports.dropWhile = dropWhile.dropWhile; +exports.fill = fill.fill; +exports.flatMap = flatMap.flatMap; +exports.flatMapDeep = flatMapDeep.flatMapDeep; +exports.flatten = flatten.flatten; +exports.flattenDeep = flattenDeep.flattenDeep; +exports.forEachRight = forEachRight.forEachRight; +exports.groupBy = groupBy.groupBy; +exports.head = head.head; +exports.initial = initial.initial; +exports.intersection = intersection.intersection; +exports.intersectionBy = intersectionBy.intersectionBy; +exports.intersectionWith = intersectionWith.intersectionWith; +exports.isSubset = isSubset.isSubset; +exports.isSubsetWith = isSubsetWith.isSubsetWith; +exports.keyBy = keyBy.keyBy; +exports.last = last.last; +exports.maxBy = maxBy.maxBy; +exports.minBy = minBy.minBy; +exports.orderBy = orderBy.orderBy; +exports.partition = partition.partition; +exports.pull = pull.pull; +exports.pullAt = pullAt.pullAt; +exports.remove = remove.remove; +exports.sample = sample.sample; +exports.sampleSize = sampleSize.sampleSize; +exports.shuffle = shuffle.shuffle; +exports.sortBy = sortBy.sortBy; +exports.tail = tail.tail; +exports.take = take.take; +exports.takeRight = takeRight.takeRight; +exports.takeRightWhile = takeRightWhile.takeRightWhile; +exports.takeWhile = takeWhile.takeWhile; +exports.toFilled = toFilled.toFilled; +exports.union = union.union; +exports.unionBy = unionBy.unionBy; +exports.unionWith = unionWith.unionWith; +exports.uniq = uniq.uniq; +exports.uniqBy = uniqBy.uniqBy; +exports.uniqWith = uniqWith.uniqWith; +exports.unzip = unzip.unzip; +exports.unzipWith = unzipWith.unzipWith; +exports.windowed = windowed.windowed; +exports.without = without.without; +exports.xor = xor.xor; +exports.xorBy = xorBy.xorBy; +exports.xorWith = xorWith.xorWith; +exports.zip = zip.zip; +exports.zipObject = zipObject.zipObject; +exports.zipWith = zipWith.zipWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f56ab128cfdb2553a953060d4e70526f7405e7eb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/index.mjs @@ -0,0 +1,60 @@ +export { at } from './at.mjs'; +export { chunk } from './chunk.mjs'; +export { compact } from './compact.mjs'; +export { countBy } from './countBy.mjs'; +export { difference } from './difference.mjs'; +export { differenceBy } from './differenceBy.mjs'; +export { differenceWith } from './differenceWith.mjs'; +export { drop } from './drop.mjs'; +export { dropRight } from './dropRight.mjs'; +export { dropRightWhile } from './dropRightWhile.mjs'; +export { dropWhile } from './dropWhile.mjs'; +export { fill } from './fill.mjs'; +export { flatMap } from './flatMap.mjs'; +export { flatMapDeep } from './flatMapDeep.mjs'; +export { flatten } from './flatten.mjs'; +export { flattenDeep } from './flattenDeep.mjs'; +export { forEachRight } from './forEachRight.mjs'; +export { groupBy } from './groupBy.mjs'; +export { head } from './head.mjs'; +export { initial } from './initial.mjs'; +export { intersection } from './intersection.mjs'; +export { intersectionBy } from './intersectionBy.mjs'; +export { intersectionWith } from './intersectionWith.mjs'; +export { isSubset } from './isSubset.mjs'; +export { isSubsetWith } from './isSubsetWith.mjs'; +export { keyBy } from './keyBy.mjs'; +export { last } from './last.mjs'; +export { maxBy } from './maxBy.mjs'; +export { minBy } from './minBy.mjs'; +export { orderBy } from './orderBy.mjs'; +export { partition } from './partition.mjs'; +export { pull } from './pull.mjs'; +export { pullAt } from './pullAt.mjs'; +export { remove } from './remove.mjs'; +export { sample } from './sample.mjs'; +export { sampleSize } from './sampleSize.mjs'; +export { shuffle } from './shuffle.mjs'; +export { sortBy } from './sortBy.mjs'; +export { tail } from './tail.mjs'; +export { take } from './take.mjs'; +export { takeRight } from './takeRight.mjs'; +export { takeRightWhile } from './takeRightWhile.mjs'; +export { takeWhile } from './takeWhile.mjs'; +export { toFilled } from './toFilled.mjs'; +export { union } from './union.mjs'; +export { unionBy } from './unionBy.mjs'; +export { unionWith } from './unionWith.mjs'; +export { uniq } from './uniq.mjs'; +export { uniqBy } from './uniqBy.mjs'; +export { uniqWith } from './uniqWith.mjs'; +export { unzip } from './unzip.mjs'; +export { unzipWith } from './unzipWith.mjs'; +export { windowed } from './windowed.mjs'; +export { without } from './without.mjs'; +export { xor } from './xor.mjs'; +export { xorBy } from './xorBy.mjs'; +export { xorWith } from './xorWith.mjs'; +export { zip } from './zip.mjs'; +export { zipObject } from './zipObject.mjs'; +export { zipWith } from './zipWith.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b29c9e706876bee35901a8169aaa3322fbabb51c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.d.mts @@ -0,0 +1,54 @@ +/** + * Returns an empty array when the input is a tuple containing exactly one element. + * + * @template T The type of the single element. + * @param {[T]} arr - A tuple containing exactly one element. + * @returns {[]} An empty array since there is only one element. + * + * @example + * const array = [100] as const; + * const result = initial(array); + * // result will be [] + */ +declare function initial(arr: readonly [T]): []; +/** + * Returns an empty array when the input array is empty. + * + * @returns {[]} Always returns an empty array for an empty input. + * + * @example + * const array = [] as const; + * const result = initial(array); + * // result will be [] + */ +declare function initial(arr: readonly []): []; +/** + * Returns a new array containing all elements except the last one from a tuple with multiple elements. + * + * @template T The types of the initial elements. + * @template U The type of the last element in the tuple. + * @param {[...T[], U]} arr - A tuple with one or more elements. + * @returns {T[]} A new array containing all but the last element of the tuple. + * + * @example + * const array = ['apple', 'banana', 'cherry'] as const; + * const result = initial(array); + * // result will be ['apple', 'banana'] + */ +declare function initial(arr: readonly [...T[], U]): T[]; +/** + * Returns a new array containing all elements except the last one from the input array. + * If the input array is empty or has only one element, the function returns an empty array. + * + * @template T The type of elements in the array. + * @param {T[]} arr - The input array. + * @returns {T[]} A new array containing all but the last element of the input array. + * + * @example + * const arr = [1, 2, 3, 4]; + * const result = initial(arr); + * // result will be [1, 2, 3] + */ +declare function initial(arr: readonly T[]): T[]; + +export { initial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b29c9e706876bee35901a8169aaa3322fbabb51c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.d.ts @@ -0,0 +1,54 @@ +/** + * Returns an empty array when the input is a tuple containing exactly one element. + * + * @template T The type of the single element. + * @param {[T]} arr - A tuple containing exactly one element. + * @returns {[]} An empty array since there is only one element. + * + * @example + * const array = [100] as const; + * const result = initial(array); + * // result will be [] + */ +declare function initial(arr: readonly [T]): []; +/** + * Returns an empty array when the input array is empty. + * + * @returns {[]} Always returns an empty array for an empty input. + * + * @example + * const array = [] as const; + * const result = initial(array); + * // result will be [] + */ +declare function initial(arr: readonly []): []; +/** + * Returns a new array containing all elements except the last one from a tuple with multiple elements. + * + * @template T The types of the initial elements. + * @template U The type of the last element in the tuple. + * @param {[...T[], U]} arr - A tuple with one or more elements. + * @returns {T[]} A new array containing all but the last element of the tuple. + * + * @example + * const array = ['apple', 'banana', 'cherry'] as const; + * const result = initial(array); + * // result will be ['apple', 'banana'] + */ +declare function initial(arr: readonly [...T[], U]): T[]; +/** + * Returns a new array containing all elements except the last one from the input array. + * If the input array is empty or has only one element, the function returns an empty array. + * + * @template T The type of elements in the array. + * @param {T[]} arr - The input array. + * @returns {T[]} A new array containing all but the last element of the input array. + * + * @example + * const arr = [1, 2, 3, 4]; + * const result = initial(arr); + * // result will be [1, 2, 3] + */ +declare function initial(arr: readonly T[]): T[]; + +export { initial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.js new file mode 100644 index 0000000000000000000000000000000000000000..73a8fe0dd9aa47437ceefe59cea2838e1fcdf5cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function initial(arr) { + return arr.slice(0, -1); +} + +exports.initial = initial; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a5cd45fd5878d1319344277bda576a8f266f2a73 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/initial.mjs @@ -0,0 +1,5 @@ +function initial(arr) { + return arr.slice(0, -1); +} + +export { initial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2164a6b05bba486d45b9515a643a64d7137ca9ff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.d.mts @@ -0,0 +1,21 @@ +/** + * Returns the intersection of two arrays. + * + * This function takes two arrays and returns a new array containing the elements that are + * present in both arrays. It effectively filters out any elements from the first array that + * are not found in the second array. + * + * @template T - The type of elements in the array. + * @param {T[]} firstArr - The first array to compare. + * @param {T[]} secondArr - The second array to compare. + * @returns {T[]} A new array containing the elements that are present in both arrays. + * + * @example + * const array1 = [1, 2, 3, 4, 5]; + * const array2 = [3, 4, 5, 6, 7]; + * const result = intersection(array1, array2); + * // result will be [3, 4, 5] since these elements are in both arrays. + */ +declare function intersection(firstArr: readonly T[], secondArr: readonly T[]): T[]; + +export { intersection }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2164a6b05bba486d45b9515a643a64d7137ca9ff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.d.ts @@ -0,0 +1,21 @@ +/** + * Returns the intersection of two arrays. + * + * This function takes two arrays and returns a new array containing the elements that are + * present in both arrays. It effectively filters out any elements from the first array that + * are not found in the second array. + * + * @template T - The type of elements in the array. + * @param {T[]} firstArr - The first array to compare. + * @param {T[]} secondArr - The second array to compare. + * @returns {T[]} A new array containing the elements that are present in both arrays. + * + * @example + * const array1 = [1, 2, 3, 4, 5]; + * const array2 = [3, 4, 5, 6, 7]; + * const result = intersection(array1, array2); + * // result will be [3, 4, 5] since these elements are in both arrays. + */ +declare function intersection(firstArr: readonly T[], secondArr: readonly T[]): T[]; + +export { intersection }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.js new file mode 100644 index 0000000000000000000000000000000000000000..7b5a39ec7a27e1d1d560d91a68971317e2e69295 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function intersection(firstArr, secondArr) { + const secondSet = new Set(secondArr); + return firstArr.filter(item => { + return secondSet.has(item); + }); +} + +exports.intersection = intersection; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0ce21b6d23016165569918c24695fd6088a6aa5f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersection.mjs @@ -0,0 +1,8 @@ +function intersection(firstArr, secondArr) { + const secondSet = new Set(secondArr); + return firstArr.filter(item => { + return secondSet.has(item); + }); +} + +export { intersection }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0ddb0ee508edfce4214fbe583fe9bd2196ac0b29 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.d.mts @@ -0,0 +1,36 @@ +/** + * Returns the intersection of two arrays based on a mapping function. + * + * This function takes two arrays and a mapping function. It returns a new array containing + * the elements from the first array that, when mapped using the provided function, have matching + * mapped elements in the second array. It effectively filters out any elements from the first array + * that do not have corresponding mapped values in the second array. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @param {T[]} firstArr - The first array to compare. + * @param {U[]} secondArr - The second array to compare. + * @param {(item: T | U) => unknown} mapper - A function to map the elements of both arrays for comparison. + * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array. + * + * @example + * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const array2 = [{ id: 2 }, { id: 4 }]; + * const mapper = item => item.id; + * const result = intersectionBy(array1, array2, mapper); + * // result will be [{ id: 2 }] since only this element has a matching id in both arrays. + * + * @example + * const array1 = [ + * { id: 1, name: 'jane' }, + * { id: 2, name: 'amy' }, + * { id: 3, name: 'michael' }, + * ]; + * const array2 = [2, 4]; + * const mapper = item => (typeof item === 'object' ? item.id : item); + * const result = intersectionBy(array1, array2, mapper); + * // result will be [{ id: 2, name: 'amy' }] since only this element has a matching id that is equal to seconds array's element. + */ +declare function intersectionBy(firstArr: readonly T[], secondArr: readonly U[], mapper: (item: T | U) => unknown): T[]; + +export { intersectionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0ddb0ee508edfce4214fbe583fe9bd2196ac0b29 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.d.ts @@ -0,0 +1,36 @@ +/** + * Returns the intersection of two arrays based on a mapping function. + * + * This function takes two arrays and a mapping function. It returns a new array containing + * the elements from the first array that, when mapped using the provided function, have matching + * mapped elements in the second array. It effectively filters out any elements from the first array + * that do not have corresponding mapped values in the second array. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @param {T[]} firstArr - The first array to compare. + * @param {U[]} secondArr - The second array to compare. + * @param {(item: T | U) => unknown} mapper - A function to map the elements of both arrays for comparison. + * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array. + * + * @example + * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const array2 = [{ id: 2 }, { id: 4 }]; + * const mapper = item => item.id; + * const result = intersectionBy(array1, array2, mapper); + * // result will be [{ id: 2 }] since only this element has a matching id in both arrays. + * + * @example + * const array1 = [ + * { id: 1, name: 'jane' }, + * { id: 2, name: 'amy' }, + * { id: 3, name: 'michael' }, + * ]; + * const array2 = [2, 4]; + * const mapper = item => (typeof item === 'object' ? item.id : item); + * const result = intersectionBy(array1, array2, mapper); + * // result will be [{ id: 2, name: 'amy' }] since only this element has a matching id that is equal to seconds array's element. + */ +declare function intersectionBy(firstArr: readonly T[], secondArr: readonly U[], mapper: (item: T | U) => unknown): T[]; + +export { intersectionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.js new file mode 100644 index 0000000000000000000000000000000000000000..a9adb3fe342cda1195fcb003ee8dc76231dc1b7e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.js @@ -0,0 +1,10 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function intersectionBy(firstArr, secondArr, mapper) { + const mappedSecondSet = new Set(secondArr.map(mapper)); + return firstArr.filter(item => mappedSecondSet.has(mapper(item))); +} + +exports.intersectionBy = intersectionBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e9f647eab96231cc8ef1df32d23302a0a8c89bd1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionBy.mjs @@ -0,0 +1,6 @@ +function intersectionBy(firstArr, secondArr, mapper) { + const mappedSecondSet = new Set(secondArr.map(mapper)); + return firstArr.filter(item => mappedSecondSet.has(mapper(item))); +} + +export { intersectionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e5c6f5ca77a2d82a15b299b77f123ee2ac16e286 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.d.mts @@ -0,0 +1,37 @@ +/** + * Returns the intersection of two arrays based on a custom equality function. + * + * This function takes two arrays and a custom equality function. It returns a new array containing + * the elements from the first array that have matching elements in the second array, as determined + * by the custom equality function. It effectively filters out any elements from the first array that + * do not have corresponding matches in the second array according to the equality function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @param {T[]} firstArr - The first array to compare. + * @param {U[]} secondArr - The second array to compare. + * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal. + * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise. + * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function. + * + * @example + * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const array2 = [{ id: 2 }, { id: 4 }]; + * const areItemsEqual = (a, b) => a.id === b.id; + * const result = intersectionWith(array1, array2, areItemsEqual); + * // result will be [{ id: 2 }] since this element has a matching id in both arrays. + * + * @example + * const array1 = [ + * { id: 1, name: 'jane' }, + * { id: 2, name: 'amy' }, + * { id: 3, name: 'michael' }, + * ]; + * const array2 = [2, 4]; + * const areItemsEqual = (a, b) => a.id === b; + * const result = intersectionWith(array1, array2, areItemsEqual); + * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element. + */ +declare function intersectionWith(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[]; + +export { intersectionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e5c6f5ca77a2d82a15b299b77f123ee2ac16e286 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.d.ts @@ -0,0 +1,37 @@ +/** + * Returns the intersection of two arrays based on a custom equality function. + * + * This function takes two arrays and a custom equality function. It returns a new array containing + * the elements from the first array that have matching elements in the second array, as determined + * by the custom equality function. It effectively filters out any elements from the first array that + * do not have corresponding matches in the second array according to the equality function. + * + * @template T - The type of elements in the first array. + * @template U - The type of elements in the second array. + * @param {T[]} firstArr - The first array to compare. + * @param {U[]} secondArr - The second array to compare. + * @param {(x: T, y: U) => boolean} areItemsEqual - A custom function to determine if two elements are equal. + * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise. + * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function. + * + * @example + * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const array2 = [{ id: 2 }, { id: 4 }]; + * const areItemsEqual = (a, b) => a.id === b.id; + * const result = intersectionWith(array1, array2, areItemsEqual); + * // result will be [{ id: 2 }] since this element has a matching id in both arrays. + * + * @example + * const array1 = [ + * { id: 1, name: 'jane' }, + * { id: 2, name: 'amy' }, + * { id: 3, name: 'michael' }, + * ]; + * const array2 = [2, 4]; + * const areItemsEqual = (a, b) => a.id === b; + * const result = intersectionWith(array1, array2, areItemsEqual); + * // result will be [{ id: 2, name: 'amy' }] since this element has a matching id that is equal to seconds array's element. + */ +declare function intersectionWith(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[]; + +export { intersectionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.js new file mode 100644 index 0000000000000000000000000000000000000000..721c210788642b4bdd2f55c0f5f69d8b46d51dff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function intersectionWith(firstArr, secondArr, areItemsEqual) { + return firstArr.filter(firstItem => { + return secondArr.some(secondItem => { + return areItemsEqual(firstItem, secondItem); + }); + }); +} + +exports.intersectionWith = intersectionWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5c7a5c20bb49f84ba22601007f136fadb447f7a2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/intersectionWith.mjs @@ -0,0 +1,9 @@ +function intersectionWith(firstArr, secondArr, areItemsEqual) { + return firstArr.filter(firstItem => { + return secondArr.some(secondItem => { + return areItemsEqual(firstItem, secondItem); + }); + }); +} + +export { intersectionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0c52f72540cdf23e950dcc58d5c101e47d7b5ab5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.d.mts @@ -0,0 +1,26 @@ +/** + * Checks if the `subset` array is entirely contained within the `superset` array. + * + * + * @template T - The type of elements contained in the arrays. + * @param {T[]} superset - The array that may contain all elements of the subset. + * @param {T[]} subset - The array to check against the superset. + * @returns {boolean} - Returns `true` if all elements of the `subset` are present in the `superset`, otherwise returns `false`. + * + * @example + * ```typescript + * const superset = [1, 2, 3, 4, 5]; + * const subset = [2, 3, 4]; + * isSubset(superset, subset); // true + * ``` + * + * @example + * ```typescript + * const superset = ['a', 'b', 'c']; + * const subset = ['a', 'd']; + * isSubset(superset, subset); // false + * ``` + */ +declare function isSubset(superset: readonly T[], subset: readonly T[]): boolean; + +export { isSubset }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0c52f72540cdf23e950dcc58d5c101e47d7b5ab5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.d.ts @@ -0,0 +1,26 @@ +/** + * Checks if the `subset` array is entirely contained within the `superset` array. + * + * + * @template T - The type of elements contained in the arrays. + * @param {T[]} superset - The array that may contain all elements of the subset. + * @param {T[]} subset - The array to check against the superset. + * @returns {boolean} - Returns `true` if all elements of the `subset` are present in the `superset`, otherwise returns `false`. + * + * @example + * ```typescript + * const superset = [1, 2, 3, 4, 5]; + * const subset = [2, 3, 4]; + * isSubset(superset, subset); // true + * ``` + * + * @example + * ```typescript + * const superset = ['a', 'b', 'c']; + * const subset = ['a', 'd']; + * isSubset(superset, subset); // false + * ``` + */ +declare function isSubset(superset: readonly T[], subset: readonly T[]): boolean; + +export { isSubset }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.js new file mode 100644 index 0000000000000000000000000000000000000000..1cd0f23a6670ea03c7671cd83e3a1581d1b8f258 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const difference = require('./difference.js'); + +function isSubset(superset, subset) { + return difference.difference(subset, superset).length === 0; +} + +exports.isSubset = isSubset; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5b54581dec975ae958c59f559bc370c9c1f3b5be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubset.mjs @@ -0,0 +1,7 @@ +import { difference } from './difference.mjs'; + +function isSubset(superset, subset) { + return difference(subset, superset).length === 0; +} + +export { isSubset }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0a2fc20bd7db64bdfabff6c4d1dfa945bfae747b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.d.mts @@ -0,0 +1,33 @@ +/** + * Checks if the `subset` array is entirely contained within the `superset` array based on a custom equality function. + * + * This function takes two arrays and a custom comparison function. It returns a boolean indicating + * whether all elements in the subset array are present in the superset array, as determined by the provided + * custom equality function. + * + * @template T - The type of elements contained in the arrays. + * @param {T[]} superset - The array that may contain all elements of the subset. + * @param {T[]} subset - The array to check against the superset. + * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal. + * @returns {boolean} - Returns `true` if all elements of the subset are present in the superset + * according to the custom equality function, otherwise returns `false`. + * + * @example + * ```typescript + * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const subset = [{ id: 2 }, { id: 1 }]; + * const areItemsEqual = (a, b) => a.id === b.id; + * isSubsetWith(superset, subset, areItemsEqual); // true + * ``` + * + * @example + * ```typescript + * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const subset = [{ id: 4 }]; + * const areItemsEqual = (a, b) => a.id === b.id; + * isSubsetWith(superset, subset, areItemsEqual); // false + * ``` + */ +declare function isSubsetWith(superset: readonly T[], subset: readonly T[], areItemsEqual: (x: T, y: T) => boolean): boolean; + +export { isSubsetWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0a2fc20bd7db64bdfabff6c4d1dfa945bfae747b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.d.ts @@ -0,0 +1,33 @@ +/** + * Checks if the `subset` array is entirely contained within the `superset` array based on a custom equality function. + * + * This function takes two arrays and a custom comparison function. It returns a boolean indicating + * whether all elements in the subset array are present in the superset array, as determined by the provided + * custom equality function. + * + * @template T - The type of elements contained in the arrays. + * @param {T[]} superset - The array that may contain all elements of the subset. + * @param {T[]} subset - The array to check against the superset. + * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal. + * @returns {boolean} - Returns `true` if all elements of the subset are present in the superset + * according to the custom equality function, otherwise returns `false`. + * + * @example + * ```typescript + * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const subset = [{ id: 2 }, { id: 1 }]; + * const areItemsEqual = (a, b) => a.id === b.id; + * isSubsetWith(superset, subset, areItemsEqual); // true + * ``` + * + * @example + * ```typescript + * const superset = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const subset = [{ id: 4 }]; + * const areItemsEqual = (a, b) => a.id === b.id; + * isSubsetWith(superset, subset, areItemsEqual); // false + * ``` + */ +declare function isSubsetWith(superset: readonly T[], subset: readonly T[], areItemsEqual: (x: T, y: T) => boolean): boolean; + +export { isSubsetWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.js new file mode 100644 index 0000000000000000000000000000000000000000..82051ff691c264722070148baeaae7077eec39f5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const differenceWith = require('./differenceWith.js'); + +function isSubsetWith(superset, subset, areItemsEqual) { + return differenceWith.differenceWith(subset, superset, areItemsEqual).length === 0; +} + +exports.isSubsetWith = isSubsetWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3e39bcb4a9111ea41f626e44ffddc7048b7dfbec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/isSubsetWith.mjs @@ -0,0 +1,7 @@ +import { differenceWith } from './differenceWith.mjs'; + +function isSubsetWith(superset, subset, areItemsEqual) { + return differenceWith(subset, superset, areItemsEqual).length === 0; +} + +export { isSubsetWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7a90e89423a719b0385e1f883c0630e3b9452f0c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.d.mts @@ -0,0 +1,30 @@ +/** + * Maps each element of an array based on a provided key-generating function. + * + * This function takes an array and a function that generates a key from each element. It returns + * an object where the keys are the generated keys and the values are the corresponding elements. + * If there are multiple elements generating the same key, the last element among them is used + * as the value. + * + * @template T - The type of elements in the array. + * @template K - The type of keys. + * @param {T[]} arr - The array of elements to be mapped. + * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element. + * @returns {Record} An object where keys are mapped to each element of an array. + * + * @example + * const array = [ + * { category: 'fruit', name: 'apple' }, + * { category: 'fruit', name: 'banana' }, + * { category: 'vegetable', name: 'carrot' } + * ]; + * const result = keyBy(array, item => item.category); + * // result will be: + * // { + * // fruit: { category: 'fruit', name: 'banana' }, + * // vegetable: { category: 'vegetable', name: 'carrot' } + * // } + */ +declare function keyBy(arr: readonly T[], getKeyFromItem: (item: T) => K): Record; + +export { keyBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7a90e89423a719b0385e1f883c0630e3b9452f0c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.d.ts @@ -0,0 +1,30 @@ +/** + * Maps each element of an array based on a provided key-generating function. + * + * This function takes an array and a function that generates a key from each element. It returns + * an object where the keys are the generated keys and the values are the corresponding elements. + * If there are multiple elements generating the same key, the last element among them is used + * as the value. + * + * @template T - The type of elements in the array. + * @template K - The type of keys. + * @param {T[]} arr - The array of elements to be mapped. + * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element. + * @returns {Record} An object where keys are mapped to each element of an array. + * + * @example + * const array = [ + * { category: 'fruit', name: 'apple' }, + * { category: 'fruit', name: 'banana' }, + * { category: 'vegetable', name: 'carrot' } + * ]; + * const result = keyBy(array, item => item.category); + * // result will be: + * // { + * // fruit: { category: 'fruit', name: 'banana' }, + * // vegetable: { category: 'vegetable', name: 'carrot' } + * // } + */ +declare function keyBy(arr: readonly T[], getKeyFromItem: (item: T) => K): Record; + +export { keyBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.js new file mode 100644 index 0000000000000000000000000000000000000000..dcdfc37c74b6377cc07c8f0e947b421d87752563 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function keyBy(arr, getKeyFromItem) { + const result = {}; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + const key = getKeyFromItem(item); + result[key] = item; + } + return result; +} + +exports.keyBy = keyBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e39e5512b1f981ec37dbb244bf5f7ca43f676500 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/keyBy.mjs @@ -0,0 +1,11 @@ +function keyBy(arr, getKeyFromItem) { + const result = {}; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + const key = getKeyFromItem(item); + result[key] = item; + } + return result; +} + +export { keyBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5ae9e0aa64adeaa04fea7236f1587965255cb8ce --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.d.mts @@ -0,0 +1,48 @@ +/** + * Returns the last element of an array. + * + * This function takes an array and returns the last element of the array. + * If the array is empty, the function returns `undefined`. + * + * Unlike some implementations, this function is optimized for performance + * by directly accessing the last index of the array. + * + * @template T - The type of elements in the array. + * @param {[...T[], T]} arr - The array from which to get the last element. + * @returns {T} The last element of the array, or `undefined` if the array is empty. + * + * @example + * const arr = [1, 2, 3]; + * const lastElement = last(arr); + * // lastElement will be 3 + * + * const emptyArr: number[] = []; + * const noElement = last(emptyArr); + * // noElement will be undefined + */ +declare function last(arr: readonly [...T[], T]): T; +/** + * Returns the last element of an array. + * + * This function takes an array and returns the last element of the array. + * If the array is empty, the function returns `undefined`. + * + * Unlike some implementations, this function is optimized for performance + * by directly accessing the last index of the array. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array from which to get the last element. + * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty. + * + * @example + * const arr = [1, 2, 3]; + * const lastElement = last(arr); + * // lastElement will be 3 + * + * const emptyArr: number[] = []; + * const noElement = last(emptyArr); + * // noElement will be undefined + */ +declare function last(arr: readonly T[]): T | undefined; + +export { last }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5ae9e0aa64adeaa04fea7236f1587965255cb8ce --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.d.ts @@ -0,0 +1,48 @@ +/** + * Returns the last element of an array. + * + * This function takes an array and returns the last element of the array. + * If the array is empty, the function returns `undefined`. + * + * Unlike some implementations, this function is optimized for performance + * by directly accessing the last index of the array. + * + * @template T - The type of elements in the array. + * @param {[...T[], T]} arr - The array from which to get the last element. + * @returns {T} The last element of the array, or `undefined` if the array is empty. + * + * @example + * const arr = [1, 2, 3]; + * const lastElement = last(arr); + * // lastElement will be 3 + * + * const emptyArr: number[] = []; + * const noElement = last(emptyArr); + * // noElement will be undefined + */ +declare function last(arr: readonly [...T[], T]): T; +/** + * Returns the last element of an array. + * + * This function takes an array and returns the last element of the array. + * If the array is empty, the function returns `undefined`. + * + * Unlike some implementations, this function is optimized for performance + * by directly accessing the last index of the array. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array from which to get the last element. + * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty. + * + * @example + * const arr = [1, 2, 3]; + * const lastElement = last(arr); + * // lastElement will be 3 + * + * const emptyArr: number[] = []; + * const noElement = last(emptyArr); + * // noElement will be undefined + */ +declare function last(arr: readonly T[]): T | undefined; + +export { last }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.js new file mode 100644 index 0000000000000000000000000000000000000000..7567438cadfc38bb2df5856a5d6323e72efd1ce3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function last(arr) { + return arr[arr.length - 1]; +} + +exports.last = last; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.mjs new file mode 100644 index 0000000000000000000000000000000000000000..22cf184d211b35a43f693511825b038dd369d0d6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/last.mjs @@ -0,0 +1,5 @@ +function last(arr) { + return arr[arr.length - 1]; +} + +export { last }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1a6181ade3c394f4204c6a2398c3c619d76809ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.d.mts @@ -0,0 +1,45 @@ +/** + * Finds the element in an array that has the maximum value when applying + * the `getValue` function to each element. + * + * @template T - The type of elements in the array. + * @param {[T, ...T[]]} items The nonempty array of elements to search. + * @param {(element: T) => number} getValue A function that selects a numeric value from each element. + * @returns {T} The element with the maximum value as determined by the `getValue` function. + * @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 } + */ +declare function maxBy(items: readonly [T, ...T[]], getValue: (element: T) => number): T; +/** + * Finds the element in an array that has the maximum value when applying + * the `getValue` function 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} getValue A function that selects a numeric value from each element. + * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function, + * or `undefined` if the array is empty. + * @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 } + */ +declare function maxBy(items: readonly T[], getValue: (element: T) => number): T | undefined; + +export { maxBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1a6181ade3c394f4204c6a2398c3c619d76809ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.d.ts @@ -0,0 +1,45 @@ +/** + * Finds the element in an array that has the maximum value when applying + * the `getValue` function to each element. + * + * @template T - The type of elements in the array. + * @param {[T, ...T[]]} items The nonempty array of elements to search. + * @param {(element: T) => number} getValue A function that selects a numeric value from each element. + * @returns {T} The element with the maximum value as determined by the `getValue` function. + * @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 } + */ +declare function maxBy(items: readonly [T, ...T[]], getValue: (element: T) => number): T; +/** + * Finds the element in an array that has the maximum value when applying + * the `getValue` function 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} getValue A function that selects a numeric value from each element. + * @returns {T | undefined} The element with the maximum value as determined by the `getValue` function, + * or `undefined` if the array is empty. + * @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 } + */ +declare function maxBy(items: readonly T[], getValue: (element: T) => number): T | undefined; + +export { maxBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.js new file mode 100644 index 0000000000000000000000000000000000000000..e02bdedd8ee82cffdf48868e0d4096462984f261 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function maxBy(items, getValue) { + if (items.length === 0) { + return undefined; + } + let maxElement = items[0]; + let max = getValue(maxElement); + for (let i = 1; i < items.length; i++) { + const element = items[i]; + const value = getValue(element); + if (value > max) { + max = value; + maxElement = element; + } + } + return maxElement; +} + +exports.maxBy = maxBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..446ef85937256b46568ea4ecb1d3a5d4a14a9992 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/maxBy.mjs @@ -0,0 +1,18 @@ +function maxBy(items, getValue) { + if (items.length === 0) { + return undefined; + } + let maxElement = items[0]; + let max = getValue(maxElement); + for (let i = 1; i < items.length; i++) { + const element = items[i]; + const value = getValue(element); + if (value > max) { + max = value; + maxElement = element; + } + } + return maxElement; +} + +export { maxBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8f99c831d542386e60cebbb5e50f6d6c98eb77fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.d.mts @@ -0,0 +1,45 @@ +/** + * Finds the element in an array that has the minimum value when applying + * the `getValue` function to each element. + * + * @template T - The type of elements in the array. + * @param {[T, ...T[]]} items The nonempty array of elements to search. + * @param {(element: T) => number} getValue A function that selects a numeric value from each element. + * @returns {T} The element with the minimum value as determined by the `getValue` function. + * @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 } + */ +declare function minBy(items: readonly [T, ...T[]], getValue: (element: T) => number): T; +/** + * Finds the element in an array that has the minimum value when applying + * the `getValue` function 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} getValue A function that selects a numeric value from each element. + * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function, + * or `undefined` if the array is empty. + * @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 } + */ +declare function minBy(items: readonly T[], getValue: (element: T) => number): T | undefined; + +export { minBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f99c831d542386e60cebbb5e50f6d6c98eb77fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.d.ts @@ -0,0 +1,45 @@ +/** + * Finds the element in an array that has the minimum value when applying + * the `getValue` function to each element. + * + * @template T - The type of elements in the array. + * @param {[T, ...T[]]} items The nonempty array of elements to search. + * @param {(element: T) => number} getValue A function that selects a numeric value from each element. + * @returns {T} The element with the minimum value as determined by the `getValue` function. + * @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 } + */ +declare function minBy(items: readonly [T, ...T[]], getValue: (element: T) => number): T; +/** + * Finds the element in an array that has the minimum value when applying + * the `getValue` function 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} getValue A function that selects a numeric value from each element. + * @returns {T | undefined} The element with the minimum value as determined by the `getValue` function, + * or `undefined` if the array is empty. + * @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 } + */ +declare function minBy(items: readonly T[], getValue: (element: T) => number): T | undefined; + +export { minBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.js new file mode 100644 index 0000000000000000000000000000000000000000..c6071bf3256bbedbfae696c5017b200021fe2595 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function minBy(items, getValue) { + if (items.length === 0) { + return undefined; + } + let minElement = items[0]; + let min = getValue(minElement); + for (let i = 1; i < items.length; i++) { + const element = items[i]; + const value = getValue(element); + if (value < min) { + min = value; + minElement = element; + } + } + return minElement; +} + +exports.minBy = minBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c177415b61e6f288f594bb77229dcf35f243883d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/minBy.mjs @@ -0,0 +1,18 @@ +function minBy(items, getValue) { + if (items.length === 0) { + return undefined; + } + let minElement = items[0]; + let min = getValue(minElement); + for (let i = 1; i < items.length; i++) { + const element = items[i]; + const value = getValue(element); + if (value < min) { + min = value; + minElement = element; + } + } + return minElement; +} + +export { minBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f661f5906a1c3b023d31e41319cac1167dfe2cbb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.d.mts @@ -0,0 +1,37 @@ +/** + * Sorts an array of objects based on the given `criteria` and their corresponding order directions. + * + * - If you provide keys, it sorts the objects by the values of those keys. + * - If you provide functions, it sorts based on the values returned by those functions. + * + * The function returns the array of objects sorted in corresponding order directions. + * If two objects have the same value for the current criterion, it uses the next criterion to determine their order. + * If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array of objects to be sorted. + * @param {Array<((item: T) => unknown) | keyof T>} criteria - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting. + * @param {Array<'asc' | 'desc'>} orders - An array of order directions ('asc' for ascending or 'desc' for descending). + * @returns {T[]} - The 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 = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']); + * // result will be: + * // [ + * // { user: 'barney', age: 36 }, + * // { user: 'barney', age: 34 }, + * // { user: 'fred', age: 48 }, + * // { user: 'fred', age: 40 }, + * // ] + */ +declare function orderBy(arr: readonly T[], criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): T[]; + +export { orderBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f661f5906a1c3b023d31e41319cac1167dfe2cbb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.d.ts @@ -0,0 +1,37 @@ +/** + * Sorts an array of objects based on the given `criteria` and their corresponding order directions. + * + * - If you provide keys, it sorts the objects by the values of those keys. + * - If you provide functions, it sorts based on the values returned by those functions. + * + * The function returns the array of objects sorted in corresponding order directions. + * If two objects have the same value for the current criterion, it uses the next criterion to determine their order. + * If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array of objects to be sorted. + * @param {Array<((item: T) => unknown) | keyof T>} criteria - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting. + * @param {Array<'asc' | 'desc'>} orders - An array of order directions ('asc' for ascending or 'desc' for descending). + * @returns {T[]} - The 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 = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']); + * // result will be: + * // [ + * // { user: 'barney', age: 36 }, + * // { user: 'barney', age: 34 }, + * // { user: 'fred', age: 48 }, + * // { user: 'fred', age: 40 }, + * // ] + */ +declare function orderBy(arr: readonly T[], criteria: Array<((item: T) => unknown) | keyof T>, orders: Array<'asc' | 'desc'>): T[]; + +export { orderBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.js new file mode 100644 index 0000000000000000000000000000000000000000..1222952b3c22983fd0447cbd3de14b4e2cd551ba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const compareValues = require('../_internal/compareValues.js'); + +function orderBy(arr, criteria, orders) { + return arr.slice().sort((a, b) => { + const ordersLength = orders.length; + for (let i = 0; i < criteria.length; i++) { + const order = ordersLength > i ? orders[i] : orders[ordersLength - 1]; + const criterion = criteria[i]; + const criterionIsFunction = typeof criterion === 'function'; + const valueA = criterionIsFunction ? criterion(a) : a[criterion]; + const valueB = criterionIsFunction ? criterion(b) : b[criterion]; + const result = compareValues.compareValues(valueA, valueB, order); + if (result !== 0) { + return result; + } + } + return 0; + }); +} + +exports.orderBy = orderBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..38a3d0f0264d7330fa75dec1e28182a9146cd4ba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/orderBy.mjs @@ -0,0 +1,21 @@ +import { compareValues } from '../_internal/compareValues.mjs'; + +function orderBy(arr, criteria, orders) { + return arr.slice().sort((a, b) => { + const ordersLength = orders.length; + for (let i = 0; i < criteria.length; i++) { + const order = ordersLength > i ? orders[i] : orders[ordersLength - 1]; + const criterion = criteria[i]; + const criterionIsFunction = typeof criterion === 'function'; + const valueA = criterionIsFunction ? criterion(a) : a[criterion]; + const valueB = criterionIsFunction ? criterion(b) : b[criterion]; + const result = compareValues(valueA, valueB, order); + if (result !== 0) { + return result; + } + } + return 0; + }); +} + +export { orderBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7fcf9796ebd9233b8526e00fb0895cb60db12c27 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.d.mts @@ -0,0 +1,25 @@ +/** + * Splits an array into two groups based on a predicate function. + * + * This function takes an array and a predicate function. It returns a tuple of two arrays: + * the first array contains elements for which the predicate function returns true, and + * the second array contains elements for which the predicate function returns false. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to partition. + * @param {(value: T) => boolean} isInTruthy - A predicate function that determines + * whether an element should be placed in the truthy array. The function is called with each + * element of the array. + * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for + * which the predicate returned true, and the second array contains elements for which the + * predicate returned false. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const isEven = x => x % 2 === 0; + * const [even, odd] = partition(array, isEven); + * // even will be [2, 4], and odd will be [1, 3, 5] + */ +declare function partition(arr: readonly T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]]; + +export { partition }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7fcf9796ebd9233b8526e00fb0895cb60db12c27 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.d.ts @@ -0,0 +1,25 @@ +/** + * Splits an array into two groups based on a predicate function. + * + * This function takes an array and a predicate function. It returns a tuple of two arrays: + * the first array contains elements for which the predicate function returns true, and + * the second array contains elements for which the predicate function returns false. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to partition. + * @param {(value: T) => boolean} isInTruthy - A predicate function that determines + * whether an element should be placed in the truthy array. The function is called with each + * element of the array. + * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for + * which the predicate returned true, and the second array contains elements for which the + * predicate returned false. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const isEven = x => x % 2 === 0; + * const [even, odd] = partition(array, isEven); + * // even will be [2, 4], and odd will be [1, 3, 5] + */ +declare function partition(arr: readonly T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]]; + +export { partition }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.js new file mode 100644 index 0000000000000000000000000000000000000000..d553abb8f9ab646b32944e16a577e7d788601a3d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function partition(arr, isInTruthy) { + const truthy = []; + const falsy = []; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (isInTruthy(item)) { + truthy.push(item); + } + else { + falsy.push(item); + } + } + return [truthy, falsy]; +} + +exports.partition = partition; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.mjs new file mode 100644 index 0000000000000000000000000000000000000000..cf1685aff583ef4058d45961a6b89eef1eb0a94c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/partition.mjs @@ -0,0 +1,16 @@ +function partition(arr, isInTruthy) { + const truthy = []; + const falsy = []; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (isInTruthy(item)) { + truthy.push(item); + } + else { + falsy.push(item); + } + } + return [truthy, falsy]; +} + +export { partition }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c60c87694a34f71164daac78bb42eeb06325d45e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.d.mts @@ -0,0 +1,19 @@ +/** + * Removes all specified values from an array. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `difference`. + * + * @template T, U + * @param {T[]} arr - The array to modify. + * @param {unknown[]} valuesToRemove - The values to remove from the array. + * @returns {T[]} The modified array with the specified values removed. + * + * @example + * const numbers = [1, 2, 3, 4, 5, 2, 4]; + * pull(numbers, [2, 4]); + * console.log(numbers); // [1, 3, 5] + */ +declare function pull(arr: T[], valuesToRemove: readonly unknown[]): T[]; + +export { pull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c60c87694a34f71164daac78bb42eeb06325d45e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.d.ts @@ -0,0 +1,19 @@ +/** + * Removes all specified values from an array. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `difference`. + * + * @template T, U + * @param {T[]} arr - The array to modify. + * @param {unknown[]} valuesToRemove - The values to remove from the array. + * @returns {T[]} The modified array with the specified values removed. + * + * @example + * const numbers = [1, 2, 3, 4, 5, 2, 4]; + * pull(numbers, [2, 4]); + * console.log(numbers); // [1, 3, 5] + */ +declare function pull(arr: T[], valuesToRemove: readonly unknown[]): T[]; + +export { pull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.js new file mode 100644 index 0000000000000000000000000000000000000000..2f40b4473e1b33712cb85a90ae4ab01e4249935e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function pull(arr, valuesToRemove) { + const valuesSet = new Set(valuesToRemove); + let resultIndex = 0; + for (let i = 0; i < arr.length; i++) { + if (valuesSet.has(arr[i])) { + continue; + } + if (!Object.hasOwn(arr, i)) { + delete arr[resultIndex++]; + continue; + } + arr[resultIndex++] = arr[i]; + } + arr.length = resultIndex; + return arr; +} + +exports.pull = pull; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.mjs new file mode 100644 index 0000000000000000000000000000000000000000..14b7c77f0b83b92708db89ff012fd2ea2dbb3197 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pull.mjs @@ -0,0 +1,18 @@ +function pull(arr, valuesToRemove) { + const valuesSet = new Set(valuesToRemove); + let resultIndex = 0; + for (let i = 0; i < arr.length; i++) { + if (valuesSet.has(arr[i])) { + continue; + } + if (!Object.hasOwn(arr, i)) { + delete arr[resultIndex++]; + continue; + } + arr[resultIndex++] = arr[i]; + } + arr.length = resultIndex; + return arr; +} + +export { pull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a4d829877cd455685a1ceaa0de1918056dadbc76 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.d.mts @@ -0,0 +1,19 @@ +/** + * Removes elements from an array at specified indices and returns the removed elements. + * + * This function supports negative indices, which count from the end of the array. + * + * @template T + * @param {T[]} arr - The array from which elements will be removed. + * @param {number[]} indicesToRemove - An array of indices specifying the positions of elements to remove. + * @returns {Array} An array containing the elements that were removed from the original array. + * + * @example + * const numbers = [10, 20, 30, 40, 50]; + * const removed = pullAt(numbers, [1, 3, 4]); + * console.log(removed); // [20, 40, 50] + * console.log(numbers); // [10, 30] + */ +declare function pullAt(arr: T[], indicesToRemove: number[]): T[]; + +export { pullAt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a4d829877cd455685a1ceaa0de1918056dadbc76 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.d.ts @@ -0,0 +1,19 @@ +/** + * Removes elements from an array at specified indices and returns the removed elements. + * + * This function supports negative indices, which count from the end of the array. + * + * @template T + * @param {T[]} arr - The array from which elements will be removed. + * @param {number[]} indicesToRemove - An array of indices specifying the positions of elements to remove. + * @returns {Array} An array containing the elements that were removed from the original array. + * + * @example + * const numbers = [10, 20, 30, 40, 50]; + * const removed = pullAt(numbers, [1, 3, 4]); + * console.log(removed); // [20, 40, 50] + * console.log(numbers); // [10, 30] + */ +declare function pullAt(arr: T[], indicesToRemove: number[]): T[]; + +export { pullAt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.js new file mode 100644 index 0000000000000000000000000000000000000000..317125c88d82c1929f89eb77b5bb329ac3f2f56f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const at = require('./at.js'); + +function pullAt(arr, indicesToRemove) { + const removed = at.at(arr, indicesToRemove); + const indices = new Set(indicesToRemove.slice().sort((x, y) => y - x)); + for (const index of indices) { + arr.splice(index, 1); + } + return removed; +} + +exports.pullAt = pullAt; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c69690725eec8bc5171671dc53e9c0164a3c69fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/pullAt.mjs @@ -0,0 +1,12 @@ +import { at } from './at.mjs'; + +function pullAt(arr, indicesToRemove) { + const removed = at(arr, indicesToRemove); + const indices = new Set(indicesToRemove.slice().sort((x, y) => y - x)); + for (const index of indices) { + arr.splice(index, 1); + } + return removed; +} + +export { pullAt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..86b54b56e5201a5c5db34f00ea161e2861df3ae3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.d.mts @@ -0,0 +1,19 @@ +/** + * Removes elements from an array based on a predicate function. + * + * This function changes `arr` in place. + * If you want to remove elements without modifying the original array, use `filter`. + * + * @template T + * @param {T[]} arr - The array to modify. + * @param {(value: T, index: number, array: T[]) => boolean} shouldRemoveElement - The function invoked per iteration to determine if an element should be removed. + * @returns {T[]} The modified array with the specified elements removed. + * + * @example + * const numbers = [1, 2, 3, 4, 5]; + * remove(numbers, (value) => value % 2 === 0); + * console.log(numbers); // [1, 3, 5] + */ +declare function remove(arr: T[], shouldRemoveElement: (value: T, index: number, array: T[]) => boolean): T[]; + +export { remove }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..86b54b56e5201a5c5db34f00ea161e2861df3ae3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.d.ts @@ -0,0 +1,19 @@ +/** + * Removes elements from an array based on a predicate function. + * + * This function changes `arr` in place. + * If you want to remove elements without modifying the original array, use `filter`. + * + * @template T + * @param {T[]} arr - The array to modify. + * @param {(value: T, index: number, array: T[]) => boolean} shouldRemoveElement - The function invoked per iteration to determine if an element should be removed. + * @returns {T[]} The modified array with the specified elements removed. + * + * @example + * const numbers = [1, 2, 3, 4, 5]; + * remove(numbers, (value) => value % 2 === 0); + * console.log(numbers); // [1, 3, 5] + */ +declare function remove(arr: T[], shouldRemoveElement: (value: T, index: number, array: T[]) => boolean): T[]; + +export { remove }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.js new file mode 100644 index 0000000000000000000000000000000000000000..b5a5a31de9fd1731d500007abf025a9711f8344f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function remove(arr, shouldRemoveElement) { + const originalArr = arr.slice(); + const removed = []; + let resultIndex = 0; + for (let i = 0; i < arr.length; i++) { + if (shouldRemoveElement(arr[i], i, originalArr)) { + removed.push(arr[i]); + continue; + } + if (!Object.hasOwn(arr, i)) { + delete arr[resultIndex++]; + continue; + } + arr[resultIndex++] = arr[i]; + } + arr.length = resultIndex; + return removed; +} + +exports.remove = remove; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9454402175e61a40b49a12ea2c321288af4477b5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/remove.mjs @@ -0,0 +1,20 @@ +function remove(arr, shouldRemoveElement) { + const originalArr = arr.slice(); + const removed = []; + let resultIndex = 0; + for (let i = 0; i < arr.length; i++) { + if (shouldRemoveElement(arr[i], i, originalArr)) { + removed.push(arr[i]); + continue; + } + if (!Object.hasOwn(arr, i)) { + delete arr[resultIndex++]; + continue; + } + arr[resultIndex++] = arr[i]; + } + arr.length = resultIndex; + return removed; +} + +export { remove }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..94acdb5d7b37c9ef0dafcf8a5680b2bd52dac9c4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.d.mts @@ -0,0 +1,17 @@ +/** + * Returns a random element from an array. + * + * This function takes an array and returns a single element selected randomly from the array. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to sample from. + * @returns {T} A random element from the array. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const randomElement = sample(array); + * // randomElement will be one of the elements from the array, selected randomly. + */ +declare function sample(arr: readonly T[]): T; + +export { sample }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..94acdb5d7b37c9ef0dafcf8a5680b2bd52dac9c4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.d.ts @@ -0,0 +1,17 @@ +/** + * Returns a random element from an array. + * + * This function takes an array and returns a single element selected randomly from the array. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to sample from. + * @returns {T} A random element from the array. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const randomElement = sample(array); + * // randomElement will be one of the elements from the array, selected randomly. + */ +declare function sample(arr: readonly T[]): T; + +export { sample }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.js new file mode 100644 index 0000000000000000000000000000000000000000..53706b0d2d5308511d5aa942627af18e5b866207 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.js @@ -0,0 +1,10 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function sample(arr) { + const randomIndex = Math.floor(Math.random() * arr.length); + return arr[randomIndex]; +} + +exports.sample = sample; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.mjs new file mode 100644 index 0000000000000000000000000000000000000000..69927888af4f0b079bbccbf1a1373eb0e8b952b3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sample.mjs @@ -0,0 +1,6 @@ +function sample(arr) { + const randomIndex = Math.floor(Math.random() * arr.length); + return arr[randomIndex]; +} + +export { sample }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b72eb8c833fa373b8cef14d86403fbff5a4f5979 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.d.mts @@ -0,0 +1,21 @@ +/** + * Returns a sample element array of a specified `size`. + * + * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm. + * + * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algorithm} + * + * @template T - The type of elements in the array. + * @param {T[]} array - The array to sample from. + * @param {number} size - The size of sample. + * @returns {T[]} A new array with sample size applied. + * @throws {Error} Throws an error if `size` is greater than the length of `array`. + * + * @example + * const result = sampleSize([1, 2, 3], 2) + * // result will be an array containing two of the elements from the array. + * // [1, 2] or [1, 3] or [2, 3] + */ +declare function sampleSize(array: readonly T[], size: number): T[]; + +export { sampleSize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b72eb8c833fa373b8cef14d86403fbff5a4f5979 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.d.ts @@ -0,0 +1,21 @@ +/** + * Returns a sample element array of a specified `size`. + * + * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm. + * + * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algorithm} + * + * @template T - The type of elements in the array. + * @param {T[]} array - The array to sample from. + * @param {number} size - The size of sample. + * @returns {T[]} A new array with sample size applied. + * @throws {Error} Throws an error if `size` is greater than the length of `array`. + * + * @example + * const result = sampleSize([1, 2, 3], 2) + * // result will be an array containing two of the elements from the array. + * // [1, 2] or [1, 3] or [2, 3] + */ +declare function sampleSize(array: readonly T[], size: number): T[]; + +export { sampleSize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.js new file mode 100644 index 0000000000000000000000000000000000000000..dfd15bbc8ce3743e787caa2ac44f9a8b9b99894c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const randomInt = require('../math/randomInt.js'); + +function sampleSize(array, size) { + if (size > array.length) { + throw new Error('Size must be less than or equal to the length of array.'); + } + const result = new Array(size); + const selected = new Set(); + for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) { + let index = randomInt.randomInt(0, step + 1); + if (selected.has(index)) { + index = step; + } + selected.add(index); + result[resultIndex] = array[index]; + } + return result; +} + +exports.sampleSize = sampleSize; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b48928e24ba234f9909a75a31b2660f131b193f1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sampleSize.mjs @@ -0,0 +1,20 @@ +import { randomInt } from '../math/randomInt.mjs'; + +function sampleSize(array, size) { + if (size > array.length) { + throw new Error('Size must be less than or equal to the length of array.'); + } + const result = new Array(size); + const selected = new Set(); + for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) { + let index = randomInt(0, step + 1); + if (selected.has(index)) { + index = step; + } + selected.add(index); + result[resultIndex] = array[index]; + } + return result; +} + +export { sampleSize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..783f1f0351b190777e31805d8c771791217bb9ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.d.mts @@ -0,0 +1,17 @@ +/** + * 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[]} arr - The array to shuffle. + * @returns {T[]} A new array with its elements shuffled in random order. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const shuffledArray = shuffle(array); + * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2] + */ +declare function shuffle(arr: readonly T[]): T[]; + +export { shuffle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..783f1f0351b190777e31805d8c771791217bb9ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.d.ts @@ -0,0 +1,17 @@ +/** + * 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[]} arr - The array to shuffle. + * @returns {T[]} A new array with its elements shuffled in random order. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const shuffledArray = shuffle(array); + * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2] + */ +declare function shuffle(arr: readonly T[]): T[]; + +export { shuffle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.js new file mode 100644 index 0000000000000000000000000000000000000000..16701a8be6b6e19415f68a083d779230685caec6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function shuffle(arr) { + const result = arr.slice(); + for (let i = result.length - 1; i >= 1; i--) { + const j = Math.floor(Math.random() * (i + 1)); + [result[i], result[j]] = [result[j], result[i]]; + } + return result; +} + +exports.shuffle = shuffle; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.mjs new file mode 100644 index 0000000000000000000000000000000000000000..be8732d088d0c329f77a0d72bb0724715ded12bf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/shuffle.mjs @@ -0,0 +1,10 @@ +function shuffle(arr) { + const result = arr.slice(); + for (let i = result.length - 1; i >= 1; i--) { + const j = Math.floor(Math.random() * (i + 1)); + [result[i], result[j]] = [result[j], result[i]]; + } + return result; +} + +export { shuffle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a9cc04fad5a4e431c130b4faf27e32fc43670b00 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.d.mts @@ -0,0 +1,35 @@ +/** + * Sorts an array of objects based on the given `criteria`. + * + * - If you provide keys, it sorts the objects by the values of those keys. + * - If you provide functions, it sorts based on the values returned by those functions. + * + * The function returns the array of objects sorted in ascending order. + * If two objects have the same value for the current criterion, it uses the next criterion to determine their order. + * + * @template T - The type of the objects in the array. + * @param {T[]} arr - The array of objects to be sorted. + * @param {Array<((item: T) => unknown) | keyof T>} criteria - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting. + * @returns {T[]} - The sorted array. + * + * @example + * const users = [ + * { user: 'foo', age: 24 }, + * { user: 'bar', age: 7 }, + * { user: 'foo ', age: 8 }, + * { user: 'bar ', age: 29 }, + * ]; + * + * sortBy(users, ['user', 'age']); + * sortBy(users, [obj => obj.user, 'age']); + * // results will be: + * // [ + * // { user : 'bar', age: 7 }, + * // { user : 'bar', age: 29 }, + * // { user : 'foo', age: 8 }, + * // { user : 'foo', age: 24 }, + * // ] + */ +declare function sortBy(arr: readonly T[], criteria: Array<((item: T) => unknown) | keyof T>): T[]; + +export { sortBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a9cc04fad5a4e431c130b4faf27e32fc43670b00 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.d.ts @@ -0,0 +1,35 @@ +/** + * Sorts an array of objects based on the given `criteria`. + * + * - If you provide keys, it sorts the objects by the values of those keys. + * - If you provide functions, it sorts based on the values returned by those functions. + * + * The function returns the array of objects sorted in ascending order. + * If two objects have the same value for the current criterion, it uses the next criterion to determine their order. + * + * @template T - The type of the objects in the array. + * @param {T[]} arr - The array of objects to be sorted. + * @param {Array<((item: T) => unknown) | keyof T>} criteria - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting. + * @returns {T[]} - The sorted array. + * + * @example + * const users = [ + * { user: 'foo', age: 24 }, + * { user: 'bar', age: 7 }, + * { user: 'foo ', age: 8 }, + * { user: 'bar ', age: 29 }, + * ]; + * + * sortBy(users, ['user', 'age']); + * sortBy(users, [obj => obj.user, 'age']); + * // results will be: + * // [ + * // { user : 'bar', age: 7 }, + * // { user : 'bar', age: 29 }, + * // { user : 'foo', age: 8 }, + * // { user : 'foo', age: 24 }, + * // ] + */ +declare function sortBy(arr: readonly T[], criteria: Array<((item: T) => unknown) | keyof T>): T[]; + +export { sortBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.js new file mode 100644 index 0000000000000000000000000000000000000000..f834bb74ff2c3b17c724ffb6bb6b2ff743ccad53 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const orderBy = require('./orderBy.js'); + +function sortBy(arr, criteria) { + return orderBy.orderBy(arr, criteria, ['asc']); +} + +exports.sortBy = sortBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b9ebe38a2222b9ca47a8c7a798f09f01eb072306 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/sortBy.mjs @@ -0,0 +1,7 @@ +import { orderBy } from './orderBy.mjs'; + +function sortBy(arr, criteria) { + return orderBy(arr, criteria, ['asc']); +} + +export { sortBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d38cca86bea3e0e80d6b249a738ce6621a6f0ae5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.d.mts @@ -0,0 +1,67 @@ +/** + * Returns an empty array when the input is a single-element array. + * + * @template T - The type of the single element in the array. + * @param {[T]} arr - The single-element array to process. + * @returns {[]} An empty array. + * + * @example + * const arr = [1]; + * const result = tail(arr); + * // result will be [] + */ +declare function tail(arr: readonly [T]): []; +/** + * Returns an empty array when the input is an empty array. + * + * @template T - The type of elements in the array. + * @param {[]} arr - The empty array to process. + * @returns {[]} An empty array. + * + * @example + * const arr = []; + * const result = tail(arr); + * // result will be [] + */ +declare function tail(arr: readonly []): []; +/** + * Returns a new array with all elements except for the first when the input is a tuple array. + * + * @template T - The type of the first element in the tuple array. + * @template U - The type of the remaining elements in the tuple array. + * @param {[T, ...U[]]} arr - The tuple array to process. + * @returns {U[]} A new array containing all elements of the input array except for the first one. + * + * @example + * const arr = [1, 2, 3]; + * const result = tail(arr); + * // result will be [2, 3] + */ +declare function tail(arr: readonly [T, ...U[]]): U[]; +/** + * Returns a new array with all elements except for the first. + * + * This function takes an array and returns a new array containing all the elements + * except for the first one. If the input array is empty or has only one element, + * an empty array is returned. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to get the tail of. + * @returns {T[]} A new array containing all elements of the input array except for the first one. + * + * @example + * const arr1 = [1, 2, 3]; + * const result = tail(arr1); + * // result will be [2, 3] + * + * const arr2 = [1]; + * const result2 = tail(arr2); + * // result2 will be [] + * + * const arr3 = []; + * const result3 = tail(arr3); + * // result3 will be [] + */ +declare function tail(arr: readonly T[]): T[]; + +export { tail }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d38cca86bea3e0e80d6b249a738ce6621a6f0ae5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.d.ts @@ -0,0 +1,67 @@ +/** + * Returns an empty array when the input is a single-element array. + * + * @template T - The type of the single element in the array. + * @param {[T]} arr - The single-element array to process. + * @returns {[]} An empty array. + * + * @example + * const arr = [1]; + * const result = tail(arr); + * // result will be [] + */ +declare function tail(arr: readonly [T]): []; +/** + * Returns an empty array when the input is an empty array. + * + * @template T - The type of elements in the array. + * @param {[]} arr - The empty array to process. + * @returns {[]} An empty array. + * + * @example + * const arr = []; + * const result = tail(arr); + * // result will be [] + */ +declare function tail(arr: readonly []): []; +/** + * Returns a new array with all elements except for the first when the input is a tuple array. + * + * @template T - The type of the first element in the tuple array. + * @template U - The type of the remaining elements in the tuple array. + * @param {[T, ...U[]]} arr - The tuple array to process. + * @returns {U[]} A new array containing all elements of the input array except for the first one. + * + * @example + * const arr = [1, 2, 3]; + * const result = tail(arr); + * // result will be [2, 3] + */ +declare function tail(arr: readonly [T, ...U[]]): U[]; +/** + * Returns a new array with all elements except for the first. + * + * This function takes an array and returns a new array containing all the elements + * except for the first one. If the input array is empty or has only one element, + * an empty array is returned. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to get the tail of. + * @returns {T[]} A new array containing all elements of the input array except for the first one. + * + * @example + * const arr1 = [1, 2, 3]; + * const result = tail(arr1); + * // result will be [2, 3] + * + * const arr2 = [1]; + * const result2 = tail(arr2); + * // result2 will be [] + * + * const arr3 = []; + * const result3 = tail(arr3); + * // result3 will be [] + */ +declare function tail(arr: readonly T[]): T[]; + +export { tail }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.js new file mode 100644 index 0000000000000000000000000000000000000000..573dae0ca3fc594e7ab465debf83d379eb7978a1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function tail(arr) { + return arr.slice(1); +} + +exports.tail = tail; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.mjs new file mode 100644 index 0000000000000000000000000000000000000000..870853baf9f15225662e1fc2860ec005c2f7e7b8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/tail.mjs @@ -0,0 +1,5 @@ +function tail(arr) { + return arr.slice(1); +} + +export { tail }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9f54aa8e4c192a79150ab4520b9cc0863dc29498 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.d.mts @@ -0,0 +1,25 @@ +/** + * Returns a new array containing the first `count` elements from the input array `arr`. + * If `count` is greater than the length of `arr`, the entire array is returned. + * + * @template T - Type of elements in the input array. + * + * @param {T[]} arr - The array to take elements from. + * @param {number} count - The number of elements to take. + * @returns {T[]} A new array containing the first `count` elements from `arr`. + * + * @example + * // Returns [1, 2, 3] + * take([1, 2, 3, 4, 5], 3); + * + * @example + * // Returns ['a', 'b'] + * take(['a', 'b', 'c'], 2); + * + * @example + * // Returns [1, 2, 3] + * take([1, 2, 3], 5); + */ +declare function take(arr: readonly T[], count?: number, guard?: unknown): T[]; + +export { take }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f54aa8e4c192a79150ab4520b9cc0863dc29498 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.d.ts @@ -0,0 +1,25 @@ +/** + * Returns a new array containing the first `count` elements from the input array `arr`. + * If `count` is greater than the length of `arr`, the entire array is returned. + * + * @template T - Type of elements in the input array. + * + * @param {T[]} arr - The array to take elements from. + * @param {number} count - The number of elements to take. + * @returns {T[]} A new array containing the first `count` elements from `arr`. + * + * @example + * // Returns [1, 2, 3] + * take([1, 2, 3, 4, 5], 3); + * + * @example + * // Returns ['a', 'b'] + * take(['a', 'b', 'c'], 2); + * + * @example + * // Returns [1, 2, 3] + * take([1, 2, 3], 5); + */ +declare function take(arr: readonly T[], count?: number, guard?: unknown): T[]; + +export { take }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.js new file mode 100644 index 0000000000000000000000000000000000000000..80afda4f2560c16816a39397782eccb1effee2bb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('../compat/util/toInteger.js'); + +function take(arr, count, guard) { + count = guard || count === undefined ? 1 : toInteger.toInteger(count); + return arr.slice(0, count); +} + +exports.take = take; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.mjs new file mode 100644 index 0000000000000000000000000000000000000000..dfe7a84f2a3c0d5e2515d6d7c9a90f012542400e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/take.mjs @@ -0,0 +1,8 @@ +import { toInteger } from '../compat/util/toInteger.mjs'; + +function take(arr, count, guard) { + count = guard || count === undefined ? 1 : toInteger(count); + return arr.slice(0, count); +} + +export { take }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2cb70600272f8dca11a0e7ecd663c5b4573dedd7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.d.mts @@ -0,0 +1,24 @@ +/** + * Returns a new array containing the last `count` elements from the input array `arr`. + * If `count` is greater than the length of `arr`, the entire array is returned. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to take elements from. + * @param {number} [count=1] - The number of elements to take. + * @returns {T[]} A new array containing the last `count` elements from `arr`. + * + * @example + * // Returns [4, 5] + * takeRight([1, 2, 3, 4, 5], 2); + * + * @example + * // Returns ['b', 'c'] + * takeRight(['a', 'b', 'c'], 2); + * + * @example + * // Returns [1, 2, 3] + * takeRight([1, 2, 3], 5); + */ +declare function takeRight(arr: readonly T[], count?: number, guard?: unknown): T[]; + +export { takeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2cb70600272f8dca11a0e7ecd663c5b4573dedd7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.d.ts @@ -0,0 +1,24 @@ +/** + * Returns a new array containing the last `count` elements from the input array `arr`. + * If `count` is greater than the length of `arr`, the entire array is returned. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to take elements from. + * @param {number} [count=1] - The number of elements to take. + * @returns {T[]} A new array containing the last `count` elements from `arr`. + * + * @example + * // Returns [4, 5] + * takeRight([1, 2, 3, 4, 5], 2); + * + * @example + * // Returns ['b', 'c'] + * takeRight(['a', 'b', 'c'], 2); + * + * @example + * // Returns [1, 2, 3] + * takeRight([1, 2, 3], 5); + */ +declare function takeRight(arr: readonly T[], count?: number, guard?: unknown): T[]; + +export { takeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.js new file mode 100644 index 0000000000000000000000000000000000000000..e7fcbfc6d41e5b068b3ff357aacf4a37cc8eaed5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toInteger = require('../compat/util/toInteger.js'); + +function takeRight(arr, count = 1, guard) { + count = guard || count === undefined ? 1 : toInteger.toInteger(count); + if (count <= 0 || arr == null || arr.length === 0) { + return []; + } + return arr.slice(-count); +} + +exports.takeRight = takeRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ab4350f01ede4ac44452eb185b30d956b7b70097 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRight.mjs @@ -0,0 +1,11 @@ +import { toInteger } from '../compat/util/toInteger.mjs'; + +function takeRight(arr, count = 1, guard) { + count = guard || count === undefined ? 1 : toInteger(count); + if (count <= 0 || arr == null || arr.length === 0) { + return []; + } + return arr.slice(-count); +} + +export { takeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5d97bcb19cecb6074e3ff3618fe0618f68f48ae9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.d.mts @@ -0,0 +1,20 @@ +/** + * Takes elements from the end of the array while the predicate function returns `true`. + * + * @template T - Type of elements in the input array. + * + * @param {T[]} arr - The array to take elements from. + * @param {(item: T) => boolean} shouldContinueTaking - The function invoked per element. + * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`. + * + * @example + * // Returns [3, 2, 1] + * takeRightWhile([5, 4, 3, 2, 1], n => n < 4); + * + * @example + * // Returns [] + * takeRightWhile([1, 2, 3], n => n > 3); + */ +declare function takeRightWhile(arr: readonly T[], shouldContinueTaking: (item: T) => boolean): T[]; + +export { takeRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d97bcb19cecb6074e3ff3618fe0618f68f48ae9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.d.ts @@ -0,0 +1,20 @@ +/** + * Takes elements from the end of the array while the predicate function returns `true`. + * + * @template T - Type of elements in the input array. + * + * @param {T[]} arr - The array to take elements from. + * @param {(item: T) => boolean} shouldContinueTaking - The function invoked per element. + * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`. + * + * @example + * // Returns [3, 2, 1] + * takeRightWhile([5, 4, 3, 2, 1], n => n < 4); + * + * @example + * // Returns [] + * takeRightWhile([1, 2, 3], n => n > 3); + */ +declare function takeRightWhile(arr: readonly T[], shouldContinueTaking: (item: T) => boolean): T[]; + +export { takeRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.js new file mode 100644 index 0000000000000000000000000000000000000000..4998c60bf09c5eec32ce2c034118602482fab67f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function takeRightWhile(arr, shouldContinueTaking) { + for (let i = arr.length - 1; i >= 0; i--) { + if (!shouldContinueTaking(arr[i])) { + return arr.slice(i + 1); + } + } + return arr.slice(); +} + +exports.takeRightWhile = takeRightWhile; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.mjs new file mode 100644 index 0000000000000000000000000000000000000000..38a833378ecbaba62e7dfb9dda5e1b6e00106f3f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeRightWhile.mjs @@ -0,0 +1,10 @@ +function takeRightWhile(arr, shouldContinueTaking) { + for (let i = arr.length - 1; i >= 0; i--) { + if (!shouldContinueTaking(arr[i])) { + return arr.slice(i + 1); + } + } + return arr.slice(); +} + +export { takeRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7f6207ddb4f0cb81b7239f828420cafe197635cb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.d.mts @@ -0,0 +1,21 @@ +/** + * Returns a new array containing the leading elements of the provided array + * that satisfy the provided predicate function. It stops taking elements as soon + * as an element does not satisfy the predicate. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to process. + * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true. + * @returns {T[]} A new array containing the leading elements that satisfy the predicate. + * + * @example + * // Returns [1, 2] + * takeWhile([1, 2, 3, 4], x => x < 3); + * + * @example + * // Returns [] + * takeWhile([1, 2, 3, 4], x => x > 3); + */ +declare function takeWhile(arr: readonly T[], shouldContinueTaking: (element: T) => boolean): T[]; + +export { takeWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7f6207ddb4f0cb81b7239f828420cafe197635cb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.d.ts @@ -0,0 +1,21 @@ +/** + * Returns a new array containing the leading elements of the provided array + * that satisfy the provided predicate function. It stops taking elements as soon + * as an element does not satisfy the predicate. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to process. + * @param {(element: T) => boolean} shouldContinueTaking - The predicate function that is called with each element. Elements are included in the result as long as this function returns true. + * @returns {T[]} A new array containing the leading elements that satisfy the predicate. + * + * @example + * // Returns [1, 2] + * takeWhile([1, 2, 3, 4], x => x < 3); + * + * @example + * // Returns [] + * takeWhile([1, 2, 3, 4], x => x > 3); + */ +declare function takeWhile(arr: readonly T[], shouldContinueTaking: (element: T) => boolean): T[]; + +export { takeWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.js new file mode 100644 index 0000000000000000000000000000000000000000..ab941055c72ddf52c170a6bd652e8339f7fabf1f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function takeWhile(arr, shouldContinueTaking) { + const result = []; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (!shouldContinueTaking(item)) { + break; + } + result.push(item); + } + return result; +} + +exports.takeWhile = takeWhile; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.mjs new file mode 100644 index 0000000000000000000000000000000000000000..11f8c3053ed26f5bd389508e0e5460cda17a7ecf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/takeWhile.mjs @@ -0,0 +1,13 @@ +function takeWhile(arr, shouldContinueTaking) { + const result = []; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (!shouldContinueTaking(item)) { + break; + } + result.push(item); + } + return result; +} + +export { takeWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c2f3108c884ffb0c8622b4c3dd0268ad85d80edf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.d.mts @@ -0,0 +1,92 @@ +/** + * Creates a new array filled with the specified value from the start position up to, but not including, the end position. + * This function does not mutate the original array. + * + * @template T - The type of elements in the original array. + * @template U - The type of the value to fill the new array with. + * @param {Array} arr - The array to base the new array on. + * @param {U} value - The value to fill the new array with. + * @returns {Array} The new array with the filled values. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * let result = toFilled(array, '*', 2); + * console.log(result); // [1, 2, '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', 1, 4); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*'); + * console.log(result); // ['*', '*', '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', -4, -1); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + */ +declare function toFilled(arr: readonly T[], value: U): Array; +/** + * Creates a new array filled with the specified value from the start position up to, but not including, the end position. + * This function does not mutate the original array. + * + * @template T - The type of elements in the original array. + * @template U - The type of the value to fill the new array with. + * @param {Array} arr - The array to base the new array on. + * @param {U} value - The value to fill the new array with. + * @param {number} [start=0] - The start position. Defaults to 0. + * @returns {Array} The new array with the filled values. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * let result = toFilled(array, '*', 2); + * console.log(result); // [1, 2, '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', 1, 4); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*'); + * console.log(result); // ['*', '*', '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', -4, -1); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + */ +declare function toFilled(arr: readonly T[], value: U, start: number): Array; +/** + * Creates a new array filled with the specified value from the start position up to, but not including, the end position. + * This function does not mutate the original array. + * + * @template T - The type of elements in the original array. + * @template U - The type of the value to fill the new array with. + * @param {Array} arr - The array to base the new array on. + * @param {U} value - The value to fill the new array with. + * @param {number} [start=0] - The start position. Defaults to 0. + * @param {number} [end=arr.length] - The end position. Defaults to the array's length. + * @returns {Array} The new array with the filled values. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * let result = toFilled(array, '*', 2); + * console.log(result); // [1, 2, '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', 1, 4); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*'); + * console.log(result); // ['*', '*', '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', -4, -1); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + */ +declare function toFilled(arr: readonly T[], value: U, start: number, end: number): Array; + +export { toFilled }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c2f3108c884ffb0c8622b4c3dd0268ad85d80edf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.d.ts @@ -0,0 +1,92 @@ +/** + * Creates a new array filled with the specified value from the start position up to, but not including, the end position. + * This function does not mutate the original array. + * + * @template T - The type of elements in the original array. + * @template U - The type of the value to fill the new array with. + * @param {Array} arr - The array to base the new array on. + * @param {U} value - The value to fill the new array with. + * @returns {Array} The new array with the filled values. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * let result = toFilled(array, '*', 2); + * console.log(result); // [1, 2, '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', 1, 4); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*'); + * console.log(result); // ['*', '*', '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', -4, -1); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + */ +declare function toFilled(arr: readonly T[], value: U): Array; +/** + * Creates a new array filled with the specified value from the start position up to, but not including, the end position. + * This function does not mutate the original array. + * + * @template T - The type of elements in the original array. + * @template U - The type of the value to fill the new array with. + * @param {Array} arr - The array to base the new array on. + * @param {U} value - The value to fill the new array with. + * @param {number} [start=0] - The start position. Defaults to 0. + * @returns {Array} The new array with the filled values. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * let result = toFilled(array, '*', 2); + * console.log(result); // [1, 2, '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', 1, 4); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*'); + * console.log(result); // ['*', '*', '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', -4, -1); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + */ +declare function toFilled(arr: readonly T[], value: U, start: number): Array; +/** + * Creates a new array filled with the specified value from the start position up to, but not including, the end position. + * This function does not mutate the original array. + * + * @template T - The type of elements in the original array. + * @template U - The type of the value to fill the new array with. + * @param {Array} arr - The array to base the new array on. + * @param {U} value - The value to fill the new array with. + * @param {number} [start=0] - The start position. Defaults to 0. + * @param {number} [end=arr.length] - The end position. Defaults to the array's length. + * @returns {Array} The new array with the filled values. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * let result = toFilled(array, '*', 2); + * console.log(result); // [1, 2, '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', 1, 4); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*'); + * console.log(result); // ['*', '*', '*', '*', '*'] + * console.log(array); // [1, 2, 3, 4, 5] + * + * result = toFilled(array, '*', -4, -1); + * console.log(result); // [1, '*', '*', '*', 5] + * console.log(array); // [1, 2, 3, 4, 5] + */ +declare function toFilled(arr: readonly T[], value: U, start: number, end: number): Array; + +export { toFilled }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.js new file mode 100644 index 0000000000000000000000000000000000000000..ec00e0bf08c5113f37d490c2c726efffd49c9e75 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function toFilled(arr, value, start = 0, end = arr.length) { + const length = arr.length; + const finalStart = Math.max(start >= 0 ? start : length + start, 0); + const finalEnd = Math.min(end >= 0 ? end : length + end, length); + const newArr = arr.slice(); + for (let i = finalStart; i < finalEnd; i++) { + newArr[i] = value; + } + return newArr; +} + +exports.toFilled = toFilled; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3b099e35cb3ad3be41c241b0e507cd456990c9ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/toFilled.mjs @@ -0,0 +1,12 @@ +function toFilled(arr, value, start = 0, end = arr.length) { + const length = arr.length; + const finalStart = Math.max(start >= 0 ? start : length + start, 0); + const finalEnd = Math.min(end >= 0 ? end : length + end, length); + const newArr = arr.slice(); + for (let i = finalStart; i < finalEnd; i++) { + newArr[i] = value; + } + return newArr; +} + +export { toFilled }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..005b0a7daaaf824b3a8327be84b48f6848fa189b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.d.mts @@ -0,0 +1,20 @@ +/** + * Creates an array of unique values from all given arrays. + * + * This function takes two arrays, merges them into a single array, and returns a new array + * containing only the unique values from the merged array. + * + * @template T - The type of elements in the array. + * @param {T[]} arr1 - The first array to merge and filter for unique values. + * @param {T[]} arr2 - The second array to merge and filter for unique values. + * @returns {T[]} A new array of unique values. + * + * @example + * const array1 = [1, 2, 3]; + * const array2 = [3, 4, 5]; + * const result = union(array1, array2); + * // result will be [1, 2, 3, 4, 5] + */ +declare function union(arr1: readonly T[], arr2: readonly T[]): T[]; + +export { union }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..005b0a7daaaf824b3a8327be84b48f6848fa189b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.d.ts @@ -0,0 +1,20 @@ +/** + * Creates an array of unique values from all given arrays. + * + * This function takes two arrays, merges them into a single array, and returns a new array + * containing only the unique values from the merged array. + * + * @template T - The type of elements in the array. + * @param {T[]} arr1 - The first array to merge and filter for unique values. + * @param {T[]} arr2 - The second array to merge and filter for unique values. + * @returns {T[]} A new array of unique values. + * + * @example + * const array1 = [1, 2, 3]; + * const array2 = [3, 4, 5]; + * const result = union(array1, array2); + * // result will be [1, 2, 3, 4, 5] + */ +declare function union(arr1: readonly T[], arr2: readonly T[]): T[]; + +export { union }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.js new file mode 100644 index 0000000000000000000000000000000000000000..e415fb76b60d74df62f3faf3abdf08a1156be67e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const uniq = require('./uniq.js'); + +function union(arr1, arr2) { + return uniq.uniq(arr1.concat(arr2)); +} + +exports.union = union; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c63152af19d16b3b4f888154d4deece8fc520bd0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/union.mjs @@ -0,0 +1,7 @@ +import { uniq } from './uniq.mjs'; + +function union(arr1, arr2) { + return uniq(arr1.concat(arr2)); +} + +export { union }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6593b4b9eb0a31f08aa53e886f9c0c382a1304e2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.d.mts @@ -0,0 +1,25 @@ +/** + * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality. + * + * @template T - The type of elements in the array. + * @template U - The type of mapped elements. + * @param {T[]} arr1 - The first array. + * @param {T[]} arr2 - The second array. + * @param {(item: T) => U} mapper - The function to map array elements to comparison values. + * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function. + * + * @example + * // Custom mapping function for numbers (modulo comparison) + * const moduloMapper = (x) => x % 3; + * unionBy([1, 2, 3], [4, 5, 6], moduloMapper); + * // Returns [1, 2, 3] + * + * @example + * // Custom mapping function for objects with an 'id' property + * const idMapper = (obj) => obj.id; + * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper); + * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }] + */ +declare function unionBy(arr1: readonly T[], arr2: readonly T[], mapper: (item: T) => U): T[]; + +export { unionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6593b4b9eb0a31f08aa53e886f9c0c382a1304e2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.d.ts @@ -0,0 +1,25 @@ +/** + * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality. + * + * @template T - The type of elements in the array. + * @template U - The type of mapped elements. + * @param {T[]} arr1 - The first array. + * @param {T[]} arr2 - The second array. + * @param {(item: T) => U} mapper - The function to map array elements to comparison values. + * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function. + * + * @example + * // Custom mapping function for numbers (modulo comparison) + * const moduloMapper = (x) => x % 3; + * unionBy([1, 2, 3], [4, 5, 6], moduloMapper); + * // Returns [1, 2, 3] + * + * @example + * // Custom mapping function for objects with an 'id' property + * const idMapper = (obj) => obj.id; + * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper); + * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }] + */ +declare function unionBy(arr1: readonly T[], arr2: readonly T[], mapper: (item: T) => U): T[]; + +export { unionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.js new file mode 100644 index 0000000000000000000000000000000000000000..f3854bd7bd7ed7d41c2b1957ace1fdecbee0461c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const uniqBy = require('./uniqBy.js'); + +function unionBy(arr1, arr2, mapper) { + return uniqBy.uniqBy(arr1.concat(arr2), mapper); +} + +exports.unionBy = unionBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..013bb9b1427fad019b85297307c4727dc62fc236 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionBy.mjs @@ -0,0 +1,7 @@ +import { uniqBy } from './uniqBy.mjs'; + +function unionBy(arr1, arr2, mapper) { + return uniqBy(arr1.concat(arr2), mapper); +} + +export { unionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4ed2495661786848d730da368727117b3dea4da6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.d.mts @@ -0,0 +1,23 @@ +/** + * Creates an array of unique values from two given arrays based on a custom equality function. + * + * This function takes two arrays and a custom equality function, merges the arrays, and returns + * a new array containing only the unique values as determined by the custom equality function. + * + * @template T - The type of elements in the array. + * @param {T[]} arr1 - The first array to merge and filter for unique values. + * @param {T[]} arr2 - The second array to merge and filter for unique values. + * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal. + * It takes two arguments and returns `true` if the elements are considered equal, and `false` otherwise. + * @returns {T[]} A new array of unique values based on the custom equality function. + * + * @example + * const array1 = [{ id: 1 }, { id: 2 }]; + * const array2 = [{ id: 2 }, { id: 3 }]; + * const areItemsEqual = (a, b) => a.id === b.id; + * const result = unionWith(array1, array2, areItemsEqual); + * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays + */ +declare function unionWith(arr1: readonly T[], arr2: readonly T[], areItemsEqual: (item1: T, item2: T) => boolean): T[]; + +export { unionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4ed2495661786848d730da368727117b3dea4da6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.d.ts @@ -0,0 +1,23 @@ +/** + * Creates an array of unique values from two given arrays based on a custom equality function. + * + * This function takes two arrays and a custom equality function, merges the arrays, and returns + * a new array containing only the unique values as determined by the custom equality function. + * + * @template T - The type of elements in the array. + * @param {T[]} arr1 - The first array to merge and filter for unique values. + * @param {T[]} arr2 - The second array to merge and filter for unique values. + * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal. + * It takes two arguments and returns `true` if the elements are considered equal, and `false` otherwise. + * @returns {T[]} A new array of unique values based on the custom equality function. + * + * @example + * const array1 = [{ id: 1 }, { id: 2 }]; + * const array2 = [{ id: 2 }, { id: 3 }]; + * const areItemsEqual = (a, b) => a.id === b.id; + * const result = unionWith(array1, array2, areItemsEqual); + * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays + */ +declare function unionWith(arr1: readonly T[], arr2: readonly T[], areItemsEqual: (item1: T, item2: T) => boolean): T[]; + +export { unionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.js new file mode 100644 index 0000000000000000000000000000000000000000..14857499aa3209675e906c5df9c026a49c602cf0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const uniqWith = require('./uniqWith.js'); + +function unionWith(arr1, arr2, areItemsEqual) { + return uniqWith.uniqWith(arr1.concat(arr2), areItemsEqual); +} + +exports.unionWith = unionWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7c00c078e2f8283224add7053afdcb2600d28789 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unionWith.mjs @@ -0,0 +1,7 @@ +import { uniqWith } from './uniqWith.mjs'; + +function unionWith(arr1, arr2, areItemsEqual) { + return uniqWith(arr1.concat(arr2), areItemsEqual); +} + +export { unionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..63ec962f6cbceb31f72de12f9f95d043aeb69f25 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {T[]} 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: readonly T[]): T[]; + +export { uniq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..63ec962f6cbceb31f72de12f9f95d043aeb69f25 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {T[]} 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: readonly T[]): T[]; + +export { uniq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.js new file mode 100644 index 0000000000000000000000000000000000000000..da9849b1dd7ac2935e3e3cf4a3cc29f3ae340c26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function uniq(arr) { + return Array.from(new Set(arr)); +} + +exports.uniq = uniq; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.mjs new file mode 100644 index 0000000000000000000000000000000000000000..24ae0d77b4fd97336388b1f7402a9be11f1af2e5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniq.mjs @@ -0,0 +1,5 @@ +function uniq(arr) { + return Array.from(new Set(arr)); +} + +export { uniq }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0378cec70a5cabef113277c4e5b9b8cde7e9ef38 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.d.mts @@ -0,0 +1,29 @@ +/** + * Returns a new array containing only the unique elements from the original array, + * based on the values returned by the mapper function. + * + * @template T - The type of elements in the array. + * @template U - The type of mapped elements. + * @param {T[]} arr - The array to process. + * @param {(item: T) => U} mapper - The function used to convert the array elements. + * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the mapper function. + * + * @example + * ```ts + * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor); + * // [1.2, 2.1, 3.2, 5.7, 7.19] + * ``` + * + * @example + * const array = [ + * { category: 'fruit', name: 'apple' }, + * { category: 'fruit', name: 'banana' }, + * { category: 'vegetable', name: 'carrot' }, + * ]; + * uniqBy(array, item => item.category).length + * // 2 + * ``` + */ +declare function uniqBy(arr: readonly T[], mapper: (item: T) => U): T[]; + +export { uniqBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0378cec70a5cabef113277c4e5b9b8cde7e9ef38 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.d.ts @@ -0,0 +1,29 @@ +/** + * Returns a new array containing only the unique elements from the original array, + * based on the values returned by the mapper function. + * + * @template T - The type of elements in the array. + * @template U - The type of mapped elements. + * @param {T[]} arr - The array to process. + * @param {(item: T) => U} mapper - The function used to convert the array elements. + * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the mapper function. + * + * @example + * ```ts + * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor); + * // [1.2, 2.1, 3.2, 5.7, 7.19] + * ``` + * + * @example + * const array = [ + * { category: 'fruit', name: 'apple' }, + * { category: 'fruit', name: 'banana' }, + * { category: 'vegetable', name: 'carrot' }, + * ]; + * uniqBy(array, item => item.category).length + * // 2 + * ``` + */ +declare function uniqBy(arr: readonly T[], mapper: (item: T) => U): T[]; + +export { uniqBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.js new file mode 100644 index 0000000000000000000000000000000000000000..b3009a419b72ede7daed8baaceb87db4bf2d44cd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function uniqBy(arr, mapper) { + const map = new Map(); + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + const key = mapper(item); + if (!map.has(key)) { + map.set(key, item); + } + } + return Array.from(map.values()); +} + +exports.uniqBy = uniqBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..04f4581aa9d09a67b97e2b82c1d9a3b1095c231a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqBy.mjs @@ -0,0 +1,13 @@ +function uniqBy(arr, mapper) { + const map = new Map(); + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + const key = mapper(item); + if (!map.has(key)) { + map.set(key, item); + } + } + return Array.from(map.values()); +} + +export { uniqBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1256b39168246b8202f6518604899cdd00a946a3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.d.mts @@ -0,0 +1,18 @@ +/** + * Returns a new array containing only the unique elements from the original array, + * based on the values returned by the comparator function. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to process. + * @param {(item1: T, item2: T) => boolean} areItemsEqual - The function used to compare the array elements. + * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the comparator function. + * + * @example + * ```ts + * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1); + * // [1.2, 3.2, 5.7, 7.19] + * ``` + */ +declare function uniqWith(arr: readonly T[], areItemsEqual: (item1: T, item2: T) => boolean): T[]; + +export { uniqWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1256b39168246b8202f6518604899cdd00a946a3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.d.ts @@ -0,0 +1,18 @@ +/** + * Returns a new array containing only the unique elements from the original array, + * based on the values returned by the comparator function. + * + * @template T - The type of elements in the array. + * @param {T[]} arr - The array to process. + * @param {(item1: T, item2: T) => boolean} areItemsEqual - The function used to compare the array elements. + * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the comparator function. + * + * @example + * ```ts + * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1); + * // [1.2, 3.2, 5.7, 7.19] + * ``` + */ +declare function uniqWith(arr: readonly T[], areItemsEqual: (item1: T, item2: T) => boolean): T[]; + +export { uniqWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.js new file mode 100644 index 0000000000000000000000000000000000000000..6036a0c3ba6259a667a246f53001823c516613ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function uniqWith(arr, areItemsEqual) { + const result = []; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + const isUniq = result.every(v => !areItemsEqual(v, item)); + if (isUniq) { + result.push(item); + } + } + return result; +} + +exports.uniqWith = uniqWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f8e9f368d2b1791aa424e379fbff30a2229da1d7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/uniqWith.mjs @@ -0,0 +1,13 @@ +function uniqWith(arr, areItemsEqual) { + const result = []; + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + const isUniq = result.every(v => !areItemsEqual(v, item)); + if (isUniq) { + result.push(item); + } + } + return result; +} + +export { uniqWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9b096af39ac42cf7172adf9293873c12cd5ccc5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.d.mts @@ -0,0 +1,19 @@ +/** + * 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 {Array<[...T]>} zipped - The nested array to unzip. + * @returns {Unzip} 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(zipped: ReadonlyArray<[...T]>): Unzip; +type Unzip = { + [I in keyof K]: Array; +}; + +export { unzip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9b096af39ac42cf7172adf9293873c12cd5ccc5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.d.ts @@ -0,0 +1,19 @@ +/** + * 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 {Array<[...T]>} zipped - The nested array to unzip. + * @returns {Unzip} 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(zipped: ReadonlyArray<[...T]>): Unzip; +type Unzip = { + [I in keyof K]: Array; +}; + +export { unzip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.js new file mode 100644 index 0000000000000000000000000000000000000000..91fba16506c5c4b189ecb2dafc823d6c05648694 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function unzip(zipped) { + let maxLen = 0; + for (let i = 0; i < zipped.length; i++) { + if (zipped[i].length > maxLen) { + maxLen = zipped[i].length; + } + } + const result = new Array(maxLen); + for (let i = 0; i < maxLen; i++) { + result[i] = new Array(zipped.length); + for (let j = 0; j < zipped.length; j++) { + result[i][j] = zipped[j][i]; + } + } + return result; +} + +exports.unzip = unzip; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.mjs new file mode 100644 index 0000000000000000000000000000000000000000..29b64b1eb54800cce1298598ed5515a56cfc5540 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzip.mjs @@ -0,0 +1,18 @@ +function unzip(zipped) { + let maxLen = 0; + for (let i = 0; i < zipped.length; i++) { + if (zipped[i].length > maxLen) { + maxLen = zipped[i].length; + } + } + const result = new Array(maxLen); + for (let i = 0; i < maxLen; i++) { + result[i] = new Array(zipped.length); + for (let j = 0; j < zipped.length; j++) { + result[i][j] = zipped[j][i]; + } + } + return result; +} + +export { unzip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4bd635f96063d57f3b0a3b564d48a7867e4636fb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.d.mts @@ -0,0 +1,17 @@ +/** + * Unzips an array of arrays, applying an `iteratee` function to regrouped elements. + * + * @template T, R + * @param {T[][]} target - The nested array to unzip. This is an array of arrays, + * where each inner array contains elements to be unzipped. + * @param {(...args: T[]) => R} iteratee - A function to transform the unzipped elements. + * @returns {R[]} A new array of unzipped and transformed elements. + * + * @example + * const nestedArray = [[1, 2], [3, 4], [5, 6]]; + * const result = unzipWith(nestedArray, (item, item2, item3) => item + item2 + item3); + * // result will be [9, 12] + */ +declare function unzipWith(target: readonly T[][], iteratee: (...args: T[]) => R): R[]; + +export { unzipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4bd635f96063d57f3b0a3b564d48a7867e4636fb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.d.ts @@ -0,0 +1,17 @@ +/** + * Unzips an array of arrays, applying an `iteratee` function to regrouped elements. + * + * @template T, R + * @param {T[][]} target - The nested array to unzip. This is an array of arrays, + * where each inner array contains elements to be unzipped. + * @param {(...args: T[]) => R} iteratee - A function to transform the unzipped elements. + * @returns {R[]} A new array of unzipped and transformed elements. + * + * @example + * const nestedArray = [[1, 2], [3, 4], [5, 6]]; + * const result = unzipWith(nestedArray, (item, item2, item3) => item + item2 + item3); + * // result will be [9, 12] + */ +declare function unzipWith(target: readonly T[][], iteratee: (...args: T[]) => R): R[]; + +export { unzipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.js new file mode 100644 index 0000000000000000000000000000000000000000..c41afb66af87bbda71dda0fa999fabcafd4acf49 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function unzipWith(target, iteratee) { + const maxLength = Math.max(...target.map(innerArray => innerArray.length)); + const result = new Array(maxLength); + for (let i = 0; i < maxLength; i++) { + const group = new Array(target.length); + for (let j = 0; j < target.length; j++) { + group[j] = target[j][i]; + } + result[i] = iteratee(...group); + } + return result; +} + +exports.unzipWith = unzipWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..23810f403d4ac1ba8c0e5bc40b110c6a9bf8b1dc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/unzipWith.mjs @@ -0,0 +1,14 @@ +function unzipWith(target, iteratee) { + const maxLength = Math.max(...target.map(innerArray => innerArray.length)); + const result = new Array(maxLength); + for (let i = 0; i < maxLength; i++) { + const group = new Array(target.length); + for (let j = 0; j < target.length; j++) { + group[j] = target[j][i]; + } + result[i] = iteratee(...group); + } + return result; +} + +export { unzipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..dfd21209d2b5cd614d8fe96b33041ac5b7cfea52 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.d.mts @@ -0,0 +1,50 @@ +/** + * Options for the windowed function. + * + * @interface WindowedOptions + * @property {boolean} [partialWindows=false] - Whether to include partial windows at the end of the array. + */ +interface WindowedOptions { + /** + * Whether to include partial windows at the end of the array. + * + * By default, `windowed` only includes full windows in the result, + * ignoring any leftover elements that can't form a full window. + * + * If `partialWindows` is true, the function will also include these smaller, partial windows at the end of the result. + */ + partialWindows?: boolean; +} +/** + * Creates an array of sub-arrays (windows) from the input array, each of the specified size. + * The windows can overlap depending on the step size provided. + * + * By default, only full windows are included in the result, and any leftover elements that can't form a full window are ignored. + * + * If the `partialWindows` option is set to true in the options object, the function will also include partial windows at the end of the result. + * Partial windows are smaller sub-arrays created when there aren't enough elements left in the input array to form a full window. + * + * @template T + * @param {readonly T[]} arr - The input array to create windows from. + * @param {number} size - The size of each window. Must be a positive integer. + * @param {number} [step=1] - The step size between the start of each window. Must be a positive integer. + * @param {WindowedOptions} [options={}] - Options object to configure the behavior of the function. + * @param {boolean} [options.partialWindows=false] - Whether to include partial windows at the end of the array. + * @returns {T[][]} An array of windows (sub-arrays) created from the input array. + * @throws {Error} If the size or step is not a positive integer. + * + * @example + * windowed([1, 2, 3, 4], 2); + * // => [[1, 2], [2, 3], [3, 4]] + * + * @example + * windowed([1, 2, 3, 4, 5, 6], 3, 2); + * // => [[1, 2, 3], [3, 4, 5]] + * + * @example + * windowed([1, 2, 3, 4, 5, 6], 3, 2, { partialWindows: true }); + * // => [[1, 2, 3], [3, 4, 5], [5, 6]] + */ +declare function windowed(arr: readonly T[], size: number, step?: number, { partialWindows }?: WindowedOptions): T[][]; + +export { type WindowedOptions, windowed }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dfd21209d2b5cd614d8fe96b33041ac5b7cfea52 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.d.ts @@ -0,0 +1,50 @@ +/** + * Options for the windowed function. + * + * @interface WindowedOptions + * @property {boolean} [partialWindows=false] - Whether to include partial windows at the end of the array. + */ +interface WindowedOptions { + /** + * Whether to include partial windows at the end of the array. + * + * By default, `windowed` only includes full windows in the result, + * ignoring any leftover elements that can't form a full window. + * + * If `partialWindows` is true, the function will also include these smaller, partial windows at the end of the result. + */ + partialWindows?: boolean; +} +/** + * Creates an array of sub-arrays (windows) from the input array, each of the specified size. + * The windows can overlap depending on the step size provided. + * + * By default, only full windows are included in the result, and any leftover elements that can't form a full window are ignored. + * + * If the `partialWindows` option is set to true in the options object, the function will also include partial windows at the end of the result. + * Partial windows are smaller sub-arrays created when there aren't enough elements left in the input array to form a full window. + * + * @template T + * @param {readonly T[]} arr - The input array to create windows from. + * @param {number} size - The size of each window. Must be a positive integer. + * @param {number} [step=1] - The step size between the start of each window. Must be a positive integer. + * @param {WindowedOptions} [options={}] - Options object to configure the behavior of the function. + * @param {boolean} [options.partialWindows=false] - Whether to include partial windows at the end of the array. + * @returns {T[][]} An array of windows (sub-arrays) created from the input array. + * @throws {Error} If the size or step is not a positive integer. + * + * @example + * windowed([1, 2, 3, 4], 2); + * // => [[1, 2], [2, 3], [3, 4]] + * + * @example + * windowed([1, 2, 3, 4, 5, 6], 3, 2); + * // => [[1, 2, 3], [3, 4, 5]] + * + * @example + * windowed([1, 2, 3, 4, 5, 6], 3, 2, { partialWindows: true }); + * // => [[1, 2, 3], [3, 4, 5], [5, 6]] + */ +declare function windowed(arr: readonly T[], size: number, step?: number, { partialWindows }?: WindowedOptions): T[][]; + +export { type WindowedOptions, windowed }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.js new file mode 100644 index 0000000000000000000000000000000000000000..b565b66d5ca7913f55297c8fd50121df75477b21 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function windowed(arr, size, step = 1, { partialWindows = false } = {}) { + if (size <= 0 || !Number.isInteger(size)) { + throw new Error('Size must be a positive integer.'); + } + if (step <= 0 || !Number.isInteger(step)) { + throw new Error('Step must be a positive integer.'); + } + const result = []; + const end = partialWindows ? arr.length : arr.length - size + 1; + for (let i = 0; i < end; i += step) { + result.push(arr.slice(i, i + size)); + } + return result; +} + +exports.windowed = windowed; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d476e5dc05df3a2bdc1a5d7daf9bed88a3daaaff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/windowed.mjs @@ -0,0 +1,16 @@ +function windowed(arr, size, step = 1, { partialWindows = false } = {}) { + if (size <= 0 || !Number.isInteger(size)) { + throw new Error('Size must be a positive integer.'); + } + if (step <= 0 || !Number.isInteger(step)) { + throw new Error('Step must be a positive integer.'); + } + const result = []; + const end = partialWindows ? arr.length : arr.length - size + 1; + for (let i = 0; i < end; i += step) { + result.push(arr.slice(i, i + size)); + } + return result; +} + +export { windowed }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..882430789550d8048a6b468c91a62aeaffe16459 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {T[]} 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: readonly T[], ...values: T[]): T[]; + +export { without }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..882430789550d8048a6b468c91a62aeaffe16459 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {T[]} 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: readonly T[], ...values: T[]): T[]; + +export { without }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.js new file mode 100644 index 0000000000000000000000000000000000000000..35a381c3cf934a56f58bb4fb4064ff6fbed4153a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const difference = require('./difference.js'); + +function without(array, ...values) { + return difference.difference(array, values); +} + +exports.without = without; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1ba1bc413c7e64483d81afd247d21ea7b3ff7e54 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/without.mjs @@ -0,0 +1,7 @@ +import { difference } from './difference.mjs'; + +function without(array, ...values) { + return difference(array, values); +} + +export { without }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e4025168dfe27a6db519a738a9bbefd6990e414f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.d.mts @@ -0,0 +1,20 @@ +/** + * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements + * which are in either of the arrays, but not in their intersection. + * + * @template T - The type of elements in the array. + * @param {T[]} arr1 - The first array. + * @param {T[]} arr2 - The second array. + * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both. + * + * @example + * // Returns [1, 2, 5, 6] + * xor([1, 2, 3, 4], [3, 4, 5, 6]); + * + * @example + * // Returns ['a', 'c'] + * xor(['a', 'b'], ['b', 'c']); + */ +declare function xor(arr1: readonly T[], arr2: readonly T[]): T[]; + +export { xor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e4025168dfe27a6db519a738a9bbefd6990e414f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.d.ts @@ -0,0 +1,20 @@ +/** + * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements + * which are in either of the arrays, but not in their intersection. + * + * @template T - The type of elements in the array. + * @param {T[]} arr1 - The first array. + * @param {T[]} arr2 - The second array. + * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both. + * + * @example + * // Returns [1, 2, 5, 6] + * xor([1, 2, 3, 4], [3, 4, 5, 6]); + * + * @example + * // Returns ['a', 'c'] + * xor(['a', 'b'], ['b', 'c']); + */ +declare function xor(arr1: readonly T[], arr2: readonly T[]): T[]; + +export { xor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.js new file mode 100644 index 0000000000000000000000000000000000000000..027340f69502818e176755ab2dc2c1c6f9a0a18a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const difference = require('./difference.js'); +const intersection = require('./intersection.js'); +const union = require('./union.js'); + +function xor(arr1, arr2) { + return difference.difference(union.union(arr1, arr2), intersection.intersection(arr1, arr2)); +} + +exports.xor = xor; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9632ea39f064115ef315a7a2e0f40b27db6c30b4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xor.mjs @@ -0,0 +1,9 @@ +import { difference } from './difference.mjs'; +import { intersection } from './intersection.mjs'; +import { union } from './union.mjs'; + +function xor(arr1, arr2) { + return difference(union(arr1, arr2), intersection(arr1, arr2)); +} + +export { xor }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7375e7e9709d4b35e45dab2e7e40184bcf2fd0e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.d.mts @@ -0,0 +1,22 @@ +/** + * Computes the symmetric difference between two arrays using a custom mapping function. + * The symmetric difference is the set of elements which are in either of the arrays, + * but not in their intersection, determined by the result of the mapping function. + * + * @template T - Type of elements in the input arrays. + * @template U - Type of the values returned by the mapping function. + * + * @param {T[]} arr1 - The first array. + * @param {T[]} arr2 - The second array. + * @param {(item: T) => U} mapper - The function to map array elements to comparison values. + * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function. + * + * @example + * // Custom mapping function for objects with an 'id' property + * const idMapper = obj => obj.id; + * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper); + * // Returns [{ id: 1 }, { id: 3 }] + */ +declare function xorBy(arr1: readonly T[], arr2: readonly T[], mapper: (item: T) => U): T[]; + +export { xorBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7375e7e9709d4b35e45dab2e7e40184bcf2fd0e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.d.ts @@ -0,0 +1,22 @@ +/** + * Computes the symmetric difference between two arrays using a custom mapping function. + * The symmetric difference is the set of elements which are in either of the arrays, + * but not in their intersection, determined by the result of the mapping function. + * + * @template T - Type of elements in the input arrays. + * @template U - Type of the values returned by the mapping function. + * + * @param {T[]} arr1 - The first array. + * @param {T[]} arr2 - The second array. + * @param {(item: T) => U} mapper - The function to map array elements to comparison values. + * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function. + * + * @example + * // Custom mapping function for objects with an 'id' property + * const idMapper = obj => obj.id; + * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper); + * // Returns [{ id: 1 }, { id: 3 }] + */ +declare function xorBy(arr1: readonly T[], arr2: readonly T[], mapper: (item: T) => U): T[]; + +export { xorBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.js new file mode 100644 index 0000000000000000000000000000000000000000..baf516b1bc809b0a0e426c7eeef5b05d5d8cb609 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const differenceBy = require('./differenceBy.js'); +const intersectionBy = require('./intersectionBy.js'); +const unionBy = require('./unionBy.js'); + +function xorBy(arr1, arr2, mapper) { + const union = unionBy.unionBy(arr1, arr2, mapper); + const intersection = intersectionBy.intersectionBy(arr1, arr2, mapper); + return differenceBy.differenceBy(union, intersection, mapper); +} + +exports.xorBy = xorBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d3798586317a1bf2b0897430dc86924305b07b8d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorBy.mjs @@ -0,0 +1,11 @@ +import { differenceBy } from './differenceBy.mjs'; +import { intersectionBy } from './intersectionBy.mjs'; +import { unionBy } from './unionBy.mjs'; + +function xorBy(arr1, arr2, mapper) { + const union = unionBy(arr1, arr2, mapper); + const intersection = intersectionBy(arr1, arr2, mapper); + return differenceBy(union, intersection, mapper); +} + +export { xorBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1aff58fb7ddfc01ed65cb561fa85101b2db112ac --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.d.mts @@ -0,0 +1,21 @@ +/** + * Computes the symmetric difference between two arrays using a custom equality function. + * The symmetric difference is the set of elements which are in either of the arrays, + * but not in their intersection. + * + * @template T - Type of elements in the input arrays. + * + * @param {T[]} arr1 - The first array. + * @param {T[]} arr2 - The second array. + * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements. + * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function. + * + * @example + * // Custom equality function for objects with an 'id' property + * const areObjectsEqual = (a, b) => a.id === b.id; + * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual); + * // Returns [{ id: 1 }, { id: 3 }] + */ +declare function xorWith(arr1: readonly T[], arr2: readonly T[], areElementsEqual: (item1: T, item2: T) => boolean): T[]; + +export { xorWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1aff58fb7ddfc01ed65cb561fa85101b2db112ac --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.d.ts @@ -0,0 +1,21 @@ +/** + * Computes the symmetric difference between two arrays using a custom equality function. + * The symmetric difference is the set of elements which are in either of the arrays, + * but not in their intersection. + * + * @template T - Type of elements in the input arrays. + * + * @param {T[]} arr1 - The first array. + * @param {T[]} arr2 - The second array. + * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements. + * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function. + * + * @example + * // Custom equality function for objects with an 'id' property + * const areObjectsEqual = (a, b) => a.id === b.id; + * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual); + * // Returns [{ id: 1 }, { id: 3 }] + */ +declare function xorWith(arr1: readonly T[], arr2: readonly T[], areElementsEqual: (item1: T, item2: T) => boolean): T[]; + +export { xorWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.js new file mode 100644 index 0000000000000000000000000000000000000000..54f7264317c45d5c8401f81183f4b3e67e5f12ec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const differenceWith = require('./differenceWith.js'); +const intersectionWith = require('./intersectionWith.js'); +const unionWith = require('./unionWith.js'); + +function xorWith(arr1, arr2, areElementsEqual) { + const union = unionWith.unionWith(arr1, arr2, areElementsEqual); + const intersection = intersectionWith.intersectionWith(arr1, arr2, areElementsEqual); + return differenceWith.differenceWith(union, intersection, areElementsEqual); +} + +exports.xorWith = xorWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a6b316bd0d108d20fe97facc763deab66079702c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/xorWith.mjs @@ -0,0 +1,11 @@ +import { differenceWith } from './differenceWith.mjs'; +import { intersectionWith } from './intersectionWith.mjs'; +import { unionWith } from './unionWith.mjs'; + +function xorWith(arr1, arr2, areElementsEqual) { + const union = unionWith(arr1, arr2, areElementsEqual); + const intersection = intersectionWith(arr1, arr2, areElementsEqual); + return differenceWith(union, intersection, areElementsEqual); +} + +export { xorWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c306f957630859f446bef8dcfce174b7656e17fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.d.mts @@ -0,0 +1,106 @@ +/** + * 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 {T[]} arr1 - The first array to zip. + * @returns {Array<[T]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const result = zip(arr1); + * // result will be [[1], [2], [3]] + */ +declare function zip(arr1: readonly T[]): Array<[T]>; +/** + * 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @returns {Array<[T, U]>} 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']] + */ +declare function zip(arr1: readonly T[], arr2: readonly U[]): Array<[T, U]>; +/** + * 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @param {V[]} arr3 - The third array to zip. + * @returns {Array<[T, U, V]>} 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]] + */ +declare function zip(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[]): Array<[T, U, V]>; +/** + * 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @param {V[]} arr3 - The third array to zip. + * @param {W[]} arr4 - The fourth array to zip. + * @returns {Array<[T, U, V, W]>} 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]] + */ +declare function zip(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): Array<[T, U, V, W]>; +/** + * 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} arrs - The arrays to zip together. + * @returns {T[][]} 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]] + */ +declare function zip(...arrs: Array): T[][]; + +export { zip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c306f957630859f446bef8dcfce174b7656e17fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.d.ts @@ -0,0 +1,106 @@ +/** + * 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 {T[]} arr1 - The first array to zip. + * @returns {Array<[T]>} A new array of tuples containing the corresponding elements from the input arrays. + * + * @example + * const arr1 = [1, 2, 3]; + * const result = zip(arr1); + * // result will be [[1], [2], [3]] + */ +declare function zip(arr1: readonly T[]): Array<[T]>; +/** + * 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @returns {Array<[T, U]>} 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']] + */ +declare function zip(arr1: readonly T[], arr2: readonly U[]): Array<[T, U]>; +/** + * 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @param {V[]} arr3 - The third array to zip. + * @returns {Array<[T, U, V]>} 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]] + */ +declare function zip(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[]): Array<[T, U, V]>; +/** + * 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @param {V[]} arr3 - The third array to zip. + * @param {W[]} arr4 - The fourth array to zip. + * @returns {Array<[T, U, V, W]>} 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]] + */ +declare function zip(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): Array<[T, U, V, W]>; +/** + * 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} arrs - The arrays to zip together. + * @returns {T[][]} 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]] + */ +declare function zip(...arrs: Array): T[][]; + +export { zip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.js new file mode 100644 index 0000000000000000000000000000000000000000..19d7b440b5b8a3d1e69d5eaec44dd9d45807debc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function zip(...arrs) { + let rowCount = 0; + for (let i = 0; i < arrs.length; i++) { + if (arrs[i].length > rowCount) { + rowCount = arrs[i].length; + } + } + const columnCount = arrs.length; + const result = Array(rowCount); + for (let i = 0; i < rowCount; ++i) { + const row = Array(columnCount); + for (let j = 0; j < columnCount; ++j) { + row[j] = arrs[j][i]; + } + result[i] = row; + } + return result; +} + +exports.zip = zip; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.mjs new file mode 100644 index 0000000000000000000000000000000000000000..60ece2128bd86ffb545df78e614f60f980c23afd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zip.mjs @@ -0,0 +1,20 @@ +function zip(...arrs) { + let rowCount = 0; + for (let i = 0; i < arrs.length; i++) { + if (arrs[i].length > rowCount) { + rowCount = arrs[i].length; + } + } + const columnCount = arrs.length; + const result = Array(rowCount); + for (let i = 0; i < rowCount; ++i) { + const row = Array(columnCount); + for (let j = 0; j < columnCount; ++j) { + row[j] = arrs[j][i]; + } + result[i] = row; + } + return result; +} + +export { zip }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f761a01ebafcb616af030aa9c0fb9bbbd29a6ae4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.d.mts @@ -0,0 +1,33 @@ +/** + * Combines two arrays, one of property names and one of corresponding values, into a single object. + * + * This function takes two arrays: one containing property names and another containing corresponding values. + * It returns a new object where the property names from the first array are keys, and the corresponding elements + * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will + * have `undefined` as their values. + * + * @template P - The type of elements in the array. + * @template V - The type of elements in the array. + * @param {P[]} keys - An array of property names. + * @param {V[]} 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 keys = ['a', 'b', 'c']; + * const values = [1, 2, 3]; + * const result = zipObject(keys, values); + * // result will be { a: 1, b: 2, c: 3 } + * + * const keys2 = ['a', 'b', 'c']; + * const values2 = [1, 2]; + * const result2 = zipObject(keys2, values2); + * // result2 will be { a: 1, b: 2, c: undefined } + * + * const keys2 = ['a', 'b']; + * const values2 = [1, 2, 3]; + * const result2 = zipObject(keys2, values2); + * // result2 will be { a: 1, b: 2 } + */ +declare function zipObject

(keys: readonly P[], values: readonly V[]): Record; + +export { zipObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f761a01ebafcb616af030aa9c0fb9bbbd29a6ae4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.d.ts @@ -0,0 +1,33 @@ +/** + * Combines two arrays, one of property names and one of corresponding values, into a single object. + * + * This function takes two arrays: one containing property names and another containing corresponding values. + * It returns a new object where the property names from the first array are keys, and the corresponding elements + * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will + * have `undefined` as their values. + * + * @template P - The type of elements in the array. + * @template V - The type of elements in the array. + * @param {P[]} keys - An array of property names. + * @param {V[]} 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 keys = ['a', 'b', 'c']; + * const values = [1, 2, 3]; + * const result = zipObject(keys, values); + * // result will be { a: 1, b: 2, c: 3 } + * + * const keys2 = ['a', 'b', 'c']; + * const values2 = [1, 2]; + * const result2 = zipObject(keys2, values2); + * // result2 will be { a: 1, b: 2, c: undefined } + * + * const keys2 = ['a', 'b']; + * const values2 = [1, 2, 3]; + * const result2 = zipObject(keys2, values2); + * // result2 will be { a: 1, b: 2 } + */ +declare function zipObject

(keys: readonly P[], values: readonly V[]): Record; + +export { zipObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.js new file mode 100644 index 0000000000000000000000000000000000000000..4ff4c8cd7b3e0249f8a0e56bf34086ad9e4b2f4e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function zipObject(keys, values) { + const result = {}; + for (let i = 0; i < keys.length; i++) { + result[keys[i]] = values[i]; + } + return result; +} + +exports.zipObject = zipObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0de346d34b65aec5a8d4b601924f5f6768a74957 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipObject.mjs @@ -0,0 +1,9 @@ +function zipObject(keys, values) { + const result = {}; + for (let i = 0; i < keys.length; i++) { + result[keys[i]] = values[i]; + } + return result; +} + +export { zipObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0508a8b70753d58791cc06fe4da2528106ba834f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.d.mts @@ -0,0 +1,72 @@ +/** + * Combines multiple arrays into a single array using a custom combiner function. + * + * This function takes multiple arrays and a combiner function, and returns a new array where each element + * is the result of applying the combiner function to the corresponding elements of the input arrays. + * + * @template T - The type of elements in the first array. + * @template R - The type of elements in the resulting array. + * @param {T[]} arr1 - The first array to zip. + * @param {(...items: 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. + * + * @example + * // Example usage with two arrays: + * const arr1 = [1, 2, 3]; + * const arr2 = [4, 5, 6]; + * const result = zipWith(arr1, arr2, (a, b) => a + b); + * // result will be [5, 7, 9] + * + * @example + * // Example usage with three arrays: + * const arr1 = [1, 2]; + * const arr2 = [3, 4]; + * const arr3 = [5, 6]; + * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`); + * // result will be [`135`, `246`] + */ +declare function zipWith(arr1: readonly T[], 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 {T[]} arr1 - The first array to zip. + * @param {U[]} 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: readonly T[], arr2: readonly U[], 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @param {V[]} 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: readonly T[], arr2: readonly U[], arr3: readonly V[], 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @param {V[]} arr3 - The third array to zip. + * @param {W[]} 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: readonly T[], arr2: readonly U[], arr3: readonly V[], arr4: readonly W[], combine: (item1: T, item2: U, item3: V, item4: W) => R): R[]; + +export { zipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0508a8b70753d58791cc06fe4da2528106ba834f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.d.ts @@ -0,0 +1,72 @@ +/** + * Combines multiple arrays into a single array using a custom combiner function. + * + * This function takes multiple arrays and a combiner function, and returns a new array where each element + * is the result of applying the combiner function to the corresponding elements of the input arrays. + * + * @template T - The type of elements in the first array. + * @template R - The type of elements in the resulting array. + * @param {T[]} arr1 - The first array to zip. + * @param {(...items: 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. + * + * @example + * // Example usage with two arrays: + * const arr1 = [1, 2, 3]; + * const arr2 = [4, 5, 6]; + * const result = zipWith(arr1, arr2, (a, b) => a + b); + * // result will be [5, 7, 9] + * + * @example + * // Example usage with three arrays: + * const arr1 = [1, 2]; + * const arr2 = [3, 4]; + * const arr3 = [5, 6]; + * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`); + * // result will be [`135`, `246`] + */ +declare function zipWith(arr1: readonly T[], 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 {T[]} arr1 - The first array to zip. + * @param {U[]} 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: readonly T[], arr2: readonly U[], 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @param {V[]} 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: readonly T[], arr2: readonly U[], arr3: readonly V[], 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 {T[]} arr1 - The first array to zip. + * @param {U[]} arr2 - The second array to zip. + * @param {V[]} arr3 - The third array to zip. + * @param {W[]} 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: readonly T[], arr2: readonly U[], arr3: readonly V[], arr4: readonly W[], combine: (item1: T, item2: U, item3: V, item4: W) => R): R[]; + +export { zipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.js new file mode 100644 index 0000000000000000000000000000000000000000..dad89b0cdddf150876da2991731e49dbb9fe0ac2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function zipWith(arr1, ...rest) { + const arrs = [arr1, ...rest.slice(0, -1)]; + const combine = rest[rest.length - 1]; + const maxIndex = Math.max(...arrs.map(arr => arr.length)); + const result = Array(maxIndex); + for (let i = 0; i < maxIndex; i++) { + const elements = arrs.map(arr => arr[i]); + result[i] = combine(...elements); + } + return result; +} + +exports.zipWith = zipWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ddd31ad815b42c877aa024f3cb3058f82794c74d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/array/zipWith.mjs @@ -0,0 +1,13 @@ +function zipWith(arr1, ...rest) { + const arrs = [arr1, ...rest.slice(0, -1)]; + const combine = rest[rest.length - 1]; + const maxIndex = Math.max(...arrs.map(arr => arr.length)); + const result = Array(maxIndex); + for (let i = 0; i < maxIndex; i++) { + const elements = arrs.map(arr => arr[i]); + result[i] = combine(...elements); + } + return result; +} + +export { zipWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ArrayIterator.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ArrayIterator.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cef4fddda37c6f45e81d7c1391f38af88e089eba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ArrayIterator.d.mts @@ -0,0 +1,3 @@ +type ArrayIterator = (value: T, index: number, collection: T[]) => R; + +export type { ArrayIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ArrayIterator.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ArrayIterator.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cef4fddda37c6f45e81d7c1391f38af88e089eba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ArrayIterator.d.ts @@ -0,0 +1,3 @@ +type ArrayIterator = (value: T, index: number, collection: T[]) => R; + +export type { ArrayIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ConformsPredicateObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ConformsPredicateObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bac85d8bc5ee3793faaa1287a86d2a71b99e6c61 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ConformsPredicateObject.d.mts @@ -0,0 +1,5 @@ +type ConformsPredicateObject = { + [P in keyof T]: T[P] extends (arg: infer A) => any ? A : any; +}; + +export type { ConformsPredicateObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ConformsPredicateObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ConformsPredicateObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bac85d8bc5ee3793faaa1287a86d2a71b99e6c61 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ConformsPredicateObject.d.ts @@ -0,0 +1,5 @@ +type ConformsPredicateObject = { + [P in keyof T]: T[P] extends (arg: infer A) => any ? A : any; +}; + +export type { ConformsPredicateObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/EmptyObjectOf.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/EmptyObjectOf.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9b370c0c029ed1a7e278f15acc78d1d4c9000b45 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/EmptyObjectOf.d.mts @@ -0,0 +1,6 @@ +type EmptyObject = { + [K in keyof T]?: never; +}; +type EmptyObjectOf = EmptyObject extends T ? EmptyObject : never; + +export type { EmptyObjectOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/EmptyObjectOf.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/EmptyObjectOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9b370c0c029ed1a7e278f15acc78d1d4c9000b45 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/EmptyObjectOf.d.ts @@ -0,0 +1,6 @@ +type EmptyObject = { + [K in keyof T]?: never; +}; +type EmptyObjectOf = EmptyObject extends T ? EmptyObject : never; + +export type { EmptyObjectOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/GetFieldType.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/GetFieldType.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4ccf8df1072614820eff55d45c9b9dfbee6a0042 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/GetFieldType.d.mts @@ -0,0 +1,12 @@ +type GetFieldTypeOfArrayLikeByKey = K extends number ? T[K] : K extends `${infer N extends number}` ? T[N] : K extends keyof T ? T[K] : undefined; +type GetFieldTypeOfStringByKey = K extends number ? T[K] : K extends `${infer N extends number}` ? T[N] : K extends keyof T ? T[K] : undefined; +type GetFieldTypeOfNarrowedByKey = T extends unknown[] ? GetFieldTypeOfArrayLikeByKey : T extends string ? GetFieldTypeOfStringByKey : K extends keyof T ? T[K] : K extends number ? `${K}` extends keyof T ? T[`${K}`] : undefined : K extends `${infer N extends number}` ? N extends keyof T ? T[N] : undefined : undefined; +type GetFieldTypeOfNarrowedByDotPath = P extends `${infer L}.${infer R}` ? GetFieldType, R, 'DotPath'> : GetFieldTypeOfNarrowedByKey; +type GetFieldTypeOfNarrowedByLcKR = '' extends R ? GetFieldType, K, 'Key'> : R extends `.${infer Rc}` ? GetFieldType, K, 'Key'>, Rc> : GetFieldType, K, 'Key'>, R>; +type GetFieldTypeOfNarrowedByLKR = '' extends L ? '' extends R ? GetFieldTypeOfNarrowedByKey : R extends `.${infer Rc}` ? GetFieldType, Rc> : GetFieldType, R> : L extends `${infer Lc}.` ? GetFieldTypeOfNarrowedByLcKR : GetFieldTypeOfNarrowedByLcKR; +type GetFieldTypeOfNarrowed = XT extends 'Key' ? GetFieldTypeOfNarrowedByKey : XT extends 'DotPath' ? GetFieldTypeOfNarrowedByDotPath : X extends `${infer L}['${infer K}']${infer R}` ? GetFieldTypeOfNarrowedByLKR : X extends `${infer L}["${infer K}"]${infer R}` ? GetFieldTypeOfNarrowedByLKR : X extends `${infer L}[${infer K}]${infer R}` ? GetFieldTypeOfNarrowedByLKR : GetFieldTypeOfNarrowedByDotPath; +type GetFieldTypeOfObject = Extract extends never ? GetFieldTypeOfNarrowed : GetFieldTypeOfNarrowed, X, XT> | GetFieldTypeOfNarrowed, X, XT>; +type GetFieldTypeOfPrimitive = Extract extends never ? T extends never ? never : undefined : (Exclude extends never ? never : undefined) | GetFieldTypeOfNarrowed, X, XT>; +type GetFieldType = Extract extends never ? GetFieldTypeOfPrimitive : GetFieldTypeOfPrimitive, X, XT> | GetFieldTypeOfObject, X, XT>; + +export type { GetFieldType }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/GetFieldType.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/GetFieldType.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4ccf8df1072614820eff55d45c9b9dfbee6a0042 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/GetFieldType.d.ts @@ -0,0 +1,12 @@ +type GetFieldTypeOfArrayLikeByKey = K extends number ? T[K] : K extends `${infer N extends number}` ? T[N] : K extends keyof T ? T[K] : undefined; +type GetFieldTypeOfStringByKey = K extends number ? T[K] : K extends `${infer N extends number}` ? T[N] : K extends keyof T ? T[K] : undefined; +type GetFieldTypeOfNarrowedByKey = T extends unknown[] ? GetFieldTypeOfArrayLikeByKey : T extends string ? GetFieldTypeOfStringByKey : K extends keyof T ? T[K] : K extends number ? `${K}` extends keyof T ? T[`${K}`] : undefined : K extends `${infer N extends number}` ? N extends keyof T ? T[N] : undefined : undefined; +type GetFieldTypeOfNarrowedByDotPath = P extends `${infer L}.${infer R}` ? GetFieldType, R, 'DotPath'> : GetFieldTypeOfNarrowedByKey; +type GetFieldTypeOfNarrowedByLcKR = '' extends R ? GetFieldType, K, 'Key'> : R extends `.${infer Rc}` ? GetFieldType, K, 'Key'>, Rc> : GetFieldType, K, 'Key'>, R>; +type GetFieldTypeOfNarrowedByLKR = '' extends L ? '' extends R ? GetFieldTypeOfNarrowedByKey : R extends `.${infer Rc}` ? GetFieldType, Rc> : GetFieldType, R> : L extends `${infer Lc}.` ? GetFieldTypeOfNarrowedByLcKR : GetFieldTypeOfNarrowedByLcKR; +type GetFieldTypeOfNarrowed = XT extends 'Key' ? GetFieldTypeOfNarrowedByKey : XT extends 'DotPath' ? GetFieldTypeOfNarrowedByDotPath : X extends `${infer L}['${infer K}']${infer R}` ? GetFieldTypeOfNarrowedByLKR : X extends `${infer L}["${infer K}"]${infer R}` ? GetFieldTypeOfNarrowedByLKR : X extends `${infer L}[${infer K}]${infer R}` ? GetFieldTypeOfNarrowedByLKR : GetFieldTypeOfNarrowedByDotPath; +type GetFieldTypeOfObject = Extract extends never ? GetFieldTypeOfNarrowed : GetFieldTypeOfNarrowed, X, XT> | GetFieldTypeOfNarrowed, X, XT>; +type GetFieldTypeOfPrimitive = Extract extends never ? T extends never ? never : undefined : (Exclude extends never ? never : undefined) | GetFieldTypeOfNarrowed, X, XT>; +type GetFieldType = Extract extends never ? GetFieldTypeOfPrimitive : GetFieldTypeOfPrimitive, X, XT> | GetFieldTypeOfObject, X, XT>; + +export type { GetFieldType }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsEqualCustomizer.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsEqualCustomizer.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ab00e63495d59740c42dd74fcb45bdb66fa72acc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsEqualCustomizer.d.mts @@ -0,0 +1,3 @@ +type IsEqualCustomizer = (value: any, other: any, indexOrKey: PropertyKey | undefined, parent: any, otherParent: any, stack: any) => boolean | undefined; + +export type { IsEqualCustomizer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsEqualCustomizer.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsEqualCustomizer.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ab00e63495d59740c42dd74fcb45bdb66fa72acc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsEqualCustomizer.d.ts @@ -0,0 +1,3 @@ +type IsEqualCustomizer = (value: any, other: any, indexOrKey: PropertyKey | undefined, parent: any, otherParent: any, stack: any) => boolean | undefined; + +export type { IsEqualCustomizer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsMatchWithCustomizer.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsMatchWithCustomizer.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..166966d094a118cceb6856862bd74dd5058f7198 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsMatchWithCustomizer.d.mts @@ -0,0 +1,3 @@ +type IsMatchWithCustomizer = (value: any, other: any, indexOrKey: PropertyKey, object: object, source: object) => boolean | undefined; + +export type { IsMatchWithCustomizer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsMatchWithCustomizer.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsMatchWithCustomizer.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..166966d094a118cceb6856862bd74dd5058f7198 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IsMatchWithCustomizer.d.ts @@ -0,0 +1,3 @@ +type IsMatchWithCustomizer = (value: any, other: any, indexOrKey: PropertyKey, object: object, source: object) => boolean | undefined; + +export type { IsMatchWithCustomizer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IterateeShorthand.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IterateeShorthand.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..767ed7d61bafc7a41c1d501aead563b9a0ec0276 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IterateeShorthand.d.mts @@ -0,0 +1,5 @@ +import { PartialShallow } from './PartialShallow.mjs'; + +type IterateeShorthand = PropertyKey | [PropertyKey, any] | PartialShallow; + +export type { IterateeShorthand }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IterateeShorthand.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IterateeShorthand.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bd0c192000a2f0ce653316bab518f99346fcef07 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/IterateeShorthand.d.ts @@ -0,0 +1,5 @@ +import { PartialShallow } from './PartialShallow.js'; + +type IterateeShorthand = PropertyKey | [PropertyKey, any] | PartialShallow; + +export type { IterateeShorthand }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratee.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratee.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5e7b3d8bd8664cf342dd02357d3236c712a9ee26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratee.d.mts @@ -0,0 +1,5 @@ +import { PartialShallow } from './PartialShallow.mjs'; + +type ListIteratee = ((value: T, index: number, collection: ArrayLike) => unknown) | (PropertyKey | [PropertyKey, any] | PartialShallow); + +export type { ListIteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratee.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratee.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bf58eecaa389121e2cab8df65ab6f27954f30d77 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratee.d.ts @@ -0,0 +1,5 @@ +import { PartialShallow } from './PartialShallow.js'; + +type ListIteratee = ((value: T, index: number, collection: ArrayLike) => unknown) | (PropertyKey | [PropertyKey, any] | PartialShallow); + +export type { ListIteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterateeCustom.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterateeCustom.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..85f5163327f020f4cfff5637bf2d9f582acb23a2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterateeCustom.d.mts @@ -0,0 +1,5 @@ +import { PartialShallow } from './PartialShallow.mjs'; + +type ListIterateeCustom = ((value: T, index: number, collection: ArrayLike) => R) | (PropertyKey | [PropertyKey, any] | PartialShallow); + +export type { ListIterateeCustom }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterateeCustom.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterateeCustom.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8ae6916ea737bf3a55b82707b96818f053b3e57c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterateeCustom.d.ts @@ -0,0 +1,5 @@ +import { PartialShallow } from './PartialShallow.js'; + +type ListIterateeCustom = ((value: T, index: number, collection: ArrayLike) => R) | (PropertyKey | [PropertyKey, any] | PartialShallow); + +export type { ListIterateeCustom }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterator.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterator.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..56340dfc308a64e1dcb095b88ec07047d4b25e45 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterator.d.mts @@ -0,0 +1,3 @@ +type ListIterator = (value: T, index: number, collection: ArrayLike) => R; + +export type { ListIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterator.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterator.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..56340dfc308a64e1dcb095b88ec07047d4b25e45 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIterator.d.ts @@ -0,0 +1,3 @@ +type ListIterator = (value: T, index: number, collection: ArrayLike) => R; + +export type { ListIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratorTypeGuard.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratorTypeGuard.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..78a872e34ddac6d36501f079c332e329a3b3fdfb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratorTypeGuard.d.mts @@ -0,0 +1,3 @@ +type ListIteratorTypeGuard = (value: T, index: number, collection: ArrayLike) => value is S; + +export type { ListIteratorTypeGuard }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratorTypeGuard.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratorTypeGuard.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..78a872e34ddac6d36501f079c332e329a3b3fdfb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListIteratorTypeGuard.d.ts @@ -0,0 +1,3 @@ +type ListIteratorTypeGuard = (value: T, index: number, collection: ArrayLike) => value is S; + +export type { ListIteratorTypeGuard }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListOfRecursiveArraysOrValues.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListOfRecursiveArraysOrValues.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cd1e1d20faddd478b7a2110e1f54505549ace1a4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListOfRecursiveArraysOrValues.d.mts @@ -0,0 +1,6 @@ +import { RecursiveArray } from './RecursiveArray.mjs'; + +interface ListOfRecursiveArraysOrValues extends ArrayLike> { +} + +export type { ListOfRecursiveArraysOrValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListOfRecursiveArraysOrValues.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListOfRecursiveArraysOrValues.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f23a76d8da522605f74c00ccdea742a3785d25d1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ListOfRecursiveArraysOrValues.d.ts @@ -0,0 +1,6 @@ +import { RecursiveArray } from './RecursiveArray.js'; + +interface ListOfRecursiveArraysOrValues extends ArrayLike> { +} + +export type { ListOfRecursiveArraysOrValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_ARRAY_LENGTH.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_ARRAY_LENGTH.js new file mode 100644 index 0000000000000000000000000000000000000000..e135b1c91a8fb85f5f5131e6e094c1c6d1442b18 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_ARRAY_LENGTH.js @@ -0,0 +1,7 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const MAX_ARRAY_LENGTH = 4_294_967_295; + +exports.MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_ARRAY_LENGTH.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_ARRAY_LENGTH.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6673a50910c1653a7a80b9a2c0ae9e9e346d87d8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_ARRAY_LENGTH.mjs @@ -0,0 +1,3 @@ +const MAX_ARRAY_LENGTH = 4_294_967_295; + +export { MAX_ARRAY_LENGTH }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_SAFE_INTEGER.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_SAFE_INTEGER.js new file mode 100644 index 0000000000000000000000000000000000000000..f6c837caf5f34c6f2b2b59d82483f9310acae389 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_SAFE_INTEGER.js @@ -0,0 +1,7 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER; + +exports.MAX_SAFE_INTEGER = MAX_SAFE_INTEGER; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_SAFE_INTEGER.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_SAFE_INTEGER.mjs new file mode 100644 index 0000000000000000000000000000000000000000..63706aa4f58985136edde28fbb8e74b7429cd249 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MAX_SAFE_INTEGER.mjs @@ -0,0 +1,3 @@ +const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER; + +export { MAX_SAFE_INTEGER }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/Many.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/Many.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5620f6af8aa0f3577fda4e2464c55b639e384742 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/Many.d.mts @@ -0,0 +1,3 @@ +type Many = T | readonly T[]; + +export type { Many }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/Many.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/Many.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5620f6af8aa0f3577fda4e2464c55b639e384742 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/Many.d.ts @@ -0,0 +1,3 @@ +type Many = T | readonly T[]; + +export type { Many }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoListIterator.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoListIterator.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cf4b27c4c0de028bafd9815d344ded5c904014d7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoListIterator.d.mts @@ -0,0 +1,3 @@ +type MemoListIterator = (prev: R, curr: T, index: number, list: A) => R; + +export type { MemoListIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoListIterator.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoListIterator.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cf4b27c4c0de028bafd9815d344ded5c904014d7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoListIterator.d.ts @@ -0,0 +1,3 @@ +type MemoListIterator = (prev: R, curr: T, index: number, list: A) => R; + +export type { MemoListIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoObjectIterator.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoObjectIterator.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..64a21c57d93d8799434a56f21997f5e489e140be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoObjectIterator.d.mts @@ -0,0 +1,3 @@ +type MemoObjectIterator = (prev: R, curr: T, key: string, list: A) => R; + +export type { MemoObjectIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoObjectIterator.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoObjectIterator.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..64a21c57d93d8799434a56f21997f5e489e140be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/MemoObjectIterator.d.ts @@ -0,0 +1,3 @@ +type MemoObjectIterator = (prev: R, curr: T, key: string, list: A) => R; + +export type { MemoObjectIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIteratee.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIteratee.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..18a1c9a5a09168df2901851eafb12bdbed0b2c6d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIteratee.d.mts @@ -0,0 +1,7 @@ +import { IterateeShorthand } from './IterateeShorthand.mjs'; +import { ObjectIterator } from './ObjectIterator.mjs'; + +type ObjectIteratee = ObjectIterator | IterateeShorthand; +type ObjectIterateeCustom = ObjectIterator | IterateeShorthand; + +export type { ObjectIteratee, ObjectIterateeCustom }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIteratee.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIteratee.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4c949112440e5ad985244949e7df6f6eab30874b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIteratee.d.ts @@ -0,0 +1,7 @@ +import { IterateeShorthand } from './IterateeShorthand.js'; +import { ObjectIterator } from './ObjectIterator.js'; + +type ObjectIteratee = ObjectIterator | IterateeShorthand; +type ObjectIterateeCustom = ObjectIterator | IterateeShorthand; + +export type { ObjectIteratee, ObjectIterateeCustom }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIterator.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIterator.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e06da403476ff15852eb08c54898bb929c324dd4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIterator.d.mts @@ -0,0 +1,4 @@ +type ObjectIterator = (value: T[keyof T], key: string, collection: T) => R; +type ObjectIteratorTypeGuard = (value: T[keyof T], key: string, collection: T) => value is U; + +export type { ObjectIterator, ObjectIteratorTypeGuard }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIterator.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIterator.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e06da403476ff15852eb08c54898bb929c324dd4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ObjectIterator.d.ts @@ -0,0 +1,4 @@ +type ObjectIterator = (value: T[keyof T], key: string, collection: T) => R; +type ObjectIteratorTypeGuard = (value: T[keyof T], key: string, collection: T) => value is U; + +export type { ObjectIterator, ObjectIteratorTypeGuard }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PartialShallow.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PartialShallow.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a728158a184c1830dd7e1af5a531014cf48d3727 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PartialShallow.d.mts @@ -0,0 +1,5 @@ +type PartialShallow = { + [P in keyof T]?: T[P] extends object ? object : T[P]; +}; + +export type { PartialShallow }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PartialShallow.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PartialShallow.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a728158a184c1830dd7e1af5a531014cf48d3727 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PartialShallow.d.ts @@ -0,0 +1,5 @@ +type PartialShallow = { + [P in keyof T]?: T[P] extends object ? object : T[P]; +}; + +export type { PartialShallow }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PropertyPath.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PropertyPath.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a9f4a3825823c719afca09d1047f03c36920223e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PropertyPath.d.mts @@ -0,0 +1,5 @@ +import { Many } from './Many.mjs'; + +type PropertyPath = Many; + +export type { PropertyPath }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PropertyPath.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PropertyPath.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..944569639ccdbc6919e3371f9ccdcb0763ea7fa8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/PropertyPath.d.ts @@ -0,0 +1,5 @@ +import { Many } from './Many.js'; + +type PropertyPath = Many; + +export type { PropertyPath }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/RecursiveArray.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/RecursiveArray.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8b299655909b07279ac9c53a6920a68ade1b0876 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/RecursiveArray.d.mts @@ -0,0 +1,4 @@ +interface RecursiveArray extends Array> { +} + +export type { RecursiveArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/RecursiveArray.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/RecursiveArray.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8b299655909b07279ac9c53a6920a68ade1b0876 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/RecursiveArray.d.ts @@ -0,0 +1,4 @@ +interface RecursiveArray extends Array> { +} + +export type { RecursiveArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/StringIterator.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/StringIterator.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9d5252895ee952fe37f69a4835f3703145b6d814 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/StringIterator.d.mts @@ -0,0 +1,3 @@ +type StringIterator = (char: string, index: number, string: string) => R; + +export type { StringIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/StringIterator.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/StringIterator.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9d5252895ee952fe37f69a4835f3703145b6d814 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/StringIterator.d.ts @@ -0,0 +1,3 @@ +type StringIterator = (char: string, index: number, string: string) => R; + +export type { StringIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/TupleIterator.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/TupleIterator.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e558e56fb59d34a66d9043dd8f40b5d6921bfac3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/TupleIterator.d.mts @@ -0,0 +1,3 @@ +type TupleIterator = (value: T[number], index: T extends `${infer N extends number}` ? N : never, collection: T) => TResult; + +export type { TupleIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/TupleIterator.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/TupleIterator.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e558e56fb59d34a66d9043dd8f40b5d6921bfac3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/TupleIterator.d.ts @@ -0,0 +1,3 @@ +type TupleIterator = (value: T[number], index: T extends `${infer N extends number}` ? N : never, collection: T) => TResult; + +export type { TupleIterator }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratee.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratee.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f2050bce191dbe2982acf1ba4845495d037a7530 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratee.d.mts @@ -0,0 +1,5 @@ +import { PartialShallow } from './PartialShallow.mjs'; + +type ValueIteratee = ((value: T) => unknown) | (PropertyKey | [PropertyKey, any] | PartialShallow); + +export type { ValueIteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratee.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratee.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dc3966f2bd4e8991453d78c1672a3e07abf5dc58 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratee.d.ts @@ -0,0 +1,5 @@ +import { PartialShallow } from './PartialShallow.js'; + +type ValueIteratee = ((value: T) => unknown) | (PropertyKey | [PropertyKey, any] | PartialShallow); + +export type { ValueIteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIterateeCustom.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIterateeCustom.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ce625a06c7d67c75b93c3819ef67465654b7b0f3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIterateeCustom.d.mts @@ -0,0 +1,5 @@ +import { IterateeShorthand } from './IterateeShorthand.mjs'; + +type ValueIterateeCustom = ((value: T) => TResult) | IterateeShorthand; + +export type { ValueIterateeCustom }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIterateeCustom.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIterateeCustom.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c2251aa64d5b3a91c5e4a75664954ba1ab676a7d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIterateeCustom.d.ts @@ -0,0 +1,5 @@ +import { IterateeShorthand } from './IterateeShorthand.js'; + +type ValueIterateeCustom = ((value: T) => TResult) | IterateeShorthand; + +export type { ValueIterateeCustom }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratorTypeGuard.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratorTypeGuard.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..051e2163421514d3bc9f1bf1c977206487592718 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratorTypeGuard.d.mts @@ -0,0 +1,3 @@ +type ValueIteratorTypeGuard = (value: T) => value is S; + +export type { ValueIteratorTypeGuard }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratorTypeGuard.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratorTypeGuard.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..051e2163421514d3bc9f1bf1c977206487592718 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueIteratorTypeGuard.d.ts @@ -0,0 +1,3 @@ +type ValueIteratorTypeGuard = (value: T) => value is S; + +export type { ValueIteratorTypeGuard }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIteratee.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIteratee.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c04a92e2625cf03ad7d58b4a7d71ab6626748911 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIteratee.d.mts @@ -0,0 +1,5 @@ +import { IterateeShorthand } from './IterateeShorthand.mjs'; + +type ValueKeyIteratee = ((value: T, key: string) => unknown) | IterateeShorthand; + +export type { ValueKeyIteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIteratee.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIteratee.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..88b03a8d6ab3ceb223a979c8f09d2de8c1d7c853 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIteratee.d.ts @@ -0,0 +1,5 @@ +import { IterateeShorthand } from './IterateeShorthand.js'; + +type ValueKeyIteratee = ((value: T, key: string) => unknown) | IterateeShorthand; + +export type { ValueKeyIteratee }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIterateeTypeGuard.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIterateeTypeGuard.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..943ce0e32d4248315d588221f25ce1a7fc7fc79a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIterateeTypeGuard.d.mts @@ -0,0 +1,3 @@ +type ValueKeyIterateeTypeGuard = (value: T, key: string) => value is S; + +export type { ValueKeyIterateeTypeGuard }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIterateeTypeGuard.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIterateeTypeGuard.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..943ce0e32d4248315d588221f25ce1a7fc7fc79a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/ValueKeyIterateeTypeGuard.d.ts @@ -0,0 +1,3 @@ +type ValueKeyIterateeTypeGuard = (value: T, key: string) => value is S; + +export type { ValueKeyIterateeTypeGuard }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/assignValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/assignValue.js new file mode 100644 index 0000000000000000000000000000000000000000..9e65893caa4f2ed3f8b19529894784583792ed92 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/assignValue.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const eq = require('../util/eq.js'); + +const assignValue = (object, key, value) => { + const objValue = object[key]; + if (!(Object.hasOwn(object, key) && eq.eq(objValue, value)) || (value === undefined && !(key in object))) { + object[key] = value; + } +}; + +exports.assignValue = assignValue; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/assignValue.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/assignValue.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e673e546a5a9b9f313cbece8c147374423cc1abb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/assignValue.mjs @@ -0,0 +1,10 @@ +import { eq } from '../util/eq.mjs'; + +const assignValue = (object, key, value) => { + const objValue = object[key]; + if (!(Object.hasOwn(object, key) && eq(objValue, value)) || (value === undefined && !(key in object))) { + object[key] = value; + } +}; + +export { assignValue }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/compareValues.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/compareValues.js new file mode 100644 index 0000000000000000000000000000000000000000..ebbad390e49accadc31ffd20460940f1944774be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/compareValues.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function getPriority(a) { + if (typeof a === 'symbol') { + return 1; + } + if (a === null) { + return 2; + } + if (a === undefined) { + return 3; + } + if (a !== a) { + return 4; + } + return 0; +} +const compareValues = (a, b, order) => { + if (a !== b) { + const aPriority = getPriority(a); + const bPriority = getPriority(b); + if (aPriority === bPriority && aPriority === 0) { + if (a < b) { + return order === 'desc' ? 1 : -1; + } + if (a > b) { + return order === 'desc' ? -1 : 1; + } + } + return order === 'desc' ? bPriority - aPriority : aPriority - bPriority; + } + return 0; +}; + +exports.compareValues = compareValues; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/compareValues.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/compareValues.mjs new file mode 100644 index 0000000000000000000000000000000000000000..935b06f6bc2ec314312786ea2ff7c49de667b9f6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/compareValues.mjs @@ -0,0 +1,33 @@ +function getPriority(a) { + if (typeof a === 'symbol') { + return 1; + } + if (a === null) { + return 2; + } + if (a === undefined) { + return 3; + } + if (a !== a) { + return 4; + } + return 0; +} +const compareValues = (a, b, order) => { + if (a !== b) { + const aPriority = getPriority(a); + const bPriority = getPriority(b); + if (aPriority === bPriority && aPriority === 0) { + if (a < b) { + return order === 'desc' ? 1 : -1; + } + if (a > b) { + return order === 'desc' ? -1 : 1; + } + } + return order === 'desc' ? bPriority - aPriority : aPriority - bPriority; + } + return 0; +}; + +export { compareValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/copyArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/copyArray.js new file mode 100644 index 0000000000000000000000000000000000000000..813c1594b8170bd1e36e9a25fe68497913ba3edd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/copyArray.js @@ -0,0 +1,14 @@ +'use strict'; + +function copyArray(source, array) { + const length = source.length; + if (array == null) { + array = Array(length); + } + for (let i = 0; i < length; i++) { + array[i] = source[i]; + } + return array; +} + +module.exports = copyArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/copyArray.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/copyArray.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f6c1585df0ef8014f87345cdf58defca7e0aa3f6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/copyArray.mjs @@ -0,0 +1,12 @@ +function copyArray(source, array) { + const length = source.length; + if (array == null) { + array = Array(length); + } + for (let i = 0; i < length; i++) { + array[i] = source[i]; + } + return array; +} + +export { copyArray as default }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/decimalAdjust.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/decimalAdjust.js new file mode 100644 index 0000000000000000000000000000000000000000..a3fe28cd2c82f0734982d828e5c8a204ebd1595b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/decimalAdjust.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function decimalAdjust(type, number, precision = 0) { + number = Number(number); + if (Object.is(number, -0)) { + number = '-0'; + } + precision = Math.min(Number.parseInt(precision, 10), 292); + if (precision) { + const [magnitude, exponent = 0] = number.toString().split('e'); + let adjustedValue = Math[type](Number(`${magnitude}e${Number(exponent) + precision}`)); + if (Object.is(adjustedValue, -0)) { + adjustedValue = '-0'; + } + const [newMagnitude, newExponent = 0] = adjustedValue.toString().split('e'); + return Number(`${newMagnitude}e${Number(newExponent) - precision}`); + } + return Math[type](Number(number)); +} + +exports.decimalAdjust = decimalAdjust; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/decimalAdjust.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/decimalAdjust.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5a4409fcd566ec6b47ac87751d0cc779f8df01b0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/decimalAdjust.mjs @@ -0,0 +1,19 @@ +function decimalAdjust(type, number, precision = 0) { + number = Number(number); + if (Object.is(number, -0)) { + number = '-0'; + } + precision = Math.min(Number.parseInt(precision, 10), 292); + if (precision) { + const [magnitude, exponent = 0] = number.toString().split('e'); + let adjustedValue = Math[type](Number(`${magnitude}e${Number(exponent) + precision}`)); + if (Object.is(adjustedValue, -0)) { + adjustedValue = '-0'; + } + const [newMagnitude, newExponent = 0] = adjustedValue.toString().split('e'); + return Number(`${newMagnitude}e${Number(newExponent) - precision}`); + } + return Math[type](Number(number)); +} + +export { decimalAdjust }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/flattenArrayLike.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/flattenArrayLike.js new file mode 100644 index 0000000000000000000000000000000000000000..b0d52a941490a4efc0a4aea4c7ad0b539eea4ce0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/flattenArrayLike.js @@ -0,0 +1,21 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function flattenArrayLike(values) { + const result = []; + for (let i = 0; i < values.length; i++) { + const arrayLike = values[i]; + if (!isArrayLikeObject.isArrayLikeObject(arrayLike)) { + continue; + } + for (let j = 0; j < arrayLike.length; j++) { + result.push(arrayLike[j]); + } + } + return result; +} + +exports.flattenArrayLike = flattenArrayLike; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/flattenArrayLike.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/flattenArrayLike.mjs new file mode 100644 index 0000000000000000000000000000000000000000..def529973e593b06e4953eefe681f2581266592e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/flattenArrayLike.mjs @@ -0,0 +1,17 @@ +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function flattenArrayLike(values) { + const result = []; + for (let i = 0; i < values.length; i++) { + const arrayLike = values[i]; + if (!isArrayLikeObject(arrayLike)) { + continue; + } + for (let j = 0; j < arrayLike.length; j++) { + result.push(arrayLike[j]); + } + } + return result; +} + +export { flattenArrayLike }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbols.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbols.js new file mode 100644 index 0000000000000000000000000000000000000000..cddadbd679bd056f134bc13bbc5bbe4fb2103f20 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbols.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function getSymbols(object) { + return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol)); +} + +exports.getSymbols = getSymbols; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d15be753143bda63a7d3e4610caee70548c208c7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs @@ -0,0 +1,5 @@ +function getSymbols(object) { + return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol)); +} + +export { getSymbols }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbolsIn.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbolsIn.js new file mode 100644 index 0000000000000000000000000000000000000000..16ebc379f6c99a04384a54c2a7f2c22b62f51a08 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbolsIn.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const getSymbols = require('./getSymbols.js'); + +function getSymbolsIn(object) { + const result = []; + while (object) { + result.push(...getSymbols.getSymbols(object)); + object = Object.getPrototypeOf(object); + } + return result; +} + +exports.getSymbolsIn = getSymbolsIn; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbolsIn.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbolsIn.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7dc64ba40114b50f558247d4b00657affec182c4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getSymbolsIn.mjs @@ -0,0 +1,12 @@ +import { getSymbols } from './getSymbols.mjs'; + +function getSymbolsIn(object) { + const result = []; + while (object) { + result.push(...getSymbols(object)); + object = Object.getPrototypeOf(object); + } + return result; +} + +export { getSymbolsIn }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getTag.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getTag.js new file mode 100644 index 0000000000000000000000000000000000000000..13ebb55aabdb1e3e97adaa1996a5ae3691a62a80 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getTag.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function getTag(value) { + if (value == null) { + return value === undefined ? '[object Undefined]' : '[object Null]'; + } + return Object.prototype.toString.call(value); +} + +exports.getTag = getTag; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5302f4fc21f97ae3c9fdbeb14997e9e606822193 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs @@ -0,0 +1,8 @@ +function getTag(value) { + if (value == null) { + return value === undefined ? '[object Undefined]' : '[object Null]'; + } + return Object.prototype.toString.call(value); +} + +export { getTag }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isDeepKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isDeepKey.js new file mode 100644 index 0000000000000000000000000000000000000000..52052f79cc4938d8b7ff7d2d3a18f01764688daa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isDeepKey.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isDeepKey(key) { + switch (typeof key) { + case 'number': + case 'symbol': { + return false; + } + case 'string': { + return key.includes('.') || key.includes('[') || key.includes(']'); + } + } +} + +exports.isDeepKey = isDeepKey; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isDeepKey.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isDeepKey.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e06007b586bd53394b7d6807277b0b0cb8fed468 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isDeepKey.mjs @@ -0,0 +1,13 @@ +function isDeepKey(key) { + switch (typeof key) { + case 'number': + case 'symbol': { + return false; + } + case 'string': { + return key.includes('.') || key.includes('[') || key.includes(']'); + } + } +} + +export { isDeepKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIndex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIndex.js new file mode 100644 index 0000000000000000000000000000000000000000..831387a684530549c3d5904557c0fe0604e9ca78 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIndex.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/; +function isIndex(value, length = Number.MAX_SAFE_INTEGER) { + switch (typeof value) { + case 'number': { + return Number.isInteger(value) && value >= 0 && value < length; + } + case 'symbol': { + return false; + } + case 'string': { + return IS_UNSIGNED_INTEGER.test(value); + } + } +} + +exports.isIndex = isIndex; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIndex.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIndex.mjs new file mode 100644 index 0000000000000000000000000000000000000000..66c58714e3c59cc604b21bc6e2def64c8999f167 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIndex.mjs @@ -0,0 +1,16 @@ +const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/; +function isIndex(value, length = Number.MAX_SAFE_INTEGER) { + switch (typeof value) { + case 'number': { + return Number.isInteger(value) && value >= 0 && value < length; + } + case 'symbol': { + return false; + } + case 'string': { + return IS_UNSIGNED_INTEGER.test(value); + } + } +} + +export { isIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIterateeCall.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIterateeCall.js new file mode 100644 index 0000000000000000000000000000000000000000..0adf382a255fd96056d92be1af3d6176d02ba84b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIterateeCall.js @@ -0,0 +1,21 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isIndex = require('./isIndex.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isObject = require('../predicate/isObject.js'); +const eq = require('../util/eq.js'); + +function isIterateeCall(value, index, object) { + if (!isObject.isObject(object)) { + return false; + } + if ((typeof index === 'number' && isArrayLike.isArrayLike(object) && isIndex.isIndex(index) && index < object.length) || + (typeof index === 'string' && index in object)) { + return eq.eq(object[index], value); + } + return false; +} + +exports.isIterateeCall = isIterateeCall; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIterateeCall.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIterateeCall.mjs new file mode 100644 index 0000000000000000000000000000000000000000..84bd0d39e6885eed7de39465df3498dd7a09e5a4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isIterateeCall.mjs @@ -0,0 +1,17 @@ +import { isIndex } from './isIndex.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isObject } from '../predicate/isObject.mjs'; +import { eq } from '../util/eq.mjs'; + +function isIterateeCall(value, index, object) { + if (!isObject(object)) { + return false; + } + if ((typeof index === 'number' && isArrayLike(object) && isIndex(index) && index < object.length) || + (typeof index === 'string' && index in object)) { + return eq(object[index], value); + } + return false; +} + +export { isIterateeCall }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isKey.js new file mode 100644 index 0000000000000000000000000000000000000000..e6c1aa222c5401be34dec4807cc3e21882a396d1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isKey.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isSymbol = require('../predicate/isSymbol.js'); + +const regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/; +const regexIsPlainProp = /^\w*$/; +function isKey(value, object) { + if (Array.isArray(value)) { + return false; + } + if (typeof value === 'number' || typeof value === 'boolean' || value == null || isSymbol.isSymbol(value)) { + return true; + } + return ((typeof value === 'string' && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value))) || + (object != null && Object.hasOwn(object, value))); +} + +exports.isKey = isKey; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isKey.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isKey.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9b12177a133e054a6d5e758875e9581e82bda0e0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isKey.mjs @@ -0,0 +1,16 @@ +import { isSymbol } from '../predicate/isSymbol.mjs'; + +const regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/; +const regexIsPlainProp = /^\w*$/; +function isKey(value, object) { + if (Array.isArray(value)) { + return false; + } + if (typeof value === 'number' || typeof value === 'boolean' || value == null || isSymbol(value)) { + return true; + } + return ((typeof value === 'string' && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value))) || + (object != null && Object.hasOwn(object, value))); +} + +export { isKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isPrototype.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isPrototype.js new file mode 100644 index 0000000000000000000000000000000000000000..17ca3e217fe7ce0373de45e583a2d81ee076a0e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isPrototype.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isPrototype(value) { + const constructor = value?.constructor; + const prototype = typeof constructor === 'function' ? constructor.prototype : Object.prototype; + return value === prototype; +} + +exports.isPrototype = isPrototype; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isPrototype.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isPrototype.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7ef49c374e20f87034831547ef4ba05f9571655e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/isPrototype.mjs @@ -0,0 +1,7 @@ +function isPrototype(value) { + const constructor = value?.constructor; + const prototype = typeof constructor === 'function' ? constructor.prototype : Object.prototype; + return value === prototype; +} + +export { isPrototype }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/mapToEntries.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/mapToEntries.js new file mode 100644 index 0000000000000000000000000000000000000000..fedc9776446f94fb18a648b9fa759d06af013344 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/mapToEntries.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function mapToEntries(map) { + const arr = new Array(map.size); + const keys = map.keys(); + const values = map.values(); + for (let i = 0; i < arr.length; i++) { + arr[i] = [keys.next().value, values.next().value]; + } + return arr; +} + +exports.mapToEntries = mapToEntries; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/mapToEntries.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/mapToEntries.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c229ec08d1f1bfc6f70db5da1f33661ac3d83e66 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/mapToEntries.mjs @@ -0,0 +1,11 @@ +function mapToEntries(map) { + const arr = new Array(map.size); + const keys = map.keys(); + const values = map.values(); + for (let i = 0; i < arr.length; i++) { + arr[i] = [keys.next().value, values.next().value]; + } + return arr; +} + +export { mapToEntries }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/normalizeForCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/normalizeForCase.js new file mode 100644 index 0000000000000000000000000000000000000000..b2a0ddee3ed628b44972d86ed2f747912fb91f82 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/normalizeForCase.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const toString = require('../util/toString.js'); + +function normalizeForCase(str) { + if (typeof str !== 'string') { + str = toString.toString(str); + } + return str.replace(/['\u2019]/g, ''); +} + +exports.normalizeForCase = normalizeForCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/normalizeForCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/normalizeForCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8cb14a9293bf94161a895aa54570837fab369db8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/normalizeForCase.mjs @@ -0,0 +1,10 @@ +import { toString } from '../util/toString.mjs'; + +function normalizeForCase(str) { + if (typeof str !== 'string') { + str = toString(str); + } + return str.replace(/['\u2019]/g, ''); +} + +export { normalizeForCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/setToEntries.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/setToEntries.js new file mode 100644 index 0000000000000000000000000000000000000000..9d6563db7bb63548798d38d46f9975a92c389d46 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/setToEntries.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function setToEntries(set) { + const arr = new Array(set.size); + const values = set.values(); + for (let i = 0; i < arr.length; i++) { + const value = values.next().value; + arr[i] = [value, value]; + } + return arr; +} + +exports.setToEntries = setToEntries; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/setToEntries.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/setToEntries.mjs new file mode 100644 index 0000000000000000000000000000000000000000..463002ffe304be3421986476bb903d2ea1448930 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/setToEntries.mjs @@ -0,0 +1,11 @@ +function setToEntries(set) { + const arr = new Array(set.size); + const values = set.values(); + for (let i = 0; i < arr.length; i++) { + const value = values.next().value; + arr[i] = [value, value]; + } + return arr; +} + +export { setToEntries }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/tags.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/tags.js new file mode 100644 index 0000000000000000000000000000000000000000..5a281e3daf70e7f7597f230af97c550e88f6eb65 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/tags.js @@ -0,0 +1,57 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const regexpTag = '[object RegExp]'; +const stringTag = '[object String]'; +const numberTag = '[object Number]'; +const booleanTag = '[object Boolean]'; +const argumentsTag = '[object Arguments]'; +const symbolTag = '[object Symbol]'; +const dateTag = '[object Date]'; +const mapTag = '[object Map]'; +const setTag = '[object Set]'; +const arrayTag = '[object Array]'; +const functionTag = '[object Function]'; +const arrayBufferTag = '[object ArrayBuffer]'; +const objectTag = '[object Object]'; +const errorTag = '[object Error]'; +const dataViewTag = '[object DataView]'; +const uint8ArrayTag = '[object Uint8Array]'; +const uint8ClampedArrayTag = '[object Uint8ClampedArray]'; +const uint16ArrayTag = '[object Uint16Array]'; +const uint32ArrayTag = '[object Uint32Array]'; +const bigUint64ArrayTag = '[object BigUint64Array]'; +const int8ArrayTag = '[object Int8Array]'; +const int16ArrayTag = '[object Int16Array]'; +const int32ArrayTag = '[object Int32Array]'; +const bigInt64ArrayTag = '[object BigInt64Array]'; +const float32ArrayTag = '[object Float32Array]'; +const float64ArrayTag = '[object Float64Array]'; + +exports.argumentsTag = argumentsTag; +exports.arrayBufferTag = arrayBufferTag; +exports.arrayTag = arrayTag; +exports.bigInt64ArrayTag = bigInt64ArrayTag; +exports.bigUint64ArrayTag = bigUint64ArrayTag; +exports.booleanTag = booleanTag; +exports.dataViewTag = dataViewTag; +exports.dateTag = dateTag; +exports.errorTag = errorTag; +exports.float32ArrayTag = float32ArrayTag; +exports.float64ArrayTag = float64ArrayTag; +exports.functionTag = functionTag; +exports.int16ArrayTag = int16ArrayTag; +exports.int32ArrayTag = int32ArrayTag; +exports.int8ArrayTag = int8ArrayTag; +exports.mapTag = mapTag; +exports.numberTag = numberTag; +exports.objectTag = objectTag; +exports.regexpTag = regexpTag; +exports.setTag = setTag; +exports.stringTag = stringTag; +exports.symbolTag = symbolTag; +exports.uint16ArrayTag = uint16ArrayTag; +exports.uint32ArrayTag = uint32ArrayTag; +exports.uint8ArrayTag = uint8ArrayTag; +exports.uint8ClampedArrayTag = uint8ClampedArrayTag; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/tags.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/tags.mjs new file mode 100644 index 0000000000000000000000000000000000000000..27c7c1f13bc0ed781449ecf473fbbcd51434d59f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/tags.mjs @@ -0,0 +1,28 @@ +const regexpTag = '[object RegExp]'; +const stringTag = '[object String]'; +const numberTag = '[object Number]'; +const booleanTag = '[object Boolean]'; +const argumentsTag = '[object Arguments]'; +const symbolTag = '[object Symbol]'; +const dateTag = '[object Date]'; +const mapTag = '[object Map]'; +const setTag = '[object Set]'; +const arrayTag = '[object Array]'; +const functionTag = '[object Function]'; +const arrayBufferTag = '[object ArrayBuffer]'; +const objectTag = '[object Object]'; +const errorTag = '[object Error]'; +const dataViewTag = '[object DataView]'; +const uint8ArrayTag = '[object Uint8Array]'; +const uint8ClampedArrayTag = '[object Uint8ClampedArray]'; +const uint16ArrayTag = '[object Uint16Array]'; +const uint32ArrayTag = '[object Uint32Array]'; +const bigUint64ArrayTag = '[object BigUint64Array]'; +const int8ArrayTag = '[object Int8Array]'; +const int16ArrayTag = '[object Int16Array]'; +const int32ArrayTag = '[object Int32Array]'; +const bigInt64ArrayTag = '[object BigInt64Array]'; +const float32ArrayTag = '[object Float32Array]'; +const float64ArrayTag = '[object Float64Array]'; + +export { argumentsTag, arrayBufferTag, arrayTag, bigInt64ArrayTag, bigUint64ArrayTag, booleanTag, dataViewTag, dateTag, errorTag, float32ArrayTag, float64ArrayTag, functionTag, int16ArrayTag, int32ArrayTag, int8ArrayTag, mapTag, numberTag, objectTag, regexpTag, setTag, stringTag, symbolTag, uint16ArrayTag, uint32ArrayTag, uint8ArrayTag, uint8ClampedArrayTag }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toArray.js new file mode 100644 index 0000000000000000000000000000000000000000..f61cfdc31408aa39f9c88518b63a1d331e588820 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toArray.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function toArray(value) { + return Array.isArray(value) ? value : Array.from(value); +} + +exports.toArray = toArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toArray.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toArray.mjs new file mode 100644 index 0000000000000000000000000000000000000000..cd80916f6aa88d240c6d468235c1e82f1c30ef53 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toArray.mjs @@ -0,0 +1,5 @@ +function toArray(value) { + return Array.isArray(value) ? value : Array.from(value); +} + +export { toArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toKey.js new file mode 100644 index 0000000000000000000000000000000000000000..97b66e3b8c1f65e8aebb769f305e589b63fa2c61 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toKey.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function toKey(value) { + if (typeof value === 'string' || typeof value === 'symbol') { + return value; + } + if (Object.is(value?.valueOf?.(), -0)) { + return '-0'; + } + return String(value); +} + +exports.toKey = toKey; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toKey.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toKey.mjs new file mode 100644 index 0000000000000000000000000000000000000000..74a5699ea9e27909c39d1379bc332418e834efde --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/_internal/toKey.mjs @@ -0,0 +1,11 @@ +function toKey(value) { + if (typeof value === 'string' || typeof value === 'symbol') { + return value; + } + if (Object.is(value?.valueOf?.(), -0)) { + return '-0'; + } + return String(value); +} + +export { toKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1b6da5b26b30f4490cd1185f7e5bdff2eef974bf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.d.mts @@ -0,0 +1,29 @@ +/** + * Casts value as an array if it's not one. + * + * @template T The type of elements in the array. + * @param {T | T[]} value The value to be cast to an array. + * @returns {T[]} An array containing the input value if it wasn't an array, or the original array if it was. + * + * @example + * const arr1 = castArray(1); + * // Returns: [1] + * + * const arr2 = castArray([1]); + * // Returns: [1] + * + * const arr3 = castArray({'a': 1}); + * // Returns: [{'a': 1}] + * + * const arr4 = castArray(null); + * // Returns: [null] + * + * const arr5 = castArray(undefined); + * // Returns: [undefined] + * + * const arr6 = castArray(); + * // Returns: [] + */ +declare function castArray(value?: T | readonly T[]): T[]; + +export { castArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1b6da5b26b30f4490cd1185f7e5bdff2eef974bf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.d.ts @@ -0,0 +1,29 @@ +/** + * Casts value as an array if it's not one. + * + * @template T The type of elements in the array. + * @param {T | T[]} value The value to be cast to an array. + * @returns {T[]} An array containing the input value if it wasn't an array, or the original array if it was. + * + * @example + * const arr1 = castArray(1); + * // Returns: [1] + * + * const arr2 = castArray([1]); + * // Returns: [1] + * + * const arr3 = castArray({'a': 1}); + * // Returns: [{'a': 1}] + * + * const arr4 = castArray(null); + * // Returns: [null] + * + * const arr5 = castArray(undefined); + * // Returns: [undefined] + * + * const arr6 = castArray(); + * // Returns: [] + */ +declare function castArray(value?: T | readonly T[]): T[]; + +export { castArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.js new file mode 100644 index 0000000000000000000000000000000000000000..845d59f64ab582fb5cfcbd1aef59180f4ea96d95 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function castArray(value) { + if (arguments.length === 0) { + return []; + } + return Array.isArray(value) ? value : [value]; +} + +exports.castArray = castArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.mjs new file mode 100644 index 0000000000000000000000000000000000000000..14873449d5561e3d51a3bbaba6afa90cdf4c77ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/castArray.mjs @@ -0,0 +1,8 @@ +function castArray(value) { + if (arguments.length === 0) { + return []; + } + return Array.isArray(value) ? value : [value]; +} + +export { castArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..947deecc55942bb37d891ef0762999c967a9250f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.d.mts @@ -0,0 +1,25 @@ +/** + * Splits an array into smaller arrays of a specified length. + * + * This function takes an input array and divides it into multiple smaller arrays, + * each of a specified length. If the input array cannot be evenly divided, + * the final sub-array will contain the remaining elements. + * + * @template T The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The array to be chunked into smaller arrays. + * @param {number} size - The size of each smaller array. Must be a positive integer. + * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`. + * + * @example + * // Splits an array of numbers into sub-arrays of length 2 + * chunk([1, 2, 3, 4, 5], 2); + * // Returns: [[1, 2], [3, 4], [5]] + * + * @example + * // Splits an array of strings into sub-arrays of length 3 + * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3); + * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']] + */ +declare function chunk(arr: ArrayLike | null | undefined, size?: number): T[][]; + +export { chunk }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..947deecc55942bb37d891ef0762999c967a9250f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.d.ts @@ -0,0 +1,25 @@ +/** + * Splits an array into smaller arrays of a specified length. + * + * This function takes an input array and divides it into multiple smaller arrays, + * each of a specified length. If the input array cannot be evenly divided, + * the final sub-array will contain the remaining elements. + * + * @template T The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The array to be chunked into smaller arrays. + * @param {number} size - The size of each smaller array. Must be a positive integer. + * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`. + * + * @example + * // Splits an array of numbers into sub-arrays of length 2 + * chunk([1, 2, 3, 4, 5], 2); + * // Returns: [[1, 2], [3, 4], [5]] + * + * @example + * // Splits an array of strings into sub-arrays of length 3 + * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3); + * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']] + */ +declare function chunk(arr: ArrayLike | null | undefined, size?: number): T[][]; + +export { chunk }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.js new file mode 100644 index 0000000000000000000000000000000000000000..d84b8a539e9b489dee51541b0709e638a7e4ee40 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const chunk$1 = require('../../array/chunk.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function chunk(arr, size = 1) { + size = Math.max(Math.floor(size), 0); + if (size === 0 || !isArrayLike.isArrayLike(arr)) { + return []; + } + return chunk$1.chunk(toArray.toArray(arr), size); +} + +exports.chunk = chunk; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.mjs new file mode 100644 index 0000000000000000000000000000000000000000..edb6a0a6ef9b48c14e3d523722829103485b59df --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/chunk.mjs @@ -0,0 +1,13 @@ +import { chunk as chunk$1 } from '../../array/chunk.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function chunk(arr, size = 1) { + size = Math.max(Math.floor(size), 0); + if (size === 0 || !isArrayLike(arr)) { + return []; + } + return chunk$1(toArray(arr), size); +} + +export { chunk }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..81dc8677370cbd8856941f4f8cbe44df001b0a3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.d.mts @@ -0,0 +1,15 @@ +type Falsey = false | null | 0 | 0n | '' | undefined; +/** + * Removes falsey values (false, null, 0, 0n, '', undefined, NaN) from an array. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The input array to remove falsey values. + * @returns {Array>} - A new array with all falsey values removed. + * + * @example + * compact([0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]); + * Returns: [1, 2, 3, 4, 5] + */ +declare function compact(arr: ArrayLike | null | undefined): T[]; + +export { compact }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..81dc8677370cbd8856941f4f8cbe44df001b0a3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.d.ts @@ -0,0 +1,15 @@ +type Falsey = false | null | 0 | 0n | '' | undefined; +/** + * Removes falsey values (false, null, 0, 0n, '', undefined, NaN) from an array. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The input array to remove falsey values. + * @returns {Array>} - A new array with all falsey values removed. + * + * @example + * compact([0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]); + * Returns: [1, 2, 3, 4, 5] + */ +declare function compact(arr: ArrayLike | null | undefined): T[]; + +export { compact }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.js new file mode 100644 index 0000000000000000000000000000000000000000..b13de06b5920495766c9768bcc14823023f7a711 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const compact$1 = require('../../array/compact.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function compact(arr) { + if (!isArrayLike.isArrayLike(arr)) { + return []; + } + return compact$1.compact(Array.from(arr)); +} + +exports.compact = compact; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a9a4cd500390e7c54636c16e963773caecf5773f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/compact.mjs @@ -0,0 +1,11 @@ +import { compact as compact$1 } from '../../array/compact.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function compact(arr) { + if (!isArrayLike(arr)) { + return []; + } + return compact$1(Array.from(arr)); +} + +export { compact }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..33784149cdcfbf48cad926b63a3f61209c44e4d8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.d.mts @@ -0,0 +1,30 @@ +/** + * Concatenates multiple arrays and values into a single array. + * + * @template T The type of elements in the array. + * @param {...(T | T[])} values - The values and/or arrays to concatenate. + * @returns {T[]} A new array containing all the input values. + * + * @example + * // Concatenate individual values + * concat(1, 2, 3); + * // returns [1, 2, 3] + * + * @example + * // Concatenate arrays of values + * concat([1, 2], [3, 4]); + * // returns [1, 2, 3, 4] + * + * @example + * // Concatenate a mix of individual values and arrays + * concat(1, [2, 3], 4); + * // returns [1, 2, 3, 4] + * + * @example + * // Concatenate nested arrays + * concat([1, [2, 3]], 4); + * // returns [1, [2, 3], 4] + */ +declare function concat(...values: Array): T[]; + +export { concat }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..33784149cdcfbf48cad926b63a3f61209c44e4d8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.d.ts @@ -0,0 +1,30 @@ +/** + * Concatenates multiple arrays and values into a single array. + * + * @template T The type of elements in the array. + * @param {...(T | T[])} values - The values and/or arrays to concatenate. + * @returns {T[]} A new array containing all the input values. + * + * @example + * // Concatenate individual values + * concat(1, 2, 3); + * // returns [1, 2, 3] + * + * @example + * // Concatenate arrays of values + * concat([1, 2], [3, 4]); + * // returns [1, 2, 3, 4] + * + * @example + * // Concatenate a mix of individual values and arrays + * concat(1, [2, 3], 4); + * // returns [1, 2, 3, 4] + * + * @example + * // Concatenate nested arrays + * concat([1, [2, 3]], 4); + * // returns [1, [2, 3], 4] + */ +declare function concat(...values: Array): T[]; + +export { concat }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.js new file mode 100644 index 0000000000000000000000000000000000000000..669b4bc32e468ed1f822f5a752c52af80fb62959 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('../../array/flatten.js'); + +function concat(...values) { + return flatten.flatten(values); +} + +exports.concat = concat; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.mjs new file mode 100644 index 0000000000000000000000000000000000000000..79f7a6751265e2e0b4a6830ce1a434540fbd6b0d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/concat.mjs @@ -0,0 +1,7 @@ +import { flatten } from '../../array/flatten.mjs'; + +function concat(...values) { + return flatten(values); +} + +export { concat }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..93ae774b3cfa918d406bea9d08b1a2a969b93c82 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.d.mts @@ -0,0 +1,19 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Creates an object composed of keys generated from the results of running each element of collection through + * iteratee. The corresponding value of each key is the number of times the key was returned by iteratee. The + * iteratee is invoked with one argument: (value). + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the composed aggregate object. + * + * @example + * countBy([6.1, 4.2, 6.3], Math.floor); // => { '4': 1, '6': 2 } + * countBy(['one', 'two', 'three'], 'length'); // => { '3': 2, '5': 1 } + */ +declare function countBy(collection: ArrayLike | null | undefined, iteratee?: ValueIteratee): Record; +declare function countBy(collection: T | null | undefined, iteratee?: ValueIteratee): Record; + +export { countBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8ed87f657325648bfb6cc9b8940682cc402aa2a9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.d.ts @@ -0,0 +1,19 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Creates an object composed of keys generated from the results of running each element of collection through + * iteratee. The corresponding value of each key is the number of times the key was returned by iteratee. The + * iteratee is invoked with one argument: (value). + * + * @param collection The collection to iterate over. + * @param iteratee The function invoked per iteration. + * @return Returns the composed aggregate object. + * + * @example + * countBy([6.1, 4.2, 6.3], Math.floor); // => { '4': 1, '6': 2 } + * countBy(['one', 'two', 'three'], 'length'); // => { '3': 2, '5': 1 } + */ +declare function countBy(collection: ArrayLike | null | undefined, iteratee?: ValueIteratee): Record; +declare function countBy(collection: T | null | undefined, iteratee?: ValueIteratee): Record; + +export { countBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.js new file mode 100644 index 0000000000000000000000000000000000000000..63a6b1be72c91e17bf79078e9cffed24cf107287 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLike = require('../predicate/isArrayLike.js'); +const iteratee = require('../util/iteratee.js'); + +function countBy(collection, iteratee$1) { + if (collection == null) { + return {}; + } + const array = isArrayLike.isArrayLike(collection) ? Array.from(collection) : Object.values(collection); + const mapper = iteratee.iteratee(iteratee$1 ?? undefined); + const result = Object.create(null); + for (let i = 0; i < array.length; i++) { + const item = array[i]; + const key = mapper(item); + result[key] = (result[key] ?? 0) + 1; + } + return result; +} + +exports.countBy = countBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a2b8a7ce33cea4980d37bb601f33dc9d2e894a93 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/countBy.mjs @@ -0,0 +1,19 @@ +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function countBy(collection, iteratee$1) { + if (collection == null) { + return {}; + } + const array = isArrayLike(collection) ? Array.from(collection) : Object.values(collection); + const mapper = iteratee(iteratee$1 ?? undefined); + const result = Object.create(null); + for (let i = 0; i < array.length; i++) { + const item = array[i]; + const key = mapper(item); + result[key] = (result[key] ?? 0) + 1; + } + return result; +} + +export { countBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fa930875c6273611fd6b715e14dfd44b28117697 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.d.mts @@ -0,0 +1,28 @@ +/** + * Computes the difference between an array and multiple arrays. + * + * @template T + * @param {ArrayLike | undefined | null} arr - The primary array from which to derive the difference. This is the main array + * from which elements will be compared and filtered. + * @param {Array>} values - Multiple arrays containing elements to be excluded from the primary array. + * These arrays will be flattened into a single array, and each element in this array will be checked against the primary array. + * If a match is found, that element will be excluded from the result. + * @returns {T[]} A new array containing the elements that are present in the primary array but not + * in the flattened array. + * + * @example + * const array1 = [1, 2, 3, 4, 5]; + * const array2 = [2, 4]; + * const array3 = [5, 6]; + * const result = difference(array1, array2, array3); + * // result will be [1, 3] since 2, 4, and 5 are in the other arrays and are excluded from the result. + * + * @example + * const arrayLike1 = { 0: 1, 1: 2, 2: 3, length: 3 }; + * const arrayLike2 = { 0: 2, 1: 4, length: 2 }; + * const result = difference(arrayLike1, arrayLike2); + * // result will be [1, 3] since 2 is in both array-like objects and is excluded from the result. + */ +declare function difference(arr: ArrayLike | undefined | null, ...values: Array>): T[]; + +export { difference }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fa930875c6273611fd6b715e14dfd44b28117697 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.d.ts @@ -0,0 +1,28 @@ +/** + * Computes the difference between an array and multiple arrays. + * + * @template T + * @param {ArrayLike | undefined | null} arr - The primary array from which to derive the difference. This is the main array + * from which elements will be compared and filtered. + * @param {Array>} values - Multiple arrays containing elements to be excluded from the primary array. + * These arrays will be flattened into a single array, and each element in this array will be checked against the primary array. + * If a match is found, that element will be excluded from the result. + * @returns {T[]} A new array containing the elements that are present in the primary array but not + * in the flattened array. + * + * @example + * const array1 = [1, 2, 3, 4, 5]; + * const array2 = [2, 4]; + * const array3 = [5, 6]; + * const result = difference(array1, array2, array3); + * // result will be [1, 3] since 2, 4, and 5 are in the other arrays and are excluded from the result. + * + * @example + * const arrayLike1 = { 0: 1, 1: 2, 2: 3, length: 3 }; + * const arrayLike2 = { 0: 2, 1: 4, length: 2 }; + * const result = difference(arrayLike1, arrayLike2); + * // result will be [1, 3] since 2 is in both array-like objects and is excluded from the result. + */ +declare function difference(arr: ArrayLike | undefined | null, ...values: Array>): T[]; + +export { difference }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.js new file mode 100644 index 0000000000000000000000000000000000000000..daa965eac376314a6319f015a29881b05c0d24b1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const difference$1 = require('../../array/difference.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function difference(arr, ...values) { + if (!isArrayLikeObject.isArrayLikeObject(arr)) { + return []; + } + const arr1 = toArray.toArray(arr); + const arr2 = []; + for (let i = 0; i < values.length; i++) { + const value = values[i]; + if (isArrayLikeObject.isArrayLikeObject(value)) { + arr2.push(...Array.from(value)); + } + } + return difference$1.difference(arr1, arr2); +} + +exports.difference = difference; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ef43c249c753b0dfb1a3575f648ca2c689d0a77f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/difference.mjs @@ -0,0 +1,20 @@ +import { difference as difference$1 } from '../../array/difference.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function difference(arr, ...values) { + if (!isArrayLikeObject(arr)) { + return []; + } + const arr1 = toArray(arr); + const arr2 = []; + for (let i = 0; i < values.length; i++) { + const value = values[i]; + if (isArrayLikeObject(value)) { + arr2.push(...Array.from(value)); + } + } + return difference$1(arr1, arr2); +} + +export { difference }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c2a1a1ca3eaf929d0fe35b6ca357d37cd25bfc32 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.d.mts @@ -0,0 +1,108 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values The values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor) + * // => [1.2] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2], [2.3], [1.4], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3, T4 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ArrayLike} values3 The third array of values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2, 3.5], [2.3], [1.4], [3.2], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, values3: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3, T4, T5 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ArrayLike} values3 The third array of values to exclude + * @param {ArrayLike} values4 The fourth array of values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2, 3.5, 4.8], [2.3], [1.4], [3.2], [4.1], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, values3: ArrayLike, values4: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3, T4, T5, T6 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ArrayLike} values3 The third array of values to exclude + * @param {ArrayLike} values4 The fourth array of values to exclude + * @param {ArrayLike} values5 The fifth array of values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2, 3.5, 4.8, 5.3], [2.3], [1.4], [3.2], [4.1], [5.8], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, values3: ArrayLike, values4: ArrayLike, values5: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3, T4, T5, T6, T7 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ArrayLike} values3 The third array of values to exclude + * @param {ArrayLike} values4 The fourth array of values to exclude + * @param {ArrayLike} values5 The fifth array of values to exclude + * @param {...(ArrayLike | ValueIteratee)[]} values Additional arrays of values to exclude and iteratee + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2, 3.5, 4.8, 5.3, 6.7], [2.3], [1.4], [3.2], [4.1], [5.8], [6.2], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, values3: ArrayLike, values4: ArrayLike, values5: ArrayLike, ...values: Array | ValueIteratee>): T1[]; +/** + * Creates an array of array values not included in the other given arrays. + * + * @template T + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {...Array>} values The arrays of values to exclude + * @returns {T[]} Returns the new array of filtered values + * @example + * differenceBy([2, 1], [2, 3]) + * // => [1] + */ +declare function differenceBy(array: ArrayLike | null | undefined, ...values: Array>): T[]; + +export { differenceBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..773fbf75f3de1cb1cc0472b56f81ee0182d2c2cc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.d.ts @@ -0,0 +1,108 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values The values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor) + * // => [1.2] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2], [2.3], [1.4], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3, T4 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ArrayLike} values3 The third array of values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2, 3.5], [2.3], [1.4], [3.2], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, values3: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3, T4, T5 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ArrayLike} values3 The third array of values to exclude + * @param {ArrayLike} values4 The fourth array of values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2, 3.5, 4.8], [2.3], [1.4], [3.2], [4.1], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, values3: ArrayLike, values4: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3, T4, T5, T6 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ArrayLike} values3 The third array of values to exclude + * @param {ArrayLike} values4 The fourth array of values to exclude + * @param {ArrayLike} values5 The fifth array of values to exclude + * @param {ValueIteratee} iteratee The iteratee invoked per element + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2, 3.5, 4.8, 5.3], [2.3], [1.4], [3.2], [4.1], [5.8], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, values3: ArrayLike, values4: ArrayLike, values5: ArrayLike, iteratee: ValueIteratee): T1[]; +/** + * Creates an array of array values not included in the other given arrays using an iteratee function. + * + * @template T1, T2, T3, T4, T5, T6, T7 + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {ArrayLike} values1 The first array of values to exclude + * @param {ArrayLike} values2 The second array of values to exclude + * @param {ArrayLike} values3 The third array of values to exclude + * @param {ArrayLike} values4 The fourth array of values to exclude + * @param {ArrayLike} values5 The fifth array of values to exclude + * @param {...(ArrayLike | ValueIteratee)[]} values Additional arrays of values to exclude and iteratee + * @returns {T1[]} Returns the new array of filtered values + * @example + * differenceBy([2.1, 1.2, 3.5, 4.8, 5.3, 6.7], [2.3], [1.4], [3.2], [4.1], [5.8], [6.2], Math.floor) + * // => [] + */ +declare function differenceBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, values3: ArrayLike, values4: ArrayLike, values5: ArrayLike, ...values: Array | ValueIteratee>): T1[]; +/** + * Creates an array of array values not included in the other given arrays. + * + * @template T + * @param {ArrayLike | null | undefined} array The array to inspect + * @param {...Array>} values The arrays of values to exclude + * @returns {T[]} Returns the new array of filtered values + * @example + * differenceBy([2, 1], [2, 3]) + * // => [1] + */ +declare function differenceBy(array: ArrayLike | null | undefined, ...values: Array>): T[]; + +export { differenceBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.js new file mode 100644 index 0000000000000000000000000000000000000000..8f9f57ef82ad081dffd3a1e514c196575021ab7d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.js @@ -0,0 +1,24 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const last = require('./last.js'); +const difference = require('../../array/difference.js'); +const differenceBy$1 = require('../../array/differenceBy.js'); +const flattenArrayLike = require('../_internal/flattenArrayLike.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); +const iteratee = require('../util/iteratee.js'); + +function differenceBy(arr, ..._values) { + if (!isArrayLikeObject.isArrayLikeObject(arr)) { + return []; + } + const iteratee$1 = last.last(_values); + const values = flattenArrayLike.flattenArrayLike(_values); + if (isArrayLikeObject.isArrayLikeObject(iteratee$1)) { + return difference.difference(Array.from(arr), values); + } + return differenceBy$1.differenceBy(Array.from(arr), values, iteratee.iteratee(iteratee$1)); +} + +exports.differenceBy = differenceBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e69b8a517f486640031a489c5d01376eb68b2d91 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceBy.mjs @@ -0,0 +1,20 @@ +import { last } from './last.mjs'; +import { difference } from '../../array/difference.mjs'; +import { differenceBy as differenceBy$1 } from '../../array/differenceBy.mjs'; +import { flattenArrayLike } from '../_internal/flattenArrayLike.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function differenceBy(arr, ..._values) { + if (!isArrayLikeObject(arr)) { + return []; + } + const iteratee$1 = last(_values); + const values = flattenArrayLike(_values); + if (isArrayLikeObject(iteratee$1)) { + return difference(Array.from(arr), values); + } + return differenceBy$1(Array.from(arr), values, iteratee(iteratee$1)); +} + +export { differenceBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..952d84f52bd3b67e110e474fbb422c0d89119912 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.d.mts @@ -0,0 +1,91 @@ +/** + * Computes the difference between the primary array and another array using a comparator function. + * + * @template T1, T2 + * @param {ArrayLike | null | undefined} array - The primary array to compare elements against. + * @param {ArrayLike} values - The array containing elements to compare with the primary array. + * @param {(a: T1, b: T2) => boolean} comparator - A function to determine if two elements are considered equal. + * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values` based on the comparator. + * + * @example + * const array = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const values = [{ id: 2 }]; + * const comparator = (a, b) => a.id === b.id; + * + * const result = differenceWith(array, values, comparator); + * // result will be [{ id: 1 }, { id: 3 }] + */ +declare function differenceWith(array: ArrayLike | null | undefined, values: ArrayLike, comparator: (a: T1, b: T2) => boolean): T1[]; +/** + * Computes the difference between the primary array and two arrays using a comparator function. + * + * @template T1, T2, T3 + * @param {ArrayLike | null | undefined} array - The primary array to compare elements against. + * @param {ArrayLike} values1 - The first array containing elements to compare with the primary array. + * @param {ArrayLike} values2 - The second array containing elements to compare with the primary array. + * @param {(a: T1, b: T2 | T3) => boolean} comparator - A function to determine if two elements are considered equal. + * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values1` or `values2` based on the comparator. + * + * @example + * const array = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const values1 = [{ id: 2 }]; + * const values2 = [{ id: 3 }]; + * const comparator = (a, b) => a.id === b.id; + * + * const result = differenceWith(array, values1, values2, comparator); + * // result will be [{ id: 1 }] + */ +declare function differenceWith(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, comparator: (a: T1, b: T2 | T3) => boolean): T1[]; +/** + * Computes the difference between the primary array and multiple arrays using a comparator function. + * + * @template T1, T2, T3, T4 + * @param {ArrayLike | null | undefined} array - The primary array to compare elements against. + * @param {ArrayLike} values1 - The first array containing elements to compare with the primary array. + * @param {ArrayLike} values2 - The second array containing elements to compare with the primary array. + * @param {...Array | ((a: T1, b: T2 | T3 | T4) => boolean)>} values - Additional arrays and an optional comparator function to determine if two elements are considered equal. + * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements + * in `values1`, `values2`, or subsequent arrays. If a comparator function is provided, it will be used to compare elements; + * otherwise, [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero) algorithm will be used. + * + * @example + * // Example with comparator function + * const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }]; + * const values1 = [{ id: 2 }]; + * const values2 = [{ id: 3 }]; + * const values3 = [{ id: 4 }]; + * const comparator = (a, b) => a.id === b.id; + * + * const result = differenceWith(array, values1, values2, values3, comparator); + * // result will be [{ id: 1 }] + * + * @example + * // Example without comparator function (behaves like `difference`) + * const array = [1, 2, 3, 4]; + * const values1 = [2]; + * const values2 = [3]; + * const values3 = [4]; + * + * const result = differenceWith(array, values1, values2, values3); + * // result will be [1] + */ +declare function differenceWith(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, ...values: Array | ((a: T1, b: T2 | T3 | T4) => boolean)>): T1[]; +/** + * Computes the difference between the primary array and one or more arrays without using a comparator function. + * + * @template T + * @param {ArrayLike | null | undefined} array - The primary array to compare elements against. + * @param {...Array>} values - One or more arrays containing elements to compare with the primary array. + * @returns {T[]} A new array containing the elements from the primary array that do not match any elements in the provided arrays. + * + * @example + * const array = [1, 2, 3]; + * const values1 = [2]; + * const values2 = [3]; + * + * const result = differenceWith(array, values1, values2); + * // result will be [1] + */ +declare function differenceWith(array: ArrayLike | null | undefined, ...values: Array>): T[]; + +export { differenceWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..952d84f52bd3b67e110e474fbb422c0d89119912 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.d.ts @@ -0,0 +1,91 @@ +/** + * Computes the difference between the primary array and another array using a comparator function. + * + * @template T1, T2 + * @param {ArrayLike | null | undefined} array - The primary array to compare elements against. + * @param {ArrayLike} values - The array containing elements to compare with the primary array. + * @param {(a: T1, b: T2) => boolean} comparator - A function to determine if two elements are considered equal. + * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values` based on the comparator. + * + * @example + * const array = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const values = [{ id: 2 }]; + * const comparator = (a, b) => a.id === b.id; + * + * const result = differenceWith(array, values, comparator); + * // result will be [{ id: 1 }, { id: 3 }] + */ +declare function differenceWith(array: ArrayLike | null | undefined, values: ArrayLike, comparator: (a: T1, b: T2) => boolean): T1[]; +/** + * Computes the difference between the primary array and two arrays using a comparator function. + * + * @template T1, T2, T3 + * @param {ArrayLike | null | undefined} array - The primary array to compare elements against. + * @param {ArrayLike} values1 - The first array containing elements to compare with the primary array. + * @param {ArrayLike} values2 - The second array containing elements to compare with the primary array. + * @param {(a: T1, b: T2 | T3) => boolean} comparator - A function to determine if two elements are considered equal. + * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements in `values1` or `values2` based on the comparator. + * + * @example + * const array = [{ id: 1 }, { id: 2 }, { id: 3 }]; + * const values1 = [{ id: 2 }]; + * const values2 = [{ id: 3 }]; + * const comparator = (a, b) => a.id === b.id; + * + * const result = differenceWith(array, values1, values2, comparator); + * // result will be [{ id: 1 }] + */ +declare function differenceWith(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, comparator: (a: T1, b: T2 | T3) => boolean): T1[]; +/** + * Computes the difference between the primary array and multiple arrays using a comparator function. + * + * @template T1, T2, T3, T4 + * @param {ArrayLike | null | undefined} array - The primary array to compare elements against. + * @param {ArrayLike} values1 - The first array containing elements to compare with the primary array. + * @param {ArrayLike} values2 - The second array containing elements to compare with the primary array. + * @param {...Array | ((a: T1, b: T2 | T3 | T4) => boolean)>} values - Additional arrays and an optional comparator function to determine if two elements are considered equal. + * @returns {T1[]} A new array containing the elements from the primary array that do not match any elements + * in `values1`, `values2`, or subsequent arrays. If a comparator function is provided, it will be used to compare elements; + * otherwise, [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero) algorithm will be used. + * + * @example + * // Example with comparator function + * const array = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }]; + * const values1 = [{ id: 2 }]; + * const values2 = [{ id: 3 }]; + * const values3 = [{ id: 4 }]; + * const comparator = (a, b) => a.id === b.id; + * + * const result = differenceWith(array, values1, values2, values3, comparator); + * // result will be [{ id: 1 }] + * + * @example + * // Example without comparator function (behaves like `difference`) + * const array = [1, 2, 3, 4]; + * const values1 = [2]; + * const values2 = [3]; + * const values3 = [4]; + * + * const result = differenceWith(array, values1, values2, values3); + * // result will be [1] + */ +declare function differenceWith(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, ...values: Array | ((a: T1, b: T2 | T3 | T4) => boolean)>): T1[]; +/** + * Computes the difference between the primary array and one or more arrays without using a comparator function. + * + * @template T + * @param {ArrayLike | null | undefined} array - The primary array to compare elements against. + * @param {...Array>} values - One or more arrays containing elements to compare with the primary array. + * @returns {T[]} A new array containing the elements from the primary array that do not match any elements in the provided arrays. + * + * @example + * const array = [1, 2, 3]; + * const values1 = [2]; + * const values2 = [3]; + * + * const result = differenceWith(array, values1, values2); + * // result will be [1] + */ +declare function differenceWith(array: ArrayLike | null | undefined, ...values: Array>): T[]; + +export { differenceWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.js new file mode 100644 index 0000000000000000000000000000000000000000..2ce5799dd53afa12b124205de332326f8b0dc39f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const last = require('./last.js'); +const difference = require('../../array/difference.js'); +const differenceWith$1 = require('../../array/differenceWith.js'); +const flattenArrayLike = require('../_internal/flattenArrayLike.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function differenceWith(array, ...values) { + if (!isArrayLikeObject.isArrayLikeObject(array)) { + return []; + } + const comparator = last.last(values); + const flattenedValues = flattenArrayLike.flattenArrayLike(values); + if (typeof comparator === 'function') { + return differenceWith$1.differenceWith(Array.from(array), flattenedValues, comparator); + } + return difference.difference(Array.from(array), flattenedValues); +} + +exports.differenceWith = differenceWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c0ebece7a993ea1c277a70701f7c1bae164a00a2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/differenceWith.mjs @@ -0,0 +1,19 @@ +import { last } from './last.mjs'; +import { difference } from '../../array/difference.mjs'; +import { differenceWith as differenceWith$1 } from '../../array/differenceWith.mjs'; +import { flattenArrayLike } from '../_internal/flattenArrayLike.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function differenceWith(array, ...values) { + if (!isArrayLikeObject(array)) { + return []; + } + const comparator = last(values); + const flattenedValues = flattenArrayLike(values); + if (typeof comparator === 'function') { + return differenceWith$1(Array.from(array), flattenedValues, comparator); + } + return difference(Array.from(array), flattenedValues); +} + +export { differenceWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8c2ebc3ee757513b8446d673a1a3b31574cb4fa9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.d.mts @@ -0,0 +1,20 @@ +/** + * Removes a specified number of elements from the beginning of an array and returns the rest. + * + * This function takes an array and a number, and returns a new array with the specified number + * of elements removed from the start. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} collection - The array from which to drop elements. + * @param {number} itemsCount - The number of elements to drop from the beginning of the array. + * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`. + * @returns {T[]} A new array with the specified number of elements removed from the start. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const result = drop(array, 2); + * result will be [3, 4, 5] since the first two elements are dropped. + */ +declare function drop(array: ArrayLike | null | undefined, n?: number): T[]; + +export { drop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8c2ebc3ee757513b8446d673a1a3b31574cb4fa9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.d.ts @@ -0,0 +1,20 @@ +/** + * Removes a specified number of elements from the beginning of an array and returns the rest. + * + * This function takes an array and a number, and returns a new array with the specified number + * of elements removed from the start. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} collection - The array from which to drop elements. + * @param {number} itemsCount - The number of elements to drop from the beginning of the array. + * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`. + * @returns {T[]} A new array with the specified number of elements removed from the start. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const result = drop(array, 2); + * result will be [3, 4, 5] since the first two elements are dropped. + */ +declare function drop(array: ArrayLike | null | undefined, n?: number): T[]; + +export { drop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.js new file mode 100644 index 0000000000000000000000000000000000000000..a7fb13f06cf5171400939b594c055366c4838edc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const drop$1 = require('../../array/drop.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const toInteger = require('../util/toInteger.js'); + +function drop(collection, itemsCount = 1, guard) { + if (!isArrayLike.isArrayLike(collection)) { + return []; + } + itemsCount = guard ? 1 : toInteger.toInteger(itemsCount); + return drop$1.drop(toArray.toArray(collection), itemsCount); +} + +exports.drop = drop; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6443ac7bbec1849a039c66af0a602c6472e5f944 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/drop.mjs @@ -0,0 +1,14 @@ +import { drop as drop$1 } from '../../array/drop.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { toInteger } from '../util/toInteger.mjs'; + +function drop(collection, itemsCount = 1, guard) { + if (!isArrayLike(collection)) { + return []; + } + itemsCount = guard ? 1 : toInteger(itemsCount); + return drop$1(toArray(collection), itemsCount); +} + +export { drop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7f2a126f13068aba6d999bc73d8803b166f92729 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.d.mts @@ -0,0 +1,20 @@ +/** + * Removes a specified number of elements from the end of an array and returns the rest. + * + * This function takes an array and a number, and returns a new array with the specified number + * of elements removed from the end. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} collection - The array from which to drop elements. + * @param {number} itemsCount - The number of elements to drop from the end of the array. + * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`. + * @returns {T[]} A new array with the specified number of elements removed from the end. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const result = dropRight(array, 2); + * // result will be [1, 2, 3] since the last two elements are dropped. + */ +declare function dropRight(array: ArrayLike | null | undefined, n?: number): T[]; + +export { dropRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7f2a126f13068aba6d999bc73d8803b166f92729 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.d.ts @@ -0,0 +1,20 @@ +/** + * Removes a specified number of elements from the end of an array and returns the rest. + * + * This function takes an array and a number, and returns a new array with the specified number + * of elements removed from the end. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} collection - The array from which to drop elements. + * @param {number} itemsCount - The number of elements to drop from the end of the array. + * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`. + * @returns {T[]} A new array with the specified number of elements removed from the end. + * + * @example + * const array = [1, 2, 3, 4, 5]; + * const result = dropRight(array, 2); + * // result will be [1, 2, 3] since the last two elements are dropped. + */ +declare function dropRight(array: ArrayLike | null | undefined, n?: number): T[]; + +export { dropRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.js new file mode 100644 index 0000000000000000000000000000000000000000..bd3396e129021664fef6f564b6e869a7fc313be2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const dropRight$1 = require('../../array/dropRight.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const toInteger = require('../util/toInteger.js'); + +function dropRight(collection, itemsCount = 1, guard) { + if (!isArrayLike.isArrayLike(collection)) { + return []; + } + itemsCount = guard ? 1 : toInteger.toInteger(itemsCount); + return dropRight$1.dropRight(toArray.toArray(collection), itemsCount); +} + +exports.dropRight = dropRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..dd93fd2e07bd2ae6126c4f3c376fa3b9ee7056c8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRight.mjs @@ -0,0 +1,14 @@ +import { dropRight as dropRight$1 } from '../../array/dropRight.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { toInteger } from '../util/toInteger.mjs'; + +function dropRight(collection, itemsCount = 1, guard) { + if (!isArrayLike(collection)) { + return []; + } + itemsCount = guard ? 1 : toInteger(itemsCount); + return dropRight$1(toArray(collection), itemsCount); +} + +export { dropRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..54046fdf21aa40e8f17674d7036a215da69313e3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.d.mts @@ -0,0 +1,37 @@ +import { ListIteratee } from '../_internal/ListIteratee.mjs'; + +/** + * Creates a slice of array excluding elements dropped from the end until predicate returns falsey. + * The predicate is invoked with three arguments: (value, index, array). + * + * @template T - The type of elements in the array. + * @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 } + * ]; + * + * // Using function predicate + * dropRightWhile(users, user => !user.active); + * // => [{ user: 'barney', active: true }] + * + * // Using matches shorthand + * dropRightWhile(users, { user: 'pebbles', active: false }); + * // => [{ user: 'barney', active: true }, { user: 'fred', active: false }] + * + * // Using matchesProperty shorthand + * dropRightWhile(users, ['active', false]); + * // => [{ user: 'barney', active: true }] + * + * // Using property shorthand + * dropRightWhile(users, 'active'); + * // => [{ user: 'barney', active: true }] + */ +declare function dropRightWhile(array: ArrayLike | null | undefined, predicate?: ListIteratee): T[]; + +export { dropRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee40728d435e256c5cb417f76dc7c514d206bb95 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.d.ts @@ -0,0 +1,37 @@ +import { ListIteratee } from '../_internal/ListIteratee.js'; + +/** + * Creates a slice of array excluding elements dropped from the end until predicate returns falsey. + * The predicate is invoked with three arguments: (value, index, array). + * + * @template T - The type of elements in the array. + * @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 } + * ]; + * + * // Using function predicate + * dropRightWhile(users, user => !user.active); + * // => [{ user: 'barney', active: true }] + * + * // Using matches shorthand + * dropRightWhile(users, { user: 'pebbles', active: false }); + * // => [{ user: 'barney', active: true }, { user: 'fred', active: false }] + * + * // Using matchesProperty shorthand + * dropRightWhile(users, ['active', false]); + * // => [{ user: 'barney', active: true }] + * + * // Using property shorthand + * dropRightWhile(users, 'active'); + * // => [{ user: 'barney', active: true }] + */ +declare function dropRightWhile(array: ArrayLike | null | undefined, predicate?: ListIteratee): T[]; + +export { dropRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.js new file mode 100644 index 0000000000000000000000000000000000000000..99f5b700d2e5e824a66765871703e38d387711c9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.js @@ -0,0 +1,41 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const dropRightWhile$1 = require('../../array/dropRightWhile.js'); +const identity = require('../../function/identity.js'); +const property = require('../object/property.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const matches = require('../predicate/matches.js'); +const matchesProperty = require('../predicate/matchesProperty.js'); + +function dropRightWhile(arr, predicate = identity.identity) { + if (!isArrayLike.isArrayLike(arr)) { + return []; + } + return dropRightWhileImpl(Array.from(arr), predicate); +} +function dropRightWhileImpl(arr, predicate) { + switch (typeof predicate) { + case 'function': { + return dropRightWhile$1.dropRightWhile(arr, (item, index, arr) => Boolean(predicate(item, index, arr))); + } + case 'object': { + if (Array.isArray(predicate) && predicate.length === 2) { + const key = predicate[0]; + const value = predicate[1]; + return dropRightWhile$1.dropRightWhile(arr, matchesProperty.matchesProperty(key, value)); + } + else { + return dropRightWhile$1.dropRightWhile(arr, matches.matches(predicate)); + } + } + case 'symbol': + case 'number': + case 'string': { + return dropRightWhile$1.dropRightWhile(arr, property.property(predicate)); + } + } +} + +exports.dropRightWhile = dropRightWhile; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2b3dd23b0f7cbc9df2063f1793825e4462a5f239 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropRightWhile.mjs @@ -0,0 +1,37 @@ +import { dropRightWhile as dropRightWhile$1 } from '../../array/dropRightWhile.mjs'; +import { identity } from '../../function/identity.mjs'; +import { property } from '../object/property.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { matches } from '../predicate/matches.mjs'; +import { matchesProperty } from '../predicate/matchesProperty.mjs'; + +function dropRightWhile(arr, predicate = identity) { + if (!isArrayLike(arr)) { + return []; + } + return dropRightWhileImpl(Array.from(arr), predicate); +} +function dropRightWhileImpl(arr, predicate) { + switch (typeof predicate) { + case 'function': { + return dropRightWhile$1(arr, (item, index, arr) => Boolean(predicate(item, index, arr))); + } + case 'object': { + if (Array.isArray(predicate) && predicate.length === 2) { + const key = predicate[0]; + const value = predicate[1]; + return dropRightWhile$1(arr, matchesProperty(key, value)); + } + else { + return dropRightWhile$1(arr, matches(predicate)); + } + } + case 'symbol': + case 'number': + case 'string': { + return dropRightWhile$1(arr, property(predicate)); + } + } +} + +export { dropRightWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0e3c0a631fdbef53c7e76a471ad25c457389ffec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.d.mts @@ -0,0 +1,28 @@ +import { ListIteratee } from '../_internal/ListIteratee.mjs'; + +/** + * Creates a slice of array excluding elements dropped from the beginning. + * Elements are dropped until predicate returns falsey. + * The predicate is invoked with three arguments: (value, index, array). + * + * @template T - The type of elements in the array + * @param {ArrayLike | null | undefined} arr - The array to query + * @param {ListIteratee} [predicate=identity] - The function invoked per iteration + * @returns {T[]} Returns the slice of array + * + * @example + * dropWhile([1, 2, 3], n => n < 3) + * // => [3] + * + * dropWhile([{ a: 1, b: 2 }, { a: 1, b: 3 }], { a: 1 }) + * // => [{ a: 1, b: 3 }] + * + * dropWhile([{ a: 1, b: 2 }, { a: 1, b: 3 }], ['a', 1]) + * // => [{ a: 1, b: 3 }] + * + * dropWhile([{ a: 1, b: 2 }, { a: 1, b: 3 }], 'a') + * // => [] + */ +declare function dropWhile(arr: ArrayLike | null | undefined, predicate?: ListIteratee): T[]; + +export { dropWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1ace427d3d4a1ecc85751584df663638b7964cae --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.d.ts @@ -0,0 +1,28 @@ +import { ListIteratee } from '../_internal/ListIteratee.js'; + +/** + * Creates a slice of array excluding elements dropped from the beginning. + * Elements are dropped until predicate returns falsey. + * The predicate is invoked with three arguments: (value, index, array). + * + * @template T - The type of elements in the array + * @param {ArrayLike | null | undefined} arr - The array to query + * @param {ListIteratee} [predicate=identity] - The function invoked per iteration + * @returns {T[]} Returns the slice of array + * + * @example + * dropWhile([1, 2, 3], n => n < 3) + * // => [3] + * + * dropWhile([{ a: 1, b: 2 }, { a: 1, b: 3 }], { a: 1 }) + * // => [{ a: 1, b: 3 }] + * + * dropWhile([{ a: 1, b: 2 }, { a: 1, b: 3 }], ['a', 1]) + * // => [{ a: 1, b: 3 }] + * + * dropWhile([{ a: 1, b: 2 }, { a: 1, b: 3 }], 'a') + * // => [] + */ +declare function dropWhile(arr: ArrayLike | null | undefined, predicate?: ListIteratee): T[]; + +export { dropWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.js new file mode 100644 index 0000000000000000000000000000000000000000..50462310c7ea47044b8d40f065e3d00b94801de2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.js @@ -0,0 +1,42 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const dropWhile$1 = require('../../array/dropWhile.js'); +const identity = require('../../function/identity.js'); +const toArray = require('../_internal/toArray.js'); +const property = require('../object/property.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const matches = require('../predicate/matches.js'); +const matchesProperty = require('../predicate/matchesProperty.js'); + +function dropWhile(arr, predicate = identity.identity) { + if (!isArrayLike.isArrayLike(arr)) { + return []; + } + return dropWhileImpl(toArray.toArray(arr), predicate); +} +function dropWhileImpl(arr, predicate) { + switch (typeof predicate) { + case 'function': { + return dropWhile$1.dropWhile(arr, (item, index, arr) => Boolean(predicate(item, index, arr))); + } + case 'object': { + if (Array.isArray(predicate) && predicate.length === 2) { + const key = predicate[0]; + const value = predicate[1]; + return dropWhile$1.dropWhile(arr, matchesProperty.matchesProperty(key, value)); + } + else { + return dropWhile$1.dropWhile(arr, matches.matches(predicate)); + } + } + case 'number': + case 'symbol': + case 'string': { + return dropWhile$1.dropWhile(arr, property.property(predicate)); + } + } +} + +exports.dropWhile = dropWhile; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e06f83cf48668a89799f9eac47f3168410706367 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/dropWhile.mjs @@ -0,0 +1,38 @@ +import { dropWhile as dropWhile$1 } from '../../array/dropWhile.mjs'; +import { identity } from '../../function/identity.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { property } from '../object/property.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { matches } from '../predicate/matches.mjs'; +import { matchesProperty } from '../predicate/matchesProperty.mjs'; + +function dropWhile(arr, predicate = identity) { + if (!isArrayLike(arr)) { + return []; + } + return dropWhileImpl(toArray(arr), predicate); +} +function dropWhileImpl(arr, predicate) { + switch (typeof predicate) { + case 'function': { + return dropWhile$1(arr, (item, index, arr) => Boolean(predicate(item, index, arr))); + } + case 'object': { + if (Array.isArray(predicate) && predicate.length === 2) { + const key = predicate[0]; + const value = predicate[1]; + return dropWhile$1(arr, matchesProperty(key, value)); + } + else { + return dropWhile$1(arr, matches(predicate)); + } + } + case 'number': + case 'symbol': + case 'string': { + return dropWhile$1(arr, property(predicate)); + } + } +} + +export { dropWhile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..039a7a03ef69a678009df2408c5655795e09dcaa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.d.mts @@ -0,0 +1,64 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.mjs'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.mjs'; + +/** + * Checks if all elements in a collection pass the predicate check. + * The predicate is invoked with three arguments: (value, index|key, collection). + * + * @template T - The type of elements in the collection + * @param {ArrayLike | null | undefined} collection - The collection to iterate over + * @param {ListIterateeCustom} [predicate=identity] - The function invoked per iteration + * @returns {boolean} Returns true if all elements pass the predicate check, else false + * + * @example + * // Using a function predicate + * every([true, 1, null, 'yes'], Boolean) + * // => false + * + * // Using property shorthand + * const users = [{ user: 'barney', age: 36 }, { user: 'fred', age: 40 }] + * every(users, 'age') + * // => true + * + * // Using matches shorthand + * every(users, { age: 36 }) + * // => false + * + * // Using matchesProperty shorthand + * every(users, ['age', 36]) + * // => false + */ +declare function every(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom): boolean; +/** + * Checks if all elements in an object pass the predicate check. + * The predicate is invoked with three arguments: (value, key, object). + * + * @template T - The type of the object + * @param {T | null | undefined} collection - The object to iterate over + * @param {ObjectIterateeCustom} [predicate=identity] - The function invoked per iteration + * @returns {boolean} Returns true if all elements pass the predicate check, else false + * + * @example + * // Using a function predicate + * every({ a: true, b: 1, c: null }, Boolean) + * // => false + * + * // Using property shorthand + * const users = { + * barney: { active: true, age: 36 }, + * fred: { active: true, age: 40 } + * } + * every(users, 'active') + * // => true + * + * // Using matches shorthand + * every(users, { active: true }) + * // => true + * + * // Using matchesProperty shorthand + * every(users, ['age', 36]) + * // => false + */ +declare function every(collection: T | null | undefined, predicate?: ObjectIterateeCustom): boolean; + +export { every }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..33e941c46c204f440524a9d8a6ce092d499aba80 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.d.ts @@ -0,0 +1,64 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.js'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.js'; + +/** + * Checks if all elements in a collection pass the predicate check. + * The predicate is invoked with three arguments: (value, index|key, collection). + * + * @template T - The type of elements in the collection + * @param {ArrayLike | null | undefined} collection - The collection to iterate over + * @param {ListIterateeCustom} [predicate=identity] - The function invoked per iteration + * @returns {boolean} Returns true if all elements pass the predicate check, else false + * + * @example + * // Using a function predicate + * every([true, 1, null, 'yes'], Boolean) + * // => false + * + * // Using property shorthand + * const users = [{ user: 'barney', age: 36 }, { user: 'fred', age: 40 }] + * every(users, 'age') + * // => true + * + * // Using matches shorthand + * every(users, { age: 36 }) + * // => false + * + * // Using matchesProperty shorthand + * every(users, ['age', 36]) + * // => false + */ +declare function every(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom): boolean; +/** + * Checks if all elements in an object pass the predicate check. + * The predicate is invoked with three arguments: (value, key, object). + * + * @template T - The type of the object + * @param {T | null | undefined} collection - The object to iterate over + * @param {ObjectIterateeCustom} [predicate=identity] - The function invoked per iteration + * @returns {boolean} Returns true if all elements pass the predicate check, else false + * + * @example + * // Using a function predicate + * every({ a: true, b: 1, c: null }, Boolean) + * // => false + * + * // Using property shorthand + * const users = { + * barney: { active: true, age: 36 }, + * fred: { active: true, age: 40 } + * } + * every(users, 'active') + * // => true + * + * // Using matches shorthand + * every(users, { active: true }) + * // => true + * + * // Using matchesProperty shorthand + * every(users, ['age', 36]) + * // => false + */ +declare function every(collection: T | null | undefined, predicate?: ObjectIterateeCustom): boolean; + +export { every }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.js new file mode 100644 index 0000000000000000000000000000000000000000..13d99d79d5b08dfd3305fd1c9d45067b4b6acb5a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.js @@ -0,0 +1,64 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const isIterateeCall = require('../_internal/isIterateeCall.js'); +const property = require('../object/property.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const matches = require('../predicate/matches.js'); +const matchesProperty = require('../predicate/matchesProperty.js'); + +function every(source, doesMatch, guard) { + if (!source) { + return true; + } + if (guard && isIterateeCall.isIterateeCall(source, doesMatch, guard)) { + doesMatch = undefined; + } + if (!doesMatch) { + doesMatch = identity.identity; + } + let predicate; + switch (typeof doesMatch) { + case 'function': { + predicate = doesMatch; + break; + } + case 'object': { + if (Array.isArray(doesMatch) && doesMatch.length === 2) { + const key = doesMatch[0]; + const value = doesMatch[1]; + predicate = matchesProperty.matchesProperty(key, value); + } + else { + predicate = matches.matches(doesMatch); + } + break; + } + case 'symbol': + case 'number': + case 'string': { + predicate = property.property(doesMatch); + } + } + if (!isArrayLike.isArrayLike(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 false; + } + } + return true; + } + for (let i = 0; i < source.length; i++) { + if (!predicate(source[i], i, source)) { + return false; + } + } + return true; +} + +exports.every = every; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2b9fd8e8f1280d3a833cbcb80015a17e02cd358d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/every.mjs @@ -0,0 +1,60 @@ +import { identity } from '../../function/identity.mjs'; +import { isIterateeCall } from '../_internal/isIterateeCall.mjs'; +import { property } from '../object/property.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { matches } from '../predicate/matches.mjs'; +import { matchesProperty } from '../predicate/matchesProperty.mjs'; + +function every(source, doesMatch, guard) { + if (!source) { + return true; + } + if (guard && isIterateeCall(source, doesMatch, guard)) { + doesMatch = undefined; + } + if (!doesMatch) { + doesMatch = identity; + } + let predicate; + switch (typeof doesMatch) { + case 'function': { + predicate = doesMatch; + break; + } + case 'object': { + if (Array.isArray(doesMatch) && doesMatch.length === 2) { + const key = doesMatch[0]; + const value = doesMatch[1]; + predicate = matchesProperty(key, value); + } + else { + predicate = matches(doesMatch); + } + break; + } + case 'symbol': + case 'number': + case 'string': { + predicate = property(doesMatch); + } + } + if (!isArrayLike(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 false; + } + } + return true; + } + for (let i = 0; i < source.length; i++) { + if (!predicate(source[i], i, source)) { + return false; + } + } + return true; +} + +export { every }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..adece5c22a42c528e51a313057aef411258b8c8a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.d.mts @@ -0,0 +1,50 @@ +/** + * Fills an array with a value. + * @template T + * @param {any[] | null | undefined} array - The array to fill + * @param {T} value - The value to fill array with + * @returns {T[]} Returns the filled array + * @example + * fill([1, 2, 3], 'a') + * // => ['a', 'a', 'a'] + */ +declare function fill(array: any[] | null | undefined, value: T): T[]; +/** + * Fills an array-like object with a value. + * @template T, U + * @param {U extends readonly any[] ? never : U | null | undefined} array - The array-like object to fill + * @param {T} value - The value to fill array with + * @returns {ArrayLike} Returns the filled array-like object + * @example + * fill({ length: 3 }, 2) + * // => { 0: 2, 1: 2, 2: 2, length: 3 } + */ +declare function fill>(array: U extends readonly any[] ? never : U | null | undefined, value: T): ArrayLike; +/** + * Fills an array with a value from start up to end. + * @template T, U + * @param {U[] | null | undefined} array - The array to fill + * @param {T} value - The value to fill array with + * @param {number} [start=0] - The start position + * @param {number} [end=array.length] - The end position + * @returns {Array} Returns the filled array + * @example + * fill([1, 2, 3], 'a', 1, 2) + * // => [1, 'a', 3] + */ +declare function fill(array: U[] | null | undefined, value: T, start?: number, end?: number): Array; +/** + * Fills an array-like object with a value from start up to end. + * @template T, U + * @param {U extends readonly any[] ? never : U | null | undefined} array - The array-like object to fill + * @param {T} value - The value to fill array with + * @param {number} [start=0] - The start position + * @param {number} [end=array.length] - The end position + * @returns {ArrayLike} Returns the filled array-like object + * @example + * fill({ 0: 1, 1: 2, 2: 3, length: 3 }, 'a', 1, 2) + * // => { 0: 1, 1: 'a', 2: 3, length: 3 } + */ +declare function fill>(array: U extends readonly any[] ? never : U | null | undefined, value: T, start?: number, end?: number): ArrayLike; + +export { fill }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..adece5c22a42c528e51a313057aef411258b8c8a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.d.ts @@ -0,0 +1,50 @@ +/** + * Fills an array with a value. + * @template T + * @param {any[] | null | undefined} array - The array to fill + * @param {T} value - The value to fill array with + * @returns {T[]} Returns the filled array + * @example + * fill([1, 2, 3], 'a') + * // => ['a', 'a', 'a'] + */ +declare function fill(array: any[] | null | undefined, value: T): T[]; +/** + * Fills an array-like object with a value. + * @template T, U + * @param {U extends readonly any[] ? never : U | null | undefined} array - The array-like object to fill + * @param {T} value - The value to fill array with + * @returns {ArrayLike} Returns the filled array-like object + * @example + * fill({ length: 3 }, 2) + * // => { 0: 2, 1: 2, 2: 2, length: 3 } + */ +declare function fill>(array: U extends readonly any[] ? never : U | null | undefined, value: T): ArrayLike; +/** + * Fills an array with a value from start up to end. + * @template T, U + * @param {U[] | null | undefined} array - The array to fill + * @param {T} value - The value to fill array with + * @param {number} [start=0] - The start position + * @param {number} [end=array.length] - The end position + * @returns {Array} Returns the filled array + * @example + * fill([1, 2, 3], 'a', 1, 2) + * // => [1, 'a', 3] + */ +declare function fill(array: U[] | null | undefined, value: T, start?: number, end?: number): Array; +/** + * Fills an array-like object with a value from start up to end. + * @template T, U + * @param {U extends readonly any[] ? never : U | null | undefined} array - The array-like object to fill + * @param {T} value - The value to fill array with + * @param {number} [start=0] - The start position + * @param {number} [end=array.length] - The end position + * @returns {ArrayLike} Returns the filled array-like object + * @example + * fill({ 0: 1, 1: 2, 2: 3, length: 3 }, 'a', 1, 2) + * // => { 0: 1, 1: 'a', 2: 3, length: 3 } + */ +declare function fill>(array: U extends readonly any[] ? never : U | null | undefined, value: T, start?: number, end?: number): ArrayLike; + +export { fill }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.js new file mode 100644 index 0000000000000000000000000000000000000000..95711da5e4d2467120583ad7749d5b90feab2bb5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const fill$1 = require('../../array/fill.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isString = require('../predicate/isString.js'); + +function fill(array, value, start = 0, end = array ? array.length : 0) { + if (!isArrayLike.isArrayLike(array)) { + return []; + } + if (isString.isString(array)) { + return array; + } + start = Math.floor(start); + end = Math.floor(end); + if (!start) { + start = 0; + } + if (!end) { + end = 0; + } + return fill$1.fill(array, value, start, end); +} + +exports.fill = fill; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a145e4e03c41dab7aa0397310f06c300a505f863 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/fill.mjs @@ -0,0 +1,23 @@ +import { fill as fill$1 } from '../../array/fill.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isString } from '../predicate/isString.mjs'; + +function fill(array, value, start = 0, end = array ? array.length : 0) { + if (!isArrayLike(array)) { + return []; + } + if (isString(array)) { + return array; + } + start = Math.floor(start); + end = Math.floor(end); + if (!start) { + start = 0; + } + if (!end) { + end = 0; + } + return fill$1(array, value, start, end); +} + +export { fill }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5ea7530733a04f2a76b6cb49cae7c6ffed1f23d0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.d.mts @@ -0,0 +1,74 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.mjs'; +import { ListIteratorTypeGuard } from '../_internal/ListIteratorTypeGuard.mjs'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.mjs'; +import { ObjectIteratorTypeGuard } from '../_internal/ObjectIterator.mjs'; +import { StringIterator } from '../_internal/StringIterator.mjs'; + +/** + * Filters characters in a string based on the predicate function. + * + * @param collection - The string to filter + * @param predicate - The function to test each character + * @returns An array of characters that pass the predicate test + * + * @example + * filter('123', char => char === '2') + * // => ['2'] + */ +declare function filter(collection: string | null | undefined, predicate?: StringIterator): string[]; +/** + * Filters elements in an array-like object using a type guard predicate. + * + * @param collection - The array-like object to filter + * @param predicate - The type guard function to test each element + * @returns An array of elements that are of type U + * + * @example + * filter([1, '2', 3], (x): x is number => typeof x === 'number') + * // => [1, 3] + */ +declare function filter(collection: ArrayLike | null | undefined, predicate: ListIteratorTypeGuard): U[]; +/** + * Filters elements in an array-like object based on the predicate. + * + * @param collection - The array-like object to filter + * @param predicate - The function or shorthand to test each element + * @returns An array of elements that pass the predicate test + * + * @example + * filter([1, 2, 3], x => x > 1) + * // => [2, 3] + * + * filter([{ a: 1 }, { a: 2 }], { a: 1 }) + * // => [{ a: 1 }] + */ +declare function filter(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom): T[]; +/** + * Filters values in an object using a type guard predicate. + * + * @param collection - The object to filter + * @param predicate - The type guard function to test each value + * @returns An array of values that are of type U + * + * @example + * filter({ a: 1, b: '2', c: 3 }, (x): x is number => typeof x === 'number') + * // => [1, 3] + */ +declare function filter(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard): U[]; +/** + * Filters values in an object based on the predicate. + * + * @param collection - The object to filter + * @param predicate - The function or shorthand to test each value + * @returns An array of values that pass the predicate test + * + * @example + * filter({ a: 1, b: 2 }, x => x > 1) + * // => [2] + * + * filter({ a: { x: 1 }, b: { x: 2 } }, { x: 1 }) + * // => [{ x: 1 }] + */ +declare function filter(collection: T | null | undefined, predicate?: ObjectIterateeCustom): Array; + +export { filter }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..79589aae465ccafe8cae8c35cc63959d373c5443 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.d.ts @@ -0,0 +1,74 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.js'; +import { ListIteratorTypeGuard } from '../_internal/ListIteratorTypeGuard.js'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.js'; +import { ObjectIteratorTypeGuard } from '../_internal/ObjectIterator.js'; +import { StringIterator } from '../_internal/StringIterator.js'; + +/** + * Filters characters in a string based on the predicate function. + * + * @param collection - The string to filter + * @param predicate - The function to test each character + * @returns An array of characters that pass the predicate test + * + * @example + * filter('123', char => char === '2') + * // => ['2'] + */ +declare function filter(collection: string | null | undefined, predicate?: StringIterator): string[]; +/** + * Filters elements in an array-like object using a type guard predicate. + * + * @param collection - The array-like object to filter + * @param predicate - The type guard function to test each element + * @returns An array of elements that are of type U + * + * @example + * filter([1, '2', 3], (x): x is number => typeof x === 'number') + * // => [1, 3] + */ +declare function filter(collection: ArrayLike | null | undefined, predicate: ListIteratorTypeGuard): U[]; +/** + * Filters elements in an array-like object based on the predicate. + * + * @param collection - The array-like object to filter + * @param predicate - The function or shorthand to test each element + * @returns An array of elements that pass the predicate test + * + * @example + * filter([1, 2, 3], x => x > 1) + * // => [2, 3] + * + * filter([{ a: 1 }, { a: 2 }], { a: 1 }) + * // => [{ a: 1 }] + */ +declare function filter(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom): T[]; +/** + * Filters values in an object using a type guard predicate. + * + * @param collection - The object to filter + * @param predicate - The type guard function to test each value + * @returns An array of values that are of type U + * + * @example + * filter({ a: 1, b: '2', c: 3 }, (x): x is number => typeof x === 'number') + * // => [1, 3] + */ +declare function filter(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard): U[]; +/** + * Filters values in an object based on the predicate. + * + * @param collection - The object to filter + * @param predicate - The function or shorthand to test each value + * @returns An array of values that pass the predicate test + * + * @example + * filter({ a: 1, b: 2 }, x => x > 1) + * // => [2] + * + * filter({ a: { x: 1 }, b: { x: 2 } }, { x: 1 }) + * // => [{ x: 1 }] + */ +declare function filter(collection: T | null | undefined, predicate?: ObjectIterateeCustom): Array; + +export { filter }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.js new file mode 100644 index 0000000000000000000000000000000000000000..5faf6594b9c8a141d236733ebe451c935b36e314 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.js @@ -0,0 +1,38 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const iteratee = require('../util/iteratee.js'); + +function filter(source, predicate = identity.identity) { + if (!source) { + return []; + } + predicate = iteratee.iteratee(predicate); + if (!Array.isArray(source)) { + const result = []; + const keys = Object.keys(source); + const length = isArrayLike.isArrayLike(source) ? source.length : keys.length; + for (let i = 0; i < length; i++) { + const key = keys[i]; + const value = source[key]; + if (predicate(value, key, source)) { + result.push(value); + } + } + return result; + } + const result = []; + const length = source.length; + for (let i = 0; i < length; i++) { + const value = source[i]; + if (predicate(value, i, source)) { + result.push(value); + } + } + return result; +} + +exports.filter = filter; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.mjs new file mode 100644 index 0000000000000000000000000000000000000000..edd149d86c2508fe6db0bb0bca0d27e089be7e60 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/filter.mjs @@ -0,0 +1,34 @@ +import { identity } from '../../function/identity.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function filter(source, predicate = identity) { + if (!source) { + return []; + } + predicate = iteratee(predicate); + if (!Array.isArray(source)) { + const result = []; + const keys = Object.keys(source); + const length = isArrayLike(source) ? source.length : keys.length; + for (let i = 0; i < length; i++) { + const key = keys[i]; + const value = source[key]; + if (predicate(value, key, source)) { + result.push(value); + } + } + return result; + } + const result = []; + const length = source.length; + for (let i = 0; i < length; i++) { + const value = source[i]; + if (predicate(value, i, source)) { + result.push(value); + } + } + return result; +} + +export { filter }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a5f95a9fcba2ba5629ad868d9a1f595a00c41fbe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.d.mts @@ -0,0 +1,65 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.mjs'; +import { ListIteratorTypeGuard } from '../_internal/ListIteratorTypeGuard.mjs'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.mjs'; +import { ObjectIteratorTypeGuard } from '../_internal/ObjectIterator.mjs'; + +/** + * Finds the first element in an array-like object that matches a type guard predicate. + * + * @param collection - The array-like object to search + * @param predicate - The type guard function to test each element + * @param fromIndex - The index to start searching from + * @returns The first element that matches the type guard, or undefined if none found + * + * @example + * find([1, '2', 3], (x): x is number => typeof x === 'number') + * // => 1 + */ +declare function find(collection: ArrayLike | null | undefined, predicate: ListIteratorTypeGuard, fromIndex?: number): U | undefined; +/** + * Finds the first element in an array-like object that matches a predicate. + * + * @param collection - The array-like object to search + * @param predicate - The function or shorthand to test each element + * @param fromIndex - The index to start searching from + * @returns The first matching element, or undefined if none found + * + * @example + * find([1, 2, 3], x => x > 2) + * // => 3 + * + * find([{ a: 1 }, { a: 2 }], { a: 2 }) + * // => { a: 2 } + */ +declare function find(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): T | undefined; +/** + * Finds the first value in an object that matches a type guard predicate. + * + * @param collection - The object to search + * @param predicate - The type guard function to test each value + * @param fromIndex - The index to start searching from + * @returns The first value that matches the type guard, or undefined if none found + * + * @example + * find({ a: 1, b: '2', c: 3 }, (x): x is number => typeof x === 'number') + * // => 1 + */ +declare function find(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard, fromIndex?: number): U | undefined; +/** + * Finds the first value in an object that matches a predicate. + * + * @param collection - The object to search + * @param predicate - The function or shorthand to test each value + * @param fromIndex - The index to start searching from + * @returns The first matching value, or undefined if none found + * + * @example + * find({ a: 1, b: 2 }, x => x > 1) + * // => 2 + * + * find({ a: { x: 1 }, b: { x: 2 } }, { x: 2 }) + * // => { x: 2 } + */ +declare function find(collection: T | null | undefined, predicate?: ObjectIterateeCustom, fromIndex?: number): T[keyof T] | undefined; + +export { find }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b2bd266ba4e597dddbba33c483103c97efb4d3fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.d.ts @@ -0,0 +1,65 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.js'; +import { ListIteratorTypeGuard } from '../_internal/ListIteratorTypeGuard.js'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.js'; +import { ObjectIteratorTypeGuard } from '../_internal/ObjectIterator.js'; + +/** + * Finds the first element in an array-like object that matches a type guard predicate. + * + * @param collection - The array-like object to search + * @param predicate - The type guard function to test each element + * @param fromIndex - The index to start searching from + * @returns The first element that matches the type guard, or undefined if none found + * + * @example + * find([1, '2', 3], (x): x is number => typeof x === 'number') + * // => 1 + */ +declare function find(collection: ArrayLike | null | undefined, predicate: ListIteratorTypeGuard, fromIndex?: number): U | undefined; +/** + * Finds the first element in an array-like object that matches a predicate. + * + * @param collection - The array-like object to search + * @param predicate - The function or shorthand to test each element + * @param fromIndex - The index to start searching from + * @returns The first matching element, or undefined if none found + * + * @example + * find([1, 2, 3], x => x > 2) + * // => 3 + * + * find([{ a: 1 }, { a: 2 }], { a: 2 }) + * // => { a: 2 } + */ +declare function find(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): T | undefined; +/** + * Finds the first value in an object that matches a type guard predicate. + * + * @param collection - The object to search + * @param predicate - The type guard function to test each value + * @param fromIndex - The index to start searching from + * @returns The first value that matches the type guard, or undefined if none found + * + * @example + * find({ a: 1, b: '2', c: 3 }, (x): x is number => typeof x === 'number') + * // => 1 + */ +declare function find(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard, fromIndex?: number): U | undefined; +/** + * Finds the first value in an object that matches a predicate. + * + * @param collection - The object to search + * @param predicate - The function or shorthand to test each value + * @param fromIndex - The index to start searching from + * @returns The first matching value, or undefined if none found + * + * @example + * find({ a: 1, b: 2 }, x => x > 1) + * // => 2 + * + * find({ a: { x: 1 }, b: { x: 2 } }, { x: 2 }) + * // => { x: 2 } + */ +declare function find(collection: T | null | undefined, predicate?: ObjectIterateeCustom, fromIndex?: number): T[keyof T] | undefined; + +export { find }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.js new file mode 100644 index 0000000000000000000000000000000000000000..0b93454d8265f616d1c47af5dd5a6005f8806d9c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.js @@ -0,0 +1,31 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const iteratee = require('../util/iteratee.js'); + +function find(source, _doesMatch = identity.identity, fromIndex = 0) { + if (!source) { + return undefined; + } + if (fromIndex < 0) { + fromIndex = Math.max(source.length + fromIndex, 0); + } + const doesMatch = iteratee.iteratee(_doesMatch); + if (typeof doesMatch === 'function' && !Array.isArray(source)) { + const keys = Object.keys(source); + for (let i = fromIndex; i < keys.length; i++) { + const key = keys[i]; + const value = source[key]; + if (doesMatch(value, key, source)) { + return value; + } + } + return undefined; + } + const values = Array.isArray(source) ? source.slice(fromIndex) : Object.values(source).slice(fromIndex); + return values.find(doesMatch); +} + +exports.find = find; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fc96ecc4456c6d4b8ff230c4f7ea43f85a73be71 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/find.mjs @@ -0,0 +1,27 @@ +import { identity } from '../../function/identity.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function find(source, _doesMatch = identity, fromIndex = 0) { + if (!source) { + return undefined; + } + if (fromIndex < 0) { + fromIndex = Math.max(source.length + fromIndex, 0); + } + const doesMatch = iteratee(_doesMatch); + if (typeof doesMatch === 'function' && !Array.isArray(source)) { + const keys = Object.keys(source); + for (let i = fromIndex; i < keys.length; i++) { + const key = keys[i]; + const value = source[key]; + if (doesMatch(value, key, source)) { + return value; + } + } + return undefined; + } + const values = Array.isArray(source) ? source.slice(fromIndex) : Object.values(source).slice(fromIndex); + return values.find(doesMatch); +} + +export { find }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c5b6199f39dd88daefa9da4b91b61b7c1da70de6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.d.mts @@ -0,0 +1,21 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.mjs'; + +/** + * Finds the index of the first item in an array that has a specific property, where the property name is provided as a PropertyKey. + * + * @template T + * @param {ArrayLike | null | undefined} arr - The array to search through. + * @param {((item: T, index: number, arr: any) => unknown) | Partial | [keyof T, unknown] | PropertyKey} doesMatch - The criteria to match against the items in the array. This can be a function, a partial object, a key-value pair, or a property name. + * @param {PropertyKey} propertyToCheck - The property name to check for in the items of the array. + * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0. + * @returns {number} - The index of the first item that has the specified property, or `undefined` if no match is found. + * + * @example + * // Using a property name + * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]; + * const result = findIndex(items, 'name'); + * console.log(result); // 0 + */ +declare function findIndex(arr: ArrayLike | null | undefined, doesMatch?: ListIterateeCustom, fromIndex?: number): number; + +export { findIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..12fc1af21c05eadca93678d3f4a22782dc35f49e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.d.ts @@ -0,0 +1,21 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.js'; + +/** + * Finds the index of the first item in an array that has a specific property, where the property name is provided as a PropertyKey. + * + * @template T + * @param {ArrayLike | null | undefined} arr - The array to search through. + * @param {((item: T, index: number, arr: any) => unknown) | Partial | [keyof T, unknown] | PropertyKey} doesMatch - The criteria to match against the items in the array. This can be a function, a partial object, a key-value pair, or a property name. + * @param {PropertyKey} propertyToCheck - The property name to check for in the items of the array. + * @param {number} [fromIndex=0] - The index to start the search from, defaults to 0. + * @returns {number} - The index of the first item that has the specified property, or `undefined` if no match is found. + * + * @example + * // Using a property name + * const items = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]; + * const result = findIndex(items, 'name'); + * console.log(result); // 0 + */ +declare function findIndex(arr: ArrayLike | null | undefined, doesMatch?: ListIterateeCustom, fromIndex?: number): number; + +export { findIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.js new file mode 100644 index 0000000000000000000000000000000000000000..991da80ad648f2776644cf7ea07b7347290d34d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.js @@ -0,0 +1,43 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const property = require('../object/property.js'); +const matches = require('../predicate/matches.js'); +const matchesProperty = require('../predicate/matchesProperty.js'); + +function findIndex(arr, doesMatch, fromIndex = 0) { + if (!arr) { + return -1; + } + if (fromIndex < 0) { + fromIndex = Math.max(arr.length + fromIndex, 0); + } + const subArray = Array.from(arr).slice(fromIndex); + let index = -1; + switch (typeof doesMatch) { + case 'function': { + index = subArray.findIndex(doesMatch); + break; + } + case 'object': { + if (Array.isArray(doesMatch) && doesMatch.length === 2) { + const key = doesMatch[0]; + const value = doesMatch[1]; + index = subArray.findIndex(matchesProperty.matchesProperty(key, value)); + } + else { + index = subArray.findIndex(matches.matches(doesMatch)); + } + break; + } + case 'number': + case 'symbol': + case 'string': { + index = subArray.findIndex(property.property(doesMatch)); + } + } + return index === -1 ? -1 : index + fromIndex; +} + +exports.findIndex = findIndex; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.mjs new file mode 100644 index 0000000000000000000000000000000000000000..340e65a559b39f803dcfdc0cda50ad3eef4c2d50 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findIndex.mjs @@ -0,0 +1,39 @@ +import { property } from '../object/property.mjs'; +import { matches } from '../predicate/matches.mjs'; +import { matchesProperty } from '../predicate/matchesProperty.mjs'; + +function findIndex(arr, doesMatch, fromIndex = 0) { + if (!arr) { + return -1; + } + if (fromIndex < 0) { + fromIndex = Math.max(arr.length + fromIndex, 0); + } + const subArray = Array.from(arr).slice(fromIndex); + let index = -1; + switch (typeof doesMatch) { + case 'function': { + index = subArray.findIndex(doesMatch); + break; + } + case 'object': { + if (Array.isArray(doesMatch) && doesMatch.length === 2) { + const key = doesMatch[0]; + const value = doesMatch[1]; + index = subArray.findIndex(matchesProperty(key, value)); + } + else { + index = subArray.findIndex(matches(doesMatch)); + } + break; + } + case 'number': + case 'symbol': + case 'string': { + index = subArray.findIndex(property(doesMatch)); + } + } + return index === -1 ? -1 : index + fromIndex; +} + +export { findIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..da4e811a3d0073a599ed710df437b4e4f8d81981 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.d.mts @@ -0,0 +1,82 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.mjs'; +import { ListIteratorTypeGuard } from '../_internal/ListIteratorTypeGuard.mjs'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.mjs'; +import { ObjectIteratorTypeGuard } from '../_internal/ObjectIterator.mjs'; + +/** + * Finds the last element in a collection that satisfies the predicate. + * + * @template T, S + * @param {ArrayLike | null | undefined} collection - The collection to search. + * @param {ListIteratorTypeGuard} predicate - The predicate function with type guard. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {S | undefined} The last element that satisfies the predicate. + * + * @example + * const users = [{ user: 'barney', age: 36 }, { user: 'fred', age: 40 }, { user: 'pebbles', age: 18 }]; + * findLast(users, (o): o is { user: string; age: number } => o.age < 40); + * // => { user: 'pebbles', age: 18 } + */ +declare function findLast(collection: ArrayLike | null | undefined, predicate: ListIteratorTypeGuard, fromIndex?: number): S | undefined; +/** + * Finds the last element in a collection that satisfies the predicate. + * + * @template T + * @param {ArrayLike | null | undefined} collection - The collection to search. + * @param {ListIterateeCustom} [predicate] - The predicate function, partial object, property-value pair, or property name. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {T | undefined} The last element that satisfies the predicate. + * + * @example + * const users = [{ user: 'barney', age: 36 }, { user: 'fred', age: 40 }, { user: 'pebbles', age: 18 }]; + * findLast(users, o => o.age < 40); + * // => { user: 'pebbles', age: 18 } + * + * findLast(users, { age: 36 }); + * // => { user: 'barney', age: 36 } + * + * findLast(users, ['age', 18]); + * // => { user: 'pebbles', age: 18 } + * + * findLast(users, 'age'); + * // => { user: 'fred', age: 40 } + */ +declare function findLast(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): T | undefined; +/** + * Finds the last element in an object that satisfies the predicate with type guard. + * + * @template T, S + * @param {T | null | undefined} collection - The object to search. + * @param {ObjectIteratorTypeGuard} predicate - The predicate function with type guard. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {S | undefined} The last element that satisfies the predicate. + * + * @example + * const obj = { a: 1, b: 'hello', c: 3 }; + * findLast(obj, (value): value is string => typeof value === 'string'); + * // => 'hello' + */ +declare function findLast(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard, fromIndex?: number): S | undefined; +/** + * Finds the last element in an object that satisfies the predicate. + * + * @template T + * @param {T | null | undefined} collection - The object to search. + * @param {ObjectIterateeCustom} [predicate] - The predicate function, partial object, property-value pair, or property name. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {T[keyof T] | undefined} The last element that satisfies the predicate. + * + * @example + * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2 }, c: { id: 3, name: 'Bob' } }; + * findLast(obj, o => o.id > 1); + * // => { id: 3, name: 'Bob' } + * + * findLast(obj, { name: 'Bob' }); + * // => { id: 3, name: 'Bob' } + * + * findLast(obj, 'name'); + * // => { id: 3, name: 'Bob' } + */ +declare function findLast(collection: T | null | undefined, predicate?: ObjectIterateeCustom, fromIndex?: number): T[keyof T] | undefined; + +export { findLast }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..428bd8a648b1bc6cbdd087ce68e59cddf5653644 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.d.ts @@ -0,0 +1,82 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.js'; +import { ListIteratorTypeGuard } from '../_internal/ListIteratorTypeGuard.js'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.js'; +import { ObjectIteratorTypeGuard } from '../_internal/ObjectIterator.js'; + +/** + * Finds the last element in a collection that satisfies the predicate. + * + * @template T, S + * @param {ArrayLike | null | undefined} collection - The collection to search. + * @param {ListIteratorTypeGuard} predicate - The predicate function with type guard. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {S | undefined} The last element that satisfies the predicate. + * + * @example + * const users = [{ user: 'barney', age: 36 }, { user: 'fred', age: 40 }, { user: 'pebbles', age: 18 }]; + * findLast(users, (o): o is { user: string; age: number } => o.age < 40); + * // => { user: 'pebbles', age: 18 } + */ +declare function findLast(collection: ArrayLike | null | undefined, predicate: ListIteratorTypeGuard, fromIndex?: number): S | undefined; +/** + * Finds the last element in a collection that satisfies the predicate. + * + * @template T + * @param {ArrayLike | null | undefined} collection - The collection to search. + * @param {ListIterateeCustom} [predicate] - The predicate function, partial object, property-value pair, or property name. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {T | undefined} The last element that satisfies the predicate. + * + * @example + * const users = [{ user: 'barney', age: 36 }, { user: 'fred', age: 40 }, { user: 'pebbles', age: 18 }]; + * findLast(users, o => o.age < 40); + * // => { user: 'pebbles', age: 18 } + * + * findLast(users, { age: 36 }); + * // => { user: 'barney', age: 36 } + * + * findLast(users, ['age', 18]); + * // => { user: 'pebbles', age: 18 } + * + * findLast(users, 'age'); + * // => { user: 'fred', age: 40 } + */ +declare function findLast(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): T | undefined; +/** + * Finds the last element in an object that satisfies the predicate with type guard. + * + * @template T, S + * @param {T | null | undefined} collection - The object to search. + * @param {ObjectIteratorTypeGuard} predicate - The predicate function with type guard. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {S | undefined} The last element that satisfies the predicate. + * + * @example + * const obj = { a: 1, b: 'hello', c: 3 }; + * findLast(obj, (value): value is string => typeof value === 'string'); + * // => 'hello' + */ +declare function findLast(collection: T | null | undefined, predicate: ObjectIteratorTypeGuard, fromIndex?: number): S | undefined; +/** + * Finds the last element in an object that satisfies the predicate. + * + * @template T + * @param {T | null | undefined} collection - The object to search. + * @param {ObjectIterateeCustom} [predicate] - The predicate function, partial object, property-value pair, or property name. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {T[keyof T] | undefined} The last element that satisfies the predicate. + * + * @example + * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2 }, c: { id: 3, name: 'Bob' } }; + * findLast(obj, o => o.id > 1); + * // => { id: 3, name: 'Bob' } + * + * findLast(obj, { name: 'Bob' }); + * // => { id: 3, name: 'Bob' } + * + * findLast(obj, 'name'); + * // => { id: 3, name: 'Bob' } + */ +declare function findLast(collection: T | null | undefined, predicate?: ObjectIterateeCustom, fromIndex?: number): T[keyof T] | undefined; + +export { findLast }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.js new file mode 100644 index 0000000000000000000000000000000000000000..2e988a5d2eac1d73fe4b588ee250d2bb786b3e42 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const iteratee = require('../util/iteratee.js'); +const toInteger = require('../util/toInteger.js'); + +function findLast(source, _doesMatch = identity.identity, fromIndex) { + if (!source) { + return undefined; + } + const length = Array.isArray(source) ? source.length : Object.keys(source).length; + fromIndex = toInteger.toInteger(fromIndex ?? length - 1); + if (fromIndex < 0) { + fromIndex = Math.max(length + fromIndex, 0); + } + else { + fromIndex = Math.min(fromIndex, length - 1); + } + const doesMatch = iteratee.iteratee(_doesMatch); + if (typeof doesMatch === 'function' && !Array.isArray(source)) { + const keys = Object.keys(source); + for (let i = fromIndex; i >= 0; i--) { + const key = keys[i]; + const value = source[key]; + if (doesMatch(value, key, source)) { + return value; + } + } + return undefined; + } + const values = Array.isArray(source) ? source.slice(0, fromIndex + 1) : Object.values(source).slice(0, fromIndex + 1); + return values.findLast(doesMatch); +} + +exports.findLast = findLast; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4f3ac0ce838f1dd125ec19d8487ebe4309e64412 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLast.mjs @@ -0,0 +1,33 @@ +import { identity } from '../../function/identity.mjs'; +import { iteratee } from '../util/iteratee.mjs'; +import { toInteger } from '../util/toInteger.mjs'; + +function findLast(source, _doesMatch = identity, fromIndex) { + if (!source) { + return undefined; + } + const length = Array.isArray(source) ? source.length : Object.keys(source).length; + fromIndex = toInteger(fromIndex ?? length - 1); + if (fromIndex < 0) { + fromIndex = Math.max(length + fromIndex, 0); + } + else { + fromIndex = Math.min(fromIndex, length - 1); + } + const doesMatch = iteratee(_doesMatch); + if (typeof doesMatch === 'function' && !Array.isArray(source)) { + const keys = Object.keys(source); + for (let i = fromIndex; i >= 0; i--) { + const key = keys[i]; + const value = source[key]; + if (doesMatch(value, key, source)) { + return value; + } + } + return undefined; + } + const values = Array.isArray(source) ? source.slice(0, fromIndex + 1) : Object.values(source).slice(0, fromIndex + 1); + return values.findLast(doesMatch); +} + +export { findLast }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cbabf7108bb944800d334f4042cf72015f287107 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.d.mts @@ -0,0 +1,33 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.mjs'; + +/** + * Finds the index of the last element in the array that satisfies the predicate. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to search through. + * @param {ListIterateeCustom} [predicate] - The predicate function, partial object, property-value pair, or property name. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {number} The index of the last matching element, or -1 if not found. + * + * @example + * const users = [ + * { user: 'barney', active: true }, + * { user: 'fred', active: false }, + * { user: 'pebbles', active: false } + * ]; + * + * findLastIndex(users, o => o.user === 'pebbles'); + * // => 2 + * + * findLastIndex(users, { user: 'barney', active: true }); + * // => 0 + * + * findLastIndex(users, ['active', false]); + * // => 2 + * + * findLastIndex(users, 'active'); + * // => 0 + */ +declare function findLastIndex(array: ArrayLike | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): number; + +export { findLastIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e88649818ecc8e2e6c19ebdb860c96d52ec00c3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.d.ts @@ -0,0 +1,33 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.js'; + +/** + * Finds the index of the last element in the array that satisfies the predicate. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to search through. + * @param {ListIterateeCustom} [predicate] - The predicate function, partial object, property-value pair, or property name. + * @param {number} [fromIndex] - The index to start searching from. + * @returns {number} The index of the last matching element, or -1 if not found. + * + * @example + * const users = [ + * { user: 'barney', active: true }, + * { user: 'fred', active: false }, + * { user: 'pebbles', active: false } + * ]; + * + * findLastIndex(users, o => o.user === 'pebbles'); + * // => 2 + * + * findLastIndex(users, { user: 'barney', active: true }); + * // => 0 + * + * findLastIndex(users, ['active', false]); + * // => 2 + * + * findLastIndex(users, 'active'); + * // => 0 + */ +declare function findLastIndex(array: ArrayLike | null | undefined, predicate?: ListIterateeCustom, fromIndex?: number): number; + +export { findLastIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.js new file mode 100644 index 0000000000000000000000000000000000000000..f9949bf7e78821f7cdbfe98bf78fe797a7a1990b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.js @@ -0,0 +1,44 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const toArray = require('../_internal/toArray.js'); +const property = require('../object/property.js'); +const matches = require('../predicate/matches.js'); +const matchesProperty = require('../predicate/matchesProperty.js'); + +function findLastIndex(arr, doesMatch = identity.identity, fromIndex = arr ? arr.length - 1 : 0) { + if (!arr) { + return -1; + } + if (fromIndex < 0) { + fromIndex = Math.max(arr.length + fromIndex, 0); + } + else { + fromIndex = Math.min(fromIndex, arr.length - 1); + } + const subArray = toArray.toArray(arr).slice(0, fromIndex + 1); + switch (typeof doesMatch) { + case 'function': { + return subArray.findLastIndex(doesMatch); + } + case 'object': { + if (Array.isArray(doesMatch) && doesMatch.length === 2) { + const key = doesMatch[0]; + const value = doesMatch[1]; + return subArray.findLastIndex(matchesProperty.matchesProperty(key, value)); + } + else { + return subArray.findLastIndex(matches.matches(doesMatch)); + } + } + case 'number': + case 'symbol': + case 'string': { + return subArray.findLastIndex(property.property(doesMatch)); + } + } +} + +exports.findLastIndex = findLastIndex; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5a4f7f613c1ba942a505b9d0137de2454ff333ac --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/findLastIndex.mjs @@ -0,0 +1,40 @@ +import { identity } from '../../function/identity.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { property } from '../object/property.mjs'; +import { matches } from '../predicate/matches.mjs'; +import { matchesProperty } from '../predicate/matchesProperty.mjs'; + +function findLastIndex(arr, doesMatch = identity, fromIndex = arr ? arr.length - 1 : 0) { + if (!arr) { + return -1; + } + if (fromIndex < 0) { + fromIndex = Math.max(arr.length + fromIndex, 0); + } + else { + fromIndex = Math.min(fromIndex, arr.length - 1); + } + const subArray = toArray(arr).slice(0, fromIndex + 1); + switch (typeof doesMatch) { + case 'function': { + return subArray.findLastIndex(doesMatch); + } + case 'object': { + if (Array.isArray(doesMatch) && doesMatch.length === 2) { + const key = doesMatch[0]; + const value = doesMatch[1]; + return subArray.findLastIndex(matchesProperty(key, value)); + } + else { + return subArray.findLastIndex(matches(doesMatch)); + } + } + case 'number': + case 'symbol': + case 'string': { + return subArray.findLastIndex(property(doesMatch)); + } + } +} + +export { findLastIndex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..531f6b3d804be8932bb1f38ec4853ea9eca5033c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.d.mts @@ -0,0 +1,93 @@ +import { ListIterator } from '../_internal/ListIterator.mjs'; +import { Many } from '../_internal/Many.mjs'; +import { ObjectIterator } from '../_internal/ObjectIterator.mjs'; + +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @template T + * @param {Record> | Record> | null | undefined} collection - The collection to iterate over. + * @returns {T[]} Returns the new flattened array. + * + * @example + * const obj = { a: [1, 2], b: [3, 4] }; + * flatMap(obj); + * // => [1, 2, 3, 4] + */ +declare function flatMap(collection: Record> | Record> | null | undefined): T[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @returns {any[]} Returns the new flattened array. + * + * @example + * flatMap({ a: 1, b: 2 }); + * // => [1, 2] + */ +declare function flatMap(collection: object | null | undefined): any[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @template T, R + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {ListIterator>} iteratee - The function invoked per iteration. + * @returns {R[]} Returns the new flattened array. + * + * @example + * function duplicate(n) { + * return [n, n]; + * } + * + * flatMap([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ +declare function flatMap(collection: ArrayLike | null | undefined, iteratee: ListIterator>): R[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @template T, R + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator>} iteratee - The function invoked per iteration. + * @returns {R[]} Returns the new flattened array. + * + * @example + * const obj = { a: 1, b: 2 }; + * flatMap(obj, (value, key) => [key, value]); + * // => ['a', 1, 'b', 2] + */ +declare function flatMap(collection: T | null | undefined, iteratee: ObjectIterator>): R[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {string} iteratee - The property name to use as iteratee. + * @returns {any[]} Returns the new flattened array. + * + * @example + * const users = [ + * { user: 'barney', hobbies: ['hiking', 'coding'] }, + * { user: 'fred', hobbies: ['reading'] } + * ]; + * flatMap(users, 'hobbies'); + * // => ['hiking', 'coding', 'reading'] + */ +declare function flatMap(collection: object | null | undefined, iteratee: string): any[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {object} iteratee - The object properties to match. + * @returns {boolean[]} Returns the new flattened array. + * + * @example + * const users = [ + * { user: 'barney', age: 36, active: true }, + * { user: 'fred', age: 40, active: false } + * ]; + * flatMap(users, { active: false }); + * // => [false] + */ +declare function flatMap(collection: object | null | undefined, iteratee: object): boolean[]; + +export { flatMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0c435c0f875a3a9e2024354bacef8e714c13a1f7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.d.ts @@ -0,0 +1,93 @@ +import { ListIterator } from '../_internal/ListIterator.js'; +import { Many } from '../_internal/Many.js'; +import { ObjectIterator } from '../_internal/ObjectIterator.js'; + +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @template T + * @param {Record> | Record> | null | undefined} collection - The collection to iterate over. + * @returns {T[]} Returns the new flattened array. + * + * @example + * const obj = { a: [1, 2], b: [3, 4] }; + * flatMap(obj); + * // => [1, 2, 3, 4] + */ +declare function flatMap(collection: Record> | Record> | null | undefined): T[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @returns {any[]} Returns the new flattened array. + * + * @example + * flatMap({ a: 1, b: 2 }); + * // => [1, 2] + */ +declare function flatMap(collection: object | null | undefined): any[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @template T, R + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {ListIterator>} iteratee - The function invoked per iteration. + * @returns {R[]} Returns the new flattened array. + * + * @example + * function duplicate(n) { + * return [n, n]; + * } + * + * flatMap([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ +declare function flatMap(collection: ArrayLike | null | undefined, iteratee: ListIterator>): R[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @template T, R + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator>} iteratee - The function invoked per iteration. + * @returns {R[]} Returns the new flattened array. + * + * @example + * const obj = { a: 1, b: 2 }; + * flatMap(obj, (value, key) => [key, value]); + * // => ['a', 1, 'b', 2] + */ +declare function flatMap(collection: T | null | undefined, iteratee: ObjectIterator>): R[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {string} iteratee - The property name to use as iteratee. + * @returns {any[]} Returns the new flattened array. + * + * @example + * const users = [ + * { user: 'barney', hobbies: ['hiking', 'coding'] }, + * { user: 'fred', hobbies: ['reading'] } + * ]; + * flatMap(users, 'hobbies'); + * // => ['hiking', 'coding', 'reading'] + */ +declare function flatMap(collection: object | null | undefined, iteratee: string): any[]; +/** + * Creates a flattened array of values by running each element in collection through iteratee and flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {object} iteratee - The object properties to match. + * @returns {boolean[]} Returns the new flattened array. + * + * @example + * const users = [ + * { user: 'barney', age: 36, active: true }, + * { user: 'fred', age: 40, active: false } + * ]; + * flatMap(users, { active: false }); + * // => [false] + */ +declare function flatMap(collection: object | null | undefined, iteratee: object): boolean[]; + +export { flatMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.js new file mode 100644 index 0000000000000000000000000000000000000000..42fb511e532558d7ab05e3a0413848f10db11abf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flattenDepth = require('./flattenDepth.js'); +const map = require('./map.js'); +const isNil = require('../../predicate/isNil.js'); + +function flatMap(collection, iteratee) { + if (isNil.isNil(collection)) { + return []; + } + const mapped = isNil.isNil(iteratee) ? map.map(collection) : map.map(collection, iteratee); + return flattenDepth.flattenDepth(mapped, 1); +} + +exports.flatMap = flatMap; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1275f0a211703b7541fc5a236860111998bf214a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMap.mjs @@ -0,0 +1,13 @@ +import { flattenDepth } from './flattenDepth.mjs'; +import { map } from './map.mjs'; +import { isNil } from '../../predicate/isNil.mjs'; + +function flatMap(collection, iteratee) { + if (isNil(collection)) { + return []; + } + const mapped = isNil(iteratee) ? map(collection) : map(collection, iteratee); + return flattenDepth(mapped, 1); +} + +export { flatMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8ef3d56dadc8929d2b7a3bbe9728588c8b4a2e08 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.d.mts @@ -0,0 +1,82 @@ +import { ListIterator } from '../_internal/ListIterator.mjs'; +import { ListOfRecursiveArraysOrValues } from '../_internal/ListOfRecursiveArraysOrValues.mjs'; +import { ObjectIterator } from '../_internal/ObjectIterator.mjs'; + +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @template T + * @param {Record | T> | Record | T> | null | undefined} collection - The collection to iterate over. + * @returns {T[]} Returns the new deeply flattened array. + * + * @example + * const obj = { a: [[1, 2]], b: [[[3]]] }; + * flatMapDeep(obj); + * // => [1, 2, 3] + */ +declare function flatMapDeep(collection: Record | T> | Record | T> | null | undefined): T[]; +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @template T, R + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {ListIterator | R>} iteratee - The function invoked per iteration. + * @returns {R[]} Returns the new deeply flattened array. + * + * @example + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * flatMapDeep([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ +declare function flatMapDeep(collection: ArrayLike | null | undefined, iteratee: ListIterator | R>): R[]; +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @template T, R + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator | R>} iteratee - The function invoked per iteration. + * @returns {R[]} Returns the new deeply flattened array. + * + * @example + * const obj = { a: 1, b: 2 }; + * flatMapDeep(obj, (value, key) => [[[key, value]]]); + * // => ['a', 1, 'b', 2] + */ +declare function flatMapDeep(collection: T | null | undefined, iteratee: ObjectIterator | R>): R[]; +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {string} iteratee - The property name to use as iteratee. + * @returns {any[]} Returns the new deeply flattened array. + * + * @example + * const users = [ + * { user: 'barney', hobbies: [['hiking', 'coding']] }, + * { user: 'fred', hobbies: [['reading']] } + * ]; + * flatMapDeep(users, 'hobbies'); + * // => ['hiking', 'coding', 'reading'] + */ +declare function flatMapDeep(collection: object | null | undefined, iteratee: string): any[]; +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {object} iteratee - The object properties to match. + * @returns {boolean[]} Returns the new deeply flattened array. + * + * @example + * const users = [ + * { user: 'barney', active: [true, false] }, + * { user: 'fred', active: [false] } + * ]; + * flatMapDeep(users, { active: [false] }); + * // => [false] + */ +declare function flatMapDeep(collection: object | null | undefined, iteratee: object): boolean[]; + +export { flatMapDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6dc6921a98025221205aa5a65852811cce2a243f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.d.ts @@ -0,0 +1,82 @@ +import { ListIterator } from '../_internal/ListIterator.js'; +import { ListOfRecursiveArraysOrValues } from '../_internal/ListOfRecursiveArraysOrValues.js'; +import { ObjectIterator } from '../_internal/ObjectIterator.js'; + +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @template T + * @param {Record | T> | Record | T> | null | undefined} collection - The collection to iterate over. + * @returns {T[]} Returns the new deeply flattened array. + * + * @example + * const obj = { a: [[1, 2]], b: [[[3]]] }; + * flatMapDeep(obj); + * // => [1, 2, 3] + */ +declare function flatMapDeep(collection: Record | T> | Record | T> | null | undefined): T[]; +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @template T, R + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {ListIterator | R>} iteratee - The function invoked per iteration. + * @returns {R[]} Returns the new deeply flattened array. + * + * @example + * function duplicate(n) { + * return [[[n, n]]]; + * } + * + * flatMapDeep([1, 2], duplicate); + * // => [1, 1, 2, 2] + */ +declare function flatMapDeep(collection: ArrayLike | null | undefined, iteratee: ListIterator | R>): R[]; +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @template T, R + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator | R>} iteratee - The function invoked per iteration. + * @returns {R[]} Returns the new deeply flattened array. + * + * @example + * const obj = { a: 1, b: 2 }; + * flatMapDeep(obj, (value, key) => [[[key, value]]]); + * // => ['a', 1, 'b', 2] + */ +declare function flatMapDeep(collection: T | null | undefined, iteratee: ObjectIterator | R>): R[]; +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {string} iteratee - The property name to use as iteratee. + * @returns {any[]} Returns the new deeply flattened array. + * + * @example + * const users = [ + * { user: 'barney', hobbies: [['hiking', 'coding']] }, + * { user: 'fred', hobbies: [['reading']] } + * ]; + * flatMapDeep(users, 'hobbies'); + * // => ['hiking', 'coding', 'reading'] + */ +declare function flatMapDeep(collection: object | null | undefined, iteratee: string): any[]; +/** + * Creates a flattened array of values by running each element through iteratee and recursively flattening the mapped results. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {object} iteratee - The object properties to match. + * @returns {boolean[]} Returns the new deeply flattened array. + * + * @example + * const users = [ + * { user: 'barney', active: [true, false] }, + * { user: 'fred', active: [false] } + * ]; + * flatMapDeep(users, { active: [false] }); + * // => [false] + */ +declare function flatMapDeep(collection: object | null | undefined, iteratee: object): boolean[]; + +export { flatMapDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.js new file mode 100644 index 0000000000000000000000000000000000000000..55ac2e76bb312899e2324ba8ac10b6578b71fd53 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatMapDepth = require('./flatMapDepth.js'); + +function flatMapDeep(collection, iteratee) { + return flatMapDepth.flatMapDepth(collection, iteratee, Infinity); +} + +exports.flatMapDeep = flatMapDeep; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.mjs new file mode 100644 index 0000000000000000000000000000000000000000..55e88b9b1fcbf5c897bf08ac2a63cb624738c760 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDeep.mjs @@ -0,0 +1,7 @@ +import { flatMapDepth } from './flatMapDepth.mjs'; + +function flatMapDeep(collection, iteratee) { + return flatMapDepth(collection, iteratee, Infinity); +} + +export { flatMapDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ae73aa0f204f146806b30f4a4d571683927b1f71 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.d.mts @@ -0,0 +1,86 @@ +import { ListIterator } from '../_internal/ListIterator.mjs'; +import { ListOfRecursiveArraysOrValues } from '../_internal/ListOfRecursiveArraysOrValues.mjs'; +import { ObjectIterator } from '../_internal/ObjectIterator.mjs'; + +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @template T + * @param {Record | T> | Record | T> | null | undefined} collection - The collection to iterate over. + * @returns {T[]} Returns the new flattened array. + * + * @example + * const obj = { a: [[1, 2]], b: [[[3]]] }; + * flatMapDepth(obj); + * // => [1, 2, [3]] + */ +declare function flatMapDepth(collection: Record | T> | Record | T> | null | undefined): T[]; +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @template T, R + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {ListIterator | R>} iteratee - The function invoked per iteration. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {R[]} Returns the new flattened array. + * + * @example + * function duplicate(n) { + * return [[n, n]]; + * } + * + * flatMapDepth([1, 2], duplicate, 2); + * // => [1, 1, 2, 2] + */ +declare function flatMapDepth(collection: ArrayLike | null | undefined, iteratee: ListIterator | R>, depth?: number): R[]; +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @template T, R + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator | R>} iteratee - The function invoked per iteration. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {R[]} Returns the new flattened array. + * + * @example + * const obj = { a: 1, b: 2 }; + * flatMapDepth(obj, (value, key) => [[key, value]], 2); + * // => ['a', 1, 'b', 2] + */ +declare function flatMapDepth(collection: T | null | undefined, iteratee: ObjectIterator | R>, depth?: number): R[]; +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {string} iteratee - The property name to use as iteratee. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {any[]} Returns the new flattened array. + * + * @example + * const users = [ + * { user: 'barney', hobbies: [['hiking'], ['coding']] }, + * { user: 'fred', hobbies: [['reading']] } + * ]; + * flatMapDepth(users, 'hobbies', 2); + * // => ['hiking', 'coding', 'reading'] + */ +declare function flatMapDepth(collection: object | null | undefined, iteratee: string, depth?: number): any[]; +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {object} iteratee - The object properties to match. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {boolean[]} Returns the new flattened array. + * + * @example + * const users = [ + * { user: 'barney', active: [[true], [false]] }, + * { user: 'fred', active: [[false]] } + * ]; + * flatMapDepth(users, { active: [[false]] }); + * // => [false] + */ +declare function flatMapDepth(collection: object | null | undefined, iteratee: object, depth?: number): boolean[]; + +export { flatMapDepth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f590567dd8cbd9e30359428ea0482b4cecae32dc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.d.ts @@ -0,0 +1,86 @@ +import { ListIterator } from '../_internal/ListIterator.js'; +import { ListOfRecursiveArraysOrValues } from '../_internal/ListOfRecursiveArraysOrValues.js'; +import { ObjectIterator } from '../_internal/ObjectIterator.js'; + +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @template T + * @param {Record | T> | Record | T> | null | undefined} collection - The collection to iterate over. + * @returns {T[]} Returns the new flattened array. + * + * @example + * const obj = { a: [[1, 2]], b: [[[3]]] }; + * flatMapDepth(obj); + * // => [1, 2, [3]] + */ +declare function flatMapDepth(collection: Record | T> | Record | T> | null | undefined): T[]; +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @template T, R + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {ListIterator | R>} iteratee - The function invoked per iteration. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {R[]} Returns the new flattened array. + * + * @example + * function duplicate(n) { + * return [[n, n]]; + * } + * + * flatMapDepth([1, 2], duplicate, 2); + * // => [1, 1, 2, 2] + */ +declare function flatMapDepth(collection: ArrayLike | null | undefined, iteratee: ListIterator | R>, depth?: number): R[]; +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @template T, R + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator | R>} iteratee - The function invoked per iteration. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {R[]} Returns the new flattened array. + * + * @example + * const obj = { a: 1, b: 2 }; + * flatMapDepth(obj, (value, key) => [[key, value]], 2); + * // => ['a', 1, 'b', 2] + */ +declare function flatMapDepth(collection: T | null | undefined, iteratee: ObjectIterator | R>, depth?: number): R[]; +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {string} iteratee - The property name to use as iteratee. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {any[]} Returns the new flattened array. + * + * @example + * const users = [ + * { user: 'barney', hobbies: [['hiking'], ['coding']] }, + * { user: 'fred', hobbies: [['reading']] } + * ]; + * flatMapDepth(users, 'hobbies', 2); + * // => ['hiking', 'coding', 'reading'] + */ +declare function flatMapDepth(collection: object | null | undefined, iteratee: string, depth?: number): any[]; +/** + * Creates a flattened array of values by running each element through iteratee and flattening the mapped results up to depth times. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {object} iteratee - The object properties to match. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {boolean[]} Returns the new flattened array. + * + * @example + * const users = [ + * { user: 'barney', active: [[true], [false]] }, + * { user: 'fred', active: [[false]] } + * ]; + * flatMapDepth(users, { active: [[false]] }); + * // => [false] + */ +declare function flatMapDepth(collection: object | null | undefined, iteratee: object, depth?: number): boolean[]; + +export { flatMapDepth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.js new file mode 100644 index 0000000000000000000000000000000000000000..0e854eb9208def1554116ef368e456fc395a4e48 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('./flatten.js'); +const map = require('./map.js'); +const identity = require('../../function/identity.js'); +const iteratee = require('../util/iteratee.js'); + +function flatMapDepth(collection, iteratee$1 = identity.identity, depth = 1) { + if (collection == null) { + return []; + } + const iterateeFn = iteratee.iteratee(iteratee$1); + const mapped = map.map(collection, iterateeFn); + return flatten.flatten(mapped, depth); +} + +exports.flatMapDepth = flatMapDepth; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0244082a5e5c0a5e253d6be4f962231ef4665d4d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatMapDepth.mjs @@ -0,0 +1,15 @@ +import { flatten } from './flatten.mjs'; +import { map } from './map.mjs'; +import { identity } from '../../function/identity.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function flatMapDepth(collection, iteratee$1 = identity, depth = 1) { + if (collection == null) { + return []; + } + const iterateeFn = iteratee(iteratee$1); + const mapped = map(collection, iterateeFn); + return flatten(mapped, depth); +} + +export { flatMapDepth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1ff4c124991eddb92fcdd1cc3ec4a7b9e2dcd0d4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.d.mts @@ -0,0 +1,15 @@ +/** + * Flattens array up to depth times. + * + * @template T + * @param {ArrayLike | null | undefined} value - The array to flatten. + * @param {number} depth - The maximum recursion depth. + * @returns {any[]} Returns the new flattened array. + * + * @example + * flatten([1, [2, [3, [4]], 5]], 2); + * // => [1, 2, 3, [4], 5] + */ +declare function flatten(value: ArrayLike | null | undefined): T[]; + +export { flatten }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1ff4c124991eddb92fcdd1cc3ec4a7b9e2dcd0d4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.d.ts @@ -0,0 +1,15 @@ +/** + * Flattens array up to depth times. + * + * @template T + * @param {ArrayLike | null | undefined} value - The array to flatten. + * @param {number} depth - The maximum recursion depth. + * @returns {any[]} Returns the new flattened array. + * + * @example + * flatten([1, [2, [3, [4]], 5]], 2); + * // => [1, 2, 3, [4], 5] + */ +declare function flatten(value: ArrayLike | null | undefined): T[]; + +export { flatten }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.js new file mode 100644 index 0000000000000000000000000000000000000000..10668a90c8ac8a36fbf7430a2770516a8ca52477 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.js @@ -0,0 +1,36 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLike = require('../predicate/isArrayLike.js'); + +function flatten(value, depth = 1) { + const result = []; + const flooredDepth = Math.floor(depth); + if (!isArrayLike.isArrayLike(value)) { + return result; + } + const recursive = (arr, currentDepth) => { + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (currentDepth < flooredDepth && + (Array.isArray(item) || + Boolean(item?.[Symbol.isConcatSpreadable]) || + (item !== null && typeof item === 'object' && Object.prototype.toString.call(item) === '[object Arguments]'))) { + if (Array.isArray(item)) { + recursive(item, currentDepth + 1); + } + else { + recursive(Array.from(item), currentDepth + 1); + } + } + else { + result.push(item); + } + } + }; + recursive(Array.from(value), 0); + return result; +} + +exports.flatten = flatten; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.mjs new file mode 100644 index 0000000000000000000000000000000000000000..243d21e95cadf2fe6d78f142322cea36e2eb42ec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flatten.mjs @@ -0,0 +1,32 @@ +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function flatten(value, depth = 1) { + const result = []; + const flooredDepth = Math.floor(depth); + if (!isArrayLike(value)) { + return result; + } + const recursive = (arr, currentDepth) => { + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (currentDepth < flooredDepth && + (Array.isArray(item) || + Boolean(item?.[Symbol.isConcatSpreadable]) || + (item !== null && typeof item === 'object' && Object.prototype.toString.call(item) === '[object Arguments]'))) { + if (Array.isArray(item)) { + recursive(item, currentDepth + 1); + } + else { + recursive(Array.from(item), currentDepth + 1); + } + } + else { + result.push(item); + } + } + }; + recursive(Array.from(value), 0); + return result; +} + +export { flatten }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f50f8874ef18ebb4d736eac1e5a0c637a4550b77 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.d.mts @@ -0,0 +1,16 @@ +import { ListOfRecursiveArraysOrValues } from '../_internal/ListOfRecursiveArraysOrValues.mjs'; + +/** + * Recursively flattens array. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to flatten. + * @returns {Array>} Returns the new flattened array. + * + * @example + * flattenDeep([1, [2, [3, [4]], 5]]); + * // => [1, 2, 3, 4, 5] + */ +declare function flattenDeep(value: ListOfRecursiveArraysOrValues | null | undefined): Array ? never : T>; + +export { flattenDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bf1db0d86f707e8011a277bce3b2a63a54437ad6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.d.ts @@ -0,0 +1,16 @@ +import { ListOfRecursiveArraysOrValues } from '../_internal/ListOfRecursiveArraysOrValues.js'; + +/** + * Recursively flattens array. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to flatten. + * @returns {Array>} Returns the new flattened array. + * + * @example + * flattenDeep([1, [2, [3, [4]], 5]]); + * // => [1, 2, 3, 4, 5] + */ +declare function flattenDeep(value: ListOfRecursiveArraysOrValues | null | undefined): Array ? never : T>; + +export { flattenDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.js new file mode 100644 index 0000000000000000000000000000000000000000..3727b211535924d272897d6392cfdbbc69e22cec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flattenDepth = require('./flattenDepth.js'); + +function flattenDeep(value) { + return flattenDepth.flattenDepth(value, Infinity); +} + +exports.flattenDeep = flattenDeep; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5789b165df3926bd0b4602dfa86ad567c2e569b9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDeep.mjs @@ -0,0 +1,7 @@ +import { flattenDepth } from './flattenDepth.mjs'; + +function flattenDeep(value) { + return flattenDepth(value, Infinity); +} + +export { flattenDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..3301bb15e71291e13c59f4611d11c870d39557fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.d.mts @@ -0,0 +1,22 @@ +import { ListOfRecursiveArraysOrValues } from '../_internal/ListOfRecursiveArraysOrValues.mjs'; + +/** + * Recursively flattens array up to depth times. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to flatten. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {T[]} Returns the new flattened array. + * + * @example + * const array = [1, [2, [3, [4]], 5]]; + * + * flattenDepth(array, 1); + * // => [1, 2, [3, [4]], 5] + * + * flattenDepth(array, 2); + * // => [1, 2, 3, [4], 5] + */ +declare function flattenDepth(array: ListOfRecursiveArraysOrValues | null | undefined, depth?: number): T[]; + +export { flattenDepth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3285e639d6c7a9145994b06531c9372d13a9c67f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.d.ts @@ -0,0 +1,22 @@ +import { ListOfRecursiveArraysOrValues } from '../_internal/ListOfRecursiveArraysOrValues.js'; + +/** + * Recursively flattens array up to depth times. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to flatten. + * @param {number} [depth=1] - The maximum recursion depth. + * @returns {T[]} Returns the new flattened array. + * + * @example + * const array = [1, [2, [3, [4]], 5]]; + * + * flattenDepth(array, 1); + * // => [1, 2, [3, [4]], 5] + * + * flattenDepth(array, 2); + * // => [1, 2, 3, [4], 5] + */ +declare function flattenDepth(array: ListOfRecursiveArraysOrValues | null | undefined, depth?: number): T[]; + +export { flattenDepth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.js new file mode 100644 index 0000000000000000000000000000000000000000..4848f719625e038b554da2880277c9ea5efd0752 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flatten = require('./flatten.js'); + +function flattenDepth(array, depth = 1) { + return flatten.flatten(array, depth); +} + +exports.flattenDepth = flattenDepth; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ea2c0971f85534a3da9de7679dfd47f48f338a5b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/flattenDepth.mjs @@ -0,0 +1,7 @@ +import { flatten } from './flatten.mjs'; + +function flattenDepth(array, depth = 1) { + return flatten(array, depth); +} + +export { flattenDepth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e2ef3d911b3397ad9294cd680d016454a176716b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.d.mts @@ -0,0 +1,110 @@ +import { ArrayIterator } from '../_internal/ArrayIterator.mjs'; +import { ListIterator } from '../_internal/ListIterator.mjs'; +import { ObjectIterator } from '../_internal/ObjectIterator.mjs'; +import { StringIterator } from '../_internal/StringIterator.mjs'; + +/** + * Iterates over elements of array and invokes iteratee for each element. + * + * @template T + * @param {T[]} collection - The array to iterate over. + * @param {ArrayIterator} [iteratee] - The function invoked per iteration. + * @returns {T[]} Returns array. + * + * @example + * forEach([1, 2], value => console.log(value)); + * // => Logs `1` then `2`. + */ +declare function forEach(collection: T[], iteratee?: ArrayIterator): T[]; +/** + * Iterates over characters of string and invokes iteratee for each character. + * + * @param {string} collection - The string to iterate over. + * @param {StringIterator} [iteratee] - The function invoked per iteration. + * @returns {string} Returns string. + * + * @example + * forEach('abc', char => console.log(char)); + * // => Logs 'a', 'b', then 'c'. + */ +declare function forEach(collection: string, iteratee?: StringIterator): string; +/** + * Iterates over elements of collection and invokes iteratee for each element. + * + * @template T + * @param {ArrayLike} collection - The collection to iterate over. + * @param {ListIterator} [iteratee] - The function invoked per iteration. + * @returns {ArrayLike} Returns collection. + * + * @example + * forEach({ 0: 'a', 1: 'b', length: 2 }, value => console.log(value)); + * // => Logs 'a' then 'b'. + */ +declare function forEach(collection: ArrayLike, iteratee?: ListIterator): ArrayLike; +/** + * Iterates over own enumerable string keyed properties of an object and invokes iteratee for each property. + * + * @template T + * @param {T} collection - The object to iterate over. + * @param {ObjectIterator} [iteratee] - The function invoked per iteration. + * @returns {T} Returns object. + * + * @example + * forEach({ a: 1, b: 2 }, (value, key) => console.log(key)); + * // => Logs 'a' then 'b'. + */ +declare function forEach(collection: T, iteratee?: ObjectIterator): T; +/** + * Iterates over elements of array and invokes iteratee for each element. + * + * @template T, U + * @param {U & (T[] | null | undefined)} collection - The array to iterate over. + * @param {ArrayIterator} [iteratee] - The function invoked per iteration. + * @returns {U} Returns the array. + * + * @example + * forEach([1, 2], value => console.log(value)); + * // => Logs `1` then `2`. + */ +declare function forEach(collection: U & (T[] | null | undefined), iteratee?: ArrayIterator): U; +/** + * Iterates over characters of string and invokes iteratee for each character. + * + * @template T + * @param {T} collection - The string to iterate over. + * @param {StringIterator} [iteratee] - The function invoked per iteration. + * @returns {T} Returns the string. + * + * @example + * forEach('abc', char => console.log(char)); + * // => Logs 'a', 'b', then 'c'. + */ +declare function forEach(collection: T, iteratee?: StringIterator): T; +/** + * Iterates over elements of collection and invokes iteratee for each element. + * + * @template T, L + * @param {L & (ArrayLike | null | undefined)} collection - The collection to iterate over. + * @param {ListIterator} [iteratee] - The function invoked per iteration. + * @returns {L} Returns the collection. + * + * @example + * forEach({ 0: 'a', 1: 'b', length: 2 }, value => console.log(value)); + * // => Logs 'a' then 'b'. + */ +declare function forEach | null | undefined>(collection: L & (ArrayLike | null | undefined), iteratee?: ListIterator): L; +/** + * Iterates over own enumerable string keyed properties of an object and invokes iteratee for each property. + * + * @template T + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator} [iteratee] - The function invoked per iteration. + * @returns {T | null | undefined} Returns the object. + * + * @example + * forEach({ a: 1, b: 2 }, (value, key) => console.log(key)); + * // => Logs 'a' then 'b'. + */ +declare function forEach(collection: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + +export { forEach }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d8e3cae966dc832d0f97186ece0c3570aeac9e44 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.d.ts @@ -0,0 +1,110 @@ +import { ArrayIterator } from '../_internal/ArrayIterator.js'; +import { ListIterator } from '../_internal/ListIterator.js'; +import { ObjectIterator } from '../_internal/ObjectIterator.js'; +import { StringIterator } from '../_internal/StringIterator.js'; + +/** + * Iterates over elements of array and invokes iteratee for each element. + * + * @template T + * @param {T[]} collection - The array to iterate over. + * @param {ArrayIterator} [iteratee] - The function invoked per iteration. + * @returns {T[]} Returns array. + * + * @example + * forEach([1, 2], value => console.log(value)); + * // => Logs `1` then `2`. + */ +declare function forEach(collection: T[], iteratee?: ArrayIterator): T[]; +/** + * Iterates over characters of string and invokes iteratee for each character. + * + * @param {string} collection - The string to iterate over. + * @param {StringIterator} [iteratee] - The function invoked per iteration. + * @returns {string} Returns string. + * + * @example + * forEach('abc', char => console.log(char)); + * // => Logs 'a', 'b', then 'c'. + */ +declare function forEach(collection: string, iteratee?: StringIterator): string; +/** + * Iterates over elements of collection and invokes iteratee for each element. + * + * @template T + * @param {ArrayLike} collection - The collection to iterate over. + * @param {ListIterator} [iteratee] - The function invoked per iteration. + * @returns {ArrayLike} Returns collection. + * + * @example + * forEach({ 0: 'a', 1: 'b', length: 2 }, value => console.log(value)); + * // => Logs 'a' then 'b'. + */ +declare function forEach(collection: ArrayLike, iteratee?: ListIterator): ArrayLike; +/** + * Iterates over own enumerable string keyed properties of an object and invokes iteratee for each property. + * + * @template T + * @param {T} collection - The object to iterate over. + * @param {ObjectIterator} [iteratee] - The function invoked per iteration. + * @returns {T} Returns object. + * + * @example + * forEach({ a: 1, b: 2 }, (value, key) => console.log(key)); + * // => Logs 'a' then 'b'. + */ +declare function forEach(collection: T, iteratee?: ObjectIterator): T; +/** + * Iterates over elements of array and invokes iteratee for each element. + * + * @template T, U + * @param {U & (T[] | null | undefined)} collection - The array to iterate over. + * @param {ArrayIterator} [iteratee] - The function invoked per iteration. + * @returns {U} Returns the array. + * + * @example + * forEach([1, 2], value => console.log(value)); + * // => Logs `1` then `2`. + */ +declare function forEach(collection: U & (T[] | null | undefined), iteratee?: ArrayIterator): U; +/** + * Iterates over characters of string and invokes iteratee for each character. + * + * @template T + * @param {T} collection - The string to iterate over. + * @param {StringIterator} [iteratee] - The function invoked per iteration. + * @returns {T} Returns the string. + * + * @example + * forEach('abc', char => console.log(char)); + * // => Logs 'a', 'b', then 'c'. + */ +declare function forEach(collection: T, iteratee?: StringIterator): T; +/** + * Iterates over elements of collection and invokes iteratee for each element. + * + * @template T, L + * @param {L & (ArrayLike | null | undefined)} collection - The collection to iterate over. + * @param {ListIterator} [iteratee] - The function invoked per iteration. + * @returns {L} Returns the collection. + * + * @example + * forEach({ 0: 'a', 1: 'b', length: 2 }, value => console.log(value)); + * // => Logs 'a' then 'b'. + */ +declare function forEach | null | undefined>(collection: L & (ArrayLike | null | undefined), iteratee?: ListIterator): L; +/** + * Iterates over own enumerable string keyed properties of an object and invokes iteratee for each property. + * + * @template T + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator} [iteratee] - The function invoked per iteration. + * @returns {T | null | undefined} Returns the object. + * + * @example + * forEach({ a: 1, b: 2 }, (value, key) => console.log(key)); + * // => Logs 'a' then 'b'. + */ +declare function forEach(collection: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + +export { forEach }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.js new file mode 100644 index 0000000000000000000000000000000000000000..ae954d128ef56f9cfb386a58174782bf536fa8c6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const range = require('../../math/range.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function forEach(collection, callback = identity.identity) { + if (!collection) { + return collection; + } + const keys = isArrayLike.isArrayLike(collection) || Array.isArray(collection) ? range.range(0, collection.length) : Object.keys(collection); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = collection[key]; + const result = callback(value, key, collection); + if (result === false) { + break; + } + } + return collection; +} + +exports.forEach = forEach; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e2713cd6213a66859de77d8cb9bc4fa1bc0123e9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEach.mjs @@ -0,0 +1,21 @@ +import { identity } from '../../function/identity.mjs'; +import { range } from '../../math/range.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function forEach(collection, callback = identity) { + if (!collection) { + return collection; + } + const keys = isArrayLike(collection) || Array.isArray(collection) ? range(0, collection.length) : Object.keys(collection); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = collection[key]; + const result = callback(value, key, collection); + if (result === false) { + break; + } + } + return collection; +} + +export { forEach }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6be227e9212dd075cdfaaba50140142fcb6f1b01 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.d.mts @@ -0,0 +1,110 @@ +import { ArrayIterator } from '../_internal/ArrayIterator.mjs'; +import { ListIterator } from '../_internal/ListIterator.mjs'; +import { ObjectIterator } from '../_internal/ObjectIterator.mjs'; +import { StringIterator } from '../_internal/StringIterator.mjs'; + +/** + * Iterates over elements of array from right to left and invokes iteratee for each element. + * + * @template T + * @param {T[]} collection - The array to iterate over. + * @param {ArrayIterator} [iteratee] - The function invoked per iteration. + * @returns {T[]} Returns array. + * + * @example + * forEachRight([1, 2], value => console.log(value)); + * // => Logs `2` then `1`. + */ +declare function forEachRight(collection: T[], iteratee?: ArrayIterator): T[]; +/** + * Iterates over characters of string from right to left and invokes iteratee for each character. + * + * @param {string} collection - The string to iterate over. + * @param {StringIterator} [iteratee] - The function invoked per iteration. + * @returns {string} Returns string. + * + * @example + * forEachRight('abc', char => console.log(char)); + * // => Logs 'c', 'b', then 'a'. + */ +declare function forEachRight(collection: string, iteratee?: StringIterator): string; +/** + * Iterates over elements of collection from right to left and invokes iteratee for each element. + * + * @template T + * @param {ArrayLike} collection - The collection to iterate over. + * @param {ListIterator} [iteratee] - The function invoked per iteration. + * @returns {ArrayLike} Returns collection. + * + * @example + * forEachRight({ 0: 'a', 1: 'b', length: 2 }, value => console.log(value)); + * // => Logs 'b' then 'a'. + */ +declare function forEachRight(collection: ArrayLike, iteratee?: ListIterator): ArrayLike; +/** + * Iterates over own enumerable string keyed properties of an object from right to left and invokes iteratee for each property. + * + * @template T + * @param {T} collection - The object to iterate over. + * @param {ObjectIterator} [iteratee] - The function invoked per iteration. + * @returns {T} Returns object. + * + * @example + * forEachRight({ a: 1, b: 2 }, (value, key) => console.log(key)); + * // => Logs 'b' then 'a'. + */ +declare function forEachRight(collection: T, iteratee?: ObjectIterator): T; +/** + * Iterates over elements of array from right to left and invokes iteratee for each element. + * + * @template T, U + * @param {U & (T[] | null | undefined)} collection - The array to iterate over. + * @param {ArrayIterator} [iteratee] - The function invoked per iteration. + * @returns {U} Returns the array. + * + * @example + * forEachRight([1, 2], value => console.log(value)); + * // => Logs `2` then `1`. + */ +declare function forEachRight(collection: U & (T[] | null | undefined), iteratee?: ArrayIterator): U; +/** + * Iterates over characters of string from right to left and invokes iteratee for each character. + * + * @template T + * @param {T} collection - The string to iterate over. + * @param {StringIterator} [iteratee] - The function invoked per iteration. + * @returns {T} Returns the string. + * + * @example + * forEachRight('abc', char => console.log(char)); + * // => Logs 'c', 'b', then 'a'. + */ +declare function forEachRight(collection: T, iteratee?: StringIterator): T; +/** + * Iterates over elements of collection from right to left and invokes iteratee for each element. + * + * @template T, L + * @param {L & (ArrayLike | null | undefined)} collection - The collection to iterate over. + * @param {ListIterator} [iteratee] - The function invoked per iteration. + * @returns {L} Returns the collection. + * + * @example + * forEachRight({ 0: 'a', 1: 'b', length: 2 }, value => console.log(value)); + * // => Logs 'b' then 'a'. + */ +declare function forEachRight | null | undefined>(collection: L & (ArrayLike | null | undefined), iteratee?: ListIterator): L; +/** + * Iterates over own enumerable string keyed properties of an object from right to left and invokes iteratee for each property. + * + * @template T + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator} [iteratee] - The function invoked per iteration. + * @returns {T | null | undefined} Returns the object. + * + * @example + * forEachRight({ a: 1, b: 2 }, (value, key) => console.log(key)); + * // => Logs 'b' then 'a'. + */ +declare function forEachRight(collection: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + +export { forEachRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7a4d452d78a11385db6eece17fd8051af4b1010d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.d.ts @@ -0,0 +1,110 @@ +import { ArrayIterator } from '../_internal/ArrayIterator.js'; +import { ListIterator } from '../_internal/ListIterator.js'; +import { ObjectIterator } from '../_internal/ObjectIterator.js'; +import { StringIterator } from '../_internal/StringIterator.js'; + +/** + * Iterates over elements of array from right to left and invokes iteratee for each element. + * + * @template T + * @param {T[]} collection - The array to iterate over. + * @param {ArrayIterator} [iteratee] - The function invoked per iteration. + * @returns {T[]} Returns array. + * + * @example + * forEachRight([1, 2], value => console.log(value)); + * // => Logs `2` then `1`. + */ +declare function forEachRight(collection: T[], iteratee?: ArrayIterator): T[]; +/** + * Iterates over characters of string from right to left and invokes iteratee for each character. + * + * @param {string} collection - The string to iterate over. + * @param {StringIterator} [iteratee] - The function invoked per iteration. + * @returns {string} Returns string. + * + * @example + * forEachRight('abc', char => console.log(char)); + * // => Logs 'c', 'b', then 'a'. + */ +declare function forEachRight(collection: string, iteratee?: StringIterator): string; +/** + * Iterates over elements of collection from right to left and invokes iteratee for each element. + * + * @template T + * @param {ArrayLike} collection - The collection to iterate over. + * @param {ListIterator} [iteratee] - The function invoked per iteration. + * @returns {ArrayLike} Returns collection. + * + * @example + * forEachRight({ 0: 'a', 1: 'b', length: 2 }, value => console.log(value)); + * // => Logs 'b' then 'a'. + */ +declare function forEachRight(collection: ArrayLike, iteratee?: ListIterator): ArrayLike; +/** + * Iterates over own enumerable string keyed properties of an object from right to left and invokes iteratee for each property. + * + * @template T + * @param {T} collection - The object to iterate over. + * @param {ObjectIterator} [iteratee] - The function invoked per iteration. + * @returns {T} Returns object. + * + * @example + * forEachRight({ a: 1, b: 2 }, (value, key) => console.log(key)); + * // => Logs 'b' then 'a'. + */ +declare function forEachRight(collection: T, iteratee?: ObjectIterator): T; +/** + * Iterates over elements of array from right to left and invokes iteratee for each element. + * + * @template T, U + * @param {U & (T[] | null | undefined)} collection - The array to iterate over. + * @param {ArrayIterator} [iteratee] - The function invoked per iteration. + * @returns {U} Returns the array. + * + * @example + * forEachRight([1, 2], value => console.log(value)); + * // => Logs `2` then `1`. + */ +declare function forEachRight(collection: U & (T[] | null | undefined), iteratee?: ArrayIterator): U; +/** + * Iterates over characters of string from right to left and invokes iteratee for each character. + * + * @template T + * @param {T} collection - The string to iterate over. + * @param {StringIterator} [iteratee] - The function invoked per iteration. + * @returns {T} Returns the string. + * + * @example + * forEachRight('abc', char => console.log(char)); + * // => Logs 'c', 'b', then 'a'. + */ +declare function forEachRight(collection: T, iteratee?: StringIterator): T; +/** + * Iterates over elements of collection from right to left and invokes iteratee for each element. + * + * @template T, L + * @param {L & (ArrayLike | null | undefined)} collection - The collection to iterate over. + * @param {ListIterator} [iteratee] - The function invoked per iteration. + * @returns {L} Returns the collection. + * + * @example + * forEachRight({ 0: 'a', 1: 'b', length: 2 }, value => console.log(value)); + * // => Logs 'b' then 'a'. + */ +declare function forEachRight | null | undefined>(collection: L & (ArrayLike | null | undefined), iteratee?: ListIterator): L; +/** + * Iterates over own enumerable string keyed properties of an object from right to left and invokes iteratee for each property. + * + * @template T + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ObjectIterator} [iteratee] - The function invoked per iteration. + * @returns {T | null | undefined} Returns the object. + * + * @example + * forEachRight({ a: 1, b: 2 }, (value, key) => console.log(key)); + * // => Logs 'b' then 'a'. + */ +declare function forEachRight(collection: T | null | undefined, iteratee?: ObjectIterator): T | null | undefined; + +export { forEachRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.js new file mode 100644 index 0000000000000000000000000000000000000000..8cf57bad968307297397cd5c99e7b5b1219dc297 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const range = require('../../math/range.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function forEachRight(collection, callback = identity.identity) { + if (!collection) { + return collection; + } + const keys = isArrayLike.isArrayLike(collection) ? range.range(0, collection.length) : Object.keys(collection); + for (let i = keys.length - 1; i >= 0; i--) { + const key = keys[i]; + const value = collection[key]; + const result = callback(value, key, collection); + if (result === false) { + break; + } + } + return collection; +} + +exports.forEachRight = forEachRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..33752e0e5e526556a9f8f6d6bd56468ad6631cab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/forEachRight.mjs @@ -0,0 +1,21 @@ +import { identity } from '../../function/identity.mjs'; +import { range } from '../../math/range.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function forEachRight(collection, callback = identity) { + if (!collection) { + return collection; + } + const keys = isArrayLike(collection) ? range(0, collection.length) : Object.keys(collection); + for (let i = keys.length - 1; i >= 0; i--) { + const key = keys[i]; + const value = collection[key]; + const result = callback(value, key, collection); + if (result === false) { + break; + } + } + return collection; +} + +export { forEachRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2d3403b27e5466400fc74e6cb66169601f4578ca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.d.mts @@ -0,0 +1,35 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Creates an object composed of keys generated from the results of running each element of collection through iteratee. + * The order of grouped values is determined by the order they occur in collection. + * + * @template T - The type of elements in the array-like collection + * @param {ArrayLike | null | undefined} collection - The collection to iterate over + * @param {ValueIteratee} [iteratee=identity] - The iteratee to transform keys + * @returns {Record} Returns the composed aggregate object + * + * @example + * groupBy([6.1, 4.2, 6.3], Math.floor) + * // => { '4': [4.2], '6': [6.1, 6.3] } + * + * groupBy(['one', 'two', 'three'], 'length') + * // => { '3': ['one', 'two'], '5': ['three'] } + */ +declare function groupBy(collection: ArrayLike | null | undefined, iteratee?: ValueIteratee): Record; +/** + * Creates an object composed of keys generated from the results of running each element of collection through iteratee. + * The order of grouped values is determined by the order they occur in collection. + * + * @template T - The type of the object + * @param {T | null | undefined} collection - The object to iterate over + * @param {ValueIteratee} [iteratee=identity] - The iteratee to transform keys + * @returns {Record>} Returns the composed aggregate object + * + * @example + * groupBy({ a: 6.1, b: 4.2, c: 6.3 }, Math.floor) + * // => { '4': [4.2], '6': [6.1, 6.3] } + */ +declare function groupBy(collection: T | null | undefined, iteratee?: ValueIteratee): Record>; + +export { groupBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f5272fd7c6a35eb54a91cdf4dc1a14dda835698c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.d.ts @@ -0,0 +1,35 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Creates an object composed of keys generated from the results of running each element of collection through iteratee. + * The order of grouped values is determined by the order they occur in collection. + * + * @template T - The type of elements in the array-like collection + * @param {ArrayLike | null | undefined} collection - The collection to iterate over + * @param {ValueIteratee} [iteratee=identity] - The iteratee to transform keys + * @returns {Record} Returns the composed aggregate object + * + * @example + * groupBy([6.1, 4.2, 6.3], Math.floor) + * // => { '4': [4.2], '6': [6.1, 6.3] } + * + * groupBy(['one', 'two', 'three'], 'length') + * // => { '3': ['one', 'two'], '5': ['three'] } + */ +declare function groupBy(collection: ArrayLike | null | undefined, iteratee?: ValueIteratee): Record; +/** + * Creates an object composed of keys generated from the results of running each element of collection through iteratee. + * The order of grouped values is determined by the order they occur in collection. + * + * @template T - The type of the object + * @param {T | null | undefined} collection - The object to iterate over + * @param {ValueIteratee} [iteratee=identity] - The iteratee to transform keys + * @returns {Record>} Returns the composed aggregate object + * + * @example + * groupBy({ a: 6.1, b: 4.2, c: 6.3 }, Math.floor) + * // => { '4': [4.2], '6': [6.1, 6.3] } + */ +declare function groupBy(collection: T | null | undefined, iteratee?: ValueIteratee): Record>; + +export { groupBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.js new file mode 100644 index 0000000000000000000000000000000000000000..5dbecbde50adca7a22bc178f74e5c691e1f9c07e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const groupBy$1 = require('../../array/groupBy.js'); +const identity = require('../../function/identity.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const iteratee = require('../util/iteratee.js'); + +function groupBy(source, _getKeyFromItem) { + if (source == null) { + return {}; + } + const items = isArrayLike.isArrayLike(source) ? Array.from(source) : Object.values(source); + const getKeyFromItem = iteratee.iteratee(_getKeyFromItem ?? identity.identity); + return groupBy$1.groupBy(items, getKeyFromItem); +} + +exports.groupBy = groupBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9945a91c951b23d2f26cccc207dd1698e05a4111 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/groupBy.mjs @@ -0,0 +1,15 @@ +import { groupBy as groupBy$1 } from '../../array/groupBy.mjs'; +import { identity } from '../../function/identity.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function groupBy(source, _getKeyFromItem) { + if (source == null) { + return {}; + } + const items = isArrayLike(source) ? Array.from(source) : Object.values(source); + const getKeyFromItem = iteratee(_getKeyFromItem ?? identity); + return groupBy$1(items, getKeyFromItem); +} + +export { groupBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0b59f8aa8b4fbb786028900a0f2a216de1630001 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.d.mts @@ -0,0 +1,32 @@ +/** + * Returns the first element of an array or `undefined` if the array is empty. + * + * @template T - The type of elements in the array. + * @param {readonly [T, ...unknown[]]} array - A non-empty tuple with at least one element. + * @returns {T} The first element of the array. + * + * @example + * const arr = [1, 2, 3] as const; + * const first = head(arr); + * // first will be 1 + */ +declare function head(array: readonly [T, ...unknown[]]): T; +/** + * Returns the first element of an array or `undefined` if the array is empty. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} array - The array from which to get the first element. + * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty/null/undefined. + * + * @example + * const arr = [1, 2, 3]; + * const first = head(arr); + * // first will be 1 + * + * const emptyArr: number[] = []; + * const noElement = head(emptyArr); + * // noElement will be undefined + */ +declare function head(array: ArrayLike | null | undefined): T | undefined; + +export { head }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0b59f8aa8b4fbb786028900a0f2a216de1630001 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.d.ts @@ -0,0 +1,32 @@ +/** + * Returns the first element of an array or `undefined` if the array is empty. + * + * @template T - The type of elements in the array. + * @param {readonly [T, ...unknown[]]} array - A non-empty tuple with at least one element. + * @returns {T} The first element of the array. + * + * @example + * const arr = [1, 2, 3] as const; + * const first = head(arr); + * // first will be 1 + */ +declare function head(array: readonly [T, ...unknown[]]): T; +/** + * Returns the first element of an array or `undefined` if the array is empty. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} array - The array from which to get the first element. + * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty/null/undefined. + * + * @example + * const arr = [1, 2, 3]; + * const first = head(arr); + * // first will be 1 + * + * const emptyArr: number[] = []; + * const noElement = head(emptyArr); + * // noElement will be undefined + */ +declare function head(array: ArrayLike | null | undefined): T | undefined; + +export { head }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.js new file mode 100644 index 0000000000000000000000000000000000000000..5e333ead08e0bb5f1c59e2a240a008aefcb2e1b6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const head$1 = require('../../array/head.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function head(arr) { + if (!isArrayLike.isArrayLike(arr)) { + return undefined; + } + return head$1.head(toArray.toArray(arr)); +} + +exports.head = head; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.mjs new file mode 100644 index 0000000000000000000000000000000000000000..53069969fad604c4904b991cd1ebde415e811fa5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/head.mjs @@ -0,0 +1,12 @@ +import { head as head$1 } from '../../array/head.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function head(arr) { + if (!isArrayLike(arr)) { + return undefined; + } + return head$1(toArray(arr)); +} + +export { head }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2f733487c4f974f2c7cbd464be98c3efb6868d1b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.d.mts @@ -0,0 +1,22 @@ +/** + * Checks if a specified value exists within a given array-like collection. + * + * The comparison uses SameValueZero to check for inclusion. + * + * @template T The type of elements in the collection + * @param collection The array-like collection to search in + * @param target The value to search for in the collection + * @param [fromIndex=0] The index to start searching from. If negative, it is treated as an offset from the end + * @returns `true` if the value is found in the collection, `false` otherwise + * + * @example + * includes([1, 2, 3], 2); // true + * includes([1, 2, 3], 4); // false + * includes('hello', 'e'); // true + * includes(null, 1); // false + * includes([1, 2, 3], 2, 2); // false + * includes([1, 2, 3], 2, -2); // true + */ +declare function includes(collection: Record | Record | null | undefined, target: T, fromIndex?: number): boolean; + +export { includes }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2f733487c4f974f2c7cbd464be98c3efb6868d1b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.d.ts @@ -0,0 +1,22 @@ +/** + * Checks if a specified value exists within a given array-like collection. + * + * The comparison uses SameValueZero to check for inclusion. + * + * @template T The type of elements in the collection + * @param collection The array-like collection to search in + * @param target The value to search for in the collection + * @param [fromIndex=0] The index to start searching from. If negative, it is treated as an offset from the end + * @returns `true` if the value is found in the collection, `false` otherwise + * + * @example + * includes([1, 2, 3], 2); // true + * includes([1, 2, 3], 4); // false + * includes('hello', 'e'); // true + * includes(null, 1); // false + * includes([1, 2, 3], 2, 2); // false + * includes([1, 2, 3], 2, -2); // true + */ +declare function includes(collection: Record | Record | null | undefined, target: T, fromIndex?: number): boolean; + +export { includes }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.js new file mode 100644 index 0000000000000000000000000000000000000000..da2180ffb07d3b0f653ea630d91f8b0b953d433f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.js @@ -0,0 +1,44 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isString = require('../predicate/isString.js'); +const eq = require('../util/eq.js'); +const toInteger = require('../util/toInteger.js'); + +function includes(source, target, fromIndex, guard) { + if (source == null) { + return false; + } + if (guard || !fromIndex) { + fromIndex = 0; + } + else { + fromIndex = toInteger.toInteger(fromIndex); + } + if (isString.isString(source)) { + if (fromIndex > source.length || target instanceof RegExp) { + return false; + } + if (fromIndex < 0) { + fromIndex = Math.max(0, source.length + fromIndex); + } + return source.includes(target, fromIndex); + } + if (Array.isArray(source)) { + return source.includes(target, fromIndex); + } + const keys = Object.keys(source); + if (fromIndex < 0) { + fromIndex = Math.max(0, keys.length + fromIndex); + } + for (let i = fromIndex; i < keys.length; i++) { + const value = Reflect.get(source, keys[i]); + if (eq.eq(value, target)) { + return true; + } + } + return false; +} + +exports.includes = includes; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.mjs new file mode 100644 index 0000000000000000000000000000000000000000..364811b406798ecf20c1f6473bb5152fa57eb132 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/includes.mjs @@ -0,0 +1,40 @@ +import { isString } from '../predicate/isString.mjs'; +import { eq } from '../util/eq.mjs'; +import { toInteger } from '../util/toInteger.mjs'; + +function includes(source, target, fromIndex, guard) { + if (source == null) { + return false; + } + if (guard || !fromIndex) { + fromIndex = 0; + } + else { + fromIndex = toInteger(fromIndex); + } + if (isString(source)) { + if (fromIndex > source.length || target instanceof RegExp) { + return false; + } + if (fromIndex < 0) { + fromIndex = Math.max(0, source.length + fromIndex); + } + return source.includes(target, fromIndex); + } + if (Array.isArray(source)) { + return source.includes(target, fromIndex); + } + const keys = Object.keys(source); + if (fromIndex < 0) { + fromIndex = Math.max(0, keys.length + fromIndex); + } + for (let i = fromIndex; i < keys.length; i++) { + const value = Reflect.get(source, keys[i]); + if (eq(value, target)) { + return true; + } + } + return false; +} + +export { includes }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b6617487ac34ba2f5199711b2ba94ccc7adeef26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.d.mts @@ -0,0 +1,20 @@ +/** + * Finds the index of the first occurrence of a value in an array. + * + * This method is similar to `Array.prototype.indexOf`, but it also finds `NaN` values. + * It uses strict equality (`===`) to compare elements. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} array - The array to search. + * @param {T} searchElement - The value to search for. + * @param {number} [fromIndex] - The index to start the search at. + * @returns {number} The index (zero-based) of the first occurrence of the value in the array, or `-1` if the value is not found. + * + * @example + * const array = [1, 2, 3, NaN]; + * indexOf(array, 3); // => 2 + * indexOf(array, NaN); // => 3 + */ +declare function indexOf(array: ArrayLike | null | undefined, searchElement: T, fromIndex?: number): number; + +export { indexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b6617487ac34ba2f5199711b2ba94ccc7adeef26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.d.ts @@ -0,0 +1,20 @@ +/** + * Finds the index of the first occurrence of a value in an array. + * + * This method is similar to `Array.prototype.indexOf`, but it also finds `NaN` values. + * It uses strict equality (`===`) to compare elements. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} array - The array to search. + * @param {T} searchElement - The value to search for. + * @param {number} [fromIndex] - The index to start the search at. + * @returns {number} The index (zero-based) of the first occurrence of the value in the array, or `-1` if the value is not found. + * + * @example + * const array = [1, 2, 3, NaN]; + * indexOf(array, 3); // => 2 + * indexOf(array, NaN); // => 3 + */ +declare function indexOf(array: ArrayLike | null | undefined, searchElement: T, fromIndex?: number): number; + +export { indexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.js new file mode 100644 index 0000000000000000000000000000000000000000..beb85f2ada80071188452ac8dcf430fed5516101 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLike = require('../predicate/isArrayLike.js'); + +function indexOf(array, searchElement, fromIndex) { + if (!isArrayLike.isArrayLike(array)) { + return -1; + } + if (Number.isNaN(searchElement)) { + fromIndex = fromIndex ?? 0; + if (fromIndex < 0) { + fromIndex = Math.max(0, array.length + fromIndex); + } + for (let i = fromIndex; i < array.length; i++) { + if (Number.isNaN(array[i])) { + return i; + } + } + return -1; + } + return Array.from(array).indexOf(searchElement, fromIndex); +} + +exports.indexOf = indexOf; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4c3a4ca7975999c74dc27b82b7ed1f292026fb5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/indexOf.mjs @@ -0,0 +1,22 @@ +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function indexOf(array, searchElement, fromIndex) { + if (!isArrayLike(array)) { + return -1; + } + if (Number.isNaN(searchElement)) { + fromIndex = fromIndex ?? 0; + if (fromIndex < 0) { + fromIndex = Math.max(0, array.length + fromIndex); + } + for (let i = fromIndex; i < array.length; i++) { + if (Number.isNaN(array[i])) { + return i; + } + } + return -1; + } + return Array.from(array).indexOf(searchElement, fromIndex); +} + +export { indexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..115b5bd62fa5df17cd33473ba7c6fb4f299cb9f8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.d.mts @@ -0,0 +1,16 @@ +/** + * Returns a new array containing all elements except the last one from the input array. + * If the input array is empty or has only one element, the function returns an empty array. + * + * @template T The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The input array. + * @returns {T[]} A new array containing all but the last element of the input array. + * + * @example + * const arr = [1, 2, 3, 4]; + * const result = initial(arr); + * // result will be [1, 2, 3] + */ +declare function initial(arr: ArrayLike | null | undefined): T[]; + +export { initial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..115b5bd62fa5df17cd33473ba7c6fb4f299cb9f8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.d.ts @@ -0,0 +1,16 @@ +/** + * Returns a new array containing all elements except the last one from the input array. + * If the input array is empty or has only one element, the function returns an empty array. + * + * @template T The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The input array. + * @returns {T[]} A new array containing all but the last element of the input array. + * + * @example + * const arr = [1, 2, 3, 4]; + * const result = initial(arr); + * // result will be [1, 2, 3] + */ +declare function initial(arr: ArrayLike | null | undefined): T[]; + +export { initial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.js new file mode 100644 index 0000000000000000000000000000000000000000..9e5bf9a2810b9e18d37160d4aac4ef6a1ea87f1d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const initial$1 = require('../../array/initial.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function initial(arr) { + if (!isArrayLike.isArrayLike(arr)) { + return []; + } + return initial$1.initial(Array.from(arr)); +} + +exports.initial = initial; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7725ca9cfd0058b927c064a4d3122e17abebdab1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/initial.mjs @@ -0,0 +1,11 @@ +import { initial as initial$1 } from '../../array/initial.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function initial(arr) { + if (!isArrayLike(arr)) { + return []; + } + return initial$1(Array.from(arr)); +} + +export { initial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..98121840d8de67344fb55ce767453a6890e26044 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.d.mts @@ -0,0 +1,20 @@ +/** + * Returns the intersection of multiple arrays. + * + * This function takes multiple arrays and returns a new array containing the elements that are + * present in all provided arrays. It effectively filters out any elements that are not found + * in every array. + * + * @template T - The type of elements in the arrays. + * @param {...(ArrayLike | null | undefined)} arrays - The arrays to compare. + * @returns {T[]} A new array containing the elements that are present in all arrays. + * + * @example + * const array1 = [1, 2, 3, 4, 5]; + * const array2 = [3, 4, 5, 6, 7]; + * const result = intersection(array1, array2); + * // result will be [3, 4, 5] since these elements are in both arrays. + */ +declare function intersection(...arrays: Array | null | undefined>): T[]; + +export { intersection }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..98121840d8de67344fb55ce767453a6890e26044 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.d.ts @@ -0,0 +1,20 @@ +/** + * Returns the intersection of multiple arrays. + * + * This function takes multiple arrays and returns a new array containing the elements that are + * present in all provided arrays. It effectively filters out any elements that are not found + * in every array. + * + * @template T - The type of elements in the arrays. + * @param {...(ArrayLike | null | undefined)} arrays - The arrays to compare. + * @returns {T[]} A new array containing the elements that are present in all arrays. + * + * @example + * const array1 = [1, 2, 3, 4, 5]; + * const array2 = [3, 4, 5, 6, 7]; + * const result = intersection(array1, array2); + * // result will be [3, 4, 5] since these elements are in both arrays. + */ +declare function intersection(...arrays: Array | null | undefined>): T[]; + +export { intersection }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.js new file mode 100644 index 0000000000000000000000000000000000000000..598f4e2ae408cdc2ffc08d364e462762ae100427 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const intersection$1 = require('../../array/intersection.js'); +const uniq = require('../../array/uniq.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function intersection(...arrays) { + if (arrays.length === 0) { + return []; + } + if (!isArrayLikeObject.isArrayLikeObject(arrays[0])) { + return []; + } + let result = uniq.uniq(Array.from(arrays[0])); + for (let i = 1; i < arrays.length; i++) { + const array = arrays[i]; + if (!isArrayLikeObject.isArrayLikeObject(array)) { + return []; + } + result = intersection$1.intersection(result, Array.from(array)); + } + return result; +} + +exports.intersection = intersection; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.mjs new file mode 100644 index 0000000000000000000000000000000000000000..feae1f014c15bee4ed3bb844590267dcfa256726 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersection.mjs @@ -0,0 +1,23 @@ +import { intersection as intersection$1 } from '../../array/intersection.mjs'; +import { uniq } from '../../array/uniq.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function intersection(...arrays) { + if (arrays.length === 0) { + return []; + } + if (!isArrayLikeObject(arrays[0])) { + return []; + } + let result = uniq(Array.from(arrays[0])); + for (let i = 1; i < arrays.length; i++) { + const array = arrays[i]; + if (!isArrayLikeObject(array)) { + return []; + } + result = intersection$1(result, Array.from(array)); + } + return result; +} + +export { intersection }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4473a87e9560cc310bf1803ce6dc0fbf2c2aa6aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.d.mts @@ -0,0 +1,73 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Creates an array of unique values that are included in all given arrays, using an iteratee to compute equality. + * + * @template T, U + * @param {ArrayLike | null} array - The array to inspect. + * @param {ArrayLike} values - The values to compare. + * @param {ValueIteratee} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + */ +declare function intersectionBy(array: ArrayLike | null, values: ArrayLike, iteratee: ValueIteratee): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using an iteratee to compute equality. + * + * @template T, U, V + * @param {ArrayLike | null} array - The array to inspect. + * @param {ArrayLike} values1 - The first values to compare. + * @param {ArrayLike} values2 - The second values to compare. + * @param {ValueIteratee} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2.1, 1.2], [2.3, 3.4], [2.5], Math.floor); + * // => [2.1] + */ +declare function intersectionBy(array: ArrayLike | null, values1: ArrayLike, values2: ArrayLike, iteratee: ValueIteratee): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using an iteratee to compute equality. + * + * @template T, U, V, W + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ArrayLike} values1 - The first values to compare. + * @param {ArrayLike} values2 - The second values to compare. + * @param {...Array | ValueIteratee>} values - The other arrays to compare, and the iteratee to use. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2.1, 1.2], [2.3, 3.4], [2.5], [2.6, 1.7], Math.floor); + * // => [2.1] + */ +declare function intersectionBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, ...values: Array | ValueIteratee>): T[]; +/** + * Creates an array of unique values that are included in all given arrays. + * + * @template T + * @param {ArrayLike | null} [array] - The array to inspect. + * @param {...Array>} values - The values to compare. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2, 1], [2, 3]); + * // => [2] + */ +declare function intersectionBy(array?: ArrayLike | null, ...values: Array>): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using an iteratee to compute equality. + * + * @template T + * @param {...Array | ValueIteratee>} values - The arrays to compare and the iteratee to use. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + */ +declare function intersectionBy(...values: Array | ValueIteratee>): T[]; + +export { intersectionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..79057e60c3f2a8a900f6b91dab50a2b0274bb730 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.d.ts @@ -0,0 +1,73 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Creates an array of unique values that are included in all given arrays, using an iteratee to compute equality. + * + * @template T, U + * @param {ArrayLike | null} array - The array to inspect. + * @param {ArrayLike} values - The values to compare. + * @param {ValueIteratee} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + */ +declare function intersectionBy(array: ArrayLike | null, values: ArrayLike, iteratee: ValueIteratee): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using an iteratee to compute equality. + * + * @template T, U, V + * @param {ArrayLike | null} array - The array to inspect. + * @param {ArrayLike} values1 - The first values to compare. + * @param {ArrayLike} values2 - The second values to compare. + * @param {ValueIteratee} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2.1, 1.2], [2.3, 3.4], [2.5], Math.floor); + * // => [2.1] + */ +declare function intersectionBy(array: ArrayLike | null, values1: ArrayLike, values2: ArrayLike, iteratee: ValueIteratee): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using an iteratee to compute equality. + * + * @template T, U, V, W + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ArrayLike} values1 - The first values to compare. + * @param {ArrayLike} values2 - The second values to compare. + * @param {...Array | ValueIteratee>} values - The other arrays to compare, and the iteratee to use. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2.1, 1.2], [2.3, 3.4], [2.5], [2.6, 1.7], Math.floor); + * // => [2.1] + */ +declare function intersectionBy(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, ...values: Array | ValueIteratee>): T[]; +/** + * Creates an array of unique values that are included in all given arrays. + * + * @template T + * @param {ArrayLike | null} [array] - The array to inspect. + * @param {...Array>} values - The values to compare. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2, 1], [2, 3]); + * // => [2] + */ +declare function intersectionBy(array?: ArrayLike | null, ...values: Array>): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using an iteratee to compute equality. + * + * @template T + * @param {...Array | ValueIteratee>} values - The arrays to compare and the iteratee to use. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); + * // => [2.1] + */ +declare function intersectionBy(...values: Array | ValueIteratee>): T[]; + +export { intersectionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.js new file mode 100644 index 0000000000000000000000000000000000000000..9edba43a178d31492c63ef5d4f4bcf30a47fcffe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const intersectionBy$1 = require('../../array/intersectionBy.js'); +const last = require('../../array/last.js'); +const uniq = require('../../array/uniq.js'); +const identity = require('../../function/identity.js'); +const property = require('../object/property.js'); +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); + +function intersectionBy(array, ...values) { + if (!isArrayLikeObject.isArrayLikeObject(array)) { + return []; + } + const lastValue = last.last(values); + if (lastValue === undefined) { + return Array.from(array); + } + let result = uniq.uniq(Array.from(array)); + const count = isArrayLikeObject.isArrayLikeObject(lastValue) ? values.length : values.length - 1; + for (let i = 0; i < count; ++i) { + const value = values[i]; + if (!isArrayLikeObject.isArrayLikeObject(value)) { + return []; + } + if (isArrayLikeObject.isArrayLikeObject(lastValue)) { + result = intersectionBy$1.intersectionBy(result, Array.from(value), identity.identity); + } + else if (typeof lastValue === 'function') { + result = intersectionBy$1.intersectionBy(result, Array.from(value), value => lastValue(value)); + } + else if (typeof lastValue === 'string') { + result = intersectionBy$1.intersectionBy(result, Array.from(value), property.property(lastValue)); + } + } + return result; +} + +exports.intersectionBy = intersectionBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d02762b86c4fb9d2502b5630245cb2d1eb69fe94 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionBy.mjs @@ -0,0 +1,36 @@ +import { intersectionBy as intersectionBy$1 } from '../../array/intersectionBy.mjs'; +import { last } from '../../array/last.mjs'; +import { uniq } from '../../array/uniq.mjs'; +import { identity } from '../../function/identity.mjs'; +import { property } from '../object/property.mjs'; +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; + +function intersectionBy(array, ...values) { + if (!isArrayLikeObject(array)) { + return []; + } + const lastValue = last(values); + if (lastValue === undefined) { + return Array.from(array); + } + let result = uniq(Array.from(array)); + const count = isArrayLikeObject(lastValue) ? values.length : values.length - 1; + for (let i = 0; i < count; ++i) { + const value = values[i]; + if (!isArrayLikeObject(value)) { + return []; + } + if (isArrayLikeObject(lastValue)) { + result = intersectionBy$1(result, Array.from(value), identity); + } + else if (typeof lastValue === 'function') { + result = intersectionBy$1(result, Array.from(value), value => lastValue(value)); + } + else if (typeof lastValue === 'string') { + result = intersectionBy$1(result, Array.from(value), property(lastValue)); + } + } + return result; +} + +export { intersectionBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f50211a800bf7b916159eeff7e7b48a2c709a323 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.d.mts @@ -0,0 +1,68 @@ +/** + * Creates an array of unique values that are included in all given arrays, using a comparator function for equality comparisons. + * + * @template T, U + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ArrayLike} values - The values to compare. + * @param {(a: T, b: T | U) => boolean} comparator - The comparator invoked per element. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * intersectionWith(objects, others, (a, b) => a.x === b.x && a.y === b.y); + * // => [{ 'x': 1, 'y': 2 }] + */ +declare function intersectionWith(array: ArrayLike | null | undefined, values: ArrayLike, comparator: (a: T, b: T | U) => boolean): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using a comparator function for equality comparisons. + * + * @template T, U, V + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ArrayLike} values1 - The first values to compare. + * @param {ArrayLike} values2 - The second values to compare. + * @param {(a: T, b: T | U | V) => boolean} comparator - The comparator invoked per element. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others1 = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * const others2 = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }]; + * intersectionWith(objects, others1, others2, (a, b) => a.x === b.x && a.y === b.y); + * // => [{ 'x': 1, 'y': 2 }] + */ +declare function intersectionWith(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, comparator: (a: T, b: T | U | V) => boolean): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using a comparator function for equality comparisons. + * + * @template T, U, V, W + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ArrayLike} values1 - The first values to compare. + * @param {ArrayLike} values2 - The second values to compare. + * @param {...Array | (a: T, b: T | U | V | W) => boolean>} values - The other arrays to compare, and the comparator to use. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others1 = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * const others2 = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }]; + * const others3 = [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]; + * intersectionWith(objects, others1, others2, others3, (a, b) => a.x === b.x && a.y === b.y); + * // => [{ 'x': 1, 'y': 2 }] + */ +declare function intersectionWith(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, ...values: Array | ((a: T, b: T | U | V | W) => boolean)>): T[]; +/** + * Creates an array of unique values that are included in all given arrays. + * + * @template T + * @param {ArrayLike | null} [array] - The array to inspect. + * @param {...Array | (a: T, b: never) => boolean>} values - The values to compare. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionWith([2, 1], [2, 3]); + * // => [2] + */ +declare function intersectionWith(array?: ArrayLike | null, ...values: Array | ((a: T, b: never) => boolean)>): T[]; + +export { intersectionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f50211a800bf7b916159eeff7e7b48a2c709a323 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.d.ts @@ -0,0 +1,68 @@ +/** + * Creates an array of unique values that are included in all given arrays, using a comparator function for equality comparisons. + * + * @template T, U + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ArrayLike} values - The values to compare. + * @param {(a: T, b: T | U) => boolean} comparator - The comparator invoked per element. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * intersectionWith(objects, others, (a, b) => a.x === b.x && a.y === b.y); + * // => [{ 'x': 1, 'y': 2 }] + */ +declare function intersectionWith(array: ArrayLike | null | undefined, values: ArrayLike, comparator: (a: T, b: T | U) => boolean): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using a comparator function for equality comparisons. + * + * @template T, U, V + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ArrayLike} values1 - The first values to compare. + * @param {ArrayLike} values2 - The second values to compare. + * @param {(a: T, b: T | U | V) => boolean} comparator - The comparator invoked per element. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others1 = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * const others2 = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }]; + * intersectionWith(objects, others1, others2, (a, b) => a.x === b.x && a.y === b.y); + * // => [{ 'x': 1, 'y': 2 }] + */ +declare function intersectionWith(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, comparator: (a: T, b: T | U | V) => boolean): T[]; +/** + * Creates an array of unique values that are included in all given arrays, using a comparator function for equality comparisons. + * + * @template T, U, V, W + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {ArrayLike} values1 - The first values to compare. + * @param {ArrayLike} values2 - The second values to compare. + * @param {...Array | (a: T, b: T | U | V | W) => boolean>} values - The other arrays to compare, and the comparator to use. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; + * const others1 = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; + * const others2 = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }]; + * const others3 = [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]; + * intersectionWith(objects, others1, others2, others3, (a, b) => a.x === b.x && a.y === b.y); + * // => [{ 'x': 1, 'y': 2 }] + */ +declare function intersectionWith(array: ArrayLike | null | undefined, values1: ArrayLike, values2: ArrayLike, ...values: Array | ((a: T, b: T | U | V | W) => boolean)>): T[]; +/** + * Creates an array of unique values that are included in all given arrays. + * + * @template T + * @param {ArrayLike | null} [array] - The array to inspect. + * @param {...Array | (a: T, b: never) => boolean>} values - The values to compare. + * @returns {T[]} Returns the new array of intersecting values. + * + * @example + * intersectionWith([2, 1], [2, 3]); + * // => [2] + */ +declare function intersectionWith(array?: ArrayLike | null, ...values: Array | ((a: T, b: never) => boolean)>): T[]; + +export { intersectionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.js new file mode 100644 index 0000000000000000000000000000000000000000..60f56ca5725fe9d670c818f39835a697ae71c7bd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.js @@ -0,0 +1,46 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const last = require('./last.js'); +const intersectionWith$1 = require('../../array/intersectionWith.js'); +const uniq = require('./uniq.js'); +const eq = require('../util/eq.js'); + +function intersectionWith(firstArr, ...otherArrs) { + if (firstArr == null) { + return []; + } + const _comparator = last.last(otherArrs); + let comparator = eq.eq; + let uniq$1 = uniq.uniq; + if (typeof _comparator === 'function') { + comparator = _comparator; + uniq$1 = uniqPreserve0; + otherArrs.pop(); + } + let result = uniq$1(Array.from(firstArr)); + for (let i = 0; i < otherArrs.length; ++i) { + const otherArr = otherArrs[i]; + if (otherArr == null) { + return []; + } + result = intersectionWith$1.intersectionWith(result, Array.from(otherArr), comparator); + } + return result; +} +function uniqPreserve0(arr) { + const result = []; + const added = new Set(); + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (added.has(item)) { + continue; + } + result.push(item); + added.add(item); + } + return result; +} + +exports.intersectionWith = intersectionWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1d106a9a5c1cdfd383f39bf5c11774dc247374a0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/intersectionWith.mjs @@ -0,0 +1,42 @@ +import { last } from './last.mjs'; +import { intersectionWith as intersectionWith$1 } from '../../array/intersectionWith.mjs'; +import { uniq } from './uniq.mjs'; +import { eq } from '../util/eq.mjs'; + +function intersectionWith(firstArr, ...otherArrs) { + if (firstArr == null) { + return []; + } + const _comparator = last(otherArrs); + let comparator = eq; + let uniq$1 = uniq; + if (typeof _comparator === 'function') { + comparator = _comparator; + uniq$1 = uniqPreserve0; + otherArrs.pop(); + } + let result = uniq$1(Array.from(firstArr)); + for (let i = 0; i < otherArrs.length; ++i) { + const otherArr = otherArrs[i]; + if (otherArr == null) { + return []; + } + result = intersectionWith$1(result, Array.from(otherArr), comparator); + } + return result; +} +function uniqPreserve0(arr) { + const result = []; + const added = new Set(); + for (let i = 0; i < arr.length; i++) { + const item = arr[i]; + if (added.has(item)) { + continue; + } + result.push(item); + added.add(item); + } + return result; +} + +export { intersectionWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fa3234e51703a9e146653449f861f1e5aca50b5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.d.mts @@ -0,0 +1,32 @@ +/** + * Invokes the method at path of each element in collection. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {string} methodName - The name of the method to invoke. + * @param {...any[]} args - The arguments to invoke each method with. + * @returns {any[]} Returns the array of results. + * + * @example + * invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); + * // => [[1, 5, 7], [1, 2, 3]] + * + * invokeMap([123, 456], 'toString', 2); + * // => ['1111011', '111001000'] + */ +declare function invokeMap(collection: object | null | undefined, methodName: string, ...args: any[]): any[]; +/** + * Invokes the method at path of each element in collection. + * + * @template R + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {(...args: any[]) => R} method - The method to invoke. + * @param {...any[]} args - The arguments to invoke each method with. + * @returns {R[]} Returns the array of results. + * + * @example + * invokeMap([5, 1, 7], Array.prototype.slice, 1); + * // => [[], [], []] + */ +declare function invokeMap(collection: object | null | undefined, method: (...args: any[]) => R, ...args: any[]): R[]; + +export { invokeMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fa3234e51703a9e146653449f861f1e5aca50b5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.d.ts @@ -0,0 +1,32 @@ +/** + * Invokes the method at path of each element in collection. + * + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {string} methodName - The name of the method to invoke. + * @param {...any[]} args - The arguments to invoke each method with. + * @returns {any[]} Returns the array of results. + * + * @example + * invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); + * // => [[1, 5, 7], [1, 2, 3]] + * + * invokeMap([123, 456], 'toString', 2); + * // => ['1111011', '111001000'] + */ +declare function invokeMap(collection: object | null | undefined, methodName: string, ...args: any[]): any[]; +/** + * Invokes the method at path of each element in collection. + * + * @template R + * @param {object | null | undefined} collection - The collection to iterate over. + * @param {(...args: any[]) => R} method - The method to invoke. + * @param {...any[]} args - The arguments to invoke each method with. + * @returns {R[]} Returns the array of results. + * + * @example + * invokeMap([5, 1, 7], Array.prototype.slice, 1); + * // => [[], [], []] + */ +declare function invokeMap(collection: object | null | undefined, method: (...args: any[]) => R, ...args: any[]): R[]; + +export { invokeMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.js new file mode 100644 index 0000000000000000000000000000000000000000..14762e6f7eff6b59b1f23d39b4e70480a2862fec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isFunction = require('../../predicate/isFunction.js'); +const isNil = require('../../predicate/isNil.js'); +const get = require('../object/get.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function invokeMap(collection, path, ...args) { + if (isNil.isNil(collection)) { + return []; + } + const values = isArrayLike.isArrayLike(collection) ? Array.from(collection) : Object.values(collection); + const result = []; + for (let i = 0; i < values.length; i++) { + const value = values[i]; + if (isFunction.isFunction(path)) { + result.push(path.apply(value, args)); + continue; + } + const method = get.get(value, path); + let thisContext = value; + if (Array.isArray(path)) { + const pathExceptLast = path.slice(0, -1); + if (pathExceptLast.length > 0) { + thisContext = get.get(value, pathExceptLast); + } + } + else if (typeof path === 'string' && path.includes('.')) { + const parts = path.split('.'); + const pathExceptLast = parts.slice(0, -1).join('.'); + thisContext = get.get(value, pathExceptLast); + } + result.push(method == null ? undefined : method.apply(thisContext, args)); + } + return result; +} + +exports.invokeMap = invokeMap; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.mjs new file mode 100644 index 0000000000000000000000000000000000000000..41b2897e622ec3b9598fc4ebff48c05800068b34 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/invokeMap.mjs @@ -0,0 +1,36 @@ +import { isFunction } from '../../predicate/isFunction.mjs'; +import { isNil } from '../../predicate/isNil.mjs'; +import { get } from '../object/get.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function invokeMap(collection, path, ...args) { + if (isNil(collection)) { + return []; + } + const values = isArrayLike(collection) ? Array.from(collection) : Object.values(collection); + const result = []; + for (let i = 0; i < values.length; i++) { + const value = values[i]; + if (isFunction(path)) { + result.push(path.apply(value, args)); + continue; + } + const method = get(value, path); + let thisContext = value; + if (Array.isArray(path)) { + const pathExceptLast = path.slice(0, -1); + if (pathExceptLast.length > 0) { + thisContext = get(value, pathExceptLast); + } + } + else if (typeof path === 'string' && path.includes('.')) { + const parts = path.split('.'); + const pathExceptLast = parts.slice(0, -1).join('.'); + thisContext = get(value, pathExceptLast); + } + result.push(method == null ? undefined : method.apply(thisContext, args)); + } + return result; +} + +export { invokeMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..45dd93c92e11ba238ca3353b256c19e82231d998 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.d.mts @@ -0,0 +1,15 @@ +/** + * Joins elements of an array into a string. + * + * @param {ArrayLike | null | undefined} array - The array to join. + * @param {string} [separator=','] - The separator used to join the elements, default is common separator `,`. + * @returns {string} - Returns a string containing all elements of the array joined by the specified separator. + * + * @example + * const arr = ["a", "b", "c"]; + * const result = join(arr, "~"); + * console.log(result); // Output: "a~b~c" + */ +declare function join(array: ArrayLike | null | undefined, separator?: string): string; + +export { join }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..45dd93c92e11ba238ca3353b256c19e82231d998 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.d.ts @@ -0,0 +1,15 @@ +/** + * Joins elements of an array into a string. + * + * @param {ArrayLike | null | undefined} array - The array to join. + * @param {string} [separator=','] - The separator used to join the elements, default is common separator `,`. + * @returns {string} - Returns a string containing all elements of the array joined by the specified separator. + * + * @example + * const arr = ["a", "b", "c"]; + * const result = join(arr, "~"); + * console.log(result); // Output: "a~b~c" + */ +declare function join(array: ArrayLike | null | undefined, separator?: string): string; + +export { join }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.js new file mode 100644 index 0000000000000000000000000000000000000000..2daf7fbb50bc6287b45cbdee459f7e8e7ec529c3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLike = require('../predicate/isArrayLike.js'); + +function join(array, separator) { + if (!isArrayLike.isArrayLike(array)) { + return ''; + } + return Array.from(array).join(separator); +} + +exports.join = join; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ba9634090f8dbe92f07e26ecefc20cee06d47bc4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/join.mjs @@ -0,0 +1,10 @@ +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function join(array, separator) { + if (!isArrayLike(array)) { + return ''; + } + return Array.from(array).join(separator); +} + +export { join }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..03917993cdffaa73cb918c40ead67020eaec6cba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.d.mts @@ -0,0 +1,39 @@ +import { ValueIterateeCustom } from '../_internal/ValueIterateeCustom.mjs'; + +/** + * Creates an object composed of keys generated from the results of running each element of collection thru iteratee. + * + * @template T + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {ValueIterateeCustom} [iteratee] - The iteratee to transform keys. + * @returns {Record} Returns the composed aggregate object. + * + * @example + * const array = [ + * { dir: 'left', code: 97 }, + * { dir: 'right', code: 100 } + * ]; + * + * keyBy(array, o => String.fromCharCode(o.code)); + * // => { a: { dir: 'left', code: 97 }, d: { dir: 'right', code: 100 } } + * + * keyBy(array, 'dir'); + * // => { left: { dir: 'left', code: 97 }, right: { dir: 'right', code: 100 } } + */ +declare function keyBy(collection: ArrayLike | null | undefined, iteratee?: ValueIterateeCustom): Record; +/** + * Creates an object composed of keys generated from the results of running each element of collection thru iteratee. + * + * @template T + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ValueIterateeCustom} [iteratee] - The iteratee to transform keys. + * @returns {Record} Returns the composed aggregate object. + * + * @example + * const obj = { a: { dir: 'left', code: 97 }, b: { dir: 'right', code: 100 } }; + * keyBy(obj, o => String.fromCharCode(o.code)); + * // => { a: { dir: 'left', code: 97 }, d: { dir: 'right', code: 100 } } + */ +declare function keyBy(collection: T | null | undefined, iteratee?: ValueIterateeCustom): Record; + +export { keyBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4b3896799a8ccb0bb3cc835b7d5eee91878ec59d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.d.ts @@ -0,0 +1,39 @@ +import { ValueIterateeCustom } from '../_internal/ValueIterateeCustom.js'; + +/** + * Creates an object composed of keys generated from the results of running each element of collection thru iteratee. + * + * @template T + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {ValueIterateeCustom} [iteratee] - The iteratee to transform keys. + * @returns {Record} Returns the composed aggregate object. + * + * @example + * const array = [ + * { dir: 'left', code: 97 }, + * { dir: 'right', code: 100 } + * ]; + * + * keyBy(array, o => String.fromCharCode(o.code)); + * // => { a: { dir: 'left', code: 97 }, d: { dir: 'right', code: 100 } } + * + * keyBy(array, 'dir'); + * // => { left: { dir: 'left', code: 97 }, right: { dir: 'right', code: 100 } } + */ +declare function keyBy(collection: ArrayLike | null | undefined, iteratee?: ValueIterateeCustom): Record; +/** + * Creates an object composed of keys generated from the results of running each element of collection thru iteratee. + * + * @template T + * @param {T | null | undefined} collection - The object to iterate over. + * @param {ValueIterateeCustom} [iteratee] - The iteratee to transform keys. + * @returns {Record} Returns the composed aggregate object. + * + * @example + * const obj = { a: { dir: 'left', code: 97 }, b: { dir: 'right', code: 100 } }; + * keyBy(obj, o => String.fromCharCode(o.code)); + * // => { a: { dir: 'left', code: 97 }, d: { dir: 'right', code: 100 } } + */ +declare function keyBy(collection: T | null | undefined, iteratee?: ValueIterateeCustom): Record; + +export { keyBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.js new file mode 100644 index 0000000000000000000000000000000000000000..e935e142610276986079dd2e38791c9f883f0781 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const reduce = require('./reduce.js'); +const identity = require('../../function/identity.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const isObjectLike = require('../predicate/isObjectLike.js'); +const iteratee = require('../util/iteratee.js'); + +function keyBy(collection, iteratee$1) { + if (!isArrayLike.isArrayLike(collection) && !isObjectLike.isObjectLike(collection)) { + return {}; + } + const keyFn = iteratee.iteratee(iteratee$1 ?? identity.identity); + return reduce.reduce(collection, (result, value) => { + const key = keyFn(value); + result[key] = value; + return result; + }, {}); +} + +exports.keyBy = keyBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..410ff2a2063c9082d92c36b798176a9eeab002dc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/keyBy.mjs @@ -0,0 +1,19 @@ +import { reduce } from './reduce.mjs'; +import { identity } from '../../function/identity.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { isObjectLike } from '../predicate/isObjectLike.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function keyBy(collection, iteratee$1) { + if (!isArrayLike(collection) && !isObjectLike(collection)) { + return {}; + } + const keyFn = iteratee(iteratee$1 ?? identity); + return reduce(collection, (result, value) => { + const key = keyFn(value); + result[key] = value; + return result; + }, {}); +} + +export { keyBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4270a8028ec072b58e6f8b00bc84a04fd5a5a6ad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.d.mts @@ -0,0 +1,25 @@ +/** + * Returns the last element of an array. + * + * This function takes an array and returns the last element of the array. + * If the array is empty, the function returns `undefined`. + * + * Unlike some implementations, this function is optimized for performance + * by directly accessing the last index of the array. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The array from which to get the last element. + * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty. + * + * @example + * const arr = [1, 2, 3]; + * const lastElement = last(arr); + * // lastElement will be 3 + * + * const emptyArr: number[] = []; + * const noElement = last(emptyArr); + * // noElement will be undefined + */ +declare function last(array: ArrayLike | null | undefined): T | undefined; + +export { last }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4270a8028ec072b58e6f8b00bc84a04fd5a5a6ad --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.d.ts @@ -0,0 +1,25 @@ +/** + * Returns the last element of an array. + * + * This function takes an array and returns the last element of the array. + * If the array is empty, the function returns `undefined`. + * + * Unlike some implementations, this function is optimized for performance + * by directly accessing the last index of the array. + * + * @template T - The type of elements in the array. + * @param {ArrayLike | null | undefined} arr - The array from which to get the last element. + * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty. + * + * @example + * const arr = [1, 2, 3]; + * const lastElement = last(arr); + * // lastElement will be 3 + * + * const emptyArr: number[] = []; + * const noElement = last(emptyArr); + * // noElement will be undefined + */ +declare function last(array: ArrayLike | null | undefined): T | undefined; + +export { last }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.js new file mode 100644 index 0000000000000000000000000000000000000000..85a596f206a04ca98fd2c1fc60c0204a11eb0dbd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const last$1 = require('../../array/last.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function last(array) { + if (!isArrayLike.isArrayLike(array)) { + return undefined; + } + return last$1.last(toArray.toArray(array)); +} + +exports.last = last; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e7aa26f9897746e0bd4129946b876111f51c0cbf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/last.mjs @@ -0,0 +1,12 @@ +import { last as last$1 } from '../../array/last.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function last(array) { + if (!isArrayLike(array)) { + return undefined; + } + return last$1(toArray(array)); +} + +export { last }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bcb4d37779ac4480079573eb508b710cae732ad9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.d.mts @@ -0,0 +1,22 @@ +/** + * Gets the index at which the last occurrence of value is found in array. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {T} value - The value to search for. + * @param {true | number} [fromIndex] - The index to search from or true to search from the end. + * @returns {number} Returns the index of the matched value, else -1. + * + * @example + * lastIndexOf([1, 2, 1, 2], 2); + * // => 3 + * + * lastIndexOf([1, 2, 1, 2], 2, 2); + * // => 1 + * + * lastIndexOf([1, 2, 1, 2], 2, true); + * // => 3 + */ +declare function lastIndexOf(array: ArrayLike | null | undefined, searchElement: T, fromIndex?: true | number): number; + +export { lastIndexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bcb4d37779ac4480079573eb508b710cae732ad9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.d.ts @@ -0,0 +1,22 @@ +/** + * Gets the index at which the last occurrence of value is found in array. + * + * @template T + * @param {ArrayLike | null | undefined} array - The array to inspect. + * @param {T} value - The value to search for. + * @param {true | number} [fromIndex] - The index to search from or true to search from the end. + * @returns {number} Returns the index of the matched value, else -1. + * + * @example + * lastIndexOf([1, 2, 1, 2], 2); + * // => 3 + * + * lastIndexOf([1, 2, 1, 2], 2, 2); + * // => 1 + * + * lastIndexOf([1, 2, 1, 2], 2, true); + * // => 3 + */ +declare function lastIndexOf(array: ArrayLike | null | undefined, searchElement: T, fromIndex?: true | number): number; + +export { lastIndexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.js new file mode 100644 index 0000000000000000000000000000000000000000..186815739ccda7ec589809df9baea0f2fbdeb610 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLike = require('../predicate/isArrayLike.js'); + +function lastIndexOf(array, searchElement, fromIndex) { + if (!isArrayLike.isArrayLike(array) || array.length === 0) { + return -1; + } + const length = array.length; + let index = fromIndex ?? length - 1; + if (fromIndex != null) { + index = index < 0 ? Math.max(length + index, 0) : Math.min(index, length - 1); + } + if (Number.isNaN(searchElement)) { + for (let i = index; i >= 0; i--) { + if (Number.isNaN(array[i])) { + return i; + } + } + } + return Array.from(array).lastIndexOf(searchElement, index); +} + +exports.lastIndexOf = lastIndexOf; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.mjs new file mode 100644 index 0000000000000000000000000000000000000000..887ea4093b08c88e09043e20c36f3bf4b95d7f26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/lastIndexOf.mjs @@ -0,0 +1,22 @@ +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function lastIndexOf(array, searchElement, fromIndex) { + if (!isArrayLike(array) || array.length === 0) { + return -1; + } + const length = array.length; + let index = fromIndex ?? length - 1; + if (fromIndex != null) { + index = index < 0 ? Math.max(length + index, 0) : Math.min(index, length - 1); + } + if (Number.isNaN(searchElement)) { + for (let i = index; i >= 0; i--) { + if (Number.isNaN(array[i])) { + return i; + } + } + } + return Array.from(array).lastIndexOf(searchElement, index); +} + +export { lastIndexOf }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bf3fb72481c75bccb73bb78fff1e88e8da204132 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.d.mts @@ -0,0 +1,112 @@ +import { ArrayIterator } from '../_internal/ArrayIterator.mjs'; +import { ListIterator } from '../_internal/ListIterator.mjs'; +import { ObjectIterator } from '../_internal/ObjectIterator.mjs'; +import { TupleIterator } from '../_internal/TupleIterator.mjs'; + +/** + * Maps each element in a tuple to a new tuple of values using an iteratee. + * + * @param {T} collection - The tuple to iterate over + * @param {TupleIterator} iteratee - The function invoked per iteration + * @returns {{ [K in keyof T]: U }} - Returns the new mapped tuple + * + * @example + * // Using a transformation function on a tuple + * const tuple = [1, 'hello', true] as const; + * map(tuple, value => String(value)); // => ['1', 'hello', 'true'] + */ +declare function map(collection: T, iteratee: TupleIterator): { + [K in keyof T]: U; +}; +/** + * Maps each element in an array to a new array using an iteratee. + * + * @param {T[] | null | undefined} collection - The array to iterate over + * @param {ArrayIterator} iteratee - The function invoked per iteration + * @returns {U[]} - Returns the new mapped array + * + * @example + * // Using a transformation function on an array + * const array = [1, 2, 3]; + * map(array, x => x * 2); // => [2, 4, 6] + */ +declare function map(collection: T[] | null | undefined, iteratee: ArrayIterator): U[]; +/** + * Maps each element in an array-like object to a new array using an iteratee. + * + * @param {ArrayLike | null | undefined} collection - The array-like object to iterate over + * @param {ListIterator} iteratee - The function invoked per iteration + * @returns {U[]} - Returns the new mapped array + * + * @example + * // Using a transformation function on an array-like object + * const arrayLike = { length: 2, 0: 'a', 1: 'b' }; + * map(arrayLike, x => x.toUpperCase()); // => ['A', 'B'] + */ +declare function map(collection: ArrayLike | null | undefined, iteratee: ListIterator): U[]; +/** + * Maps each value in an object to a new array. + * + * @param {Record | Record | null | undefined} collection - The object to iterate over + * @returns {T[]} - Returns an array of the object's values + * + * @example + * // Converting an object's values to an array + * const obj = { a: 1, b: 2, c: 3 }; + * map(obj); // => [1, 2, 3] + */ +declare function map(collection: Record | Record | null | undefined): T[]; +/** + * Maps each element in an object to a new array using an iteratee. + * + * @param {T | null | undefined} collection - The object to iterate over + * @param {ObjectIterator} iteratee - The function invoked per iteration + * @returns {U[]} - Returns the new mapped array + * + * @example + * // Using a transformation function on an object + * const obj = { a: 1, b: 2 }; + * map(obj, (value, key) => `${key}:${value}`); // => ['a:1', 'b:2'] + */ +declare function map(collection: T | null | undefined, iteratee: ObjectIterator): U[]; +/** + * Maps each element in an object to a new array by plucking the specified property. + * + * @param {Record | Record | null | undefined} collection - The object to iterate over + * @param {K} iteratee - The property to pluck from each element + * @returns {Array} - Returns the new array of plucked values + * + * @example + * // Plucking a property from each object + * const users = [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }]; + * map(users, 'name'); // => ['John', 'Jane'] + */ +declare function map(collection: Record | Record | null | undefined, iteratee: K): Array; +/** + * Maps each element in an object to a new array by plucking the specified string property. + * + * @param {Record | Record | null | undefined} collection - The object to iterate over + * @param {string} [iteratee] - The string property to pluck from each element + * @returns {any[]} - Returns the new array of plucked values + * + * @example + * // Plucking a nested property + * const users = [{ info: { name: 'John' } }, { info: { name: 'Jane' } }]; + * map(users, 'info.name'); // => ['John', 'Jane'] + */ +declare function map(collection: Record | Record | null | undefined, iteratee?: string): any[]; +/** + * Maps each element in an object to a new array by matching against a source object. + * + * @param {Record | Record | null | undefined} collection - The object to iterate over + * @param {object} [iteratee] - The object to match against + * @returns {boolean[]} - Returns an array of boolean values indicating matches + * + * @example + * // Matching against a source object + * const users = [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }]; + * map(users, { age: 30 }); // => [true, false] + */ +declare function map(collection: Record | Record | null | undefined, iteratee?: object): boolean[]; + +export { map }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6be6989c076cb630b772313be94da307d608fced --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.d.ts @@ -0,0 +1,112 @@ +import { ArrayIterator } from '../_internal/ArrayIterator.js'; +import { ListIterator } from '../_internal/ListIterator.js'; +import { ObjectIterator } from '../_internal/ObjectIterator.js'; +import { TupleIterator } from '../_internal/TupleIterator.js'; + +/** + * Maps each element in a tuple to a new tuple of values using an iteratee. + * + * @param {T} collection - The tuple to iterate over + * @param {TupleIterator} iteratee - The function invoked per iteration + * @returns {{ [K in keyof T]: U }} - Returns the new mapped tuple + * + * @example + * // Using a transformation function on a tuple + * const tuple = [1, 'hello', true] as const; + * map(tuple, value => String(value)); // => ['1', 'hello', 'true'] + */ +declare function map(collection: T, iteratee: TupleIterator): { + [K in keyof T]: U; +}; +/** + * Maps each element in an array to a new array using an iteratee. + * + * @param {T[] | null | undefined} collection - The array to iterate over + * @param {ArrayIterator} iteratee - The function invoked per iteration + * @returns {U[]} - Returns the new mapped array + * + * @example + * // Using a transformation function on an array + * const array = [1, 2, 3]; + * map(array, x => x * 2); // => [2, 4, 6] + */ +declare function map(collection: T[] | null | undefined, iteratee: ArrayIterator): U[]; +/** + * Maps each element in an array-like object to a new array using an iteratee. + * + * @param {ArrayLike | null | undefined} collection - The array-like object to iterate over + * @param {ListIterator} iteratee - The function invoked per iteration + * @returns {U[]} - Returns the new mapped array + * + * @example + * // Using a transformation function on an array-like object + * const arrayLike = { length: 2, 0: 'a', 1: 'b' }; + * map(arrayLike, x => x.toUpperCase()); // => ['A', 'B'] + */ +declare function map(collection: ArrayLike | null | undefined, iteratee: ListIterator): U[]; +/** + * Maps each value in an object to a new array. + * + * @param {Record | Record | null | undefined} collection - The object to iterate over + * @returns {T[]} - Returns an array of the object's values + * + * @example + * // Converting an object's values to an array + * const obj = { a: 1, b: 2, c: 3 }; + * map(obj); // => [1, 2, 3] + */ +declare function map(collection: Record | Record | null | undefined): T[]; +/** + * Maps each element in an object to a new array using an iteratee. + * + * @param {T | null | undefined} collection - The object to iterate over + * @param {ObjectIterator} iteratee - The function invoked per iteration + * @returns {U[]} - Returns the new mapped array + * + * @example + * // Using a transformation function on an object + * const obj = { a: 1, b: 2 }; + * map(obj, (value, key) => `${key}:${value}`); // => ['a:1', 'b:2'] + */ +declare function map(collection: T | null | undefined, iteratee: ObjectIterator): U[]; +/** + * Maps each element in an object to a new array by plucking the specified property. + * + * @param {Record | Record | null | undefined} collection - The object to iterate over + * @param {K} iteratee - The property to pluck from each element + * @returns {Array} - Returns the new array of plucked values + * + * @example + * // Plucking a property from each object + * const users = [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }]; + * map(users, 'name'); // => ['John', 'Jane'] + */ +declare function map(collection: Record | Record | null | undefined, iteratee: K): Array; +/** + * Maps each element in an object to a new array by plucking the specified string property. + * + * @param {Record | Record | null | undefined} collection - The object to iterate over + * @param {string} [iteratee] - The string property to pluck from each element + * @returns {any[]} - Returns the new array of plucked values + * + * @example + * // Plucking a nested property + * const users = [{ info: { name: 'John' } }, { info: { name: 'Jane' } }]; + * map(users, 'info.name'); // => ['John', 'Jane'] + */ +declare function map(collection: Record | Record | null | undefined, iteratee?: string): any[]; +/** + * Maps each element in an object to a new array by matching against a source object. + * + * @param {Record | Record | null | undefined} collection - The object to iterate over + * @param {object} [iteratee] - The object to match against + * @returns {boolean[]} - Returns an array of boolean values indicating matches + * + * @example + * // Matching against a source object + * const users = [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }]; + * map(users, { age: 30 }); // => [true, false] + */ +declare function map(collection: Record | Record | null | undefined, iteratee?: object): boolean[]; + +export { map }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.js new file mode 100644 index 0000000000000000000000000000000000000000..4006eec19a4d63a45f04da3dfd888bf7cd8ca880 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const range = require('../../math/range.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const iteratee = require('../util/iteratee.js'); + +function map(collection, _iteratee) { + if (!collection) { + return []; + } + const keys = isArrayLike.isArrayLike(collection) || Array.isArray(collection) ? range.range(0, collection.length) : Object.keys(collection); + const iteratee$1 = iteratee.iteratee(_iteratee ?? identity.identity); + const result = new Array(keys.length); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = collection[key]; + result[i] = iteratee$1(value, key, collection); + } + return result; +} + +exports.map = map; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e8b12f7de16b9772acc2c32da4b6ed06f1b1f5be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/map.mjs @@ -0,0 +1,21 @@ +import { identity } from '../../function/identity.mjs'; +import { range } from '../../math/range.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function map(collection, _iteratee) { + if (!collection) { + return []; + } + const keys = isArrayLike(collection) || Array.isArray(collection) ? range(0, collection.length) : Object.keys(collection); + const iteratee$1 = iteratee(_iteratee ?? identity); + const result = new Array(keys.length); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = collection[key]; + result[i] = iteratee$1(value, key, collection); + } + return result; +} + +export { map }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5e5e381ffc91890f0d2e1895c91c2c5a7cf10053 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.d.mts @@ -0,0 +1,14 @@ +/** + * Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned. + * + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {number} [n=0] - The index of the element to return. + * @return {T | undefined} Returns the nth element of `array`. + * + * @example + * nth([1, 2, 3], 1); // => 2 + * nth([1, 2, 3], -1); // => 3 + */ +declare function nth(array: ArrayLike | null | undefined, n?: number): T | undefined; + +export { nth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5e5e381ffc91890f0d2e1895c91c2c5a7cf10053 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.d.ts @@ -0,0 +1,14 @@ +/** + * Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned. + * + * @param {ArrayLike | null | undefined} array - The array to query. + * @param {number} [n=0] - The index of the element to return. + * @return {T | undefined} Returns the nth element of `array`. + * + * @example + * nth([1, 2, 3], 1); // => 2 + * nth([1, 2, 3], -1); // => 3 + */ +declare function nth(array: ArrayLike | null | undefined, n?: number): T | undefined; + +export { nth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.js new file mode 100644 index 0000000000000000000000000000000000000000..611900c8bfff575aed4025762ea2ac4f89ec3bb7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayLikeObject = require('../predicate/isArrayLikeObject.js'); +const toInteger = require('../util/toInteger.js'); + +function nth(array, n = 0) { + if (!isArrayLikeObject.isArrayLikeObject(array) || array.length === 0) { + return undefined; + } + n = toInteger.toInteger(n); + if (n < 0) { + n += array.length; + } + return array[n]; +} + +exports.nth = nth; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4ab81f82d7f227b29a365c8df7500486762a768b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/nth.mjs @@ -0,0 +1,15 @@ +import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs'; +import { toInteger } from '../util/toInteger.mjs'; + +function nth(array, n = 0) { + if (!isArrayLikeObject(array) || array.length === 0) { + return undefined; + } + n = toInteger(n); + if (n < 0) { + n += array.length; + } + return array[n]; +} + +export { nth }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8136918e240de666c6b48968b87ff823bb9a96c8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.d.mts @@ -0,0 +1,84 @@ +import { ListIteratee } from '../_internal/ListIteratee.mjs'; +import { ListIterator } from '../_internal/ListIterator.mjs'; +import { Many } from '../_internal/Many.mjs'; +import { ObjectIteratee } from '../_internal/ObjectIteratee.mjs'; +import { ObjectIterator } from '../_internal/ObjectIterator.mjs'; + +/** + * Sorts an array of elements based on multiple iteratee functions and their corresponding order directions. + * + * @template T The type of elements in the array + * @param {ArrayLike | null | undefined} collection The array to sort + * @param {Many>} iteratees The iteratee functions to sort by + * @param {Many} orders The sort orders + * @returns {T[]} Returns the new sorted array + * @example + * const users = [ + * { name: 'fred', age: 48 }, + * { name: 'barney', age: 34 } + * ]; + * + * // Sort by age in ascending order + * orderBy(users, [(user) => user.age], ['asc']); + * // => [{ name: 'barney', age: 34 }, { name: 'fred', age: 48 }] + */ +declare function orderBy(collection: ArrayLike | null | undefined, iteratees?: Many>, orders?: Many): T[]; +/** + * Sorts an array of elements based on multiple property names/paths and their corresponding order directions. + * + * @template T The type of elements in the array + * @param {ArrayLike | null | undefined} collection The array to sort + * @param {Many>} iteratees The property names/paths to sort by + * @param {Many} orders The sort orders + * @returns {T[]} Returns the new sorted array + * @example + * const users = [ + * { name: 'fred', age: 48 }, + * { name: 'barney', age: 34 } + * ]; + * + * // Sort by name in ascending order + * orderBy(users, ['name'], ['asc']); + * // => [{ name: 'barney', age: 34 }, { name: 'fred', age: 48 }] + */ +declare function orderBy(collection: ArrayLike | null | undefined, iteratees?: Many>, orders?: Many): T[]; +/** + * Sorts an object's values based on multiple iteratee functions and their corresponding order directions. + * + * @template T The object type + * @param {T | null | undefined} collection The object to sort values from + * @param {Many>} iteratees The iteratee functions to sort by + * @param {Many} orders The sort orders + * @returns {Array} Returns the new sorted array + * @example + * const obj = { + * a: { name: 'fred', age: 48 }, + * b: { name: 'barney', age: 34 } + * }; + * + * // Sort by age in ascending order + * orderBy(obj, [(user) => user.age], ['asc']); + * // => [{ name: 'barney', age: 34 }, { name: 'fred', age: 48 }] + */ +declare function orderBy(collection: T | null | undefined, iteratees?: Many>, orders?: Many): Array; +/** + * Sorts an object's values based on multiple property names/paths and their corresponding order directions. + * + * @template T The object type + * @param {T | null | undefined} collection The object to sort values from + * @param {Many>} iteratees The property names/paths to sort by + * @param {Many} orders The sort orders + * @returns {Array} Returns the new sorted array + * @example + * const obj = { + * a: { name: 'fred', age: 48 }, + * b: { name: 'barney', age: 34 } + * }; + * + * // Sort by name in ascending order + * orderBy(obj, ['name'], ['asc']); + * // => [{ name: 'barney', age: 34 }, { name: 'fred', age: 48 }] + */ +declare function orderBy(collection: T | null | undefined, iteratees?: Many>, orders?: Many): Array; + +export { orderBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..86bb98185a677f5ac13282164d8835a5403e5141 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.d.ts @@ -0,0 +1,84 @@ +import { ListIteratee } from '../_internal/ListIteratee.js'; +import { ListIterator } from '../_internal/ListIterator.js'; +import { Many } from '../_internal/Many.js'; +import { ObjectIteratee } from '../_internal/ObjectIteratee.js'; +import { ObjectIterator } from '../_internal/ObjectIterator.js'; + +/** + * Sorts an array of elements based on multiple iteratee functions and their corresponding order directions. + * + * @template T The type of elements in the array + * @param {ArrayLike | null | undefined} collection The array to sort + * @param {Many>} iteratees The iteratee functions to sort by + * @param {Many} orders The sort orders + * @returns {T[]} Returns the new sorted array + * @example + * const users = [ + * { name: 'fred', age: 48 }, + * { name: 'barney', age: 34 } + * ]; + * + * // Sort by age in ascending order + * orderBy(users, [(user) => user.age], ['asc']); + * // => [{ name: 'barney', age: 34 }, { name: 'fred', age: 48 }] + */ +declare function orderBy(collection: ArrayLike | null | undefined, iteratees?: Many>, orders?: Many): T[]; +/** + * Sorts an array of elements based on multiple property names/paths and their corresponding order directions. + * + * @template T The type of elements in the array + * @param {ArrayLike | null | undefined} collection The array to sort + * @param {Many>} iteratees The property names/paths to sort by + * @param {Many} orders The sort orders + * @returns {T[]} Returns the new sorted array + * @example + * const users = [ + * { name: 'fred', age: 48 }, + * { name: 'barney', age: 34 } + * ]; + * + * // Sort by name in ascending order + * orderBy(users, ['name'], ['asc']); + * // => [{ name: 'barney', age: 34 }, { name: 'fred', age: 48 }] + */ +declare function orderBy(collection: ArrayLike | null | undefined, iteratees?: Many>, orders?: Many): T[]; +/** + * Sorts an object's values based on multiple iteratee functions and their corresponding order directions. + * + * @template T The object type + * @param {T | null | undefined} collection The object to sort values from + * @param {Many>} iteratees The iteratee functions to sort by + * @param {Many} orders The sort orders + * @returns {Array} Returns the new sorted array + * @example + * const obj = { + * a: { name: 'fred', age: 48 }, + * b: { name: 'barney', age: 34 } + * }; + * + * // Sort by age in ascending order + * orderBy(obj, [(user) => user.age], ['asc']); + * // => [{ name: 'barney', age: 34 }, { name: 'fred', age: 48 }] + */ +declare function orderBy(collection: T | null | undefined, iteratees?: Many>, orders?: Many): Array; +/** + * Sorts an object's values based on multiple property names/paths and their corresponding order directions. + * + * @template T The object type + * @param {T | null | undefined} collection The object to sort values from + * @param {Many>} iteratees The property names/paths to sort by + * @param {Many} orders The sort orders + * @returns {Array} Returns the new sorted array + * @example + * const obj = { + * a: { name: 'fred', age: 48 }, + * b: { name: 'barney', age: 34 } + * }; + * + * // Sort by name in ascending order + * orderBy(obj, ['name'], ['asc']); + * // => [{ name: 'barney', age: 34 }, { name: 'fred', age: 48 }] + */ +declare function orderBy(collection: T | null | undefined, iteratees?: Many>, orders?: Many): Array; + +export { orderBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.js new file mode 100644 index 0000000000000000000000000000000000000000..b9a474d637db6bab9969d0620eba63d0141a39e5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.js @@ -0,0 +1,82 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const compareValues = require('../_internal/compareValues.js'); +const isKey = require('../_internal/isKey.js'); +const toPath = require('../util/toPath.js'); + +function orderBy(collection, criteria, orders, guard) { + if (collection == null) { + return []; + } + orders = guard ? undefined : orders; + if (!Array.isArray(collection)) { + collection = Object.values(collection); + } + if (!Array.isArray(criteria)) { + criteria = criteria == null ? [null] : [criteria]; + } + if (criteria.length === 0) { + criteria = [null]; + } + if (!Array.isArray(orders)) { + orders = orders == null ? [] : [orders]; + } + orders = orders.map(order => String(order)); + const getValueByNestedPath = (object, path) => { + let target = object; + for (let i = 0; i < path.length && target != null; ++i) { + target = target[path[i]]; + } + return target; + }; + const getValueByCriterion = (criterion, object) => { + if (object == null || criterion == null) { + return object; + } + if (typeof criterion === 'object' && 'key' in criterion) { + if (Object.hasOwn(object, criterion.key)) { + return object[criterion.key]; + } + return getValueByNestedPath(object, criterion.path); + } + if (typeof criterion === 'function') { + return criterion(object); + } + if (Array.isArray(criterion)) { + return getValueByNestedPath(object, criterion); + } + if (typeof object === 'object') { + return object[criterion]; + } + return object; + }; + const preparedCriteria = criteria.map((criterion) => { + if (Array.isArray(criterion) && criterion.length === 1) { + criterion = criterion[0]; + } + if (criterion == null || typeof criterion === 'function' || Array.isArray(criterion) || isKey.isKey(criterion)) { + return criterion; + } + return { key: criterion, path: toPath.toPath(criterion) }; + }); + const preparedCollection = collection.map(item => ({ + original: item, + criteria: preparedCriteria.map((criterion) => getValueByCriterion(criterion, item)), + })); + return preparedCollection + .slice() + .sort((a, b) => { + for (let i = 0; i < preparedCriteria.length; i++) { + const comparedResult = compareValues.compareValues(a.criteria[i], b.criteria[i], orders[i]); + if (comparedResult !== 0) { + return comparedResult; + } + } + return 0; + }) + .map(item => item.original); +} + +exports.orderBy = orderBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3ec5653d4dceeae4daa4a12f1fb77166d59f38b5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/orderBy.mjs @@ -0,0 +1,78 @@ +import { compareValues } from '../_internal/compareValues.mjs'; +import { isKey } from '../_internal/isKey.mjs'; +import { toPath } from '../util/toPath.mjs'; + +function orderBy(collection, criteria, orders, guard) { + if (collection == null) { + return []; + } + orders = guard ? undefined : orders; + if (!Array.isArray(collection)) { + collection = Object.values(collection); + } + if (!Array.isArray(criteria)) { + criteria = criteria == null ? [null] : [criteria]; + } + if (criteria.length === 0) { + criteria = [null]; + } + if (!Array.isArray(orders)) { + orders = orders == null ? [] : [orders]; + } + orders = orders.map(order => String(order)); + const getValueByNestedPath = (object, path) => { + let target = object; + for (let i = 0; i < path.length && target != null; ++i) { + target = target[path[i]]; + } + return target; + }; + const getValueByCriterion = (criterion, object) => { + if (object == null || criterion == null) { + return object; + } + if (typeof criterion === 'object' && 'key' in criterion) { + if (Object.hasOwn(object, criterion.key)) { + return object[criterion.key]; + } + return getValueByNestedPath(object, criterion.path); + } + if (typeof criterion === 'function') { + return criterion(object); + } + if (Array.isArray(criterion)) { + return getValueByNestedPath(object, criterion); + } + if (typeof object === 'object') { + return object[criterion]; + } + return object; + }; + const preparedCriteria = criteria.map((criterion) => { + if (Array.isArray(criterion) && criterion.length === 1) { + criterion = criterion[0]; + } + if (criterion == null || typeof criterion === 'function' || Array.isArray(criterion) || isKey(criterion)) { + return criterion; + } + return { key: criterion, path: toPath(criterion) }; + }); + const preparedCollection = collection.map(item => ({ + original: item, + criteria: preparedCriteria.map((criterion) => getValueByCriterion(criterion, item)), + })); + return preparedCollection + .slice() + .sort((a, b) => { + for (let i = 0; i < preparedCriteria.length; i++) { + const comparedResult = compareValues(a.criteria[i], b.criteria[i], orders[i]); + if (comparedResult !== 0) { + return comparedResult; + } + } + return 0; + }) + .map(item => item.original); +} + +export { orderBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ffad3fb011d6f15e3a91edf70976182ed5751799 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.d.mts @@ -0,0 +1,50 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; +import { ValueIteratorTypeGuard } from '../_internal/ValueIteratorTypeGuard.mjs'; + +/** + * Creates an array of elements split into two groups, the first of which contains elements + * predicate returns truthy for, while the second of which contains elements predicate returns falsey for. + * The predicate is invoked with one argument: (value). + * + * @template T, U + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {(value: T) => value is U} callback - The function invoked per iteration. + * @returns {[U[], Array>]} Returns the array of grouped elements. + * + * @example + * partition([1, 2, 3, 4], n => n % 2 === 0); + * // => [[2, 4], [1, 3]] + */ +declare function partition(collection: ArrayLike | null | undefined, callback: ValueIteratorTypeGuard): [U[], Array>]; +/** + * Creates an array of elements split into two groups, the first of which contains elements + * predicate returns truthy for, while the second of which contains elements predicate returns falsey for. + * The predicate is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial} callback - The function invoked per iteration. + * @returns {[T[], T[]]} Returns the array of grouped elements. + * + * @example + * partition([1, 2, 3, 4], n => n % 2 === 0); + * // => [[2, 4], [1, 3]] + */ +declare function partition(collection: ArrayLike | null | undefined, callback: ValueIteratee): [T[], T[]]; +/** + * Creates an array of elements split into two groups, the first of which contains elements + * predicate returns truthy for, while the second of which contains elements predicate returns falsey for. + * The predicate is invoked with one argument: (value). + * + * @template T + * @param {T | null | undefined} collection - The collection to iterate over. + * @param {((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial} callback - The function invoked per iteration. + * @returns {[Array, Array]} Returns the array of grouped elements. + * + * @example + * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0); + * // => [[2], [1, 3]] + */ +declare function partition(collection: T | null | undefined, callback: ValueIteratee): [Array, Array]; + +export { partition }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b8bc6d1610b924e594288215629f3e8d7b82d3a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.d.ts @@ -0,0 +1,50 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; +import { ValueIteratorTypeGuard } from '../_internal/ValueIteratorTypeGuard.js'; + +/** + * Creates an array of elements split into two groups, the first of which contains elements + * predicate returns truthy for, while the second of which contains elements predicate returns falsey for. + * The predicate is invoked with one argument: (value). + * + * @template T, U + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {(value: T) => value is U} callback - The function invoked per iteration. + * @returns {[U[], Array>]} Returns the array of grouped elements. + * + * @example + * partition([1, 2, 3, 4], n => n % 2 === 0); + * // => [[2, 4], [1, 3]] + */ +declare function partition(collection: ArrayLike | null | undefined, callback: ValueIteratorTypeGuard): [U[], Array>]; +/** + * Creates an array of elements split into two groups, the first of which contains elements + * predicate returns truthy for, while the second of which contains elements predicate returns falsey for. + * The predicate is invoked with one argument: (value). + * + * @template T + * @param {ArrayLike | null | undefined} collection - The collection to iterate over. + * @param {((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial} callback - The function invoked per iteration. + * @returns {[T[], T[]]} Returns the array of grouped elements. + * + * @example + * partition([1, 2, 3, 4], n => n % 2 === 0); + * // => [[2, 4], [1, 3]] + */ +declare function partition(collection: ArrayLike | null | undefined, callback: ValueIteratee): [T[], T[]]; +/** + * Creates an array of elements split into two groups, the first of which contains elements + * predicate returns truthy for, while the second of which contains elements predicate returns falsey for. + * The predicate is invoked with one argument: (value). + * + * @template T + * @param {T | null | undefined} collection - The collection to iterate over. + * @param {((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial} callback - The function invoked per iteration. + * @returns {[Array, Array]} Returns the array of grouped elements. + * + * @example + * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0); + * // => [[2], [1, 3]] + */ +declare function partition(collection: T | null | undefined, callback: ValueIteratee): [Array, Array]; + +export { partition }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.js new file mode 100644 index 0000000000000000000000000000000000000000..e42a18ca2b52d26c690ae18cdd5bbcbd7d79bb88 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.js @@ -0,0 +1,29 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); +const iteratee = require('../util/iteratee.js'); + +function partition(source, predicate = identity.identity) { + if (!source) { + return [[], []]; + } + const collection = isArrayLike.isArrayLike(source) ? source : Object.values(source); + predicate = iteratee.iteratee(predicate); + const matched = []; + const unmatched = []; + for (let i = 0; i < collection.length; i++) { + const value = collection[i]; + if (predicate(value)) { + matched.push(value); + } + else { + unmatched.push(value); + } + } + return [matched, unmatched]; +} + +exports.partition = partition; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4f3658bb50f89cea3deccf97d9e89da4ea18aafc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/partition.mjs @@ -0,0 +1,25 @@ +import { identity } from '../../function/identity.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function partition(source, predicate = identity) { + if (!source) { + return [[], []]; + } + const collection = isArrayLike(source) ? source : Object.values(source); + predicate = iteratee(predicate); + const matched = []; + const unmatched = []; + for (let i = 0; i < collection.length; i++) { + const value = collection[i]; + if (predicate(value)) { + matched.push(value); + } + else { + unmatched.push(value); + } + } + return [matched, unmatched]; +} + +export { partition }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..77c1dc8f7dcdcabb80fffe6307107fd7e6c8f190 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.d.mts @@ -0,0 +1,38 @@ +/** + * Removes all provided values from array using SameValueZero for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {...T[]} values - The values to remove. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [1, 2, 3, 1, 2, 3]; + * + * pull(array, 2, 3); + * console.log(array); + * // => [1, 1] + */ +declare function pull(array: T[], ...values: T[]): T[]; +/** + * Removes all provided values from array using SameValueZero for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. + * + * @template L + * @param {L} array - The array to modify. + * @param {...L[0][]} values - The values to remove. + * @returns {L} Returns `array`. + * + * @example + * var array = [1, 2, 3, 1, 2, 3]; + * + * pull(array, 2, 3); + * console.log(array); + * // => [1, 1] + */ +declare function pull>(array: L extends readonly any[] ? never : L, ...values: Array): L; + +export { pull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..77c1dc8f7dcdcabb80fffe6307107fd7e6c8f190 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.d.ts @@ -0,0 +1,38 @@ +/** + * Removes all provided values from array using SameValueZero for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {...T[]} values - The values to remove. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [1, 2, 3, 1, 2, 3]; + * + * pull(array, 2, 3); + * console.log(array); + * // => [1, 1] + */ +declare function pull(array: T[], ...values: T[]): T[]; +/** + * Removes all provided values from array using SameValueZero for equality comparisons. + * + * **Note:** Unlike `_.without`, this method mutates `array`. + * + * @template L + * @param {L} array - The array to modify. + * @param {...L[0][]} values - The values to remove. + * @returns {L} Returns `array`. + * + * @example + * var array = [1, 2, 3, 1, 2, 3]; + * + * pull(array, 2, 3); + * console.log(array); + * // => [1, 1] + */ +declare function pull>(array: L extends readonly any[] ? never : L, ...values: Array): L; + +export { pull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.js new file mode 100644 index 0000000000000000000000000000000000000000..576fe98dedd38235cb261a443e59c41e156db8d4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const pull$1 = require('../../array/pull.js'); + +function pull(arr, ...valuesToRemove) { + return pull$1.pull(arr, valuesToRemove); +} + +exports.pull = pull; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.mjs new file mode 100644 index 0000000000000000000000000000000000000000..520a22ba39b1b280212c8ddd200282c2f7c9c725 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pull.mjs @@ -0,0 +1,7 @@ +import { pull as pull$1 } from '../../array/pull.mjs'; + +function pull(arr, ...valuesToRemove) { + return pull$1(arr, valuesToRemove); +} + +export { pull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..dc31887fb8af0e3477021d1bc36e4ed6a67c8cdf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.d.mts @@ -0,0 +1,38 @@ +/** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [1, 2, 3, 1, 2, 3]; + * + * pullAll(array, [2, 3]); + * console.log(array); + * // => [1, 1] + */ +declare function pullAll(array: T[], values?: ArrayLike): T[]; +/** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @template L + * @param {L} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @returns {L} Returns `array`. + * + * @example + * var array = [1, 2, 3, 1, 2, 3]; + * + * pullAll(array, [2, 3]); + * console.log(array); + * // => [1, 1] + */ +declare function pullAll>(array: L extends readonly any[] ? never : L, values?: ArrayLike): L; + +export { pullAll }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dc31887fb8af0e3477021d1bc36e4ed6a67c8cdf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.d.ts @@ -0,0 +1,38 @@ +/** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [1, 2, 3, 1, 2, 3]; + * + * pullAll(array, [2, 3]); + * console.log(array); + * // => [1, 1] + */ +declare function pullAll(array: T[], values?: ArrayLike): T[]; +/** + * This method is like `_.pull` except that it accepts an array of values to remove. + * + * **Note:** Unlike `_.difference`, this method mutates `array`. + * + * @template L + * @param {L} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @returns {L} Returns `array`. + * + * @example + * var array = [1, 2, 3, 1, 2, 3]; + * + * pullAll(array, [2, 3]); + * console.log(array); + * // => [1, 1] + */ +declare function pullAll>(array: L extends readonly any[] ? never : L, values?: ArrayLike): L; + +export { pullAll }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.js new file mode 100644 index 0000000000000000000000000000000000000000..1f8fd096802449f8c1f34848938d97d5e57d0908 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const pull = require('../../array/pull.js'); + +function pullAll(arr, valuesToRemove = []) { + return pull.pull(arr, Array.from(valuesToRemove)); +} + +exports.pullAll = pullAll; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.mjs new file mode 100644 index 0000000000000000000000000000000000000000..beadc77ce8733d55e3668e4b380493df372b7597 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAll.mjs @@ -0,0 +1,7 @@ +import { pull } from '../../array/pull.mjs'; + +function pullAll(arr, valuesToRemove = []) { + return pull(arr, Array.from(valuesToRemove)); +} + +export { pullAll }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..69ef639f98b3d7894246f10b813fb4a710609444 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.d.mts @@ -0,0 +1,84 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.mjs'; + +/** + * Removes all specified values from an array using an iteratee function. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `differenceBy`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @param {((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ +declare function pullAllBy(array: T[], values?: ArrayLike, iteratee?: ValueIteratee): T[]; +/** + * Removes all specified values from an array using an iteratee function. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `differenceBy`. + * + * @template L + * @param {L} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @param {((value: L[0]) => unknown) | PropertyKey | [PropertyKey, any] | Partial} [iteratee] - The iteratee invoked per element. + * @returns {L} Returns `array`. + * + * @example + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ +declare function pullAllBy>(array: L extends readonly any[] ? never : L, values?: ArrayLike, iteratee?: ValueIteratee): L; +/** + * Removes all specified values from an array using an iteratee function. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `differenceBy`. + * + * @template T, U + * @param {T[]} array - The array to modify. + * @param {ArrayLike} values - The values to remove. + * @param {((value: T | U) => unknown) | PropertyKey | [PropertyKey, any] | Partial} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ +declare function pullAllBy(array: T[], values: ArrayLike, iteratee: ValueIteratee): T[]; +/** + * Removes all specified values from an array using an iteratee function. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `differenceBy`. + * + * @template L, U + * @param {L} array - The array to modify. + * @param {ArrayLike} values - The values to remove. + * @param {((value: L[0] | U) => unknown) | PropertyKey | [PropertyKey, any] | Partial} iteratee - The iteratee invoked per element. + * @returns {L} Returns `array`. + * + * @example + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ +declare function pullAllBy, U>(array: L extends readonly any[] ? never : L, values: ArrayLike, iteratee: ValueIteratee): L; + +export { pullAllBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3d74ea0975c4de1edbae580a6c5a0dbca0d52988 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.d.ts @@ -0,0 +1,84 @@ +import { ValueIteratee } from '../_internal/ValueIteratee.js'; + +/** + * Removes all specified values from an array using an iteratee function. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `differenceBy`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @param {((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial} [iteratee] - The iteratee invoked per element. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ +declare function pullAllBy(array: T[], values?: ArrayLike, iteratee?: ValueIteratee): T[]; +/** + * Removes all specified values from an array using an iteratee function. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `differenceBy`. + * + * @template L + * @param {L} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @param {((value: L[0]) => unknown) | PropertyKey | [PropertyKey, any] | Partial} [iteratee] - The iteratee invoked per element. + * @returns {L} Returns `array`. + * + * @example + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ +declare function pullAllBy>(array: L extends readonly any[] ? never : L, values?: ArrayLike, iteratee?: ValueIteratee): L; +/** + * Removes all specified values from an array using an iteratee function. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `differenceBy`. + * + * @template T, U + * @param {T[]} array - The array to modify. + * @param {ArrayLike} values - The values to remove. + * @param {((value: T | U) => unknown) | PropertyKey | [PropertyKey, any] | Partial} iteratee - The iteratee invoked per element. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ +declare function pullAllBy(array: T[], values: ArrayLike, iteratee: ValueIteratee): T[]; +/** + * Removes all specified values from an array using an iteratee function. + * + * This function changes `arr` in place. + * If you want to remove values without modifying the original array, use `differenceBy`. + * + * @template L, U + * @param {L} array - The array to modify. + * @param {ArrayLike} values - The values to remove. + * @param {((value: L[0] | U) => unknown) | PropertyKey | [PropertyKey, any] | Partial} iteratee - The iteratee invoked per element. + * @returns {L} Returns `array`. + * + * @example + * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; + * + * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); + * console.log(array); + * // => [{ 'x': 2 }] + */ +declare function pullAllBy, U>(array: L extends readonly any[] ? never : L, values: ArrayLike, iteratee: ValueIteratee): L; + +export { pullAllBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.js new file mode 100644 index 0000000000000000000000000000000000000000..b4f8aba1349443a201a56fa73565d1d6a36218c4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const iteratee = require('../util/iteratee.js'); + +function pullAllBy(arr, valuesToRemove, _getValue) { + const getValue = iteratee.iteratee(_getValue); + const valuesSet = new Set(Array.from(valuesToRemove).map(x => getValue(x))); + let resultIndex = 0; + for (let i = 0; i < arr.length; i++) { + const value = getValue(arr[i]); + if (valuesSet.has(value)) { + continue; + } + if (!Object.hasOwn(arr, i)) { + delete arr[resultIndex++]; + continue; + } + arr[resultIndex++] = arr[i]; + } + arr.length = resultIndex; + return arr; +} + +exports.pullAllBy = pullAllBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d329d9d25fd037a08eda9e82cbebafc2e7e767b6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllBy.mjs @@ -0,0 +1,22 @@ +import { iteratee } from '../util/iteratee.mjs'; + +function pullAllBy(arr, valuesToRemove, _getValue) { + const getValue = iteratee(_getValue); + const valuesSet = new Set(Array.from(valuesToRemove).map(x => getValue(x))); + let resultIndex = 0; + for (let i = 0; i < arr.length; i++) { + const value = getValue(arr[i]); + if (valuesSet.has(value)) { + continue; + } + if (!Object.hasOwn(arr, i)) { + delete arr[resultIndex++]; + continue; + } + arr[resultIndex++] = arr[i]; + } + arr.length = resultIndex; + return arr; +} + +export { pullAllBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4709f7b03fefbafa35aaac95b681eae1f7d30a66 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.d.mts @@ -0,0 +1,86 @@ +/** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ +declare function pullAllWith(array: T[], values?: ArrayLike, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @template L + * @param {L} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @param {(a: L[0], b: L[0]) => boolean} [comparator] - The comparator invoked per element. + * @returns {L} Returns `array`. + * + * @example + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ +declare function pullAllWith>(array: L extends readonly any[] ? never : L, values?: ArrayLike, comparator?: (a: L[0], b: L[0]) => boolean): L; +/** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @template T, U + * @param {T[]} array - The array to modify. + * @param {ArrayLike} values - The values to remove. + * @param {(a: T, b: U) => boolean} comparator - The comparator invoked per element. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ +declare function pullAllWith(array: T[], values: ArrayLike, comparator: (a: T, b: U) => boolean): T[]; +/** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @template L, U + * @param {L} array - The array to modify. + * @param {ArrayLike} values - The values to remove. + * @param {(a: L[0], b: U) => boolean} comparator - The comparator invoked per element. + * @returns {L} Returns `array`. + * + * @example + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ +declare function pullAllWith, U>(array: L extends readonly any[] ? never : L, values: ArrayLike, comparator: (a: L[0], b: U) => boolean): L; + +export { pullAllWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4709f7b03fefbafa35aaac95b681eae1f7d30a66 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.d.ts @@ -0,0 +1,86 @@ +/** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ +declare function pullAllWith(array: T[], values?: ArrayLike, comparator?: (a: T, b: T) => boolean): T[]; +/** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @template L + * @param {L} array - The array to modify. + * @param {ArrayLike} [values] - The values to remove. + * @param {(a: L[0], b: L[0]) => boolean} [comparator] - The comparator invoked per element. + * @returns {L} Returns `array`. + * + * @example + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ +declare function pullAllWith>(array: L extends readonly any[] ? never : L, values?: ArrayLike, comparator?: (a: L[0], b: L[0]) => boolean): L; +/** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @template T, U + * @param {T[]} array - The array to modify. + * @param {ArrayLike} values - The values to remove. + * @param {(a: T, b: U) => boolean} comparator - The comparator invoked per element. + * @returns {T[]} Returns `array`. + * + * @example + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ +declare function pullAllWith(array: T[], values: ArrayLike, comparator: (a: T, b: U) => boolean): T[]; +/** + * This method is like `_.pullAll` except that it accepts `comparator` which is + * invoked to compare elements of array to values. The comparator is invoked with + * two arguments: (arrVal, othVal). + * + * **Note:** Unlike `_.differenceWith`, this method mutates `array`. + * + * @template L, U + * @param {L} array - The array to modify. + * @param {ArrayLike} values - The values to remove. + * @param {(a: L[0], b: U) => boolean} comparator - The comparator invoked per element. + * @returns {L} Returns `array`. + * + * @example + * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; + * + * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); + * console.log(array); + * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] + */ +declare function pullAllWith, U>(array: L extends readonly any[] ? never : L, values: ArrayLike, comparator: (a: L[0], b: U) => boolean): L; + +export { pullAllWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.js new file mode 100644 index 0000000000000000000000000000000000000000..ea169803a777bc6a9526b782480d679d56cca004 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const copyArray = require('../_internal/copyArray.js'); +const eq = require('../util/eq.js'); + +function pullAllWith(array, values, comparator) { + if (array?.length == null || values?.length == null) { + return array; + } + if (array === values) { + values = copyArray(values); + } + let resultLength = 0; + if (comparator == null) { + comparator = (a, b) => eq.eq(a, b); + } + const valuesArray = Array.isArray(values) ? values : Array.from(values); + const hasUndefined = valuesArray.includes(undefined); + for (let i = 0; i < array.length; i++) { + if (i in array) { + const shouldRemove = valuesArray.some(value => comparator(array[i], value)); + if (!shouldRemove) { + array[resultLength++] = array[i]; + } + continue; + } + if (!hasUndefined) { + delete array[resultLength++]; + } + } + array.length = resultLength; + return array; +} + +exports.pullAllWith = pullAllWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f55acfb638216f3bec5615b8879b0aa78fcfd7b0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAllWith.mjs @@ -0,0 +1,33 @@ +import copyArray from '../_internal/copyArray.mjs'; +import { eq } from '../util/eq.mjs'; + +function pullAllWith(array, values, comparator) { + if (array?.length == null || values?.length == null) { + return array; + } + if (array === values) { + values = copyArray(values); + } + let resultLength = 0; + if (comparator == null) { + comparator = (a, b) => eq(a, b); + } + const valuesArray = Array.isArray(values) ? values : Array.from(values); + const hasUndefined = valuesArray.includes(undefined); + for (let i = 0; i < array.length; i++) { + if (i in array) { + const shouldRemove = valuesArray.some(value => comparator(array[i], value)); + if (!shouldRemove) { + array[resultLength++] = array[i]; + } + continue; + } + if (!hasUndefined) { + delete array[resultLength++]; + } + } + array.length = resultLength; + return array; +} + +export { pullAllWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bde0334a4d5c0d611f671d26e2882b3e8eecfb51 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.d.mts @@ -0,0 +1,48 @@ +import { Many } from '../_internal/Many.mjs'; + +/** + * Removes elements from array corresponding to the given indexes and returns an array of the removed elements. + * Indexes may be specified as an array of indexes or as individual arguments. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {...Array} indexes - The indexes of elements to remove, specified as individual indexes or arrays of indexes. + * @returns {T[]} Returns the new array of removed elements. + * + * @example + * var array = [5, 10, 15, 20]; + * var evens = pullAt(array, 1, 3); + * + * console.log(array); + * // => [5, 15] + * + * console.log(evens); + * // => [10, 20] + */ +declare function pullAt(array: T[], ...indexes: Array>): T[]; +/** + * Removes elements from array corresponding to the given indexes and returns an array of the removed elements. + * Indexes may be specified as an array of indexes or as individual arguments. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @template L + * @param {L} array - The array to modify. + * @param {...Array} indexes - The indexes of elements to remove, specified as individual indexes or arrays of indexes. + * @returns {L} Returns the new array of removed elements. + * + * @example + * var array = [5, 10, 15, 20]; + * var evens = pullAt(array, 1, 3); + * + * console.log(array); + * // => [5, 15] + * + * console.log(evens); + * // => [10, 20] + */ +declare function pullAt>(array: L extends readonly any[] ? never : L, ...indexes: Array>): L; + +export { pullAt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c5d875722156f7bff15328bd58edc59461dd827c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.d.ts @@ -0,0 +1,48 @@ +import { Many } from '../_internal/Many.js'; + +/** + * Removes elements from array corresponding to the given indexes and returns an array of the removed elements. + * Indexes may be specified as an array of indexes or as individual arguments. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @template T + * @param {T[]} array - The array to modify. + * @param {...Array} indexes - The indexes of elements to remove, specified as individual indexes or arrays of indexes. + * @returns {T[]} Returns the new array of removed elements. + * + * @example + * var array = [5, 10, 15, 20]; + * var evens = pullAt(array, 1, 3); + * + * console.log(array); + * // => [5, 15] + * + * console.log(evens); + * // => [10, 20] + */ +declare function pullAt(array: T[], ...indexes: Array>): T[]; +/** + * Removes elements from array corresponding to the given indexes and returns an array of the removed elements. + * Indexes may be specified as an array of indexes or as individual arguments. + * + * **Note:** Unlike `_.at`, this method mutates `array`. + * + * @template L + * @param {L} array - The array to modify. + * @param {...Array} indexes - The indexes of elements to remove, specified as individual indexes or arrays of indexes. + * @returns {L} Returns the new array of removed elements. + * + * @example + * var array = [5, 10, 15, 20]; + * var evens = pullAt(array, 1, 3); + * + * console.log(array); + * // => [5, 15] + * + * console.log(evens); + * // => [10, 20] + */ +declare function pullAt>(array: L extends readonly any[] ? never : L, ...indexes: Array>): L; + +export { pullAt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.js new file mode 100644 index 0000000000000000000000000000000000000000..1c6c1aa88e6c935221ce6d0f277637f130140362 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.js @@ -0,0 +1,38 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flattenDepth = require('./flattenDepth.js'); +const isIndex = require('../_internal/isIndex.js'); +const isKey = require('../_internal/isKey.js'); +const toKey = require('../_internal/toKey.js'); +const at = require('../object/at.js'); +const unset = require('../object/unset.js'); +const isArray = require('../predicate/isArray.js'); +const toPath = require('../util/toPath.js'); + +function pullAt(array, ..._indices) { + const indices = flattenDepth.flattenDepth(_indices, 1); + if (!array) { + return Array(indices.length); + } + const result = at.at(array, indices); + const indicesToPull = indices + .map(index => (isIndex.isIndex(index, array.length) ? Number(index) : index)) + .sort((a, b) => b - a); + for (const index of new Set(indicesToPull)) { + if (isIndex.isIndex(index, array.length)) { + Array.prototype.splice.call(array, index, 1); + continue; + } + if (isKey.isKey(index, array)) { + delete array[toKey.toKey(index)]; + continue; + } + const path = isArray.isArray(index) ? index : toPath.toPath(index); + unset.unset(array, path); + } + return result; +} + +exports.pullAt = pullAt; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fecaede7bf770ba66b2a2906b9a067b59dffab99 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/pullAt.mjs @@ -0,0 +1,34 @@ +import { flattenDepth } from './flattenDepth.mjs'; +import { isIndex } from '../_internal/isIndex.mjs'; +import { isKey } from '../_internal/isKey.mjs'; +import { toKey } from '../_internal/toKey.mjs'; +import { at } from '../object/at.mjs'; +import { unset } from '../object/unset.mjs'; +import { isArray } from '../predicate/isArray.mjs'; +import { toPath } from '../util/toPath.mjs'; + +function pullAt(array, ..._indices) { + const indices = flattenDepth(_indices, 1); + if (!array) { + return Array(indices.length); + } + const result = at(array, indices); + const indicesToPull = indices + .map(index => (isIndex(index, array.length) ? Number(index) : index)) + .sort((a, b) => b - a); + for (const index of new Set(indicesToPull)) { + if (isIndex(index, array.length)) { + Array.prototype.splice.call(array, index, 1); + continue; + } + if (isKey(index, array)) { + delete array[toKey(index)]; + continue; + } + const path = isArray(index) ? index : toPath(index); + unset(array, path); + } + return result; +} + +export { pullAt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6f404b1474c2578d210db5ca5eebfbffd6934678 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.d.mts @@ -0,0 +1,80 @@ +import { MemoListIterator } from '../_internal/MemoListIterator.mjs'; +import { MemoObjectIterator } from '../_internal/MemoObjectIterator.mjs'; + +/** + * Reduces an array to a single value using an iteratee function. + * + * @param {T[] | null | undefined} collection - The array to iterate over + * @param {MemoListIterator} callback - The function invoked per iteration + * @param {U} accumulator - The initial value + * @returns {U} Returns the accumulated value + * + * @example + * const array = [1, 2, 3]; + * reduce(array, (acc, value) => acc + value, 0); // => 6 + */ +declare function reduce(collection: T[] | null | undefined, callback: MemoListIterator, accumulator: U): U; +/** + * Reduces an array-like object to a single value using an iteratee function. + * + * @param {ArrayLike | null | undefined} collection - The array-like object to iterate over + * @param {MemoListIterator>} callback - The function invoked per iteration + * @param {U} accumulator - The initial value + * @returns {U} Returns the accumulated value + * + * @example + * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3}; + * reduce(arrayLike, (acc, value) => acc + value, 0); // => 6 + */ +declare function reduce(collection: ArrayLike | null | undefined, callback: MemoListIterator>, accumulator: U): U; +/** + * Reduces an object to a single value using an iteratee function. + * + * @param {T | null | undefined} collection - The object to iterate over + * @param {MemoObjectIterator} callback - The function invoked per iteration + * @param {U} accumulator - The initial value + * @returns {U} Returns the accumulated value + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * reduce(obj, (acc, value) => acc + value, 0); // => 6 + */ +declare function reduce(collection: T | null | undefined, callback: MemoObjectIterator, accumulator: U): U; +/** + * Reduces an array to a single value using an iteratee function. + * + * @param {T[] | null | undefined} collection - The array to iterate over + * @param {MemoListIterator} callback - The function invoked per iteration + * @returns {T | undefined} Returns the accumulated value + * + * @example + * const array = [1, 2, 3]; + * reduce(array, (acc, value) => acc + value); // => 6 + */ +declare function reduce(collection: T[] | null | undefined, callback: MemoListIterator): T | undefined; +/** + * Reduces an array-like object to a single value using an iteratee function. + * + * @param {ArrayLike | null | undefined} collection - The array-like object to iterate over + * @param {MemoListIterator>} callback - The function invoked per iteration + * @returns {T | undefined} Returns the accumulated value + * + * @example + * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3}; + * reduce(arrayLike, (acc, value) => acc + value); // => 6 + */ +declare function reduce(collection: ArrayLike | null | undefined, callback: MemoListIterator>): T | undefined; +/** + * Reduces an object to a single value using an iteratee function. + * + * @param {T | null | undefined} collection - The object to iterate over + * @param {MemoObjectIterator} callback - The function invoked per iteration + * @returns {T[keyof T] | undefined} Returns the accumulated value + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * reduce(obj, (acc, value) => acc + value); // => 6 + */ +declare function reduce(collection: T | null | undefined, callback: MemoObjectIterator): T[keyof T] | undefined; + +export { reduce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6777ff3b9997dba0ee974554062e0f6836355435 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.d.ts @@ -0,0 +1,80 @@ +import { MemoListIterator } from '../_internal/MemoListIterator.js'; +import { MemoObjectIterator } from '../_internal/MemoObjectIterator.js'; + +/** + * Reduces an array to a single value using an iteratee function. + * + * @param {T[] | null | undefined} collection - The array to iterate over + * @param {MemoListIterator} callback - The function invoked per iteration + * @param {U} accumulator - The initial value + * @returns {U} Returns the accumulated value + * + * @example + * const array = [1, 2, 3]; + * reduce(array, (acc, value) => acc + value, 0); // => 6 + */ +declare function reduce(collection: T[] | null | undefined, callback: MemoListIterator, accumulator: U): U; +/** + * Reduces an array-like object to a single value using an iteratee function. + * + * @param {ArrayLike | null | undefined} collection - The array-like object to iterate over + * @param {MemoListIterator>} callback - The function invoked per iteration + * @param {U} accumulator - The initial value + * @returns {U} Returns the accumulated value + * + * @example + * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3}; + * reduce(arrayLike, (acc, value) => acc + value, 0); // => 6 + */ +declare function reduce(collection: ArrayLike | null | undefined, callback: MemoListIterator>, accumulator: U): U; +/** + * Reduces an object to a single value using an iteratee function. + * + * @param {T | null | undefined} collection - The object to iterate over + * @param {MemoObjectIterator} callback - The function invoked per iteration + * @param {U} accumulator - The initial value + * @returns {U} Returns the accumulated value + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * reduce(obj, (acc, value) => acc + value, 0); // => 6 + */ +declare function reduce(collection: T | null | undefined, callback: MemoObjectIterator, accumulator: U): U; +/** + * Reduces an array to a single value using an iteratee function. + * + * @param {T[] | null | undefined} collection - The array to iterate over + * @param {MemoListIterator} callback - The function invoked per iteration + * @returns {T | undefined} Returns the accumulated value + * + * @example + * const array = [1, 2, 3]; + * reduce(array, (acc, value) => acc + value); // => 6 + */ +declare function reduce(collection: T[] | null | undefined, callback: MemoListIterator): T | undefined; +/** + * Reduces an array-like object to a single value using an iteratee function. + * + * @param {ArrayLike | null | undefined} collection - The array-like object to iterate over + * @param {MemoListIterator>} callback - The function invoked per iteration + * @returns {T | undefined} Returns the accumulated value + * + * @example + * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3}; + * reduce(arrayLike, (acc, value) => acc + value); // => 6 + */ +declare function reduce(collection: ArrayLike | null | undefined, callback: MemoListIterator>): T | undefined; +/** + * Reduces an object to a single value using an iteratee function. + * + * @param {T | null | undefined} collection - The object to iterate over + * @param {MemoObjectIterator} callback - The function invoked per iteration + * @returns {T[keyof T] | undefined} Returns the accumulated value + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * reduce(obj, (acc, value) => acc + value); // => 6 + */ +declare function reduce(collection: T | null | undefined, callback: MemoObjectIterator): T[keyof T] | undefined; + +export { reduce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.js new file mode 100644 index 0000000000000000000000000000000000000000..33e31ed92e9fea2ef96e4f2b5e6522660cc834c5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const range = require('../../math/range.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function reduce(collection, iteratee = identity.identity, accumulator) { + if (!collection) { + return accumulator; + } + let keys; + let startIndex = 0; + if (isArrayLike.isArrayLike(collection)) { + keys = range.range(0, collection.length); + if (accumulator == null && collection.length > 0) { + accumulator = collection[0]; + startIndex += 1; + } + } + else { + keys = Object.keys(collection); + if (accumulator == null) { + accumulator = collection[keys[0]]; + startIndex += 1; + } + } + for (let i = startIndex; i < keys.length; i++) { + const key = keys[i]; + const value = collection[key]; + accumulator = iteratee(accumulator, value, key, collection); + } + return accumulator; +} + +exports.reduce = reduce; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ef3bb27e557cd73a865451093361026625b17820 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduce.mjs @@ -0,0 +1,33 @@ +import { identity } from '../../function/identity.mjs'; +import { range } from '../../math/range.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function reduce(collection, iteratee = identity, accumulator) { + if (!collection) { + return accumulator; + } + let keys; + let startIndex = 0; + if (isArrayLike(collection)) { + keys = range(0, collection.length); + if (accumulator == null && collection.length > 0) { + accumulator = collection[0]; + startIndex += 1; + } + } + else { + keys = Object.keys(collection); + if (accumulator == null) { + accumulator = collection[keys[0]]; + startIndex += 1; + } + } + for (let i = startIndex; i < keys.length; i++) { + const key = keys[i]; + const value = collection[key]; + accumulator = iteratee(accumulator, value, key, collection); + } + return accumulator; +} + +export { reduce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1348c5cdfffa1547949ae0f7e106309f0b296c5a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.d.mts @@ -0,0 +1,118 @@ +import { MemoListIterator } from '../_internal/MemoListIterator.mjs'; +import { MemoObjectIterator } from '../_internal/MemoObjectIterator.mjs'; + +/** + * Reduces an array to a single value using an iteratee function, starting from the right. + * + * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one. + * This function takes the result of the previous step and the current element to perform a calculation. + * After going through all the elements, the function gives you one final result. + * + * When the `reduceRight()` function starts, there's no previous result to use. + * If you provide an initial value, it starts with that. + * If not, it uses the last element of the array and begins with the second to last element for the calculation. + * + * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one. + * This function takes the result of the previous step and the current element to perform a calculation. + * After going through all the elements, the function gives you one final result. + * + * When the `reduceRight()` function starts, there's no previous result to use. + * If you provide an initial value, it starts with that. + * If not, it uses the last element of the array and begins with the second to last element for the calculation. + * + * @template T, U + * @param {T[] | null | undefined} collection - The array to iterate over. + * @param {MemoListIterator} callback - The function invoked per iteration. + * @param {U} accumulator - The initial value. + * @returns {U} Returns the accumulated value. + * + * @example + * reduceRight([1, 2, 3], (acc, value) => acc + value, 0); + * // => 6 + */ +declare function reduceRight(collection: T[] | null | undefined, callback: MemoListIterator, accumulator: U): U; +/** + * Reduces an array-like collection to a single value using an iteratee function, starting from the right. + * + * @template T, U + * @param {ArrayLike | null | undefined} collection - The array-like collection to iterate over. + * @param {MemoListIterator>} callback - The function invoked per iteration. + * @param {U} accumulator - The initial value. + * @returns {U} Returns the accumulated value. + * + * @example + * reduceRight([1, 2, 3], (acc, value) => acc + value, 0); + * // => 6 + */ +declare function reduceRight(collection: ArrayLike | null | undefined, callback: MemoListIterator>, accumulator: U): U; +/** + * Reduces an object to a single value using an iteratee function, starting from the right. + * + * @template T, U + * @param {T | null | undefined} collection - The object to iterate over. + * @param {MemoObjectIterator} callback - The function invoked per iteration. + * @param {U} accumulator - The initial value. + * @returns {U} Returns the accumulated value. + * + * @example + * reduceRight({ a: 1, b: 2, c: 3 }, (acc, value) => acc + value, 0); + * // => 6 + */ +declare function reduceRight(collection: T | null | undefined, callback: MemoObjectIterator, accumulator: U): U; +/** + * Reduces an array to a single value using an iteratee function, starting from the right. + * + * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one. + * This function takes the result of the previous step and the current element to perform a calculation. + * After going through all the elements, the function gives you one final result. + * + * When the `reduceRight()` function starts, there's no previous result to use. + * If you provide an initial value, it starts with that. + * If not, it uses the last element of the array and begins with the second to last element for the calculation. + * + * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one. + * This function takes the result of the previous step and the current element to perform a calculation. + * After going through all the elements, the function gives you one final result. + * + * When the `reduceRight()` function starts, there's no previous result to use. + * If you provide an initial value, it starts with that. + * If not, it uses the last element of the array and begins with the second to last element for the calculation. + * + * @template T + * @param {T[] | null | undefined} collection - The array to iterate over. + * @param {MemoListIterator} callback - The function invoked per iteration. + * @returns {T | undefined} Returns the accumulated value. + * + * @example + * reduceRight([1, 2, 3], (acc, value) => acc + value); + * // => 6 + */ +declare function reduceRight(collection: T[] | null | undefined, callback: MemoListIterator): T | undefined; +/** + * Reduces an array-like collection to a single value using an iteratee function, starting from the right. + * + * @template T + * @param {ArrayLike | null | undefined} collection - The array-like collection to iterate over. + * @param {MemoListIterator>} callback - The function invoked per iteration. + * @returns {T | undefined} Returns the accumulated value. + * + * @example + * reduceRight([1, 2, 3], (acc, value) => acc + value); + * // => 6 + */ +declare function reduceRight(collection: ArrayLike | null | undefined, callback: MemoListIterator>): T | undefined; +/** + * Reduces an object to a single value using an iteratee function, starting from the right. + * + * @template T + * @param {T | null | undefined} collection - The object to iterate over. + * @param {MemoObjectIterator} callback - The function invoked per iteration. + * @returns {T[keyof T] | undefined} Returns the accumulated value. + * + * @example + * reduceRight({ a: 1, b: 2, c: 3 }, (acc, value) => acc + value); + * // => 6 + */ +declare function reduceRight(collection: T | null | undefined, callback: MemoObjectIterator): T[keyof T] | undefined; + +export { reduceRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..eaf8b6b0acb55c68e5a80208d706b6506143f109 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.d.ts @@ -0,0 +1,118 @@ +import { MemoListIterator } from '../_internal/MemoListIterator.js'; +import { MemoObjectIterator } from '../_internal/MemoObjectIterator.js'; + +/** + * Reduces an array to a single value using an iteratee function, starting from the right. + * + * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one. + * This function takes the result of the previous step and the current element to perform a calculation. + * After going through all the elements, the function gives you one final result. + * + * When the `reduceRight()` function starts, there's no previous result to use. + * If you provide an initial value, it starts with that. + * If not, it uses the last element of the array and begins with the second to last element for the calculation. + * + * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one. + * This function takes the result of the previous step and the current element to perform a calculation. + * After going through all the elements, the function gives you one final result. + * + * When the `reduceRight()` function starts, there's no previous result to use. + * If you provide an initial value, it starts with that. + * If not, it uses the last element of the array and begins with the second to last element for the calculation. + * + * @template T, U + * @param {T[] | null | undefined} collection - The array to iterate over. + * @param {MemoListIterator} callback - The function invoked per iteration. + * @param {U} accumulator - The initial value. + * @returns {U} Returns the accumulated value. + * + * @example + * reduceRight([1, 2, 3], (acc, value) => acc + value, 0); + * // => 6 + */ +declare function reduceRight(collection: T[] | null | undefined, callback: MemoListIterator, accumulator: U): U; +/** + * Reduces an array-like collection to a single value using an iteratee function, starting from the right. + * + * @template T, U + * @param {ArrayLike | null | undefined} collection - The array-like collection to iterate over. + * @param {MemoListIterator>} callback - The function invoked per iteration. + * @param {U} accumulator - The initial value. + * @returns {U} Returns the accumulated value. + * + * @example + * reduceRight([1, 2, 3], (acc, value) => acc + value, 0); + * // => 6 + */ +declare function reduceRight(collection: ArrayLike | null | undefined, callback: MemoListIterator>, accumulator: U): U; +/** + * Reduces an object to a single value using an iteratee function, starting from the right. + * + * @template T, U + * @param {T | null | undefined} collection - The object to iterate over. + * @param {MemoObjectIterator} callback - The function invoked per iteration. + * @param {U} accumulator - The initial value. + * @returns {U} Returns the accumulated value. + * + * @example + * reduceRight({ a: 1, b: 2, c: 3 }, (acc, value) => acc + value, 0); + * // => 6 + */ +declare function reduceRight(collection: T | null | undefined, callback: MemoObjectIterator, accumulator: U): U; +/** + * Reduces an array to a single value using an iteratee function, starting from the right. + * + * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one. + * This function takes the result of the previous step and the current element to perform a calculation. + * After going through all the elements, the function gives you one final result. + * + * When the `reduceRight()` function starts, there's no previous result to use. + * If you provide an initial value, it starts with that. + * If not, it uses the last element of the array and begins with the second to last element for the calculation. + * + * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one. + * This function takes the result of the previous step and the current element to perform a calculation. + * After going through all the elements, the function gives you one final result. + * + * When the `reduceRight()` function starts, there's no previous result to use. + * If you provide an initial value, it starts with that. + * If not, it uses the last element of the array and begins with the second to last element for the calculation. + * + * @template T + * @param {T[] | null | undefined} collection - The array to iterate over. + * @param {MemoListIterator} callback - The function invoked per iteration. + * @returns {T | undefined} Returns the accumulated value. + * + * @example + * reduceRight([1, 2, 3], (acc, value) => acc + value); + * // => 6 + */ +declare function reduceRight(collection: T[] | null | undefined, callback: MemoListIterator): T | undefined; +/** + * Reduces an array-like collection to a single value using an iteratee function, starting from the right. + * + * @template T + * @param {ArrayLike | null | undefined} collection - The array-like collection to iterate over. + * @param {MemoListIterator>} callback - The function invoked per iteration. + * @returns {T | undefined} Returns the accumulated value. + * + * @example + * reduceRight([1, 2, 3], (acc, value) => acc + value); + * // => 6 + */ +declare function reduceRight(collection: ArrayLike | null | undefined, callback: MemoListIterator>): T | undefined; +/** + * Reduces an object to a single value using an iteratee function, starting from the right. + * + * @template T + * @param {T | null | undefined} collection - The object to iterate over. + * @param {MemoObjectIterator} callback - The function invoked per iteration. + * @returns {T[keyof T] | undefined} Returns the accumulated value. + * + * @example + * reduceRight({ a: 1, b: 2, c: 3 }, (acc, value) => acc + value); + * // => 6 + */ +declare function reduceRight(collection: T | null | undefined, callback: MemoObjectIterator): T[keyof T] | undefined; + +export { reduceRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.js new file mode 100644 index 0000000000000000000000000000000000000000..7024e752f0b4a578499f0b90125d5f1b7287d53e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.js @@ -0,0 +1,43 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const identity = require('../../function/identity.js'); +const range = require('../../math/range.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function reduceRight(collection, iteratee = identity.identity, accumulator) { + if (!collection) { + return accumulator; + } + let keys; + let startIndex; + if (isArrayLike.isArrayLike(collection)) { + keys = range.range(0, collection.length).reverse(); + if (accumulator == null && collection.length > 0) { + accumulator = collection[collection.length - 1]; + startIndex = 1; + } + else { + startIndex = 0; + } + } + else { + keys = Object.keys(collection).reverse(); + if (accumulator == null) { + accumulator = collection[keys[0]]; + startIndex = 1; + } + else { + startIndex = 0; + } + } + for (let i = startIndex; i < keys.length; i++) { + const key = keys[i]; + const value = collection[key]; + accumulator = iteratee(accumulator, value, key, collection); + } + return accumulator; +} + +exports.reduceRight = reduceRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9e686d80f01e091f5e62933fd8d37dfc783c9062 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reduceRight.mjs @@ -0,0 +1,39 @@ +import { identity } from '../../function/identity.mjs'; +import { range } from '../../math/range.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function reduceRight(collection, iteratee = identity, accumulator) { + if (!collection) { + return accumulator; + } + let keys; + let startIndex; + if (isArrayLike(collection)) { + keys = range(0, collection.length).reverse(); + if (accumulator == null && collection.length > 0) { + accumulator = collection[collection.length - 1]; + startIndex = 1; + } + else { + startIndex = 0; + } + } + else { + keys = Object.keys(collection).reverse(); + if (accumulator == null) { + accumulator = collection[keys[0]]; + startIndex = 1; + } + else { + startIndex = 0; + } + } + for (let i = startIndex; i < keys.length; i++) { + const key = keys[i]; + const value = collection[key]; + accumulator = iteratee(accumulator, value, key, collection); + } + return accumulator; +} + +export { reduceRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..65d698bfa3266d609159a76c986cffd644a3f702 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.d.mts @@ -0,0 +1,50 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.mjs'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.mjs'; +import { StringIterator } from '../_internal/StringIterator.mjs'; + +/** + * Iterates over the collection and rejects elements based on the given predicate. + * If a function is provided, it is invoked for each element in the collection. + * + * @param {string | null | undefined} collection The string to iterate over + * @param {StringIterator} [predicate] The function invoked per iteration + * @returns {string[]} Returns a new array of characters that do not satisfy the predicate + * @example + * reject('abc', char => char === 'b') + * // => ['a', 'c'] + */ +declare function reject(collection: string | null | undefined, predicate?: StringIterator): string[]; +/** + * Iterates over the collection and rejects elements based on the given predicate. + * If a function is provided, it is invoked for each element in the collection. + * + * @template T + * @param {ArrayLike | null | undefined} collection The array-like to iterate over + * @param {ListIterateeCustom} [predicate] The function invoked per iteration + * @returns {T[]} Returns a new array of elements that do not satisfy the predicate + * @example + * reject([1, 2, 3], num => num % 2 === 0) + * // => [1, 3] + * + * reject([{ a: 1 }, { a: 2 }, { b: 1 }], 'a') + * // => [{ b: 1 }] + */ +declare function reject(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom): T[]; +/** + * Iterates over the collection and rejects elements based on the given predicate. + * If a function is provided, it is invoked for each element in the collection. + * + * @template T + * @param {T | null | undefined} collection The object to iterate over + * @param {ObjectIterateeCustom} [predicate] The function invoked per iteration + * @returns {Array} Returns a new array of elements that do not satisfy the predicate + * @example + * reject({ a: 1, b: 2, c: 3 }, value => value % 2 === 0) + * // => [1, 3] + * + * reject({ item1: { a: 0, b: true }, item2: { a: 1, b: true }, item3: { a: 2, b: false }}, { b: false }) + * // => [{ a: 0, b: true }, { a: 1, b: true }] + */ +declare function reject(collection: T | null | undefined, predicate?: ObjectIterateeCustom): Array; + +export { reject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d345c3e8c05ee34e2594ff17f0b3baa5bc2166be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.d.ts @@ -0,0 +1,50 @@ +import { ListIterateeCustom } from '../_internal/ListIterateeCustom.js'; +import { ObjectIterateeCustom } from '../_internal/ObjectIteratee.js'; +import { StringIterator } from '../_internal/StringIterator.js'; + +/** + * Iterates over the collection and rejects elements based on the given predicate. + * If a function is provided, it is invoked for each element in the collection. + * + * @param {string | null | undefined} collection The string to iterate over + * @param {StringIterator} [predicate] The function invoked per iteration + * @returns {string[]} Returns a new array of characters that do not satisfy the predicate + * @example + * reject('abc', char => char === 'b') + * // => ['a', 'c'] + */ +declare function reject(collection: string | null | undefined, predicate?: StringIterator): string[]; +/** + * Iterates over the collection and rejects elements based on the given predicate. + * If a function is provided, it is invoked for each element in the collection. + * + * @template T + * @param {ArrayLike | null | undefined} collection The array-like to iterate over + * @param {ListIterateeCustom} [predicate] The function invoked per iteration + * @returns {T[]} Returns a new array of elements that do not satisfy the predicate + * @example + * reject([1, 2, 3], num => num % 2 === 0) + * // => [1, 3] + * + * reject([{ a: 1 }, { a: 2 }, { b: 1 }], 'a') + * // => [{ b: 1 }] + */ +declare function reject(collection: ArrayLike | null | undefined, predicate?: ListIterateeCustom): T[]; +/** + * Iterates over the collection and rejects elements based on the given predicate. + * If a function is provided, it is invoked for each element in the collection. + * + * @template T + * @param {T | null | undefined} collection The object to iterate over + * @param {ObjectIterateeCustom} [predicate] The function invoked per iteration + * @returns {Array} Returns a new array of elements that do not satisfy the predicate + * @example + * reject({ a: 1, b: 2, c: 3 }, value => value % 2 === 0) + * // => [1, 3] + * + * reject({ item1: { a: 0, b: true }, item2: { a: 1, b: true }, item3: { a: 2, b: false }}, { b: false }) + * // => [{ a: 0, b: true }, { a: 1, b: true }] + */ +declare function reject(collection: T | null | undefined, predicate?: ObjectIterateeCustom): Array; + +export { reject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.js new file mode 100644 index 0000000000000000000000000000000000000000..1ac9d10540729f549c04c4e40440158f119cd1c6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const filter = require('./filter.js'); +const identity = require('../../function/identity.js'); +const negate = require('../function/negate.js'); +const iteratee = require('../util/iteratee.js'); + +function reject(source, predicate = identity.identity) { + return filter.filter(source, negate.negate(iteratee.iteratee(predicate))); +} + +exports.reject = reject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a772c606111620eeb20181a6984912e93b2e73af --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reject.mjs @@ -0,0 +1,10 @@ +import { filter } from './filter.mjs'; +import { identity } from '../../function/identity.mjs'; +import { negate } from '../function/negate.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function reject(source, predicate = identity) { + return filter(source, negate(iteratee(predicate))); +} + +export { reject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0c5e3e153d564589e19689a707a4e5de52c13eac --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.d.mts @@ -0,0 +1,19 @@ +import { ListIteratee } from '../_internal/ListIteratee.mjs'; + +/** + * Removes all elements from array that predicate returns truthy for and returns an array of the removed elements. + * + * @template L + * @param {L extends readonly any[] ? never : L} array - The array to modify. + * @param {ListIteratee} [predicate] - The function invoked per iteration. + * @returns {Array} Returns the new array of removed elements. + * + * @example + * const array = [1, 2, 3, 4]; + * const evens = remove(array, n => n % 2 === 0); + * console.log(array); // => [1, 3] + * console.log(evens); // => [2, 4] + */ +declare function remove>(array: L extends readonly any[] ? never : L, predicate?: ListIteratee): Array; + +export { remove }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..619d8488c9995e8af6c29e32fa22e32f4bda1952 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.d.ts @@ -0,0 +1,19 @@ +import { ListIteratee } from '../_internal/ListIteratee.js'; + +/** + * Removes all elements from array that predicate returns truthy for and returns an array of the removed elements. + * + * @template L + * @param {L extends readonly any[] ? never : L} array - The array to modify. + * @param {ListIteratee} [predicate] - The function invoked per iteration. + * @returns {Array} Returns the new array of removed elements. + * + * @example + * const array = [1, 2, 3, 4]; + * const evens = remove(array, n => n % 2 === 0); + * console.log(array); // => [1, 3] + * console.log(evens); // => [2, 4] + */ +declare function remove>(array: L extends readonly any[] ? never : L, predicate?: ListIteratee): Array; + +export { remove }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.js new file mode 100644 index 0000000000000000000000000000000000000000..3f229f017c7cee85362d771951e0668c2f431731 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const remove$1 = require('../../array/remove.js'); +const identity = require('../../function/identity.js'); +const iteratee = require('../util/iteratee.js'); + +function remove(arr, shouldRemoveElement = identity.identity) { + return remove$1.remove(arr, iteratee.iteratee(shouldRemoveElement)); +} + +exports.remove = remove; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d4162379c67d2f5169cc65d1827d7f50542e542b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/remove.mjs @@ -0,0 +1,9 @@ +import { remove as remove$1 } from '../../array/remove.mjs'; +import { identity } from '../../function/identity.mjs'; +import { iteratee } from '../util/iteratee.mjs'; + +function remove(arr, shouldRemoveElement = identity) { + return remove$1(arr, iteratee(shouldRemoveElement)); +} + +export { remove }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c2a05a02d8b8b37dc318b448b898166ee4dd02c3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.d.mts @@ -0,0 +1,15 @@ +/** + * Reverses `array` so that the first element becomes the last, the second element becomes the second to last, and so on. + * + * @template L + * @param {L extends readonly any[] ? never : L} array - The array to reverse. + * @returns {L} Returns `array`. + * + * @example + * const array = [1, 2, 3]; + * reverse(array); + * // => [3, 2, 1] + */ +declare function reverse>(array: L extends readonly any[] ? never : L): L; + +export { reverse }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c2a05a02d8b8b37dc318b448b898166ee4dd02c3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.d.ts @@ -0,0 +1,15 @@ +/** + * Reverses `array` so that the first element becomes the last, the second element becomes the second to last, and so on. + * + * @template L + * @param {L extends readonly any[] ? never : L} array - The array to reverse. + * @returns {L} Returns `array`. + * + * @example + * const array = [1, 2, 3]; + * reverse(array); + * // => [3, 2, 1] + */ +declare function reverse>(array: L extends readonly any[] ? never : L): L; + +export { reverse }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.js new file mode 100644 index 0000000000000000000000000000000000000000..8009e7aed119ddc24beea2f292407de5dcfb3b79 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function reverse(array) { + if (array == null) { + return array; + } + return array.reverse(); +} + +exports.reverse = reverse; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.mjs new file mode 100644 index 0000000000000000000000000000000000000000..24d2329fa86da2bed2d836b2f7e90d7bc96df21f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/reverse.mjs @@ -0,0 +1,8 @@ +function reverse(array) { + if (array == null) { + return array; + } + return array.reverse(); +} + +export { reverse }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0f0b5fd098d2be822d01875dafdde4ef6b6c7d46 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.d.mts @@ -0,0 +1,38 @@ +/** + * Gets a random element from collection. + * + * @template T + * @param {readonly [T, ...T[]]} collection - The collection to sample. + * @returns {T} Returns the random element. + * + * @example + * sample([1, 2, 3, 4]); + * // => 2 + */ +declare function sample(collection: readonly [T, ...T[]]): T; +/** + * Gets a random element from collection. + * + * @template T + * @param {Record | Record | null | undefined} collection - The collection to sample. + * @returns {T | undefined} Returns the random element. + * + * @example + * sample({ 'a': 1, 'b': 2, 'c': 3 }); + * // => 2 + */ +declare function sample(collection: Record | Record | null | undefined): T | undefined; +/** + * Gets a random element from collection. + * + * @template T + * @param {T | null | undefined} collection - The collection to sample. + * @returns {T[keyof T] | undefined} Returns the random element. + * + * @example + * sample({ 'a': 1, 'b': 2, 'c': 3 }); + * // => 2 + */ +declare function sample(collection: T | null | undefined): T[keyof T] | undefined; + +export { sample }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0f0b5fd098d2be822d01875dafdde4ef6b6c7d46 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.d.ts @@ -0,0 +1,38 @@ +/** + * Gets a random element from collection. + * + * @template T + * @param {readonly [T, ...T[]]} collection - The collection to sample. + * @returns {T} Returns the random element. + * + * @example + * sample([1, 2, 3, 4]); + * // => 2 + */ +declare function sample(collection: readonly [T, ...T[]]): T; +/** + * Gets a random element from collection. + * + * @template T + * @param {Record | Record | null | undefined} collection - The collection to sample. + * @returns {T | undefined} Returns the random element. + * + * @example + * sample({ 'a': 1, 'b': 2, 'c': 3 }); + * // => 2 + */ +declare function sample(collection: Record | Record | null | undefined): T | undefined; +/** + * Gets a random element from collection. + * + * @template T + * @param {T | null | undefined} collection - The collection to sample. + * @returns {T[keyof T] | undefined} Returns the random element. + * + * @example + * sample({ 'a': 1, 'b': 2, 'c': 3 }); + * // => 2 + */ +declare function sample(collection: T | null | undefined): T[keyof T] | undefined; + +export { sample }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.js new file mode 100644 index 0000000000000000000000000000000000000000..8dc1ed6e52f9f0fc157edf60492104d51dcd7d62 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const sample$1 = require('../../array/sample.js'); +const toArray = require('../_internal/toArray.js'); +const isArrayLike = require('../predicate/isArrayLike.js'); + +function sample(collection) { + if (collection == null) { + return undefined; + } + if (isArrayLike.isArrayLike(collection)) { + return sample$1.sample(toArray.toArray(collection)); + } + return sample$1.sample(Object.values(collection)); +} + +exports.sample = sample; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.mjs new file mode 100644 index 0000000000000000000000000000000000000000..807b995ae20d9cc424e8934b26f38be4eae98cba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sample.mjs @@ -0,0 +1,15 @@ +import { sample as sample$1 } from '../../array/sample.mjs'; +import { toArray } from '../_internal/toArray.mjs'; +import { isArrayLike } from '../predicate/isArrayLike.mjs'; + +function sample(collection) { + if (collection == null) { + return undefined; + } + if (isArrayLike(collection)) { + return sample$1(toArray(collection)); + } + return sample$1(Object.values(collection)); +} + +export { sample }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..935c69a1f7c721ee850580915cf0187c29bb81bf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.d.mts @@ -0,0 +1,28 @@ +/** + * Returns a sample element array of a specified size from a collection. + * + * @template T + * @param {Record | Record | null | undefined} collection - The collection to sample from. + * @param {number} [n] - The size of sample. + * @returns {T[]} A new array with sample size applied. + * + * @example + * sampleSize([1, 2, 3], 2); + * // => [2, 3] (example, actual result will vary) + */ +declare function sampleSize(collection: Record | Record | null | undefined, n?: number): T[]; +/** + * Returns a sample element array of a specified size from an object. + * + * @template T + * @param {T | null | undefined} collection - The object to sample from. + * @param {number} [n] - The size of sample. + * @returns {Array} A new array with sample size applied. + * + * @example + * sampleSize({ a: 1, b: 2, c: 3 }, 2); + * // => [2, 3] (example, actual result will vary) + */ +declare function sampleSize(collection: T | null | undefined, n?: number): Array; + +export { sampleSize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..935c69a1f7c721ee850580915cf0187c29bb81bf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.d.ts @@ -0,0 +1,28 @@ +/** + * Returns a sample element array of a specified size from a collection. + * + * @template T + * @param {Record | Record | null | undefined} collection - The collection to sample from. + * @param {number} [n] - The size of sample. + * @returns {T[]} A new array with sample size applied. + * + * @example + * sampleSize([1, 2, 3], 2); + * // => [2, 3] (example, actual result will vary) + */ +declare function sampleSize(collection: Record | Record | null | undefined, n?: number): T[]; +/** + * Returns a sample element array of a specified size from an object. + * + * @template T + * @param {T | null | undefined} collection - The object to sample from. + * @param {number} [n] - The size of sample. + * @returns {Array} A new array with sample size applied. + * + * @example + * sampleSize({ a: 1, b: 2, c: 3 }, 2); + * // => [2, 3] (example, actual result will vary) + */ +declare function sampleSize(collection: T | null | undefined, n?: number): Array; + +export { sampleSize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.js new file mode 100644 index 0000000000000000000000000000000000000000..016392e15e911f413d361bb7eda01e43802bfdc7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.js @@ -0,0 +1,22 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const sampleSize$1 = require('../../array/sampleSize.js'); +const isIterateeCall = require('../_internal/isIterateeCall.js'); +const clamp = require('../math/clamp.js'); +const toArray = require('../util/toArray.js'); +const toInteger = require('../util/toInteger.js'); + +function sampleSize(collection, size, guard) { + const arrayCollection = toArray.toArray(collection); + if (guard ? isIterateeCall.isIterateeCall(collection, size, guard) : size === undefined) { + size = 1; + } + else { + size = clamp.clamp(toInteger.toInteger(size), 0, arrayCollection.length); + } + return sampleSize$1.sampleSize(arrayCollection, size); +} + +exports.sampleSize = sampleSize; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f3d23a95431f8b2e99541c3d27e83a7b09eb73f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/array/sampleSize.mjs @@ -0,0 +1,18 @@ +import { sampleSize as sampleSize$1 } from '../../array/sampleSize.mjs'; +import { isIterateeCall } from '../_internal/isIterateeCall.mjs'; +import { clamp } from '../math/clamp.mjs'; +import { toArray } from '../util/toArray.mjs'; +import { toInteger } from '../util/toInteger.mjs'; + +function sampleSize(collection, size, guard) { + const arrayCollection = toArray(collection); + if (guard ? isIterateeCall(collection, size, guard) : size === undefined) { + size = 1; + } + else { + size = clamp(toInteger(size), 0, arrayCollection.length); + } + return sampleSize$1(arrayCollection, size); +} + +export { sampleSize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..aef3da58a0d4e566d9a5b02d09f74784732a279c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.d.mts @@ -0,0 +1,291 @@ +export { castArray } from './array/castArray.mjs'; +export { chunk } from './array/chunk.mjs'; +export { compact } from './array/compact.mjs'; +export { concat } from './array/concat.mjs'; +export { countBy } from './array/countBy.mjs'; +export { difference } from './array/difference.mjs'; +export { differenceBy } from './array/differenceBy.mjs'; +export { differenceWith } from './array/differenceWith.mjs'; +export { drop } from './array/drop.mjs'; +export { dropRight } from './array/dropRight.mjs'; +export { dropRightWhile } from './array/dropRightWhile.mjs'; +export { dropWhile } from './array/dropWhile.mjs'; +export { forEach as each, forEach } from './array/forEach.mjs'; +export { forEachRight as eachRight, forEachRight } from './array/forEachRight.mjs'; +export { every } from './array/every.mjs'; +export { fill } from './array/fill.mjs'; +export { filter } from './array/filter.mjs'; +export { find } from './array/find.mjs'; +export { findIndex } from './array/findIndex.mjs'; +export { findLast } from './array/findLast.mjs'; +export { findLastIndex } from './array/findLastIndex.mjs'; +export { head as first, head } from './array/head.mjs'; +export { flatMap } from './array/flatMap.mjs'; +export { flatMapDeep } from './array/flatMapDeep.mjs'; +export { flatMapDepth } from './array/flatMapDepth.mjs'; +export { flatten } from './array/flatten.mjs'; +export { flattenDeep } from './array/flattenDeep.mjs'; +export { flattenDepth } from './array/flattenDepth.mjs'; +export { groupBy } from './array/groupBy.mjs'; +export { includes } from './array/includes.mjs'; +export { indexOf } from './array/indexOf.mjs'; +export { initial } from './array/initial.mjs'; +export { intersection } from './array/intersection.mjs'; +export { intersectionBy } from './array/intersectionBy.mjs'; +export { intersectionWith } from './array/intersectionWith.mjs'; +export { invokeMap } from './array/invokeMap.mjs'; +export { join } from './array/join.mjs'; +export { keyBy } from './array/keyBy.mjs'; +export { last } from './array/last.mjs'; +export { lastIndexOf } from './array/lastIndexOf.mjs'; +export { map } from './array/map.mjs'; +export { nth } from './array/nth.mjs'; +export { orderBy } from './array/orderBy.mjs'; +export { partition } from './array/partition.mjs'; +export { pull } from './array/pull.mjs'; +export { pullAll } from './array/pullAll.mjs'; +export { pullAllBy } from './array/pullAllBy.mjs'; +export { pullAllWith } from './array/pullAllWith.mjs'; +export { pullAt } from './array/pullAt.mjs'; +export { reduce } from './array/reduce.mjs'; +export { reduceRight } from './array/reduceRight.mjs'; +export { reject } from './array/reject.mjs'; +export { remove } from './array/remove.mjs'; +export { reverse } from './array/reverse.mjs'; +export { sample } from './array/sample.mjs'; +export { sampleSize } from './array/sampleSize.mjs'; +export { shuffle } from './array/shuffle.mjs'; +export { size } from './array/size.mjs'; +export { slice } from './array/slice.mjs'; +export { some } from './array/some.mjs'; +export { sortBy } from './array/sortBy.mjs'; +export { sortedIndex } from './array/sortedIndex.mjs'; +export { sortedIndexBy } from './array/sortedIndexBy.mjs'; +export { sortedIndexOf } from './array/sortedIndexOf.mjs'; +export { sortedLastIndex } from './array/sortedLastIndex.mjs'; +export { sortedLastIndexBy } from './array/sortedLastIndexBy.mjs'; +export { sortedLastIndexOf } from './array/sortedLastIndexOf.mjs'; +export { tail } from './array/tail.mjs'; +export { take } from './array/take.mjs'; +export { takeRight } from './array/takeRight.mjs'; +export { takeRightWhile } from './array/takeRightWhile.mjs'; +export { takeWhile } from './array/takeWhile.mjs'; +export { union } from './array/union.mjs'; +export { unionBy } from './array/unionBy.mjs'; +export { unionWith } from './array/unionWith.mjs'; +export { uniq } from './array/uniq.mjs'; +export { uniqBy } from './array/uniqBy.mjs'; +export { uniqWith } from './array/uniqWith.mjs'; +export { unzip } from './array/unzip.mjs'; +export { unzipWith } from './array/unzipWith.mjs'; +export { without } from './array/without.mjs'; +export { xor } from './array/xor.mjs'; +export { xorBy } from './array/xorBy.mjs'; +export { xorWith } from './array/xorWith.mjs'; +export { zip } from './array/zip.mjs'; +export { zipObject } from './array/zipObject.mjs'; +export { zipObjectDeep } from './array/zipObjectDeep.mjs'; +export { zipWith } from './array/zipWith.mjs'; +export { after } from './function/after.mjs'; +export { ary } from './function/ary.mjs'; +export { attempt } from './function/attempt.mjs'; +export { before } from './function/before.mjs'; +export { bind } from './function/bind.mjs'; +export { bindKey } from './function/bindKey.mjs'; +export { curry } from './function/curry.mjs'; +export { curryRight } from './function/curryRight.mjs'; +export { DebouncedFunc, debounce } from './function/debounce.mjs'; +export { defer } from './function/defer.mjs'; +export { delay } from './function/delay.mjs'; +export { flip } from './function/flip.mjs'; +export { flow } from './function/flow.mjs'; +export { flowRight } from './function/flowRight.mjs'; +export { memoize } from './function/memoize.mjs'; +export { negate } from './function/negate.mjs'; +export { nthArg } from './function/nthArg.mjs'; +export { once } from './function/once.mjs'; +export { overArgs } from './function/overArgs.mjs'; +export { partial } from './function/partial.mjs'; +export { partialRight } from './function/partialRight.mjs'; +export { rearg } from './function/rearg.mjs'; +export { rest } from './function/rest.mjs'; +export { spread } from './function/spread.mjs'; +export { throttle } from './function/throttle.mjs'; +export { unary } from './function/unary.mjs'; +export { wrap } from './function/wrap.mjs'; +export { add } from './math/add.mjs'; +export { ceil } from './math/ceil.mjs'; +export { clamp } from './math/clamp.mjs'; +export { divide } from './math/divide.mjs'; +export { floor } from './math/floor.mjs'; +export { inRange } from './math/inRange.mjs'; +export { max } from './math/max.mjs'; +export { maxBy } from './math/maxBy.mjs'; +export { mean } from './math/mean.mjs'; +export { meanBy } from './math/meanBy.mjs'; +export { min } from './math/min.mjs'; +export { minBy } from './math/minBy.mjs'; +export { multiply } from './math/multiply.mjs'; +export { parseInt } from './math/parseInt.mjs'; +export { random } from './math/random.mjs'; +export { range } from './math/range.mjs'; +export { rangeRight } from './math/rangeRight.mjs'; +export { round } from './math/round.mjs'; +export { subtract } from './math/subtract.mjs'; +export { sum } from './math/sum.mjs'; +export { sumBy } from './math/sumBy.mjs'; +export { isEqual } from '../predicate/isEqual.mjs'; +export { identity } from './function/identity.mjs'; +export { noop } from './function/noop.mjs'; +export { assign } from './object/assign.mjs'; +export { assignIn, assignIn as extend } from './object/assignIn.mjs'; +export { assignInWith, assignInWith as extendWith } from './object/assignInWith.mjs'; +export { assignWith } from './object/assignWith.mjs'; +export { at } from './object/at.mjs'; +export { clone } from './object/clone.mjs'; +export { cloneDeep } from './object/cloneDeep.mjs'; +export { cloneDeepWith } from './object/cloneDeepWith.mjs'; +export { cloneWith } from './object/cloneWith.mjs'; +export { create } from './object/create.mjs'; +export { defaults } from './object/defaults.mjs'; +export { defaultsDeep } from './object/defaultsDeep.mjs'; +export { findKey } from './object/findKey.mjs'; +export { findLastKey } from './object/findLastKey.mjs'; +export { forIn } from './object/forIn.mjs'; +export { forInRight } from './object/forInRight.mjs'; +export { forOwn } from './object/forOwn.mjs'; +export { forOwnRight } from './object/forOwnRight.mjs'; +export { fromPairs } from './object/fromPairs.mjs'; +export { functions } from './object/functions.mjs'; +export { functionsIn } from './object/functionsIn.mjs'; +export { get } from './object/get.mjs'; +export { has } from './object/has.mjs'; +export { hasIn } from './object/hasIn.mjs'; +export { invert } from './object/invert.mjs'; +export { invertBy } from './object/invertBy.mjs'; +export { keys } from './object/keys.mjs'; +export { keysIn } from './object/keysIn.mjs'; +export { mapKeys } from './object/mapKeys.mjs'; +export { mapValues } from './object/mapValues.mjs'; +export { merge } from './object/merge.mjs'; +export { mergeWith } from './object/mergeWith.mjs'; +export { omit } from './object/omit.mjs'; +export { omitBy } from './object/omitBy.mjs'; +export { pick } from './object/pick.mjs'; +export { pickBy } from './object/pickBy.mjs'; +export { property } from './object/property.mjs'; +export { propertyOf } from './object/propertyOf.mjs'; +export { result } from './object/result.mjs'; +export { set } from './object/set.mjs'; +export { setWith } from './object/setWith.mjs'; +export { toDefaulted } from './object/toDefaulted.mjs'; +export { toPairs } from './object/toPairs.mjs'; +export { toPairsIn } from './object/toPairsIn.mjs'; +export { transform } from './object/transform.mjs'; +export { unset } from './object/unset.mjs'; +export { update } from './object/update.mjs'; +export { updateWith } from './object/updateWith.mjs'; +export { values } from './object/values.mjs'; +export { valuesIn } from './object/valuesIn.mjs'; +export { isFunction } from './predicate/isFunction.mjs'; +export { isLength } from './predicate/isLength.mjs'; +export { isMatchWith } from './predicate/isMatchWith.mjs'; +export { isNative } from './predicate/isNative.mjs'; +export { isNull } from './predicate/isNull.mjs'; +export { isUndefined } from './predicate/isUndefined.mjs'; +export { conforms } from './predicate/conforms.mjs'; +export { conformsTo } from './predicate/conformsTo.mjs'; +export { isArguments } from './predicate/isArguments.mjs'; +export { isArray } from './predicate/isArray.mjs'; +export { isArrayBuffer } from './predicate/isArrayBuffer.mjs'; +export { isArrayLike } from './predicate/isArrayLike.mjs'; +export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs'; +export { isBoolean } from './predicate/isBoolean.mjs'; +export { isBuffer } from './predicate/isBuffer.mjs'; +export { isDate } from './predicate/isDate.mjs'; +export { isElement } from './predicate/isElement.mjs'; +export { isEmpty } from './predicate/isEmpty.mjs'; +export { isEqualWith } from './predicate/isEqualWith.mjs'; +export { isError } from './predicate/isError.mjs'; +export { isFinite } from './predicate/isFinite.mjs'; +export { isInteger } from './predicate/isInteger.mjs'; +export { isMap } from './predicate/isMap.mjs'; +export { isMatch } from './predicate/isMatch.mjs'; +export { isNaN } from './predicate/isNaN.mjs'; +export { isNil } from './predicate/isNil.mjs'; +export { isNumber } from './predicate/isNumber.mjs'; +export { isObject } from './predicate/isObject.mjs'; +export { isObjectLike } from './predicate/isObjectLike.mjs'; +export { isPlainObject } from './predicate/isPlainObject.mjs'; +export { isRegExp } from './predicate/isRegExp.mjs'; +export { isSafeInteger } from './predicate/isSafeInteger.mjs'; +export { isSet } from './predicate/isSet.mjs'; +export { isString } from './predicate/isString.mjs'; +export { isSymbol } from './predicate/isSymbol.mjs'; +export { isTypedArray } from './predicate/isTypedArray.mjs'; +export { isWeakMap } from './predicate/isWeakMap.mjs'; +export { isWeakSet } from './predicate/isWeakSet.mjs'; +export { matches } from './predicate/matches.mjs'; +export { matchesProperty } from './predicate/matchesProperty.mjs'; +export { capitalize } from './string/capitalize.mjs'; +export { bindAll } from './util/bindAll.mjs'; +export { camelCase } from './string/camelCase.mjs'; +export { deburr } from './string/deburr.mjs'; +export { endsWith } from './string/endsWith.mjs'; +export { escape } from './string/escape.mjs'; +export { escapeRegExp } from './string/escapeRegExp.mjs'; +export { kebabCase } from './string/kebabCase.mjs'; +export { lowerCase } from './string/lowerCase.mjs'; +export { lowerFirst } from './string/lowerFirst.mjs'; +export { pad } from './string/pad.mjs'; +export { padEnd } from './string/padEnd.mjs'; +export { padStart } from './string/padStart.mjs'; +export { repeat } from './string/repeat.mjs'; +export { replace } from './string/replace.mjs'; +export { snakeCase } from './string/snakeCase.mjs'; +export { split } from './string/split.mjs'; +export { startCase } from './string/startCase.mjs'; +export { startsWith } from './string/startsWith.mjs'; +export { template, templateSettings } from './string/template.mjs'; +export { toLower } from './string/toLower.mjs'; +export { toUpper } from './string/toUpper.mjs'; +export { trim } from './string/trim.mjs'; +export { trimEnd } from './string/trimEnd.mjs'; +export { trimStart } from './string/trimStart.mjs'; +export { truncate } from './string/truncate.mjs'; +export { unescape } from './string/unescape.mjs'; +export { upperCase } from './string/upperCase.mjs'; +export { upperFirst } from './string/upperFirst.mjs'; +export { words } from './string/words.mjs'; +export { cond } from './util/cond.mjs'; +export { constant } from './util/constant.mjs'; +export { defaultTo } from './util/defaultTo.mjs'; +export { eq } from './util/eq.mjs'; +export { gt } from './util/gt.mjs'; +export { gte } from './util/gte.mjs'; +export { invoke } from './util/invoke.mjs'; +export { iteratee } from './util/iteratee.mjs'; +export { lt } from './util/lt.mjs'; +export { lte } from './util/lte.mjs'; +export { method } from './util/method.mjs'; +export { methodOf } from './util/methodOf.mjs'; +export { now } from './util/now.mjs'; +export { over } from './util/over.mjs'; +export { overEvery } from './util/overEvery.mjs'; +export { overSome } from './util/overSome.mjs'; +export { stubArray } from './util/stubArray.mjs'; +export { stubFalse } from './util/stubFalse.mjs'; +export { stubObject } from './util/stubObject.mjs'; +export { stubString } from './util/stubString.mjs'; +export { stubTrue } from './util/stubTrue.mjs'; +export { times } from './util/times.mjs'; +export { toArray } from './util/toArray.mjs'; +export { toFinite } from './util/toFinite.mjs'; +export { toInteger } from './util/toInteger.mjs'; +export { toLength } from './util/toLength.mjs'; +export { toNumber } from './util/toNumber.mjs'; +export { toPath } from './util/toPath.mjs'; +export { toPlainObject } from './util/toPlainObject.mjs'; +export { toSafeInteger } from './util/toSafeInteger.mjs'; +export { toString } from './util/toString.mjs'; +export { uniqueId } from './util/uniqueId.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..576375ee3ea061ef486c7dc7646fffcd91c504b8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.d.ts @@ -0,0 +1,291 @@ +export { castArray } from './array/castArray.js'; +export { chunk } from './array/chunk.js'; +export { compact } from './array/compact.js'; +export { concat } from './array/concat.js'; +export { countBy } from './array/countBy.js'; +export { difference } from './array/difference.js'; +export { differenceBy } from './array/differenceBy.js'; +export { differenceWith } from './array/differenceWith.js'; +export { drop } from './array/drop.js'; +export { dropRight } from './array/dropRight.js'; +export { dropRightWhile } from './array/dropRightWhile.js'; +export { dropWhile } from './array/dropWhile.js'; +export { forEach as each, forEach } from './array/forEach.js'; +export { forEachRight as eachRight, forEachRight } from './array/forEachRight.js'; +export { every } from './array/every.js'; +export { fill } from './array/fill.js'; +export { filter } from './array/filter.js'; +export { find } from './array/find.js'; +export { findIndex } from './array/findIndex.js'; +export { findLast } from './array/findLast.js'; +export { findLastIndex } from './array/findLastIndex.js'; +export { head as first, head } from './array/head.js'; +export { flatMap } from './array/flatMap.js'; +export { flatMapDeep } from './array/flatMapDeep.js'; +export { flatMapDepth } from './array/flatMapDepth.js'; +export { flatten } from './array/flatten.js'; +export { flattenDeep } from './array/flattenDeep.js'; +export { flattenDepth } from './array/flattenDepth.js'; +export { groupBy } from './array/groupBy.js'; +export { includes } from './array/includes.js'; +export { indexOf } from './array/indexOf.js'; +export { initial } from './array/initial.js'; +export { intersection } from './array/intersection.js'; +export { intersectionBy } from './array/intersectionBy.js'; +export { intersectionWith } from './array/intersectionWith.js'; +export { invokeMap } from './array/invokeMap.js'; +export { join } from './array/join.js'; +export { keyBy } from './array/keyBy.js'; +export { last } from './array/last.js'; +export { lastIndexOf } from './array/lastIndexOf.js'; +export { map } from './array/map.js'; +export { nth } from './array/nth.js'; +export { orderBy } from './array/orderBy.js'; +export { partition } from './array/partition.js'; +export { pull } from './array/pull.js'; +export { pullAll } from './array/pullAll.js'; +export { pullAllBy } from './array/pullAllBy.js'; +export { pullAllWith } from './array/pullAllWith.js'; +export { pullAt } from './array/pullAt.js'; +export { reduce } from './array/reduce.js'; +export { reduceRight } from './array/reduceRight.js'; +export { reject } from './array/reject.js'; +export { remove } from './array/remove.js'; +export { reverse } from './array/reverse.js'; +export { sample } from './array/sample.js'; +export { sampleSize } from './array/sampleSize.js'; +export { shuffle } from './array/shuffle.js'; +export { size } from './array/size.js'; +export { slice } from './array/slice.js'; +export { some } from './array/some.js'; +export { sortBy } from './array/sortBy.js'; +export { sortedIndex } from './array/sortedIndex.js'; +export { sortedIndexBy } from './array/sortedIndexBy.js'; +export { sortedIndexOf } from './array/sortedIndexOf.js'; +export { sortedLastIndex } from './array/sortedLastIndex.js'; +export { sortedLastIndexBy } from './array/sortedLastIndexBy.js'; +export { sortedLastIndexOf } from './array/sortedLastIndexOf.js'; +export { tail } from './array/tail.js'; +export { take } from './array/take.js'; +export { takeRight } from './array/takeRight.js'; +export { takeRightWhile } from './array/takeRightWhile.js'; +export { takeWhile } from './array/takeWhile.js'; +export { union } from './array/union.js'; +export { unionBy } from './array/unionBy.js'; +export { unionWith } from './array/unionWith.js'; +export { uniq } from './array/uniq.js'; +export { uniqBy } from './array/uniqBy.js'; +export { uniqWith } from './array/uniqWith.js'; +export { unzip } from './array/unzip.js'; +export { unzipWith } from './array/unzipWith.js'; +export { without } from './array/without.js'; +export { xor } from './array/xor.js'; +export { xorBy } from './array/xorBy.js'; +export { xorWith } from './array/xorWith.js'; +export { zip } from './array/zip.js'; +export { zipObject } from './array/zipObject.js'; +export { zipObjectDeep } from './array/zipObjectDeep.js'; +export { zipWith } from './array/zipWith.js'; +export { after } from './function/after.js'; +export { ary } from './function/ary.js'; +export { attempt } from './function/attempt.js'; +export { before } from './function/before.js'; +export { bind } from './function/bind.js'; +export { bindKey } from './function/bindKey.js'; +export { curry } from './function/curry.js'; +export { curryRight } from './function/curryRight.js'; +export { DebouncedFunc, debounce } from './function/debounce.js'; +export { defer } from './function/defer.js'; +export { delay } from './function/delay.js'; +export { flip } from './function/flip.js'; +export { flow } from './function/flow.js'; +export { flowRight } from './function/flowRight.js'; +export { memoize } from './function/memoize.js'; +export { negate } from './function/negate.js'; +export { nthArg } from './function/nthArg.js'; +export { once } from './function/once.js'; +export { overArgs } from './function/overArgs.js'; +export { partial } from './function/partial.js'; +export { partialRight } from './function/partialRight.js'; +export { rearg } from './function/rearg.js'; +export { rest } from './function/rest.js'; +export { spread } from './function/spread.js'; +export { throttle } from './function/throttle.js'; +export { unary } from './function/unary.js'; +export { wrap } from './function/wrap.js'; +export { add } from './math/add.js'; +export { ceil } from './math/ceil.js'; +export { clamp } from './math/clamp.js'; +export { divide } from './math/divide.js'; +export { floor } from './math/floor.js'; +export { inRange } from './math/inRange.js'; +export { max } from './math/max.js'; +export { maxBy } from './math/maxBy.js'; +export { mean } from './math/mean.js'; +export { meanBy } from './math/meanBy.js'; +export { min } from './math/min.js'; +export { minBy } from './math/minBy.js'; +export { multiply } from './math/multiply.js'; +export { parseInt } from './math/parseInt.js'; +export { random } from './math/random.js'; +export { range } from './math/range.js'; +export { rangeRight } from './math/rangeRight.js'; +export { round } from './math/round.js'; +export { subtract } from './math/subtract.js'; +export { sum } from './math/sum.js'; +export { sumBy } from './math/sumBy.js'; +export { isEqual } from '../predicate/isEqual.js'; +export { identity } from './function/identity.js'; +export { noop } from './function/noop.js'; +export { assign } from './object/assign.js'; +export { assignIn, assignIn as extend } from './object/assignIn.js'; +export { assignInWith, assignInWith as extendWith } from './object/assignInWith.js'; +export { assignWith } from './object/assignWith.js'; +export { at } from './object/at.js'; +export { clone } from './object/clone.js'; +export { cloneDeep } from './object/cloneDeep.js'; +export { cloneDeepWith } from './object/cloneDeepWith.js'; +export { cloneWith } from './object/cloneWith.js'; +export { create } from './object/create.js'; +export { defaults } from './object/defaults.js'; +export { defaultsDeep } from './object/defaultsDeep.js'; +export { findKey } from './object/findKey.js'; +export { findLastKey } from './object/findLastKey.js'; +export { forIn } from './object/forIn.js'; +export { forInRight } from './object/forInRight.js'; +export { forOwn } from './object/forOwn.js'; +export { forOwnRight } from './object/forOwnRight.js'; +export { fromPairs } from './object/fromPairs.js'; +export { functions } from './object/functions.js'; +export { functionsIn } from './object/functionsIn.js'; +export { get } from './object/get.js'; +export { has } from './object/has.js'; +export { hasIn } from './object/hasIn.js'; +export { invert } from './object/invert.js'; +export { invertBy } from './object/invertBy.js'; +export { keys } from './object/keys.js'; +export { keysIn } from './object/keysIn.js'; +export { mapKeys } from './object/mapKeys.js'; +export { mapValues } from './object/mapValues.js'; +export { merge } from './object/merge.js'; +export { mergeWith } from './object/mergeWith.js'; +export { omit } from './object/omit.js'; +export { omitBy } from './object/omitBy.js'; +export { pick } from './object/pick.js'; +export { pickBy } from './object/pickBy.js'; +export { property } from './object/property.js'; +export { propertyOf } from './object/propertyOf.js'; +export { result } from './object/result.js'; +export { set } from './object/set.js'; +export { setWith } from './object/setWith.js'; +export { toDefaulted } from './object/toDefaulted.js'; +export { toPairs } from './object/toPairs.js'; +export { toPairsIn } from './object/toPairsIn.js'; +export { transform } from './object/transform.js'; +export { unset } from './object/unset.js'; +export { update } from './object/update.js'; +export { updateWith } from './object/updateWith.js'; +export { values } from './object/values.js'; +export { valuesIn } from './object/valuesIn.js'; +export { isFunction } from './predicate/isFunction.js'; +export { isLength } from './predicate/isLength.js'; +export { isMatchWith } from './predicate/isMatchWith.js'; +export { isNative } from './predicate/isNative.js'; +export { isNull } from './predicate/isNull.js'; +export { isUndefined } from './predicate/isUndefined.js'; +export { conforms } from './predicate/conforms.js'; +export { conformsTo } from './predicate/conformsTo.js'; +export { isArguments } from './predicate/isArguments.js'; +export { isArray } from './predicate/isArray.js'; +export { isArrayBuffer } from './predicate/isArrayBuffer.js'; +export { isArrayLike } from './predicate/isArrayLike.js'; +export { isArrayLikeObject } from './predicate/isArrayLikeObject.js'; +export { isBoolean } from './predicate/isBoolean.js'; +export { isBuffer } from './predicate/isBuffer.js'; +export { isDate } from './predicate/isDate.js'; +export { isElement } from './predicate/isElement.js'; +export { isEmpty } from './predicate/isEmpty.js'; +export { isEqualWith } from './predicate/isEqualWith.js'; +export { isError } from './predicate/isError.js'; +export { isFinite } from './predicate/isFinite.js'; +export { isInteger } from './predicate/isInteger.js'; +export { isMap } from './predicate/isMap.js'; +export { isMatch } from './predicate/isMatch.js'; +export { isNaN } from './predicate/isNaN.js'; +export { isNil } from './predicate/isNil.js'; +export { isNumber } from './predicate/isNumber.js'; +export { isObject } from './predicate/isObject.js'; +export { isObjectLike } from './predicate/isObjectLike.js'; +export { isPlainObject } from './predicate/isPlainObject.js'; +export { isRegExp } from './predicate/isRegExp.js'; +export { isSafeInteger } from './predicate/isSafeInteger.js'; +export { isSet } from './predicate/isSet.js'; +export { isString } from './predicate/isString.js'; +export { isSymbol } from './predicate/isSymbol.js'; +export { isTypedArray } from './predicate/isTypedArray.js'; +export { isWeakMap } from './predicate/isWeakMap.js'; +export { isWeakSet } from './predicate/isWeakSet.js'; +export { matches } from './predicate/matches.js'; +export { matchesProperty } from './predicate/matchesProperty.js'; +export { capitalize } from './string/capitalize.js'; +export { bindAll } from './util/bindAll.js'; +export { camelCase } from './string/camelCase.js'; +export { deburr } from './string/deburr.js'; +export { endsWith } from './string/endsWith.js'; +export { escape } from './string/escape.js'; +export { escapeRegExp } from './string/escapeRegExp.js'; +export { kebabCase } from './string/kebabCase.js'; +export { lowerCase } from './string/lowerCase.js'; +export { lowerFirst } from './string/lowerFirst.js'; +export { pad } from './string/pad.js'; +export { padEnd } from './string/padEnd.js'; +export { padStart } from './string/padStart.js'; +export { repeat } from './string/repeat.js'; +export { replace } from './string/replace.js'; +export { snakeCase } from './string/snakeCase.js'; +export { split } from './string/split.js'; +export { startCase } from './string/startCase.js'; +export { startsWith } from './string/startsWith.js'; +export { template, templateSettings } from './string/template.js'; +export { toLower } from './string/toLower.js'; +export { toUpper } from './string/toUpper.js'; +export { trim } from './string/trim.js'; +export { trimEnd } from './string/trimEnd.js'; +export { trimStart } from './string/trimStart.js'; +export { truncate } from './string/truncate.js'; +export { unescape } from './string/unescape.js'; +export { upperCase } from './string/upperCase.js'; +export { upperFirst } from './string/upperFirst.js'; +export { words } from './string/words.js'; +export { cond } from './util/cond.js'; +export { constant } from './util/constant.js'; +export { defaultTo } from './util/defaultTo.js'; +export { eq } from './util/eq.js'; +export { gt } from './util/gt.js'; +export { gte } from './util/gte.js'; +export { invoke } from './util/invoke.js'; +export { iteratee } from './util/iteratee.js'; +export { lt } from './util/lt.js'; +export { lte } from './util/lte.js'; +export { method } from './util/method.js'; +export { methodOf } from './util/methodOf.js'; +export { now } from './util/now.js'; +export { over } from './util/over.js'; +export { overEvery } from './util/overEvery.js'; +export { overSome } from './util/overSome.js'; +export { stubArray } from './util/stubArray.js'; +export { stubFalse } from './util/stubFalse.js'; +export { stubObject } from './util/stubObject.js'; +export { stubString } from './util/stubString.js'; +export { stubTrue } from './util/stubTrue.js'; +export { times } from './util/times.js'; +export { toArray } from './util/toArray.js'; +export { toFinite } from './util/toFinite.js'; +export { toInteger } from './util/toInteger.js'; +export { toLength } from './util/toLength.js'; +export { toNumber } from './util/toNumber.js'; +export { toPath } from './util/toPath.js'; +export { toPlainObject } from './util/toPlainObject.js'; +export { toSafeInteger } from './util/toSafeInteger.js'; +export { toString } from './util/toString.js'; +export { uniqueId } from './util/uniqueId.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.js new file mode 100644 index 0000000000000000000000000000000000000000..050a7bb0abde2b8e96d3ec57b4a2a54a13c0a2e4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.js @@ -0,0 +1,595 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const castArray = require('./array/castArray.js'); +const chunk = require('./array/chunk.js'); +const compact = require('./array/compact.js'); +const concat = require('./array/concat.js'); +const countBy = require('./array/countBy.js'); +const difference = require('./array/difference.js'); +const differenceBy = require('./array/differenceBy.js'); +const differenceWith = require('./array/differenceWith.js'); +const drop = require('./array/drop.js'); +const dropRight = require('./array/dropRight.js'); +const dropRightWhile = require('./array/dropRightWhile.js'); +const dropWhile = require('./array/dropWhile.js'); +const forEach = require('./array/forEach.js'); +const forEachRight = require('./array/forEachRight.js'); +const every = require('./array/every.js'); +const fill = require('./array/fill.js'); +const filter = require('./array/filter.js'); +const find = require('./array/find.js'); +const findIndex = require('./array/findIndex.js'); +const findLast = require('./array/findLast.js'); +const findLastIndex = require('./array/findLastIndex.js'); +const head = require('./array/head.js'); +const flatMap = require('./array/flatMap.js'); +const flatMapDeep = require('./array/flatMapDeep.js'); +const flatMapDepth = require('./array/flatMapDepth.js'); +const flatten = require('./array/flatten.js'); +const flattenDeep = require('./array/flattenDeep.js'); +const flattenDepth = require('./array/flattenDepth.js'); +const groupBy = require('./array/groupBy.js'); +const includes = require('./array/includes.js'); +const indexOf = require('./array/indexOf.js'); +const initial = require('./array/initial.js'); +const intersection = require('./array/intersection.js'); +const intersectionBy = require('./array/intersectionBy.js'); +const intersectionWith = require('./array/intersectionWith.js'); +const invokeMap = require('./array/invokeMap.js'); +const join = require('./array/join.js'); +const keyBy = require('./array/keyBy.js'); +const last = require('./array/last.js'); +const lastIndexOf = require('./array/lastIndexOf.js'); +const map = require('./array/map.js'); +const nth = require('./array/nth.js'); +const orderBy = require('./array/orderBy.js'); +const partition = require('./array/partition.js'); +const pull = require('./array/pull.js'); +const pullAll = require('./array/pullAll.js'); +const pullAllBy = require('./array/pullAllBy.js'); +const pullAllWith = require('./array/pullAllWith.js'); +const pullAt = require('./array/pullAt.js'); +const reduce = require('./array/reduce.js'); +const reduceRight = require('./array/reduceRight.js'); +const reject = require('./array/reject.js'); +const remove = require('./array/remove.js'); +const reverse = require('./array/reverse.js'); +const sample = require('./array/sample.js'); +const sampleSize = require('./array/sampleSize.js'); +const shuffle = require('./array/shuffle.js'); +const size = require('./array/size.js'); +const slice = require('./array/slice.js'); +const some = require('./array/some.js'); +const sortBy = require('./array/sortBy.js'); +const sortedIndex = require('./array/sortedIndex.js'); +const sortedIndexBy = require('./array/sortedIndexBy.js'); +const sortedIndexOf = require('./array/sortedIndexOf.js'); +const sortedLastIndex = require('./array/sortedLastIndex.js'); +const sortedLastIndexBy = require('./array/sortedLastIndexBy.js'); +const sortedLastIndexOf = require('./array/sortedLastIndexOf.js'); +const tail = require('./array/tail.js'); +const take = require('./array/take.js'); +const takeRight = require('./array/takeRight.js'); +const takeRightWhile = require('./array/takeRightWhile.js'); +const takeWhile = require('./array/takeWhile.js'); +const union = require('./array/union.js'); +const unionBy = require('./array/unionBy.js'); +const unionWith = require('./array/unionWith.js'); +const uniq = require('./array/uniq.js'); +const uniqBy = require('./array/uniqBy.js'); +const uniqWith = require('./array/uniqWith.js'); +const unzip = require('./array/unzip.js'); +const unzipWith = require('./array/unzipWith.js'); +const without = require('./array/without.js'); +const xor = require('./array/xor.js'); +const xorBy = require('./array/xorBy.js'); +const xorWith = require('./array/xorWith.js'); +const zip = require('./array/zip.js'); +const zipObject = require('./array/zipObject.js'); +const zipObjectDeep = require('./array/zipObjectDeep.js'); +const zipWith = require('./array/zipWith.js'); +const after = require('./function/after.js'); +const ary = require('./function/ary.js'); +const attempt = require('./function/attempt.js'); +const before = require('./function/before.js'); +const bind = require('./function/bind.js'); +const bindKey = require('./function/bindKey.js'); +const curry = require('./function/curry.js'); +const curryRight = require('./function/curryRight.js'); +const debounce = require('./function/debounce.js'); +const defer = require('./function/defer.js'); +const delay = require('./function/delay.js'); +const flip = require('./function/flip.js'); +const flow = require('./function/flow.js'); +const flowRight = require('./function/flowRight.js'); +const memoize = require('./function/memoize.js'); +const negate = require('./function/negate.js'); +const nthArg = require('./function/nthArg.js'); +const once = require('./function/once.js'); +const overArgs = require('./function/overArgs.js'); +const partial = require('./function/partial.js'); +const partialRight = require('./function/partialRight.js'); +const rearg = require('./function/rearg.js'); +const rest = require('./function/rest.js'); +const spread = require('./function/spread.js'); +const throttle = require('./function/throttle.js'); +const unary = require('./function/unary.js'); +const wrap = require('./function/wrap.js'); +const add = require('./math/add.js'); +const ceil = require('./math/ceil.js'); +const clamp = require('./math/clamp.js'); +const divide = require('./math/divide.js'); +const floor = require('./math/floor.js'); +const inRange = require('./math/inRange.js'); +const max = require('./math/max.js'); +const maxBy = require('./math/maxBy.js'); +const mean = require('./math/mean.js'); +const meanBy = require('./math/meanBy.js'); +const min = require('./math/min.js'); +const minBy = require('./math/minBy.js'); +const multiply = require('./math/multiply.js'); +const parseInt = require('./math/parseInt.js'); +const random = require('./math/random.js'); +const range = require('./math/range.js'); +const rangeRight = require('./math/rangeRight.js'); +const round = require('./math/round.js'); +const subtract = require('./math/subtract.js'); +const sum = require('./math/sum.js'); +const sumBy = require('./math/sumBy.js'); +const isEqual = require('../predicate/isEqual.js'); +const identity = require('./function/identity.js'); +const noop = require('./function/noop.js'); +const assign = require('./object/assign.js'); +const assignIn = require('./object/assignIn.js'); +const assignInWith = require('./object/assignInWith.js'); +const assignWith = require('./object/assignWith.js'); +const at = require('./object/at.js'); +const clone = require('./object/clone.js'); +const cloneDeep = require('./object/cloneDeep.js'); +const cloneDeepWith = require('./object/cloneDeepWith.js'); +const cloneWith = require('./object/cloneWith.js'); +const create = require('./object/create.js'); +const defaults = require('./object/defaults.js'); +const defaultsDeep = require('./object/defaultsDeep.js'); +const findKey = require('./object/findKey.js'); +const findLastKey = require('./object/findLastKey.js'); +const forIn = require('./object/forIn.js'); +const forInRight = require('./object/forInRight.js'); +const forOwn = require('./object/forOwn.js'); +const forOwnRight = require('./object/forOwnRight.js'); +const fromPairs = require('./object/fromPairs.js'); +const functions = require('./object/functions.js'); +const functionsIn = require('./object/functionsIn.js'); +const get = require('./object/get.js'); +const has = require('./object/has.js'); +const hasIn = require('./object/hasIn.js'); +const invert = require('./object/invert.js'); +const invertBy = require('./object/invertBy.js'); +const keys = require('./object/keys.js'); +const keysIn = require('./object/keysIn.js'); +const mapKeys = require('./object/mapKeys.js'); +const mapValues = require('./object/mapValues.js'); +const merge = require('./object/merge.js'); +const mergeWith = require('./object/mergeWith.js'); +const omit = require('./object/omit.js'); +const omitBy = require('./object/omitBy.js'); +const pick = require('./object/pick.js'); +const pickBy = require('./object/pickBy.js'); +const property = require('./object/property.js'); +const propertyOf = require('./object/propertyOf.js'); +const result = require('./object/result.js'); +const set = require('./object/set.js'); +const setWith = require('./object/setWith.js'); +const toDefaulted = require('./object/toDefaulted.js'); +const toPairs = require('./object/toPairs.js'); +const toPairsIn = require('./object/toPairsIn.js'); +const transform = require('./object/transform.js'); +const unset = require('./object/unset.js'); +const update = require('./object/update.js'); +const updateWith = require('./object/updateWith.js'); +const values = require('./object/values.js'); +const valuesIn = require('./object/valuesIn.js'); +const isFunction = require('./predicate/isFunction.js'); +const isLength = require('./predicate/isLength.js'); +const isMatchWith = require('./predicate/isMatchWith.js'); +const isNative = require('./predicate/isNative.js'); +const isNull = require('./predicate/isNull.js'); +const isUndefined = require('./predicate/isUndefined.js'); +const conforms = require('./predicate/conforms.js'); +const conformsTo = require('./predicate/conformsTo.js'); +const isArguments = require('./predicate/isArguments.js'); +const isArray = require('./predicate/isArray.js'); +const isArrayBuffer = require('./predicate/isArrayBuffer.js'); +const isArrayLike = require('./predicate/isArrayLike.js'); +const isArrayLikeObject = require('./predicate/isArrayLikeObject.js'); +const isBoolean = require('./predicate/isBoolean.js'); +const isBuffer = require('./predicate/isBuffer.js'); +const isDate = require('./predicate/isDate.js'); +const isElement = require('./predicate/isElement.js'); +const isEmpty = require('./predicate/isEmpty.js'); +const isEqualWith = require('./predicate/isEqualWith.js'); +const isError = require('./predicate/isError.js'); +const isFinite = require('./predicate/isFinite.js'); +const isInteger = require('./predicate/isInteger.js'); +const isMap = require('./predicate/isMap.js'); +const isMatch = require('./predicate/isMatch.js'); +const isNaN = require('./predicate/isNaN.js'); +const isNil = require('./predicate/isNil.js'); +const isNumber = require('./predicate/isNumber.js'); +const isObject = require('./predicate/isObject.js'); +const isObjectLike = require('./predicate/isObjectLike.js'); +const isPlainObject = require('./predicate/isPlainObject.js'); +const isRegExp = require('./predicate/isRegExp.js'); +const isSafeInteger = require('./predicate/isSafeInteger.js'); +const isSet = require('./predicate/isSet.js'); +const isString = require('./predicate/isString.js'); +const isSymbol = require('./predicate/isSymbol.js'); +const isTypedArray = require('./predicate/isTypedArray.js'); +const isWeakMap = require('./predicate/isWeakMap.js'); +const isWeakSet = require('./predicate/isWeakSet.js'); +const matches = require('./predicate/matches.js'); +const matchesProperty = require('./predicate/matchesProperty.js'); +const capitalize = require('./string/capitalize.js'); +const bindAll = require('./util/bindAll.js'); +const camelCase = require('./string/camelCase.js'); +const deburr = require('./string/deburr.js'); +const endsWith = require('./string/endsWith.js'); +const escape = require('./string/escape.js'); +const escapeRegExp = require('./string/escapeRegExp.js'); +const kebabCase = require('./string/kebabCase.js'); +const lowerCase = require('./string/lowerCase.js'); +const lowerFirst = require('./string/lowerFirst.js'); +const pad = require('./string/pad.js'); +const padEnd = require('./string/padEnd.js'); +const padStart = require('./string/padStart.js'); +const repeat = require('./string/repeat.js'); +const replace = require('./string/replace.js'); +const snakeCase = require('./string/snakeCase.js'); +const split = require('./string/split.js'); +const startCase = require('./string/startCase.js'); +const startsWith = require('./string/startsWith.js'); +const template = require('./string/template.js'); +const toLower = require('./string/toLower.js'); +const toUpper = require('./string/toUpper.js'); +const trim = require('./string/trim.js'); +const trimEnd = require('./string/trimEnd.js'); +const trimStart = require('./string/trimStart.js'); +const truncate = require('./string/truncate.js'); +const unescape = require('./string/unescape.js'); +const upperCase = require('./string/upperCase.js'); +const upperFirst = require('./string/upperFirst.js'); +const words = require('./string/words.js'); +const cond = require('./util/cond.js'); +const constant = require('./util/constant.js'); +const defaultTo = require('./util/defaultTo.js'); +const eq = require('./util/eq.js'); +const gt = require('./util/gt.js'); +const gte = require('./util/gte.js'); +const invoke = require('./util/invoke.js'); +const iteratee = require('./util/iteratee.js'); +const lt = require('./util/lt.js'); +const lte = require('./util/lte.js'); +const method = require('./util/method.js'); +const methodOf = require('./util/methodOf.js'); +const now = require('./util/now.js'); +const over = require('./util/over.js'); +const overEvery = require('./util/overEvery.js'); +const overSome = require('./util/overSome.js'); +const stubArray = require('./util/stubArray.js'); +const stubFalse = require('./util/stubFalse.js'); +const stubObject = require('./util/stubObject.js'); +const stubString = require('./util/stubString.js'); +const stubTrue = require('./util/stubTrue.js'); +const times = require('./util/times.js'); +const toArray = require('./util/toArray.js'); +const toFinite = require('./util/toFinite.js'); +const toInteger = require('./util/toInteger.js'); +const toLength = require('./util/toLength.js'); +const toNumber = require('./util/toNumber.js'); +const toPath = require('./util/toPath.js'); +const toPlainObject = require('./util/toPlainObject.js'); +const toSafeInteger = require('./util/toSafeInteger.js'); +const toString = require('./util/toString.js'); +const uniqueId = require('./util/uniqueId.js'); + + + +exports.castArray = castArray.castArray; +exports.chunk = chunk.chunk; +exports.compact = compact.compact; +exports.concat = concat.concat; +exports.countBy = countBy.countBy; +exports.difference = difference.difference; +exports.differenceBy = differenceBy.differenceBy; +exports.differenceWith = differenceWith.differenceWith; +exports.drop = drop.drop; +exports.dropRight = dropRight.dropRight; +exports.dropRightWhile = dropRightWhile.dropRightWhile; +exports.dropWhile = dropWhile.dropWhile; +exports.each = forEach.forEach; +exports.forEach = forEach.forEach; +exports.eachRight = forEachRight.forEachRight; +exports.forEachRight = forEachRight.forEachRight; +exports.every = every.every; +exports.fill = fill.fill; +exports.filter = filter.filter; +exports.find = find.find; +exports.findIndex = findIndex.findIndex; +exports.findLast = findLast.findLast; +exports.findLastIndex = findLastIndex.findLastIndex; +exports.first = head.head; +exports.head = head.head; +exports.flatMap = flatMap.flatMap; +exports.flatMapDeep = flatMapDeep.flatMapDeep; +exports.flatMapDepth = flatMapDepth.flatMapDepth; +exports.flatten = flatten.flatten; +exports.flattenDeep = flattenDeep.flattenDeep; +exports.flattenDepth = flattenDepth.flattenDepth; +exports.groupBy = groupBy.groupBy; +exports.includes = includes.includes; +exports.indexOf = indexOf.indexOf; +exports.initial = initial.initial; +exports.intersection = intersection.intersection; +exports.intersectionBy = intersectionBy.intersectionBy; +exports.intersectionWith = intersectionWith.intersectionWith; +exports.invokeMap = invokeMap.invokeMap; +exports.join = join.join; +exports.keyBy = keyBy.keyBy; +exports.last = last.last; +exports.lastIndexOf = lastIndexOf.lastIndexOf; +exports.map = map.map; +exports.nth = nth.nth; +exports.orderBy = orderBy.orderBy; +exports.partition = partition.partition; +exports.pull = pull.pull; +exports.pullAll = pullAll.pullAll; +exports.pullAllBy = pullAllBy.pullAllBy; +exports.pullAllWith = pullAllWith.pullAllWith; +exports.pullAt = pullAt.pullAt; +exports.reduce = reduce.reduce; +exports.reduceRight = reduceRight.reduceRight; +exports.reject = reject.reject; +exports.remove = remove.remove; +exports.reverse = reverse.reverse; +exports.sample = sample.sample; +exports.sampleSize = sampleSize.sampleSize; +exports.shuffle = shuffle.shuffle; +exports.size = size.size; +exports.slice = slice.slice; +exports.some = some.some; +exports.sortBy = sortBy.sortBy; +exports.sortedIndex = sortedIndex.sortedIndex; +exports.sortedIndexBy = sortedIndexBy.sortedIndexBy; +exports.sortedIndexOf = sortedIndexOf.sortedIndexOf; +exports.sortedLastIndex = sortedLastIndex.sortedLastIndex; +exports.sortedLastIndexBy = sortedLastIndexBy.sortedLastIndexBy; +exports.sortedLastIndexOf = sortedLastIndexOf.sortedLastIndexOf; +exports.tail = tail.tail; +exports.take = take.take; +exports.takeRight = takeRight.takeRight; +exports.takeRightWhile = takeRightWhile.takeRightWhile; +exports.takeWhile = takeWhile.takeWhile; +exports.union = union.union; +exports.unionBy = unionBy.unionBy; +exports.unionWith = unionWith.unionWith; +exports.uniq = uniq.uniq; +exports.uniqBy = uniqBy.uniqBy; +exports.uniqWith = uniqWith.uniqWith; +exports.unzip = unzip.unzip; +exports.unzipWith = unzipWith.unzipWith; +exports.without = without.without; +exports.xor = xor.xor; +exports.xorBy = xorBy.xorBy; +exports.xorWith = xorWith.xorWith; +exports.zip = zip.zip; +exports.zipObject = zipObject.zipObject; +exports.zipObjectDeep = zipObjectDeep.zipObjectDeep; +exports.zipWith = zipWith.zipWith; +exports.after = after.after; +exports.ary = ary.ary; +exports.attempt = attempt.attempt; +exports.before = before.before; +exports.bind = bind.bind; +exports.bindKey = bindKey.bindKey; +exports.curry = curry.curry; +exports.curryRight = curryRight.curryRight; +exports.debounce = debounce.debounce; +exports.defer = defer.defer; +exports.delay = delay.delay; +exports.flip = flip.flip; +exports.flow = flow.flow; +exports.flowRight = flowRight.flowRight; +exports.memoize = memoize.memoize; +exports.negate = negate.negate; +exports.nthArg = nthArg.nthArg; +exports.once = once.once; +exports.overArgs = overArgs.overArgs; +exports.partial = partial.partial; +exports.partialRight = partialRight.partialRight; +exports.rearg = rearg.rearg; +exports.rest = rest.rest; +exports.spread = spread.spread; +exports.throttle = throttle.throttle; +exports.unary = unary.unary; +exports.wrap = wrap.wrap; +exports.add = add.add; +exports.ceil = ceil.ceil; +exports.clamp = clamp.clamp; +exports.divide = divide.divide; +exports.floor = floor.floor; +exports.inRange = inRange.inRange; +exports.max = max.max; +exports.maxBy = maxBy.maxBy; +exports.mean = mean.mean; +exports.meanBy = meanBy.meanBy; +exports.min = min.min; +exports.minBy = minBy.minBy; +exports.multiply = multiply.multiply; +exports.parseInt = parseInt.parseInt; +exports.random = random.random; +exports.range = range.range; +exports.rangeRight = rangeRight.rangeRight; +exports.round = round.round; +exports.subtract = subtract.subtract; +exports.sum = sum.sum; +exports.sumBy = sumBy.sumBy; +exports.isEqual = isEqual.isEqual; +exports.identity = identity.identity; +exports.noop = noop.noop; +exports.assign = assign.assign; +exports.assignIn = assignIn.assignIn; +exports.extend = assignIn.assignIn; +exports.assignInWith = assignInWith.assignInWith; +exports.extendWith = assignInWith.assignInWith; +exports.assignWith = assignWith.assignWith; +exports.at = at.at; +exports.clone = clone.clone; +exports.cloneDeep = cloneDeep.cloneDeep; +exports.cloneDeepWith = cloneDeepWith.cloneDeepWith; +exports.cloneWith = cloneWith.cloneWith; +exports.create = create.create; +exports.defaults = defaults.defaults; +exports.defaultsDeep = defaultsDeep.defaultsDeep; +exports.findKey = findKey.findKey; +exports.findLastKey = findLastKey.findLastKey; +exports.forIn = forIn.forIn; +exports.forInRight = forInRight.forInRight; +exports.forOwn = forOwn.forOwn; +exports.forOwnRight = forOwnRight.forOwnRight; +exports.fromPairs = fromPairs.fromPairs; +exports.functions = functions.functions; +exports.functionsIn = functionsIn.functionsIn; +exports.get = get.get; +exports.has = has.has; +exports.hasIn = hasIn.hasIn; +exports.invert = invert.invert; +exports.invertBy = invertBy.invertBy; +exports.keys = keys.keys; +exports.keysIn = keysIn.keysIn; +exports.mapKeys = mapKeys.mapKeys; +exports.mapValues = mapValues.mapValues; +exports.merge = merge.merge; +exports.mergeWith = mergeWith.mergeWith; +exports.omit = omit.omit; +exports.omitBy = omitBy.omitBy; +exports.pick = pick.pick; +exports.pickBy = pickBy.pickBy; +exports.property = property.property; +exports.propertyOf = propertyOf.propertyOf; +exports.result = result.result; +exports.set = set.set; +exports.setWith = setWith.setWith; +exports.toDefaulted = toDefaulted.toDefaulted; +exports.toPairs = toPairs.toPairs; +exports.toPairsIn = toPairsIn.toPairsIn; +exports.transform = transform.transform; +exports.unset = unset.unset; +exports.update = update.update; +exports.updateWith = updateWith.updateWith; +exports.values = values.values; +exports.valuesIn = valuesIn.valuesIn; +exports.isFunction = isFunction.isFunction; +exports.isLength = isLength.isLength; +exports.isMatchWith = isMatchWith.isMatchWith; +exports.isNative = isNative.isNative; +exports.isNull = isNull.isNull; +exports.isUndefined = isUndefined.isUndefined; +exports.conforms = conforms.conforms; +exports.conformsTo = conformsTo.conformsTo; +exports.isArguments = isArguments.isArguments; +exports.isArray = isArray.isArray; +exports.isArrayBuffer = isArrayBuffer.isArrayBuffer; +exports.isArrayLike = isArrayLike.isArrayLike; +exports.isArrayLikeObject = isArrayLikeObject.isArrayLikeObject; +exports.isBoolean = isBoolean.isBoolean; +exports.isBuffer = isBuffer.isBuffer; +exports.isDate = isDate.isDate; +exports.isElement = isElement.isElement; +exports.isEmpty = isEmpty.isEmpty; +exports.isEqualWith = isEqualWith.isEqualWith; +exports.isError = isError.isError; +exports.isFinite = isFinite.isFinite; +exports.isInteger = isInteger.isInteger; +exports.isMap = isMap.isMap; +exports.isMatch = isMatch.isMatch; +exports.isNaN = isNaN.isNaN; +exports.isNil = isNil.isNil; +exports.isNumber = isNumber.isNumber; +exports.isObject = isObject.isObject; +exports.isObjectLike = isObjectLike.isObjectLike; +exports.isPlainObject = isPlainObject.isPlainObject; +exports.isRegExp = isRegExp.isRegExp; +exports.isSafeInteger = isSafeInteger.isSafeInteger; +exports.isSet = isSet.isSet; +exports.isString = isString.isString; +exports.isSymbol = isSymbol.isSymbol; +exports.isTypedArray = isTypedArray.isTypedArray; +exports.isWeakMap = isWeakMap.isWeakMap; +exports.isWeakSet = isWeakSet.isWeakSet; +exports.matches = matches.matches; +exports.matchesProperty = matchesProperty.matchesProperty; +exports.capitalize = capitalize.capitalize; +exports.bindAll = bindAll.bindAll; +exports.camelCase = camelCase.camelCase; +exports.deburr = deburr.deburr; +exports.endsWith = endsWith.endsWith; +exports.escape = escape.escape; +exports.escapeRegExp = escapeRegExp.escapeRegExp; +exports.kebabCase = kebabCase.kebabCase; +exports.lowerCase = lowerCase.lowerCase; +exports.lowerFirst = lowerFirst.lowerFirst; +exports.pad = pad.pad; +exports.padEnd = padEnd.padEnd; +exports.padStart = padStart.padStart; +exports.repeat = repeat.repeat; +exports.replace = replace.replace; +exports.snakeCase = snakeCase.snakeCase; +exports.split = split.split; +exports.startCase = startCase.startCase; +exports.startsWith = startsWith.startsWith; +exports.template = template.template; +exports.templateSettings = template.templateSettings; +exports.toLower = toLower.toLower; +exports.toUpper = toUpper.toUpper; +exports.trim = trim.trim; +exports.trimEnd = trimEnd.trimEnd; +exports.trimStart = trimStart.trimStart; +exports.truncate = truncate.truncate; +exports.unescape = unescape.unescape; +exports.upperCase = upperCase.upperCase; +exports.upperFirst = upperFirst.upperFirst; +exports.words = words.words; +exports.cond = cond.cond; +exports.constant = constant.constant; +exports.defaultTo = defaultTo.defaultTo; +exports.eq = eq.eq; +exports.gt = gt.gt; +exports.gte = gte.gte; +exports.invoke = invoke.invoke; +exports.iteratee = iteratee.iteratee; +exports.lt = lt.lt; +exports.lte = lte.lte; +exports.method = method.method; +exports.methodOf = methodOf.methodOf; +exports.now = now.now; +exports.over = over.over; +exports.overEvery = overEvery.overEvery; +exports.overSome = overSome.overSome; +exports.stubArray = stubArray.stubArray; +exports.stubFalse = stubFalse.stubFalse; +exports.stubObject = stubObject.stubObject; +exports.stubString = stubString.stubString; +exports.stubTrue = stubTrue.stubTrue; +exports.times = times.times; +exports.toArray = toArray.toArray; +exports.toFinite = toFinite.toFinite; +exports.toInteger = toInteger.toInteger; +exports.toLength = toLength.toLength; +exports.toNumber = toNumber.toNumber; +exports.toPath = toPath.toPath; +exports.toPlainObject = toPlainObject.toPlainObject; +exports.toSafeInteger = toSafeInteger.toSafeInteger; +exports.toString = toString.toString; +exports.uniqueId = uniqueId.uniqueId; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3bfc8ace7b604a6b21215cb72ff6aee7cccd4b13 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/compat.mjs @@ -0,0 +1,291 @@ +export { castArray } from './array/castArray.mjs'; +export { chunk } from './array/chunk.mjs'; +export { compact } from './array/compact.mjs'; +export { concat } from './array/concat.mjs'; +export { countBy } from './array/countBy.mjs'; +export { difference } from './array/difference.mjs'; +export { differenceBy } from './array/differenceBy.mjs'; +export { differenceWith } from './array/differenceWith.mjs'; +export { drop } from './array/drop.mjs'; +export { dropRight } from './array/dropRight.mjs'; +export { dropRightWhile } from './array/dropRightWhile.mjs'; +export { dropWhile } from './array/dropWhile.mjs'; +export { forEach as each, forEach } from './array/forEach.mjs'; +export { forEachRight as eachRight, forEachRight } from './array/forEachRight.mjs'; +export { every } from './array/every.mjs'; +export { fill } from './array/fill.mjs'; +export { filter } from './array/filter.mjs'; +export { find } from './array/find.mjs'; +export { findIndex } from './array/findIndex.mjs'; +export { findLast } from './array/findLast.mjs'; +export { findLastIndex } from './array/findLastIndex.mjs'; +export { head as first, head } from './array/head.mjs'; +export { flatMap } from './array/flatMap.mjs'; +export { flatMapDeep } from './array/flatMapDeep.mjs'; +export { flatMapDepth } from './array/flatMapDepth.mjs'; +export { flatten } from './array/flatten.mjs'; +export { flattenDeep } from './array/flattenDeep.mjs'; +export { flattenDepth } from './array/flattenDepth.mjs'; +export { groupBy } from './array/groupBy.mjs'; +export { includes } from './array/includes.mjs'; +export { indexOf } from './array/indexOf.mjs'; +export { initial } from './array/initial.mjs'; +export { intersection } from './array/intersection.mjs'; +export { intersectionBy } from './array/intersectionBy.mjs'; +export { intersectionWith } from './array/intersectionWith.mjs'; +export { invokeMap } from './array/invokeMap.mjs'; +export { join } from './array/join.mjs'; +export { keyBy } from './array/keyBy.mjs'; +export { last } from './array/last.mjs'; +export { lastIndexOf } from './array/lastIndexOf.mjs'; +export { map } from './array/map.mjs'; +export { nth } from './array/nth.mjs'; +export { orderBy } from './array/orderBy.mjs'; +export { partition } from './array/partition.mjs'; +export { pull } from './array/pull.mjs'; +export { pullAll } from './array/pullAll.mjs'; +export { pullAllBy } from './array/pullAllBy.mjs'; +export { pullAllWith } from './array/pullAllWith.mjs'; +export { pullAt } from './array/pullAt.mjs'; +export { reduce } from './array/reduce.mjs'; +export { reduceRight } from './array/reduceRight.mjs'; +export { reject } from './array/reject.mjs'; +export { remove } from './array/remove.mjs'; +export { reverse } from './array/reverse.mjs'; +export { sample } from './array/sample.mjs'; +export { sampleSize } from './array/sampleSize.mjs'; +export { shuffle } from './array/shuffle.mjs'; +export { size } from './array/size.mjs'; +export { slice } from './array/slice.mjs'; +export { some } from './array/some.mjs'; +export { sortBy } from './array/sortBy.mjs'; +export { sortedIndex } from './array/sortedIndex.mjs'; +export { sortedIndexBy } from './array/sortedIndexBy.mjs'; +export { sortedIndexOf } from './array/sortedIndexOf.mjs'; +export { sortedLastIndex } from './array/sortedLastIndex.mjs'; +export { sortedLastIndexBy } from './array/sortedLastIndexBy.mjs'; +export { sortedLastIndexOf } from './array/sortedLastIndexOf.mjs'; +export { tail } from './array/tail.mjs'; +export { take } from './array/take.mjs'; +export { takeRight } from './array/takeRight.mjs'; +export { takeRightWhile } from './array/takeRightWhile.mjs'; +export { takeWhile } from './array/takeWhile.mjs'; +export { union } from './array/union.mjs'; +export { unionBy } from './array/unionBy.mjs'; +export { unionWith } from './array/unionWith.mjs'; +export { uniq } from './array/uniq.mjs'; +export { uniqBy } from './array/uniqBy.mjs'; +export { uniqWith } from './array/uniqWith.mjs'; +export { unzip } from './array/unzip.mjs'; +export { unzipWith } from './array/unzipWith.mjs'; +export { without } from './array/without.mjs'; +export { xor } from './array/xor.mjs'; +export { xorBy } from './array/xorBy.mjs'; +export { xorWith } from './array/xorWith.mjs'; +export { zip } from './array/zip.mjs'; +export { zipObject } from './array/zipObject.mjs'; +export { zipObjectDeep } from './array/zipObjectDeep.mjs'; +export { zipWith } from './array/zipWith.mjs'; +export { after } from './function/after.mjs'; +export { ary } from './function/ary.mjs'; +export { attempt } from './function/attempt.mjs'; +export { before } from './function/before.mjs'; +export { bind } from './function/bind.mjs'; +export { bindKey } from './function/bindKey.mjs'; +export { curry } from './function/curry.mjs'; +export { curryRight } from './function/curryRight.mjs'; +export { debounce } from './function/debounce.mjs'; +export { defer } from './function/defer.mjs'; +export { delay } from './function/delay.mjs'; +export { flip } from './function/flip.mjs'; +export { flow } from './function/flow.mjs'; +export { flowRight } from './function/flowRight.mjs'; +export { memoize } from './function/memoize.mjs'; +export { negate } from './function/negate.mjs'; +export { nthArg } from './function/nthArg.mjs'; +export { once } from './function/once.mjs'; +export { overArgs } from './function/overArgs.mjs'; +export { partial } from './function/partial.mjs'; +export { partialRight } from './function/partialRight.mjs'; +export { rearg } from './function/rearg.mjs'; +export { rest } from './function/rest.mjs'; +export { spread } from './function/spread.mjs'; +export { throttle } from './function/throttle.mjs'; +export { unary } from './function/unary.mjs'; +export { wrap } from './function/wrap.mjs'; +export { add } from './math/add.mjs'; +export { ceil } from './math/ceil.mjs'; +export { clamp } from './math/clamp.mjs'; +export { divide } from './math/divide.mjs'; +export { floor } from './math/floor.mjs'; +export { inRange } from './math/inRange.mjs'; +export { max } from './math/max.mjs'; +export { maxBy } from './math/maxBy.mjs'; +export { mean } from './math/mean.mjs'; +export { meanBy } from './math/meanBy.mjs'; +export { min } from './math/min.mjs'; +export { minBy } from './math/minBy.mjs'; +export { multiply } from './math/multiply.mjs'; +export { parseInt } from './math/parseInt.mjs'; +export { random } from './math/random.mjs'; +export { range } from './math/range.mjs'; +export { rangeRight } from './math/rangeRight.mjs'; +export { round } from './math/round.mjs'; +export { subtract } from './math/subtract.mjs'; +export { sum } from './math/sum.mjs'; +export { sumBy } from './math/sumBy.mjs'; +export { isEqual } from '../predicate/isEqual.mjs'; +export { identity } from './function/identity.mjs'; +export { noop } from './function/noop.mjs'; +export { assign } from './object/assign.mjs'; +export { assignIn, assignIn as extend } from './object/assignIn.mjs'; +export { assignInWith, assignInWith as extendWith } from './object/assignInWith.mjs'; +export { assignWith } from './object/assignWith.mjs'; +export { at } from './object/at.mjs'; +export { clone } from './object/clone.mjs'; +export { cloneDeep } from './object/cloneDeep.mjs'; +export { cloneDeepWith } from './object/cloneDeepWith.mjs'; +export { cloneWith } from './object/cloneWith.mjs'; +export { create } from './object/create.mjs'; +export { defaults } from './object/defaults.mjs'; +export { defaultsDeep } from './object/defaultsDeep.mjs'; +export { findKey } from './object/findKey.mjs'; +export { findLastKey } from './object/findLastKey.mjs'; +export { forIn } from './object/forIn.mjs'; +export { forInRight } from './object/forInRight.mjs'; +export { forOwn } from './object/forOwn.mjs'; +export { forOwnRight } from './object/forOwnRight.mjs'; +export { fromPairs } from './object/fromPairs.mjs'; +export { functions } from './object/functions.mjs'; +export { functionsIn } from './object/functionsIn.mjs'; +export { get } from './object/get.mjs'; +export { has } from './object/has.mjs'; +export { hasIn } from './object/hasIn.mjs'; +export { invert } from './object/invert.mjs'; +export { invertBy } from './object/invertBy.mjs'; +export { keys } from './object/keys.mjs'; +export { keysIn } from './object/keysIn.mjs'; +export { mapKeys } from './object/mapKeys.mjs'; +export { mapValues } from './object/mapValues.mjs'; +export { merge } from './object/merge.mjs'; +export { mergeWith } from './object/mergeWith.mjs'; +export { omit } from './object/omit.mjs'; +export { omitBy } from './object/omitBy.mjs'; +export { pick } from './object/pick.mjs'; +export { pickBy } from './object/pickBy.mjs'; +export { property } from './object/property.mjs'; +export { propertyOf } from './object/propertyOf.mjs'; +export { result } from './object/result.mjs'; +export { set } from './object/set.mjs'; +export { setWith } from './object/setWith.mjs'; +export { toDefaulted } from './object/toDefaulted.mjs'; +export { toPairs } from './object/toPairs.mjs'; +export { toPairsIn } from './object/toPairsIn.mjs'; +export { transform } from './object/transform.mjs'; +export { unset } from './object/unset.mjs'; +export { update } from './object/update.mjs'; +export { updateWith } from './object/updateWith.mjs'; +export { values } from './object/values.mjs'; +export { valuesIn } from './object/valuesIn.mjs'; +export { isFunction } from './predicate/isFunction.mjs'; +export { isLength } from './predicate/isLength.mjs'; +export { isMatchWith } from './predicate/isMatchWith.mjs'; +export { isNative } from './predicate/isNative.mjs'; +export { isNull } from './predicate/isNull.mjs'; +export { isUndefined } from './predicate/isUndefined.mjs'; +export { conforms } from './predicate/conforms.mjs'; +export { conformsTo } from './predicate/conformsTo.mjs'; +export { isArguments } from './predicate/isArguments.mjs'; +export { isArray } from './predicate/isArray.mjs'; +export { isArrayBuffer } from './predicate/isArrayBuffer.mjs'; +export { isArrayLike } from './predicate/isArrayLike.mjs'; +export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs'; +export { isBoolean } from './predicate/isBoolean.mjs'; +export { isBuffer } from './predicate/isBuffer.mjs'; +export { isDate } from './predicate/isDate.mjs'; +export { isElement } from './predicate/isElement.mjs'; +export { isEmpty } from './predicate/isEmpty.mjs'; +export { isEqualWith } from './predicate/isEqualWith.mjs'; +export { isError } from './predicate/isError.mjs'; +export { isFinite } from './predicate/isFinite.mjs'; +export { isInteger } from './predicate/isInteger.mjs'; +export { isMap } from './predicate/isMap.mjs'; +export { isMatch } from './predicate/isMatch.mjs'; +export { isNaN } from './predicate/isNaN.mjs'; +export { isNil } from './predicate/isNil.mjs'; +export { isNumber } from './predicate/isNumber.mjs'; +export { isObject } from './predicate/isObject.mjs'; +export { isObjectLike } from './predicate/isObjectLike.mjs'; +export { isPlainObject } from './predicate/isPlainObject.mjs'; +export { isRegExp } from './predicate/isRegExp.mjs'; +export { isSafeInteger } from './predicate/isSafeInteger.mjs'; +export { isSet } from './predicate/isSet.mjs'; +export { isString } from './predicate/isString.mjs'; +export { isSymbol } from './predicate/isSymbol.mjs'; +export { isTypedArray } from './predicate/isTypedArray.mjs'; +export { isWeakMap } from './predicate/isWeakMap.mjs'; +export { isWeakSet } from './predicate/isWeakSet.mjs'; +export { matches } from './predicate/matches.mjs'; +export { matchesProperty } from './predicate/matchesProperty.mjs'; +export { capitalize } from './string/capitalize.mjs'; +export { bindAll } from './util/bindAll.mjs'; +export { camelCase } from './string/camelCase.mjs'; +export { deburr } from './string/deburr.mjs'; +export { endsWith } from './string/endsWith.mjs'; +export { escape } from './string/escape.mjs'; +export { escapeRegExp } from './string/escapeRegExp.mjs'; +export { kebabCase } from './string/kebabCase.mjs'; +export { lowerCase } from './string/lowerCase.mjs'; +export { lowerFirst } from './string/lowerFirst.mjs'; +export { pad } from './string/pad.mjs'; +export { padEnd } from './string/padEnd.mjs'; +export { padStart } from './string/padStart.mjs'; +export { repeat } from './string/repeat.mjs'; +export { replace } from './string/replace.mjs'; +export { snakeCase } from './string/snakeCase.mjs'; +export { split } from './string/split.mjs'; +export { startCase } from './string/startCase.mjs'; +export { startsWith } from './string/startsWith.mjs'; +export { template, templateSettings } from './string/template.mjs'; +export { toLower } from './string/toLower.mjs'; +export { toUpper } from './string/toUpper.mjs'; +export { trim } from './string/trim.mjs'; +export { trimEnd } from './string/trimEnd.mjs'; +export { trimStart } from './string/trimStart.mjs'; +export { truncate } from './string/truncate.mjs'; +export { unescape } from './string/unescape.mjs'; +export { upperCase } from './string/upperCase.mjs'; +export { upperFirst } from './string/upperFirst.mjs'; +export { words } from './string/words.mjs'; +export { cond } from './util/cond.mjs'; +export { constant } from './util/constant.mjs'; +export { defaultTo } from './util/defaultTo.mjs'; +export { eq } from './util/eq.mjs'; +export { gt } from './util/gt.mjs'; +export { gte } from './util/gte.mjs'; +export { invoke } from './util/invoke.mjs'; +export { iteratee } from './util/iteratee.mjs'; +export { lt } from './util/lt.mjs'; +export { lte } from './util/lte.mjs'; +export { method } from './util/method.mjs'; +export { methodOf } from './util/methodOf.mjs'; +export { now } from './util/now.mjs'; +export { over } from './util/over.mjs'; +export { overEvery } from './util/overEvery.mjs'; +export { overSome } from './util/overSome.mjs'; +export { stubArray } from './util/stubArray.mjs'; +export { stubFalse } from './util/stubFalse.mjs'; +export { stubObject } from './util/stubObject.mjs'; +export { stubString } from './util/stubString.mjs'; +export { stubTrue } from './util/stubTrue.mjs'; +export { times } from './util/times.mjs'; +export { toArray } from './util/toArray.mjs'; +export { toFinite } from './util/toFinite.mjs'; +export { toInteger } from './util/toInteger.mjs'; +export { toLength } from './util/toLength.mjs'; +export { toNumber } from './util/toNumber.mjs'; +export { toPath } from './util/toPath.mjs'; +export { toPlainObject } from './util/toPlainObject.mjs'; +export { toSafeInteger } from './util/toSafeInteger.mjs'; +export { toString } from './util/toString.mjs'; +export { uniqueId } from './util/uniqueId.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..eb215ab0543e7ced6f716a2c510adb3a81ef4bcc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.d.mts @@ -0,0 +1,292 @@ +export { castArray } from './array/castArray.mjs'; +export { chunk } from './array/chunk.mjs'; +export { compact } from './array/compact.mjs'; +export { concat } from './array/concat.mjs'; +export { countBy } from './array/countBy.mjs'; +export { difference } from './array/difference.mjs'; +export { differenceBy } from './array/differenceBy.mjs'; +export { differenceWith } from './array/differenceWith.mjs'; +export { drop } from './array/drop.mjs'; +export { dropRight } from './array/dropRight.mjs'; +export { dropRightWhile } from './array/dropRightWhile.mjs'; +export { dropWhile } from './array/dropWhile.mjs'; +export { forEach as each, forEach } from './array/forEach.mjs'; +export { forEachRight as eachRight, forEachRight } from './array/forEachRight.mjs'; +export { every } from './array/every.mjs'; +export { fill } from './array/fill.mjs'; +export { filter } from './array/filter.mjs'; +export { find } from './array/find.mjs'; +export { findIndex } from './array/findIndex.mjs'; +export { findLast } from './array/findLast.mjs'; +export { findLastIndex } from './array/findLastIndex.mjs'; +export { head as first, head } from './array/head.mjs'; +export { flatMap } from './array/flatMap.mjs'; +export { flatMapDeep } from './array/flatMapDeep.mjs'; +export { flatMapDepth } from './array/flatMapDepth.mjs'; +export { flatten } from './array/flatten.mjs'; +export { flattenDeep } from './array/flattenDeep.mjs'; +export { flattenDepth } from './array/flattenDepth.mjs'; +export { groupBy } from './array/groupBy.mjs'; +export { includes } from './array/includes.mjs'; +export { indexOf } from './array/indexOf.mjs'; +export { initial } from './array/initial.mjs'; +export { intersection } from './array/intersection.mjs'; +export { intersectionBy } from './array/intersectionBy.mjs'; +export { intersectionWith } from './array/intersectionWith.mjs'; +export { invokeMap } from './array/invokeMap.mjs'; +export { join } from './array/join.mjs'; +export { keyBy } from './array/keyBy.mjs'; +export { last } from './array/last.mjs'; +export { lastIndexOf } from './array/lastIndexOf.mjs'; +export { map } from './array/map.mjs'; +export { nth } from './array/nth.mjs'; +export { orderBy } from './array/orderBy.mjs'; +export { partition } from './array/partition.mjs'; +export { pull } from './array/pull.mjs'; +export { pullAll } from './array/pullAll.mjs'; +export { pullAllBy } from './array/pullAllBy.mjs'; +export { pullAllWith } from './array/pullAllWith.mjs'; +export { pullAt } from './array/pullAt.mjs'; +export { reduce } from './array/reduce.mjs'; +export { reduceRight } from './array/reduceRight.mjs'; +export { reject } from './array/reject.mjs'; +export { remove } from './array/remove.mjs'; +export { reverse } from './array/reverse.mjs'; +export { sample } from './array/sample.mjs'; +export { sampleSize } from './array/sampleSize.mjs'; +export { shuffle } from './array/shuffle.mjs'; +export { size } from './array/size.mjs'; +export { slice } from './array/slice.mjs'; +export { some } from './array/some.mjs'; +export { sortBy } from './array/sortBy.mjs'; +export { sortedIndex } from './array/sortedIndex.mjs'; +export { sortedIndexBy } from './array/sortedIndexBy.mjs'; +export { sortedIndexOf } from './array/sortedIndexOf.mjs'; +export { sortedLastIndex } from './array/sortedLastIndex.mjs'; +export { sortedLastIndexBy } from './array/sortedLastIndexBy.mjs'; +export { sortedLastIndexOf } from './array/sortedLastIndexOf.mjs'; +export { tail } from './array/tail.mjs'; +export { take } from './array/take.mjs'; +export { takeRight } from './array/takeRight.mjs'; +export { takeRightWhile } from './array/takeRightWhile.mjs'; +export { takeWhile } from './array/takeWhile.mjs'; +export { union } from './array/union.mjs'; +export { unionBy } from './array/unionBy.mjs'; +export { unionWith } from './array/unionWith.mjs'; +export { uniq } from './array/uniq.mjs'; +export { uniqBy } from './array/uniqBy.mjs'; +export { uniqWith } from './array/uniqWith.mjs'; +export { unzip } from './array/unzip.mjs'; +export { unzipWith } from './array/unzipWith.mjs'; +export { without } from './array/without.mjs'; +export { xor } from './array/xor.mjs'; +export { xorBy } from './array/xorBy.mjs'; +export { xorWith } from './array/xorWith.mjs'; +export { zip } from './array/zip.mjs'; +export { zipObject } from './array/zipObject.mjs'; +export { zipObjectDeep } from './array/zipObjectDeep.mjs'; +export { zipWith } from './array/zipWith.mjs'; +export { after } from './function/after.mjs'; +export { ary } from './function/ary.mjs'; +export { attempt } from './function/attempt.mjs'; +export { before } from './function/before.mjs'; +export { bind } from './function/bind.mjs'; +export { bindKey } from './function/bindKey.mjs'; +export { curry } from './function/curry.mjs'; +export { curryRight } from './function/curryRight.mjs'; +export { DebouncedFunc, debounce } from './function/debounce.mjs'; +export { defer } from './function/defer.mjs'; +export { delay } from './function/delay.mjs'; +export { flip } from './function/flip.mjs'; +export { flow } from './function/flow.mjs'; +export { flowRight } from './function/flowRight.mjs'; +export { memoize } from './function/memoize.mjs'; +export { negate } from './function/negate.mjs'; +export { nthArg } from './function/nthArg.mjs'; +export { once } from './function/once.mjs'; +export { overArgs } from './function/overArgs.mjs'; +export { partial } from './function/partial.mjs'; +export { partialRight } from './function/partialRight.mjs'; +export { rearg } from './function/rearg.mjs'; +export { rest } from './function/rest.mjs'; +export { spread } from './function/spread.mjs'; +export { throttle } from './function/throttle.mjs'; +export { unary } from './function/unary.mjs'; +export { wrap } from './function/wrap.mjs'; +export { add } from './math/add.mjs'; +export { ceil } from './math/ceil.mjs'; +export { clamp } from './math/clamp.mjs'; +export { divide } from './math/divide.mjs'; +export { floor } from './math/floor.mjs'; +export { inRange } from './math/inRange.mjs'; +export { max } from './math/max.mjs'; +export { maxBy } from './math/maxBy.mjs'; +export { mean } from './math/mean.mjs'; +export { meanBy } from './math/meanBy.mjs'; +export { min } from './math/min.mjs'; +export { minBy } from './math/minBy.mjs'; +export { multiply } from './math/multiply.mjs'; +export { parseInt } from './math/parseInt.mjs'; +export { random } from './math/random.mjs'; +export { range } from './math/range.mjs'; +export { rangeRight } from './math/rangeRight.mjs'; +export { round } from './math/round.mjs'; +export { subtract } from './math/subtract.mjs'; +export { sum } from './math/sum.mjs'; +export { sumBy } from './math/sumBy.mjs'; +export { isEqual } from '../predicate/isEqual.mjs'; +export { identity } from './function/identity.mjs'; +export { noop } from './function/noop.mjs'; +export { assign } from './object/assign.mjs'; +export { assignIn, assignIn as extend } from './object/assignIn.mjs'; +export { assignInWith, assignInWith as extendWith } from './object/assignInWith.mjs'; +export { assignWith } from './object/assignWith.mjs'; +export { at } from './object/at.mjs'; +export { clone } from './object/clone.mjs'; +export { cloneDeep } from './object/cloneDeep.mjs'; +export { cloneDeepWith } from './object/cloneDeepWith.mjs'; +export { cloneWith } from './object/cloneWith.mjs'; +export { create } from './object/create.mjs'; +export { defaults } from './object/defaults.mjs'; +export { defaultsDeep } from './object/defaultsDeep.mjs'; +export { findKey } from './object/findKey.mjs'; +export { findLastKey } from './object/findLastKey.mjs'; +export { forIn } from './object/forIn.mjs'; +export { forInRight } from './object/forInRight.mjs'; +export { forOwn } from './object/forOwn.mjs'; +export { forOwnRight } from './object/forOwnRight.mjs'; +export { fromPairs } from './object/fromPairs.mjs'; +export { functions } from './object/functions.mjs'; +export { functionsIn } from './object/functionsIn.mjs'; +export { get } from './object/get.mjs'; +export { has } from './object/has.mjs'; +export { hasIn } from './object/hasIn.mjs'; +export { invert } from './object/invert.mjs'; +export { invertBy } from './object/invertBy.mjs'; +export { keys } from './object/keys.mjs'; +export { keysIn } from './object/keysIn.mjs'; +export { mapKeys } from './object/mapKeys.mjs'; +export { mapValues } from './object/mapValues.mjs'; +export { merge } from './object/merge.mjs'; +export { mergeWith } from './object/mergeWith.mjs'; +export { omit } from './object/omit.mjs'; +export { omitBy } from './object/omitBy.mjs'; +export { pick } from './object/pick.mjs'; +export { pickBy } from './object/pickBy.mjs'; +export { property } from './object/property.mjs'; +export { propertyOf } from './object/propertyOf.mjs'; +export { result } from './object/result.mjs'; +export { set } from './object/set.mjs'; +export { setWith } from './object/setWith.mjs'; +export { toDefaulted } from './object/toDefaulted.mjs'; +export { toPairs } from './object/toPairs.mjs'; +export { toPairsIn } from './object/toPairsIn.mjs'; +export { transform } from './object/transform.mjs'; +export { unset } from './object/unset.mjs'; +export { update } from './object/update.mjs'; +export { updateWith } from './object/updateWith.mjs'; +export { values } from './object/values.mjs'; +export { valuesIn } from './object/valuesIn.mjs'; +export { isFunction } from './predicate/isFunction.mjs'; +export { isLength } from './predicate/isLength.mjs'; +export { isMatchWith } from './predicate/isMatchWith.mjs'; +export { isNative } from './predicate/isNative.mjs'; +export { isNull } from './predicate/isNull.mjs'; +export { isUndefined } from './predicate/isUndefined.mjs'; +export { conforms } from './predicate/conforms.mjs'; +export { conformsTo } from './predicate/conformsTo.mjs'; +export { isArguments } from './predicate/isArguments.mjs'; +export { isArray } from './predicate/isArray.mjs'; +export { isArrayBuffer } from './predicate/isArrayBuffer.mjs'; +export { isArrayLike } from './predicate/isArrayLike.mjs'; +export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs'; +export { isBoolean } from './predicate/isBoolean.mjs'; +export { isBuffer } from './predicate/isBuffer.mjs'; +export { isDate } from './predicate/isDate.mjs'; +export { isElement } from './predicate/isElement.mjs'; +export { isEmpty } from './predicate/isEmpty.mjs'; +export { isEqualWith } from './predicate/isEqualWith.mjs'; +export { isError } from './predicate/isError.mjs'; +export { isFinite } from './predicate/isFinite.mjs'; +export { isInteger } from './predicate/isInteger.mjs'; +export { isMap } from './predicate/isMap.mjs'; +export { isMatch } from './predicate/isMatch.mjs'; +export { isNaN } from './predicate/isNaN.mjs'; +export { isNil } from './predicate/isNil.mjs'; +export { isNumber } from './predicate/isNumber.mjs'; +export { isObject } from './predicate/isObject.mjs'; +export { isObjectLike } from './predicate/isObjectLike.mjs'; +export { isPlainObject } from './predicate/isPlainObject.mjs'; +export { isRegExp } from './predicate/isRegExp.mjs'; +export { isSafeInteger } from './predicate/isSafeInteger.mjs'; +export { isSet } from './predicate/isSet.mjs'; +export { isString } from './predicate/isString.mjs'; +export { isSymbol } from './predicate/isSymbol.mjs'; +export { isTypedArray } from './predicate/isTypedArray.mjs'; +export { isWeakMap } from './predicate/isWeakMap.mjs'; +export { isWeakSet } from './predicate/isWeakSet.mjs'; +export { matches } from './predicate/matches.mjs'; +export { matchesProperty } from './predicate/matchesProperty.mjs'; +export { capitalize } from './string/capitalize.mjs'; +export { bindAll } from './util/bindAll.mjs'; +export { camelCase } from './string/camelCase.mjs'; +export { deburr } from './string/deburr.mjs'; +export { endsWith } from './string/endsWith.mjs'; +export { escape } from './string/escape.mjs'; +export { escapeRegExp } from './string/escapeRegExp.mjs'; +export { kebabCase } from './string/kebabCase.mjs'; +export { lowerCase } from './string/lowerCase.mjs'; +export { lowerFirst } from './string/lowerFirst.mjs'; +export { pad } from './string/pad.mjs'; +export { padEnd } from './string/padEnd.mjs'; +export { padStart } from './string/padStart.mjs'; +export { repeat } from './string/repeat.mjs'; +export { replace } from './string/replace.mjs'; +export { snakeCase } from './string/snakeCase.mjs'; +export { split } from './string/split.mjs'; +export { startCase } from './string/startCase.mjs'; +export { startsWith } from './string/startsWith.mjs'; +export { template, templateSettings } from './string/template.mjs'; +export { toLower } from './string/toLower.mjs'; +export { toUpper } from './string/toUpper.mjs'; +export { trim } from './string/trim.mjs'; +export { trimEnd } from './string/trimEnd.mjs'; +export { trimStart } from './string/trimStart.mjs'; +export { truncate } from './string/truncate.mjs'; +export { unescape } from './string/unescape.mjs'; +export { upperCase } from './string/upperCase.mjs'; +export { upperFirst } from './string/upperFirst.mjs'; +export { words } from './string/words.mjs'; +export { cond } from './util/cond.mjs'; +export { constant } from './util/constant.mjs'; +export { defaultTo } from './util/defaultTo.mjs'; +export { eq } from './util/eq.mjs'; +export { gt } from './util/gt.mjs'; +export { gte } from './util/gte.mjs'; +export { invoke } from './util/invoke.mjs'; +export { iteratee } from './util/iteratee.mjs'; +export { lt } from './util/lt.mjs'; +export { lte } from './util/lte.mjs'; +export { method } from './util/method.mjs'; +export { methodOf } from './util/methodOf.mjs'; +export { now } from './util/now.mjs'; +export { over } from './util/over.mjs'; +export { overEvery } from './util/overEvery.mjs'; +export { overSome } from './util/overSome.mjs'; +export { stubArray } from './util/stubArray.mjs'; +export { stubFalse } from './util/stubFalse.mjs'; +export { stubObject } from './util/stubObject.mjs'; +export { stubString } from './util/stubString.mjs'; +export { stubTrue } from './util/stubTrue.mjs'; +export { times } from './util/times.mjs'; +export { toArray } from './util/toArray.mjs'; +export { toFinite } from './util/toFinite.mjs'; +export { toInteger } from './util/toInteger.mjs'; +export { toLength } from './util/toLength.mjs'; +export { toNumber } from './util/toNumber.mjs'; +export { toPath } from './util/toPath.mjs'; +export { toPlainObject } from './util/toPlainObject.mjs'; +export { toSafeInteger } from './util/toSafeInteger.mjs'; +export { toString } from './util/toString.mjs'; +export { uniqueId } from './util/uniqueId.mjs'; +export { toolkit as default } from './toolkit.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b140241ab4c712ce125d911d24a9b137154e04e6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.d.ts @@ -0,0 +1,292 @@ +export { castArray } from './array/castArray.js'; +export { chunk } from './array/chunk.js'; +export { compact } from './array/compact.js'; +export { concat } from './array/concat.js'; +export { countBy } from './array/countBy.js'; +export { difference } from './array/difference.js'; +export { differenceBy } from './array/differenceBy.js'; +export { differenceWith } from './array/differenceWith.js'; +export { drop } from './array/drop.js'; +export { dropRight } from './array/dropRight.js'; +export { dropRightWhile } from './array/dropRightWhile.js'; +export { dropWhile } from './array/dropWhile.js'; +export { forEach as each, forEach } from './array/forEach.js'; +export { forEachRight as eachRight, forEachRight } from './array/forEachRight.js'; +export { every } from './array/every.js'; +export { fill } from './array/fill.js'; +export { filter } from './array/filter.js'; +export { find } from './array/find.js'; +export { findIndex } from './array/findIndex.js'; +export { findLast } from './array/findLast.js'; +export { findLastIndex } from './array/findLastIndex.js'; +export { head as first, head } from './array/head.js'; +export { flatMap } from './array/flatMap.js'; +export { flatMapDeep } from './array/flatMapDeep.js'; +export { flatMapDepth } from './array/flatMapDepth.js'; +export { flatten } from './array/flatten.js'; +export { flattenDeep } from './array/flattenDeep.js'; +export { flattenDepth } from './array/flattenDepth.js'; +export { groupBy } from './array/groupBy.js'; +export { includes } from './array/includes.js'; +export { indexOf } from './array/indexOf.js'; +export { initial } from './array/initial.js'; +export { intersection } from './array/intersection.js'; +export { intersectionBy } from './array/intersectionBy.js'; +export { intersectionWith } from './array/intersectionWith.js'; +export { invokeMap } from './array/invokeMap.js'; +export { join } from './array/join.js'; +export { keyBy } from './array/keyBy.js'; +export { last } from './array/last.js'; +export { lastIndexOf } from './array/lastIndexOf.js'; +export { map } from './array/map.js'; +export { nth } from './array/nth.js'; +export { orderBy } from './array/orderBy.js'; +export { partition } from './array/partition.js'; +export { pull } from './array/pull.js'; +export { pullAll } from './array/pullAll.js'; +export { pullAllBy } from './array/pullAllBy.js'; +export { pullAllWith } from './array/pullAllWith.js'; +export { pullAt } from './array/pullAt.js'; +export { reduce } from './array/reduce.js'; +export { reduceRight } from './array/reduceRight.js'; +export { reject } from './array/reject.js'; +export { remove } from './array/remove.js'; +export { reverse } from './array/reverse.js'; +export { sample } from './array/sample.js'; +export { sampleSize } from './array/sampleSize.js'; +export { shuffle } from './array/shuffle.js'; +export { size } from './array/size.js'; +export { slice } from './array/slice.js'; +export { some } from './array/some.js'; +export { sortBy } from './array/sortBy.js'; +export { sortedIndex } from './array/sortedIndex.js'; +export { sortedIndexBy } from './array/sortedIndexBy.js'; +export { sortedIndexOf } from './array/sortedIndexOf.js'; +export { sortedLastIndex } from './array/sortedLastIndex.js'; +export { sortedLastIndexBy } from './array/sortedLastIndexBy.js'; +export { sortedLastIndexOf } from './array/sortedLastIndexOf.js'; +export { tail } from './array/tail.js'; +export { take } from './array/take.js'; +export { takeRight } from './array/takeRight.js'; +export { takeRightWhile } from './array/takeRightWhile.js'; +export { takeWhile } from './array/takeWhile.js'; +export { union } from './array/union.js'; +export { unionBy } from './array/unionBy.js'; +export { unionWith } from './array/unionWith.js'; +export { uniq } from './array/uniq.js'; +export { uniqBy } from './array/uniqBy.js'; +export { uniqWith } from './array/uniqWith.js'; +export { unzip } from './array/unzip.js'; +export { unzipWith } from './array/unzipWith.js'; +export { without } from './array/without.js'; +export { xor } from './array/xor.js'; +export { xorBy } from './array/xorBy.js'; +export { xorWith } from './array/xorWith.js'; +export { zip } from './array/zip.js'; +export { zipObject } from './array/zipObject.js'; +export { zipObjectDeep } from './array/zipObjectDeep.js'; +export { zipWith } from './array/zipWith.js'; +export { after } from './function/after.js'; +export { ary } from './function/ary.js'; +export { attempt } from './function/attempt.js'; +export { before } from './function/before.js'; +export { bind } from './function/bind.js'; +export { bindKey } from './function/bindKey.js'; +export { curry } from './function/curry.js'; +export { curryRight } from './function/curryRight.js'; +export { DebouncedFunc, debounce } from './function/debounce.js'; +export { defer } from './function/defer.js'; +export { delay } from './function/delay.js'; +export { flip } from './function/flip.js'; +export { flow } from './function/flow.js'; +export { flowRight } from './function/flowRight.js'; +export { memoize } from './function/memoize.js'; +export { negate } from './function/negate.js'; +export { nthArg } from './function/nthArg.js'; +export { once } from './function/once.js'; +export { overArgs } from './function/overArgs.js'; +export { partial } from './function/partial.js'; +export { partialRight } from './function/partialRight.js'; +export { rearg } from './function/rearg.js'; +export { rest } from './function/rest.js'; +export { spread } from './function/spread.js'; +export { throttle } from './function/throttle.js'; +export { unary } from './function/unary.js'; +export { wrap } from './function/wrap.js'; +export { add } from './math/add.js'; +export { ceil } from './math/ceil.js'; +export { clamp } from './math/clamp.js'; +export { divide } from './math/divide.js'; +export { floor } from './math/floor.js'; +export { inRange } from './math/inRange.js'; +export { max } from './math/max.js'; +export { maxBy } from './math/maxBy.js'; +export { mean } from './math/mean.js'; +export { meanBy } from './math/meanBy.js'; +export { min } from './math/min.js'; +export { minBy } from './math/minBy.js'; +export { multiply } from './math/multiply.js'; +export { parseInt } from './math/parseInt.js'; +export { random } from './math/random.js'; +export { range } from './math/range.js'; +export { rangeRight } from './math/rangeRight.js'; +export { round } from './math/round.js'; +export { subtract } from './math/subtract.js'; +export { sum } from './math/sum.js'; +export { sumBy } from './math/sumBy.js'; +export { isEqual } from '../predicate/isEqual.js'; +export { identity } from './function/identity.js'; +export { noop } from './function/noop.js'; +export { assign } from './object/assign.js'; +export { assignIn, assignIn as extend } from './object/assignIn.js'; +export { assignInWith, assignInWith as extendWith } from './object/assignInWith.js'; +export { assignWith } from './object/assignWith.js'; +export { at } from './object/at.js'; +export { clone } from './object/clone.js'; +export { cloneDeep } from './object/cloneDeep.js'; +export { cloneDeepWith } from './object/cloneDeepWith.js'; +export { cloneWith } from './object/cloneWith.js'; +export { create } from './object/create.js'; +export { defaults } from './object/defaults.js'; +export { defaultsDeep } from './object/defaultsDeep.js'; +export { findKey } from './object/findKey.js'; +export { findLastKey } from './object/findLastKey.js'; +export { forIn } from './object/forIn.js'; +export { forInRight } from './object/forInRight.js'; +export { forOwn } from './object/forOwn.js'; +export { forOwnRight } from './object/forOwnRight.js'; +export { fromPairs } from './object/fromPairs.js'; +export { functions } from './object/functions.js'; +export { functionsIn } from './object/functionsIn.js'; +export { get } from './object/get.js'; +export { has } from './object/has.js'; +export { hasIn } from './object/hasIn.js'; +export { invert } from './object/invert.js'; +export { invertBy } from './object/invertBy.js'; +export { keys } from './object/keys.js'; +export { keysIn } from './object/keysIn.js'; +export { mapKeys } from './object/mapKeys.js'; +export { mapValues } from './object/mapValues.js'; +export { merge } from './object/merge.js'; +export { mergeWith } from './object/mergeWith.js'; +export { omit } from './object/omit.js'; +export { omitBy } from './object/omitBy.js'; +export { pick } from './object/pick.js'; +export { pickBy } from './object/pickBy.js'; +export { property } from './object/property.js'; +export { propertyOf } from './object/propertyOf.js'; +export { result } from './object/result.js'; +export { set } from './object/set.js'; +export { setWith } from './object/setWith.js'; +export { toDefaulted } from './object/toDefaulted.js'; +export { toPairs } from './object/toPairs.js'; +export { toPairsIn } from './object/toPairsIn.js'; +export { transform } from './object/transform.js'; +export { unset } from './object/unset.js'; +export { update } from './object/update.js'; +export { updateWith } from './object/updateWith.js'; +export { values } from './object/values.js'; +export { valuesIn } from './object/valuesIn.js'; +export { isFunction } from './predicate/isFunction.js'; +export { isLength } from './predicate/isLength.js'; +export { isMatchWith } from './predicate/isMatchWith.js'; +export { isNative } from './predicate/isNative.js'; +export { isNull } from './predicate/isNull.js'; +export { isUndefined } from './predicate/isUndefined.js'; +export { conforms } from './predicate/conforms.js'; +export { conformsTo } from './predicate/conformsTo.js'; +export { isArguments } from './predicate/isArguments.js'; +export { isArray } from './predicate/isArray.js'; +export { isArrayBuffer } from './predicate/isArrayBuffer.js'; +export { isArrayLike } from './predicate/isArrayLike.js'; +export { isArrayLikeObject } from './predicate/isArrayLikeObject.js'; +export { isBoolean } from './predicate/isBoolean.js'; +export { isBuffer } from './predicate/isBuffer.js'; +export { isDate } from './predicate/isDate.js'; +export { isElement } from './predicate/isElement.js'; +export { isEmpty } from './predicate/isEmpty.js'; +export { isEqualWith } from './predicate/isEqualWith.js'; +export { isError } from './predicate/isError.js'; +export { isFinite } from './predicate/isFinite.js'; +export { isInteger } from './predicate/isInteger.js'; +export { isMap } from './predicate/isMap.js'; +export { isMatch } from './predicate/isMatch.js'; +export { isNaN } from './predicate/isNaN.js'; +export { isNil } from './predicate/isNil.js'; +export { isNumber } from './predicate/isNumber.js'; +export { isObject } from './predicate/isObject.js'; +export { isObjectLike } from './predicate/isObjectLike.js'; +export { isPlainObject } from './predicate/isPlainObject.js'; +export { isRegExp } from './predicate/isRegExp.js'; +export { isSafeInteger } from './predicate/isSafeInteger.js'; +export { isSet } from './predicate/isSet.js'; +export { isString } from './predicate/isString.js'; +export { isSymbol } from './predicate/isSymbol.js'; +export { isTypedArray } from './predicate/isTypedArray.js'; +export { isWeakMap } from './predicate/isWeakMap.js'; +export { isWeakSet } from './predicate/isWeakSet.js'; +export { matches } from './predicate/matches.js'; +export { matchesProperty } from './predicate/matchesProperty.js'; +export { capitalize } from './string/capitalize.js'; +export { bindAll } from './util/bindAll.js'; +export { camelCase } from './string/camelCase.js'; +export { deburr } from './string/deburr.js'; +export { endsWith } from './string/endsWith.js'; +export { escape } from './string/escape.js'; +export { escapeRegExp } from './string/escapeRegExp.js'; +export { kebabCase } from './string/kebabCase.js'; +export { lowerCase } from './string/lowerCase.js'; +export { lowerFirst } from './string/lowerFirst.js'; +export { pad } from './string/pad.js'; +export { padEnd } from './string/padEnd.js'; +export { padStart } from './string/padStart.js'; +export { repeat } from './string/repeat.js'; +export { replace } from './string/replace.js'; +export { snakeCase } from './string/snakeCase.js'; +export { split } from './string/split.js'; +export { startCase } from './string/startCase.js'; +export { startsWith } from './string/startsWith.js'; +export { template, templateSettings } from './string/template.js'; +export { toLower } from './string/toLower.js'; +export { toUpper } from './string/toUpper.js'; +export { trim } from './string/trim.js'; +export { trimEnd } from './string/trimEnd.js'; +export { trimStart } from './string/trimStart.js'; +export { truncate } from './string/truncate.js'; +export { unescape } from './string/unescape.js'; +export { upperCase } from './string/upperCase.js'; +export { upperFirst } from './string/upperFirst.js'; +export { words } from './string/words.js'; +export { cond } from './util/cond.js'; +export { constant } from './util/constant.js'; +export { defaultTo } from './util/defaultTo.js'; +export { eq } from './util/eq.js'; +export { gt } from './util/gt.js'; +export { gte } from './util/gte.js'; +export { invoke } from './util/invoke.js'; +export { iteratee } from './util/iteratee.js'; +export { lt } from './util/lt.js'; +export { lte } from './util/lte.js'; +export { method } from './util/method.js'; +export { methodOf } from './util/methodOf.js'; +export { now } from './util/now.js'; +export { over } from './util/over.js'; +export { overEvery } from './util/overEvery.js'; +export { overSome } from './util/overSome.js'; +export { stubArray } from './util/stubArray.js'; +export { stubFalse } from './util/stubFalse.js'; +export { stubObject } from './util/stubObject.js'; +export { stubString } from './util/stubString.js'; +export { stubTrue } from './util/stubTrue.js'; +export { times } from './util/times.js'; +export { toArray } from './util/toArray.js'; +export { toFinite } from './util/toFinite.js'; +export { toInteger } from './util/toInteger.js'; +export { toLength } from './util/toLength.js'; +export { toNumber } from './util/toNumber.js'; +export { toPath } from './util/toPath.js'; +export { toPlainObject } from './util/toPlainObject.js'; +export { toSafeInteger } from './util/toSafeInteger.js'; +export { toString } from './util/toString.js'; +export { uniqueId } from './util/uniqueId.js'; +export { toolkit as default } from './toolkit.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9c6d181f30e8350e5b10219f556c8964ab398979 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.js @@ -0,0 +1,597 @@ +'use strict'; + +Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } }); + +const castArray = require('./array/castArray.js'); +const chunk = require('./array/chunk.js'); +const compact = require('./array/compact.js'); +const concat = require('./array/concat.js'); +const countBy = require('./array/countBy.js'); +const difference = require('./array/difference.js'); +const differenceBy = require('./array/differenceBy.js'); +const differenceWith = require('./array/differenceWith.js'); +const drop = require('./array/drop.js'); +const dropRight = require('./array/dropRight.js'); +const dropRightWhile = require('./array/dropRightWhile.js'); +const dropWhile = require('./array/dropWhile.js'); +const forEach = require('./array/forEach.js'); +const forEachRight = require('./array/forEachRight.js'); +const every = require('./array/every.js'); +const fill = require('./array/fill.js'); +const filter = require('./array/filter.js'); +const find = require('./array/find.js'); +const findIndex = require('./array/findIndex.js'); +const findLast = require('./array/findLast.js'); +const findLastIndex = require('./array/findLastIndex.js'); +const head = require('./array/head.js'); +const flatMap = require('./array/flatMap.js'); +const flatMapDeep = require('./array/flatMapDeep.js'); +const flatMapDepth = require('./array/flatMapDepth.js'); +const flatten = require('./array/flatten.js'); +const flattenDeep = require('./array/flattenDeep.js'); +const flattenDepth = require('./array/flattenDepth.js'); +const groupBy = require('./array/groupBy.js'); +const includes = require('./array/includes.js'); +const indexOf = require('./array/indexOf.js'); +const initial = require('./array/initial.js'); +const intersection = require('./array/intersection.js'); +const intersectionBy = require('./array/intersectionBy.js'); +const intersectionWith = require('./array/intersectionWith.js'); +const invokeMap = require('./array/invokeMap.js'); +const join = require('./array/join.js'); +const keyBy = require('./array/keyBy.js'); +const last = require('./array/last.js'); +const lastIndexOf = require('./array/lastIndexOf.js'); +const map = require('./array/map.js'); +const nth = require('./array/nth.js'); +const orderBy = require('./array/orderBy.js'); +const partition = require('./array/partition.js'); +const pull = require('./array/pull.js'); +const pullAll = require('./array/pullAll.js'); +const pullAllBy = require('./array/pullAllBy.js'); +const pullAllWith = require('./array/pullAllWith.js'); +const pullAt = require('./array/pullAt.js'); +const reduce = require('./array/reduce.js'); +const reduceRight = require('./array/reduceRight.js'); +const reject = require('./array/reject.js'); +const remove = require('./array/remove.js'); +const reverse = require('./array/reverse.js'); +const sample = require('./array/sample.js'); +const sampleSize = require('./array/sampleSize.js'); +const shuffle = require('./array/shuffle.js'); +const size = require('./array/size.js'); +const slice = require('./array/slice.js'); +const some = require('./array/some.js'); +const sortBy = require('./array/sortBy.js'); +const sortedIndex = require('./array/sortedIndex.js'); +const sortedIndexBy = require('./array/sortedIndexBy.js'); +const sortedIndexOf = require('./array/sortedIndexOf.js'); +const sortedLastIndex = require('./array/sortedLastIndex.js'); +const sortedLastIndexBy = require('./array/sortedLastIndexBy.js'); +const sortedLastIndexOf = require('./array/sortedLastIndexOf.js'); +const tail = require('./array/tail.js'); +const take = require('./array/take.js'); +const takeRight = require('./array/takeRight.js'); +const takeRightWhile = require('./array/takeRightWhile.js'); +const takeWhile = require('./array/takeWhile.js'); +const union = require('./array/union.js'); +const unionBy = require('./array/unionBy.js'); +const unionWith = require('./array/unionWith.js'); +const uniq = require('./array/uniq.js'); +const uniqBy = require('./array/uniqBy.js'); +const uniqWith = require('./array/uniqWith.js'); +const unzip = require('./array/unzip.js'); +const unzipWith = require('./array/unzipWith.js'); +const without = require('./array/without.js'); +const xor = require('./array/xor.js'); +const xorBy = require('./array/xorBy.js'); +const xorWith = require('./array/xorWith.js'); +const zip = require('./array/zip.js'); +const zipObject = require('./array/zipObject.js'); +const zipObjectDeep = require('./array/zipObjectDeep.js'); +const zipWith = require('./array/zipWith.js'); +const after = require('./function/after.js'); +const ary = require('./function/ary.js'); +const attempt = require('./function/attempt.js'); +const before = require('./function/before.js'); +const bind = require('./function/bind.js'); +const bindKey = require('./function/bindKey.js'); +const curry = require('./function/curry.js'); +const curryRight = require('./function/curryRight.js'); +const debounce = require('./function/debounce.js'); +const defer = require('./function/defer.js'); +const delay = require('./function/delay.js'); +const flip = require('./function/flip.js'); +const flow = require('./function/flow.js'); +const flowRight = require('./function/flowRight.js'); +const memoize = require('./function/memoize.js'); +const negate = require('./function/negate.js'); +const nthArg = require('./function/nthArg.js'); +const once = require('./function/once.js'); +const overArgs = require('./function/overArgs.js'); +const partial = require('./function/partial.js'); +const partialRight = require('./function/partialRight.js'); +const rearg = require('./function/rearg.js'); +const rest = require('./function/rest.js'); +const spread = require('./function/spread.js'); +const throttle = require('./function/throttle.js'); +const unary = require('./function/unary.js'); +const wrap = require('./function/wrap.js'); +const add = require('./math/add.js'); +const ceil = require('./math/ceil.js'); +const clamp = require('./math/clamp.js'); +const divide = require('./math/divide.js'); +const floor = require('./math/floor.js'); +const inRange = require('./math/inRange.js'); +const max = require('./math/max.js'); +const maxBy = require('./math/maxBy.js'); +const mean = require('./math/mean.js'); +const meanBy = require('./math/meanBy.js'); +const min = require('./math/min.js'); +const minBy = require('./math/minBy.js'); +const multiply = require('./math/multiply.js'); +const parseInt = require('./math/parseInt.js'); +const random = require('./math/random.js'); +const range = require('./math/range.js'); +const rangeRight = require('./math/rangeRight.js'); +const round = require('./math/round.js'); +const subtract = require('./math/subtract.js'); +const sum = require('./math/sum.js'); +const sumBy = require('./math/sumBy.js'); +const isEqual = require('../predicate/isEqual.js'); +const identity = require('./function/identity.js'); +const noop = require('./function/noop.js'); +const assign = require('./object/assign.js'); +const assignIn = require('./object/assignIn.js'); +const assignInWith = require('./object/assignInWith.js'); +const assignWith = require('./object/assignWith.js'); +const at = require('./object/at.js'); +const clone = require('./object/clone.js'); +const cloneDeep = require('./object/cloneDeep.js'); +const cloneDeepWith = require('./object/cloneDeepWith.js'); +const cloneWith = require('./object/cloneWith.js'); +const create = require('./object/create.js'); +const defaults = require('./object/defaults.js'); +const defaultsDeep = require('./object/defaultsDeep.js'); +const findKey = require('./object/findKey.js'); +const findLastKey = require('./object/findLastKey.js'); +const forIn = require('./object/forIn.js'); +const forInRight = require('./object/forInRight.js'); +const forOwn = require('./object/forOwn.js'); +const forOwnRight = require('./object/forOwnRight.js'); +const fromPairs = require('./object/fromPairs.js'); +const functions = require('./object/functions.js'); +const functionsIn = require('./object/functionsIn.js'); +const get = require('./object/get.js'); +const has = require('./object/has.js'); +const hasIn = require('./object/hasIn.js'); +const invert = require('./object/invert.js'); +const invertBy = require('./object/invertBy.js'); +const keys = require('./object/keys.js'); +const keysIn = require('./object/keysIn.js'); +const mapKeys = require('./object/mapKeys.js'); +const mapValues = require('./object/mapValues.js'); +const merge = require('./object/merge.js'); +const mergeWith = require('./object/mergeWith.js'); +const omit = require('./object/omit.js'); +const omitBy = require('./object/omitBy.js'); +const pick = require('./object/pick.js'); +const pickBy = require('./object/pickBy.js'); +const property = require('./object/property.js'); +const propertyOf = require('./object/propertyOf.js'); +const result = require('./object/result.js'); +const set = require('./object/set.js'); +const setWith = require('./object/setWith.js'); +const toDefaulted = require('./object/toDefaulted.js'); +const toPairs = require('./object/toPairs.js'); +const toPairsIn = require('./object/toPairsIn.js'); +const transform = require('./object/transform.js'); +const unset = require('./object/unset.js'); +const update = require('./object/update.js'); +const updateWith = require('./object/updateWith.js'); +const values = require('./object/values.js'); +const valuesIn = require('./object/valuesIn.js'); +const isFunction = require('./predicate/isFunction.js'); +const isLength = require('./predicate/isLength.js'); +const isMatchWith = require('./predicate/isMatchWith.js'); +const isNative = require('./predicate/isNative.js'); +const isNull = require('./predicate/isNull.js'); +const isUndefined = require('./predicate/isUndefined.js'); +const conforms = require('./predicate/conforms.js'); +const conformsTo = require('./predicate/conformsTo.js'); +const isArguments = require('./predicate/isArguments.js'); +const isArray = require('./predicate/isArray.js'); +const isArrayBuffer = require('./predicate/isArrayBuffer.js'); +const isArrayLike = require('./predicate/isArrayLike.js'); +const isArrayLikeObject = require('./predicate/isArrayLikeObject.js'); +const isBoolean = require('./predicate/isBoolean.js'); +const isBuffer = require('./predicate/isBuffer.js'); +const isDate = require('./predicate/isDate.js'); +const isElement = require('./predicate/isElement.js'); +const isEmpty = require('./predicate/isEmpty.js'); +const isEqualWith = require('./predicate/isEqualWith.js'); +const isError = require('./predicate/isError.js'); +const isFinite = require('./predicate/isFinite.js'); +const isInteger = require('./predicate/isInteger.js'); +const isMap = require('./predicate/isMap.js'); +const isMatch = require('./predicate/isMatch.js'); +const isNaN = require('./predicate/isNaN.js'); +const isNil = require('./predicate/isNil.js'); +const isNumber = require('./predicate/isNumber.js'); +const isObject = require('./predicate/isObject.js'); +const isObjectLike = require('./predicate/isObjectLike.js'); +const isPlainObject = require('./predicate/isPlainObject.js'); +const isRegExp = require('./predicate/isRegExp.js'); +const isSafeInteger = require('./predicate/isSafeInteger.js'); +const isSet = require('./predicate/isSet.js'); +const isString = require('./predicate/isString.js'); +const isSymbol = require('./predicate/isSymbol.js'); +const isTypedArray = require('./predicate/isTypedArray.js'); +const isWeakMap = require('./predicate/isWeakMap.js'); +const isWeakSet = require('./predicate/isWeakSet.js'); +const matches = require('./predicate/matches.js'); +const matchesProperty = require('./predicate/matchesProperty.js'); +const capitalize = require('./string/capitalize.js'); +const bindAll = require('./util/bindAll.js'); +const camelCase = require('./string/camelCase.js'); +const deburr = require('./string/deburr.js'); +const endsWith = require('./string/endsWith.js'); +const escape = require('./string/escape.js'); +const escapeRegExp = require('./string/escapeRegExp.js'); +const kebabCase = require('./string/kebabCase.js'); +const lowerCase = require('./string/lowerCase.js'); +const lowerFirst = require('./string/lowerFirst.js'); +const pad = require('./string/pad.js'); +const padEnd = require('./string/padEnd.js'); +const padStart = require('./string/padStart.js'); +const repeat = require('./string/repeat.js'); +const replace = require('./string/replace.js'); +const snakeCase = require('./string/snakeCase.js'); +const split = require('./string/split.js'); +const startCase = require('./string/startCase.js'); +const startsWith = require('./string/startsWith.js'); +const template = require('./string/template.js'); +const toLower = require('./string/toLower.js'); +const toUpper = require('./string/toUpper.js'); +const trim = require('./string/trim.js'); +const trimEnd = require('./string/trimEnd.js'); +const trimStart = require('./string/trimStart.js'); +const truncate = require('./string/truncate.js'); +const unescape = require('./string/unescape.js'); +const upperCase = require('./string/upperCase.js'); +const upperFirst = require('./string/upperFirst.js'); +const words = require('./string/words.js'); +const cond = require('./util/cond.js'); +const constant = require('./util/constant.js'); +const defaultTo = require('./util/defaultTo.js'); +const eq = require('./util/eq.js'); +const gt = require('./util/gt.js'); +const gte = require('./util/gte.js'); +const invoke = require('./util/invoke.js'); +const iteratee = require('./util/iteratee.js'); +const lt = require('./util/lt.js'); +const lte = require('./util/lte.js'); +const method = require('./util/method.js'); +const methodOf = require('./util/methodOf.js'); +const now = require('./util/now.js'); +const over = require('./util/over.js'); +const overEvery = require('./util/overEvery.js'); +const overSome = require('./util/overSome.js'); +const stubArray = require('./util/stubArray.js'); +const stubFalse = require('./util/stubFalse.js'); +const stubObject = require('./util/stubObject.js'); +const stubString = require('./util/stubString.js'); +const stubTrue = require('./util/stubTrue.js'); +const times = require('./util/times.js'); +const toArray = require('./util/toArray.js'); +const toFinite = require('./util/toFinite.js'); +const toInteger = require('./util/toInteger.js'); +const toLength = require('./util/toLength.js'); +const toNumber = require('./util/toNumber.js'); +const toPath = require('./util/toPath.js'); +const toPlainObject = require('./util/toPlainObject.js'); +const toSafeInteger = require('./util/toSafeInteger.js'); +const toString = require('./util/toString.js'); +const uniqueId = require('./util/uniqueId.js'); +const toolkit = require('./toolkit.js'); + + + +exports.castArray = castArray.castArray; +exports.chunk = chunk.chunk; +exports.compact = compact.compact; +exports.concat = concat.concat; +exports.countBy = countBy.countBy; +exports.difference = difference.difference; +exports.differenceBy = differenceBy.differenceBy; +exports.differenceWith = differenceWith.differenceWith; +exports.drop = drop.drop; +exports.dropRight = dropRight.dropRight; +exports.dropRightWhile = dropRightWhile.dropRightWhile; +exports.dropWhile = dropWhile.dropWhile; +exports.each = forEach.forEach; +exports.forEach = forEach.forEach; +exports.eachRight = forEachRight.forEachRight; +exports.forEachRight = forEachRight.forEachRight; +exports.every = every.every; +exports.fill = fill.fill; +exports.filter = filter.filter; +exports.find = find.find; +exports.findIndex = findIndex.findIndex; +exports.findLast = findLast.findLast; +exports.findLastIndex = findLastIndex.findLastIndex; +exports.first = head.head; +exports.head = head.head; +exports.flatMap = flatMap.flatMap; +exports.flatMapDeep = flatMapDeep.flatMapDeep; +exports.flatMapDepth = flatMapDepth.flatMapDepth; +exports.flatten = flatten.flatten; +exports.flattenDeep = flattenDeep.flattenDeep; +exports.flattenDepth = flattenDepth.flattenDepth; +exports.groupBy = groupBy.groupBy; +exports.includes = includes.includes; +exports.indexOf = indexOf.indexOf; +exports.initial = initial.initial; +exports.intersection = intersection.intersection; +exports.intersectionBy = intersectionBy.intersectionBy; +exports.intersectionWith = intersectionWith.intersectionWith; +exports.invokeMap = invokeMap.invokeMap; +exports.join = join.join; +exports.keyBy = keyBy.keyBy; +exports.last = last.last; +exports.lastIndexOf = lastIndexOf.lastIndexOf; +exports.map = map.map; +exports.nth = nth.nth; +exports.orderBy = orderBy.orderBy; +exports.partition = partition.partition; +exports.pull = pull.pull; +exports.pullAll = pullAll.pullAll; +exports.pullAllBy = pullAllBy.pullAllBy; +exports.pullAllWith = pullAllWith.pullAllWith; +exports.pullAt = pullAt.pullAt; +exports.reduce = reduce.reduce; +exports.reduceRight = reduceRight.reduceRight; +exports.reject = reject.reject; +exports.remove = remove.remove; +exports.reverse = reverse.reverse; +exports.sample = sample.sample; +exports.sampleSize = sampleSize.sampleSize; +exports.shuffle = shuffle.shuffle; +exports.size = size.size; +exports.slice = slice.slice; +exports.some = some.some; +exports.sortBy = sortBy.sortBy; +exports.sortedIndex = sortedIndex.sortedIndex; +exports.sortedIndexBy = sortedIndexBy.sortedIndexBy; +exports.sortedIndexOf = sortedIndexOf.sortedIndexOf; +exports.sortedLastIndex = sortedLastIndex.sortedLastIndex; +exports.sortedLastIndexBy = sortedLastIndexBy.sortedLastIndexBy; +exports.sortedLastIndexOf = sortedLastIndexOf.sortedLastIndexOf; +exports.tail = tail.tail; +exports.take = take.take; +exports.takeRight = takeRight.takeRight; +exports.takeRightWhile = takeRightWhile.takeRightWhile; +exports.takeWhile = takeWhile.takeWhile; +exports.union = union.union; +exports.unionBy = unionBy.unionBy; +exports.unionWith = unionWith.unionWith; +exports.uniq = uniq.uniq; +exports.uniqBy = uniqBy.uniqBy; +exports.uniqWith = uniqWith.uniqWith; +exports.unzip = unzip.unzip; +exports.unzipWith = unzipWith.unzipWith; +exports.without = without.without; +exports.xor = xor.xor; +exports.xorBy = xorBy.xorBy; +exports.xorWith = xorWith.xorWith; +exports.zip = zip.zip; +exports.zipObject = zipObject.zipObject; +exports.zipObjectDeep = zipObjectDeep.zipObjectDeep; +exports.zipWith = zipWith.zipWith; +exports.after = after.after; +exports.ary = ary.ary; +exports.attempt = attempt.attempt; +exports.before = before.before; +exports.bind = bind.bind; +exports.bindKey = bindKey.bindKey; +exports.curry = curry.curry; +exports.curryRight = curryRight.curryRight; +exports.debounce = debounce.debounce; +exports.defer = defer.defer; +exports.delay = delay.delay; +exports.flip = flip.flip; +exports.flow = flow.flow; +exports.flowRight = flowRight.flowRight; +exports.memoize = memoize.memoize; +exports.negate = negate.negate; +exports.nthArg = nthArg.nthArg; +exports.once = once.once; +exports.overArgs = overArgs.overArgs; +exports.partial = partial.partial; +exports.partialRight = partialRight.partialRight; +exports.rearg = rearg.rearg; +exports.rest = rest.rest; +exports.spread = spread.spread; +exports.throttle = throttle.throttle; +exports.unary = unary.unary; +exports.wrap = wrap.wrap; +exports.add = add.add; +exports.ceil = ceil.ceil; +exports.clamp = clamp.clamp; +exports.divide = divide.divide; +exports.floor = floor.floor; +exports.inRange = inRange.inRange; +exports.max = max.max; +exports.maxBy = maxBy.maxBy; +exports.mean = mean.mean; +exports.meanBy = meanBy.meanBy; +exports.min = min.min; +exports.minBy = minBy.minBy; +exports.multiply = multiply.multiply; +exports.parseInt = parseInt.parseInt; +exports.random = random.random; +exports.range = range.range; +exports.rangeRight = rangeRight.rangeRight; +exports.round = round.round; +exports.subtract = subtract.subtract; +exports.sum = sum.sum; +exports.sumBy = sumBy.sumBy; +exports.isEqual = isEqual.isEqual; +exports.identity = identity.identity; +exports.noop = noop.noop; +exports.assign = assign.assign; +exports.assignIn = assignIn.assignIn; +exports.extend = assignIn.assignIn; +exports.assignInWith = assignInWith.assignInWith; +exports.extendWith = assignInWith.assignInWith; +exports.assignWith = assignWith.assignWith; +exports.at = at.at; +exports.clone = clone.clone; +exports.cloneDeep = cloneDeep.cloneDeep; +exports.cloneDeepWith = cloneDeepWith.cloneDeepWith; +exports.cloneWith = cloneWith.cloneWith; +exports.create = create.create; +exports.defaults = defaults.defaults; +exports.defaultsDeep = defaultsDeep.defaultsDeep; +exports.findKey = findKey.findKey; +exports.findLastKey = findLastKey.findLastKey; +exports.forIn = forIn.forIn; +exports.forInRight = forInRight.forInRight; +exports.forOwn = forOwn.forOwn; +exports.forOwnRight = forOwnRight.forOwnRight; +exports.fromPairs = fromPairs.fromPairs; +exports.functions = functions.functions; +exports.functionsIn = functionsIn.functionsIn; +exports.get = get.get; +exports.has = has.has; +exports.hasIn = hasIn.hasIn; +exports.invert = invert.invert; +exports.invertBy = invertBy.invertBy; +exports.keys = keys.keys; +exports.keysIn = keysIn.keysIn; +exports.mapKeys = mapKeys.mapKeys; +exports.mapValues = mapValues.mapValues; +exports.merge = merge.merge; +exports.mergeWith = mergeWith.mergeWith; +exports.omit = omit.omit; +exports.omitBy = omitBy.omitBy; +exports.pick = pick.pick; +exports.pickBy = pickBy.pickBy; +exports.property = property.property; +exports.propertyOf = propertyOf.propertyOf; +exports.result = result.result; +exports.set = set.set; +exports.setWith = setWith.setWith; +exports.toDefaulted = toDefaulted.toDefaulted; +exports.toPairs = toPairs.toPairs; +exports.toPairsIn = toPairsIn.toPairsIn; +exports.transform = transform.transform; +exports.unset = unset.unset; +exports.update = update.update; +exports.updateWith = updateWith.updateWith; +exports.values = values.values; +exports.valuesIn = valuesIn.valuesIn; +exports.isFunction = isFunction.isFunction; +exports.isLength = isLength.isLength; +exports.isMatchWith = isMatchWith.isMatchWith; +exports.isNative = isNative.isNative; +exports.isNull = isNull.isNull; +exports.isUndefined = isUndefined.isUndefined; +exports.conforms = conforms.conforms; +exports.conformsTo = conformsTo.conformsTo; +exports.isArguments = isArguments.isArguments; +exports.isArray = isArray.isArray; +exports.isArrayBuffer = isArrayBuffer.isArrayBuffer; +exports.isArrayLike = isArrayLike.isArrayLike; +exports.isArrayLikeObject = isArrayLikeObject.isArrayLikeObject; +exports.isBoolean = isBoolean.isBoolean; +exports.isBuffer = isBuffer.isBuffer; +exports.isDate = isDate.isDate; +exports.isElement = isElement.isElement; +exports.isEmpty = isEmpty.isEmpty; +exports.isEqualWith = isEqualWith.isEqualWith; +exports.isError = isError.isError; +exports.isFinite = isFinite.isFinite; +exports.isInteger = isInteger.isInteger; +exports.isMap = isMap.isMap; +exports.isMatch = isMatch.isMatch; +exports.isNaN = isNaN.isNaN; +exports.isNil = isNil.isNil; +exports.isNumber = isNumber.isNumber; +exports.isObject = isObject.isObject; +exports.isObjectLike = isObjectLike.isObjectLike; +exports.isPlainObject = isPlainObject.isPlainObject; +exports.isRegExp = isRegExp.isRegExp; +exports.isSafeInteger = isSafeInteger.isSafeInteger; +exports.isSet = isSet.isSet; +exports.isString = isString.isString; +exports.isSymbol = isSymbol.isSymbol; +exports.isTypedArray = isTypedArray.isTypedArray; +exports.isWeakMap = isWeakMap.isWeakMap; +exports.isWeakSet = isWeakSet.isWeakSet; +exports.matches = matches.matches; +exports.matchesProperty = matchesProperty.matchesProperty; +exports.capitalize = capitalize.capitalize; +exports.bindAll = bindAll.bindAll; +exports.camelCase = camelCase.camelCase; +exports.deburr = deburr.deburr; +exports.endsWith = endsWith.endsWith; +exports.escape = escape.escape; +exports.escapeRegExp = escapeRegExp.escapeRegExp; +exports.kebabCase = kebabCase.kebabCase; +exports.lowerCase = lowerCase.lowerCase; +exports.lowerFirst = lowerFirst.lowerFirst; +exports.pad = pad.pad; +exports.padEnd = padEnd.padEnd; +exports.padStart = padStart.padStart; +exports.repeat = repeat.repeat; +exports.replace = replace.replace; +exports.snakeCase = snakeCase.snakeCase; +exports.split = split.split; +exports.startCase = startCase.startCase; +exports.startsWith = startsWith.startsWith; +exports.template = template.template; +exports.templateSettings = template.templateSettings; +exports.toLower = toLower.toLower; +exports.toUpper = toUpper.toUpper; +exports.trim = trim.trim; +exports.trimEnd = trimEnd.trimEnd; +exports.trimStart = trimStart.trimStart; +exports.truncate = truncate.truncate; +exports.unescape = unescape.unescape; +exports.upperCase = upperCase.upperCase; +exports.upperFirst = upperFirst.upperFirst; +exports.words = words.words; +exports.cond = cond.cond; +exports.constant = constant.constant; +exports.defaultTo = defaultTo.defaultTo; +exports.eq = eq.eq; +exports.gt = gt.gt; +exports.gte = gte.gte; +exports.invoke = invoke.invoke; +exports.iteratee = iteratee.iteratee; +exports.lt = lt.lt; +exports.lte = lte.lte; +exports.method = method.method; +exports.methodOf = methodOf.methodOf; +exports.now = now.now; +exports.over = over.over; +exports.overEvery = overEvery.overEvery; +exports.overSome = overSome.overSome; +exports.stubArray = stubArray.stubArray; +exports.stubFalse = stubFalse.stubFalse; +exports.stubObject = stubObject.stubObject; +exports.stubString = stubString.stubString; +exports.stubTrue = stubTrue.stubTrue; +exports.times = times.times; +exports.toArray = toArray.toArray; +exports.toFinite = toFinite.toFinite; +exports.toInteger = toInteger.toInteger; +exports.toLength = toLength.toLength; +exports.toNumber = toNumber.toNumber; +exports.toPath = toPath.toPath; +exports.toPlainObject = toPlainObject.toPlainObject; +exports.toSafeInteger = toSafeInteger.toSafeInteger; +exports.toString = toString.toString; +exports.uniqueId = uniqueId.uniqueId; +exports.default = toolkit.toolkit; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d17ef371fbd45d2da36cf5fe8f38ec356ec9acc1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/index.mjs @@ -0,0 +1,292 @@ +export { castArray } from './array/castArray.mjs'; +export { chunk } from './array/chunk.mjs'; +export { compact } from './array/compact.mjs'; +export { concat } from './array/concat.mjs'; +export { countBy } from './array/countBy.mjs'; +export { difference } from './array/difference.mjs'; +export { differenceBy } from './array/differenceBy.mjs'; +export { differenceWith } from './array/differenceWith.mjs'; +export { drop } from './array/drop.mjs'; +export { dropRight } from './array/dropRight.mjs'; +export { dropRightWhile } from './array/dropRightWhile.mjs'; +export { dropWhile } from './array/dropWhile.mjs'; +export { forEach as each, forEach } from './array/forEach.mjs'; +export { forEachRight as eachRight, forEachRight } from './array/forEachRight.mjs'; +export { every } from './array/every.mjs'; +export { fill } from './array/fill.mjs'; +export { filter } from './array/filter.mjs'; +export { find } from './array/find.mjs'; +export { findIndex } from './array/findIndex.mjs'; +export { findLast } from './array/findLast.mjs'; +export { findLastIndex } from './array/findLastIndex.mjs'; +export { head as first, head } from './array/head.mjs'; +export { flatMap } from './array/flatMap.mjs'; +export { flatMapDeep } from './array/flatMapDeep.mjs'; +export { flatMapDepth } from './array/flatMapDepth.mjs'; +export { flatten } from './array/flatten.mjs'; +export { flattenDeep } from './array/flattenDeep.mjs'; +export { flattenDepth } from './array/flattenDepth.mjs'; +export { groupBy } from './array/groupBy.mjs'; +export { includes } from './array/includes.mjs'; +export { indexOf } from './array/indexOf.mjs'; +export { initial } from './array/initial.mjs'; +export { intersection } from './array/intersection.mjs'; +export { intersectionBy } from './array/intersectionBy.mjs'; +export { intersectionWith } from './array/intersectionWith.mjs'; +export { invokeMap } from './array/invokeMap.mjs'; +export { join } from './array/join.mjs'; +export { keyBy } from './array/keyBy.mjs'; +export { last } from './array/last.mjs'; +export { lastIndexOf } from './array/lastIndexOf.mjs'; +export { map } from './array/map.mjs'; +export { nth } from './array/nth.mjs'; +export { orderBy } from './array/orderBy.mjs'; +export { partition } from './array/partition.mjs'; +export { pull } from './array/pull.mjs'; +export { pullAll } from './array/pullAll.mjs'; +export { pullAllBy } from './array/pullAllBy.mjs'; +export { pullAllWith } from './array/pullAllWith.mjs'; +export { pullAt } from './array/pullAt.mjs'; +export { reduce } from './array/reduce.mjs'; +export { reduceRight } from './array/reduceRight.mjs'; +export { reject } from './array/reject.mjs'; +export { remove } from './array/remove.mjs'; +export { reverse } from './array/reverse.mjs'; +export { sample } from './array/sample.mjs'; +export { sampleSize } from './array/sampleSize.mjs'; +export { shuffle } from './array/shuffle.mjs'; +export { size } from './array/size.mjs'; +export { slice } from './array/slice.mjs'; +export { some } from './array/some.mjs'; +export { sortBy } from './array/sortBy.mjs'; +export { sortedIndex } from './array/sortedIndex.mjs'; +export { sortedIndexBy } from './array/sortedIndexBy.mjs'; +export { sortedIndexOf } from './array/sortedIndexOf.mjs'; +export { sortedLastIndex } from './array/sortedLastIndex.mjs'; +export { sortedLastIndexBy } from './array/sortedLastIndexBy.mjs'; +export { sortedLastIndexOf } from './array/sortedLastIndexOf.mjs'; +export { tail } from './array/tail.mjs'; +export { take } from './array/take.mjs'; +export { takeRight } from './array/takeRight.mjs'; +export { takeRightWhile } from './array/takeRightWhile.mjs'; +export { takeWhile } from './array/takeWhile.mjs'; +export { union } from './array/union.mjs'; +export { unionBy } from './array/unionBy.mjs'; +export { unionWith } from './array/unionWith.mjs'; +export { uniq } from './array/uniq.mjs'; +export { uniqBy } from './array/uniqBy.mjs'; +export { uniqWith } from './array/uniqWith.mjs'; +export { unzip } from './array/unzip.mjs'; +export { unzipWith } from './array/unzipWith.mjs'; +export { without } from './array/without.mjs'; +export { xor } from './array/xor.mjs'; +export { xorBy } from './array/xorBy.mjs'; +export { xorWith } from './array/xorWith.mjs'; +export { zip } from './array/zip.mjs'; +export { zipObject } from './array/zipObject.mjs'; +export { zipObjectDeep } from './array/zipObjectDeep.mjs'; +export { zipWith } from './array/zipWith.mjs'; +export { after } from './function/after.mjs'; +export { ary } from './function/ary.mjs'; +export { attempt } from './function/attempt.mjs'; +export { before } from './function/before.mjs'; +export { bind } from './function/bind.mjs'; +export { bindKey } from './function/bindKey.mjs'; +export { curry } from './function/curry.mjs'; +export { curryRight } from './function/curryRight.mjs'; +export { debounce } from './function/debounce.mjs'; +export { defer } from './function/defer.mjs'; +export { delay } from './function/delay.mjs'; +export { flip } from './function/flip.mjs'; +export { flow } from './function/flow.mjs'; +export { flowRight } from './function/flowRight.mjs'; +export { memoize } from './function/memoize.mjs'; +export { negate } from './function/negate.mjs'; +export { nthArg } from './function/nthArg.mjs'; +export { once } from './function/once.mjs'; +export { overArgs } from './function/overArgs.mjs'; +export { partial } from './function/partial.mjs'; +export { partialRight } from './function/partialRight.mjs'; +export { rearg } from './function/rearg.mjs'; +export { rest } from './function/rest.mjs'; +export { spread } from './function/spread.mjs'; +export { throttle } from './function/throttle.mjs'; +export { unary } from './function/unary.mjs'; +export { wrap } from './function/wrap.mjs'; +export { add } from './math/add.mjs'; +export { ceil } from './math/ceil.mjs'; +export { clamp } from './math/clamp.mjs'; +export { divide } from './math/divide.mjs'; +export { floor } from './math/floor.mjs'; +export { inRange } from './math/inRange.mjs'; +export { max } from './math/max.mjs'; +export { maxBy } from './math/maxBy.mjs'; +export { mean } from './math/mean.mjs'; +export { meanBy } from './math/meanBy.mjs'; +export { min } from './math/min.mjs'; +export { minBy } from './math/minBy.mjs'; +export { multiply } from './math/multiply.mjs'; +export { parseInt } from './math/parseInt.mjs'; +export { random } from './math/random.mjs'; +export { range } from './math/range.mjs'; +export { rangeRight } from './math/rangeRight.mjs'; +export { round } from './math/round.mjs'; +export { subtract } from './math/subtract.mjs'; +export { sum } from './math/sum.mjs'; +export { sumBy } from './math/sumBy.mjs'; +export { isEqual } from '../predicate/isEqual.mjs'; +export { identity } from './function/identity.mjs'; +export { noop } from './function/noop.mjs'; +export { assign } from './object/assign.mjs'; +export { assignIn, assignIn as extend } from './object/assignIn.mjs'; +export { assignInWith, assignInWith as extendWith } from './object/assignInWith.mjs'; +export { assignWith } from './object/assignWith.mjs'; +export { at } from './object/at.mjs'; +export { clone } from './object/clone.mjs'; +export { cloneDeep } from './object/cloneDeep.mjs'; +export { cloneDeepWith } from './object/cloneDeepWith.mjs'; +export { cloneWith } from './object/cloneWith.mjs'; +export { create } from './object/create.mjs'; +export { defaults } from './object/defaults.mjs'; +export { defaultsDeep } from './object/defaultsDeep.mjs'; +export { findKey } from './object/findKey.mjs'; +export { findLastKey } from './object/findLastKey.mjs'; +export { forIn } from './object/forIn.mjs'; +export { forInRight } from './object/forInRight.mjs'; +export { forOwn } from './object/forOwn.mjs'; +export { forOwnRight } from './object/forOwnRight.mjs'; +export { fromPairs } from './object/fromPairs.mjs'; +export { functions } from './object/functions.mjs'; +export { functionsIn } from './object/functionsIn.mjs'; +export { get } from './object/get.mjs'; +export { has } from './object/has.mjs'; +export { hasIn } from './object/hasIn.mjs'; +export { invert } from './object/invert.mjs'; +export { invertBy } from './object/invertBy.mjs'; +export { keys } from './object/keys.mjs'; +export { keysIn } from './object/keysIn.mjs'; +export { mapKeys } from './object/mapKeys.mjs'; +export { mapValues } from './object/mapValues.mjs'; +export { merge } from './object/merge.mjs'; +export { mergeWith } from './object/mergeWith.mjs'; +export { omit } from './object/omit.mjs'; +export { omitBy } from './object/omitBy.mjs'; +export { pick } from './object/pick.mjs'; +export { pickBy } from './object/pickBy.mjs'; +export { property } from './object/property.mjs'; +export { propertyOf } from './object/propertyOf.mjs'; +export { result } from './object/result.mjs'; +export { set } from './object/set.mjs'; +export { setWith } from './object/setWith.mjs'; +export { toDefaulted } from './object/toDefaulted.mjs'; +export { toPairs } from './object/toPairs.mjs'; +export { toPairsIn } from './object/toPairsIn.mjs'; +export { transform } from './object/transform.mjs'; +export { unset } from './object/unset.mjs'; +export { update } from './object/update.mjs'; +export { updateWith } from './object/updateWith.mjs'; +export { values } from './object/values.mjs'; +export { valuesIn } from './object/valuesIn.mjs'; +export { isFunction } from './predicate/isFunction.mjs'; +export { isLength } from './predicate/isLength.mjs'; +export { isMatchWith } from './predicate/isMatchWith.mjs'; +export { isNative } from './predicate/isNative.mjs'; +export { isNull } from './predicate/isNull.mjs'; +export { isUndefined } from './predicate/isUndefined.mjs'; +export { conforms } from './predicate/conforms.mjs'; +export { conformsTo } from './predicate/conformsTo.mjs'; +export { isArguments } from './predicate/isArguments.mjs'; +export { isArray } from './predicate/isArray.mjs'; +export { isArrayBuffer } from './predicate/isArrayBuffer.mjs'; +export { isArrayLike } from './predicate/isArrayLike.mjs'; +export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs'; +export { isBoolean } from './predicate/isBoolean.mjs'; +export { isBuffer } from './predicate/isBuffer.mjs'; +export { isDate } from './predicate/isDate.mjs'; +export { isElement } from './predicate/isElement.mjs'; +export { isEmpty } from './predicate/isEmpty.mjs'; +export { isEqualWith } from './predicate/isEqualWith.mjs'; +export { isError } from './predicate/isError.mjs'; +export { isFinite } from './predicate/isFinite.mjs'; +export { isInteger } from './predicate/isInteger.mjs'; +export { isMap } from './predicate/isMap.mjs'; +export { isMatch } from './predicate/isMatch.mjs'; +export { isNaN } from './predicate/isNaN.mjs'; +export { isNil } from './predicate/isNil.mjs'; +export { isNumber } from './predicate/isNumber.mjs'; +export { isObject } from './predicate/isObject.mjs'; +export { isObjectLike } from './predicate/isObjectLike.mjs'; +export { isPlainObject } from './predicate/isPlainObject.mjs'; +export { isRegExp } from './predicate/isRegExp.mjs'; +export { isSafeInteger } from './predicate/isSafeInteger.mjs'; +export { isSet } from './predicate/isSet.mjs'; +export { isString } from './predicate/isString.mjs'; +export { isSymbol } from './predicate/isSymbol.mjs'; +export { isTypedArray } from './predicate/isTypedArray.mjs'; +export { isWeakMap } from './predicate/isWeakMap.mjs'; +export { isWeakSet } from './predicate/isWeakSet.mjs'; +export { matches } from './predicate/matches.mjs'; +export { matchesProperty } from './predicate/matchesProperty.mjs'; +export { capitalize } from './string/capitalize.mjs'; +export { bindAll } from './util/bindAll.mjs'; +export { camelCase } from './string/camelCase.mjs'; +export { deburr } from './string/deburr.mjs'; +export { endsWith } from './string/endsWith.mjs'; +export { escape } from './string/escape.mjs'; +export { escapeRegExp } from './string/escapeRegExp.mjs'; +export { kebabCase } from './string/kebabCase.mjs'; +export { lowerCase } from './string/lowerCase.mjs'; +export { lowerFirst } from './string/lowerFirst.mjs'; +export { pad } from './string/pad.mjs'; +export { padEnd } from './string/padEnd.mjs'; +export { padStart } from './string/padStart.mjs'; +export { repeat } from './string/repeat.mjs'; +export { replace } from './string/replace.mjs'; +export { snakeCase } from './string/snakeCase.mjs'; +export { split } from './string/split.mjs'; +export { startCase } from './string/startCase.mjs'; +export { startsWith } from './string/startsWith.mjs'; +export { template, templateSettings } from './string/template.mjs'; +export { toLower } from './string/toLower.mjs'; +export { toUpper } from './string/toUpper.mjs'; +export { trim } from './string/trim.mjs'; +export { trimEnd } from './string/trimEnd.mjs'; +export { trimStart } from './string/trimStart.mjs'; +export { truncate } from './string/truncate.mjs'; +export { unescape } from './string/unescape.mjs'; +export { upperCase } from './string/upperCase.mjs'; +export { upperFirst } from './string/upperFirst.mjs'; +export { words } from './string/words.mjs'; +export { cond } from './util/cond.mjs'; +export { constant } from './util/constant.mjs'; +export { defaultTo } from './util/defaultTo.mjs'; +export { eq } from './util/eq.mjs'; +export { gt } from './util/gt.mjs'; +export { gte } from './util/gte.mjs'; +export { invoke } from './util/invoke.mjs'; +export { iteratee } from './util/iteratee.mjs'; +export { lt } from './util/lt.mjs'; +export { lte } from './util/lte.mjs'; +export { method } from './util/method.mjs'; +export { methodOf } from './util/methodOf.mjs'; +export { now } from './util/now.mjs'; +export { over } from './util/over.mjs'; +export { overEvery } from './util/overEvery.mjs'; +export { overSome } from './util/overSome.mjs'; +export { stubArray } from './util/stubArray.mjs'; +export { stubFalse } from './util/stubFalse.mjs'; +export { stubObject } from './util/stubObject.mjs'; +export { stubString } from './util/stubString.mjs'; +export { stubTrue } from './util/stubTrue.mjs'; +export { times } from './util/times.mjs'; +export { toArray } from './util/toArray.mjs'; +export { toFinite } from './util/toFinite.mjs'; +export { toInteger } from './util/toInteger.mjs'; +export { toLength } from './util/toLength.mjs'; +export { toNumber } from './util/toNumber.mjs'; +export { toPath } from './util/toPath.mjs'; +export { toPlainObject } from './util/toPlainObject.mjs'; +export { toSafeInteger } from './util/toSafeInteger.mjs'; +export { toString } from './util/toString.mjs'; +export { uniqueId } from './util/uniqueId.mjs'; +export { toolkit as default } from './toolkit.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1a9c89749969129bffbbd442124746bdee356c49 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.d.mts @@ -0,0 +1,9 @@ +import * as compat from './compat.mjs'; + +type ToolkitFn = (value: any) => any; +type Compat = typeof compat; +interface Toolkit extends ToolkitFn, Compat { +} +declare const toolkit: Toolkit; + +export { type Toolkit, toolkit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..200d5cc4bc72af4b428a07e8438f654dfe4dc90e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.d.ts @@ -0,0 +1,9 @@ +import * as compat from './compat.js'; + +type ToolkitFn = (value: any) => any; +type Compat = typeof compat; +interface Toolkit extends ToolkitFn, Compat { +} +declare const toolkit: Toolkit; + +export { type Toolkit, toolkit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.js new file mode 100644 index 0000000000000000000000000000000000000000..94b344e31e5c49b2cac7672cf3263f5c3a8340ae --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const compat = require('./compat.js'); + +const toolkit = ((value) => { + return value; +}); +Object.assign(toolkit, compat); +toolkit.partial.placeholder = toolkit; +toolkit.partialRight.placeholder = toolkit; + +exports.toolkit = toolkit; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.mjs new file mode 100644 index 0000000000000000000000000000000000000000..46928f9adce875c8b87b419ed909f8ced72bac02 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/compat/toolkit.mjs @@ -0,0 +1,10 @@ +import * as compat from './compat.mjs'; + +const toolkit = ((value) => { + return value; +}); +Object.assign(toolkit, compat); +toolkit.partial.placeholder = toolkit; +toolkit.partialRight.placeholder = toolkit; + +export { toolkit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e09d4dc60629a3f36e25f802d928bfcdd2884c26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.d.mts @@ -0,0 +1,9 @@ +/** + * An error class representing an aborted operation. + * @augments Error + */ +declare class AbortError extends Error { + constructor(message?: string); +} + +export { AbortError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e09d4dc60629a3f36e25f802d928bfcdd2884c26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.d.ts @@ -0,0 +1,9 @@ +/** + * An error class representing an aborted operation. + * @augments Error + */ +declare class AbortError extends Error { + constructor(message?: string); +} + +export { AbortError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.js new file mode 100644 index 0000000000000000000000000000000000000000..8dacc05ae2730ef4c7e046321e30b0872921a0e5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +class AbortError extends Error { + constructor(message = 'The operation was aborted') { + super(message); + this.name = 'AbortError'; + } +} + +exports.AbortError = AbortError; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7858a041ba426e7f664fc03bfd1fa6684611f61f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/AbortError.mjs @@ -0,0 +1,8 @@ +class AbortError extends Error { + constructor(message = 'The operation was aborted') { + super(message); + this.name = 'AbortError'; + } +} + +export { AbortError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7f4856c644713f7cc9ff8257da5b5c1be18d3f75 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.d.mts @@ -0,0 +1,9 @@ +/** + * An error class representing an timeout operation. + * @augments Error + */ +declare class TimeoutError extends Error { + constructor(message?: string); +} + +export { TimeoutError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7f4856c644713f7cc9ff8257da5b5c1be18d3f75 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.d.ts @@ -0,0 +1,9 @@ +/** + * An error class representing an timeout operation. + * @augments Error + */ +declare class TimeoutError extends Error { + constructor(message?: string); +} + +export { TimeoutError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.js new file mode 100644 index 0000000000000000000000000000000000000000..450fb3972d94d08273612f17353af13dd0ca5890 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +class TimeoutError extends Error { + constructor(message = 'The operation was timed out') { + super(message); + this.name = 'TimeoutError'; + } +} + +exports.TimeoutError = TimeoutError; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.mjs new file mode 100644 index 0000000000000000000000000000000000000000..17d8ce34d3431a02ec5e43166ab0b42219511271 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/TimeoutError.mjs @@ -0,0 +1,8 @@ +class TimeoutError extends Error { + constructor(message = 'The operation was timed out') { + super(message); + this.name = 'TimeoutError'; + } +} + +export { TimeoutError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6bcb1ebc4ca4bb7c9dde17e69acef87e5b7143cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.d.mts @@ -0,0 +1,2 @@ +export { AbortError } from './AbortError.mjs'; +export { TimeoutError } from './TimeoutError.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0ac2b2afe2cd49027bd911e582068e5492b57d21 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.d.ts @@ -0,0 +1,2 @@ +export { AbortError } from './AbortError.js'; +export { TimeoutError } from './TimeoutError.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.js new file mode 100644 index 0000000000000000000000000000000000000000..547d72eeeb055716ebdef1ccbc1987bf91b9e5d7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const AbortError = require('./AbortError.js'); +const TimeoutError = require('./TimeoutError.js'); + + + +exports.AbortError = AbortError.AbortError; +exports.TimeoutError = TimeoutError.TimeoutError; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6bcb1ebc4ca4bb7c9dde17e69acef87e5b7143cf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/error/index.mjs @@ -0,0 +1,2 @@ +export { AbortError } from './AbortError.mjs'; +export { TimeoutError } from './TimeoutError.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..75fbf67c56775f9e0848d1dfde03f155fee4d2fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.d.mts @@ -0,0 +1,31 @@ +/** + * Creates a function that only executes starting from the `n`-th call. + * The provided function will be invoked starting from the `n`-th call. + * + * This is particularly useful for scenarios involving events or asynchronous operations + * where an action should occur only after a certain number of invocations. + * + * @template F - The type of the function to be invoked. + * @param {number} n - The number of calls required for `func` to execute. + * @param {F} func - The function to be invoked. + * @returns {(...args: Parameters) => ReturnType | undefined} - A new function that: + * - Tracks the number of calls. + * - Invokes `func` starting from the `n`-th call. + * - Returns `undefined` if fewer than `n` calls have been made. + * @throws {Error} - Throws an error if `n` is negative. + * @example + * + * const afterFn = after(3, () => { + * console.log("called") + * }); + * + * // Will not log anything. + * afterFn() + * // Will not log anything. + * afterFn() + * // Will log 'called'. + * afterFn() + */ +declare function after any>(n: number, func: F): (...args: Parameters) => ReturnType | undefined; + +export { after }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..75fbf67c56775f9e0848d1dfde03f155fee4d2fa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.d.ts @@ -0,0 +1,31 @@ +/** + * Creates a function that only executes starting from the `n`-th call. + * The provided function will be invoked starting from the `n`-th call. + * + * This is particularly useful for scenarios involving events or asynchronous operations + * where an action should occur only after a certain number of invocations. + * + * @template F - The type of the function to be invoked. + * @param {number} n - The number of calls required for `func` to execute. + * @param {F} func - The function to be invoked. + * @returns {(...args: Parameters) => ReturnType | undefined} - A new function that: + * - Tracks the number of calls. + * - Invokes `func` starting from the `n`-th call. + * - Returns `undefined` if fewer than `n` calls have been made. + * @throws {Error} - Throws an error if `n` is negative. + * @example + * + * const afterFn = after(3, () => { + * console.log("called") + * }); + * + * // Will not log anything. + * afterFn() + * // Will not log anything. + * afterFn() + * // Will log 'called'. + * afterFn() + */ +declare function after any>(n: number, func: F): (...args: Parameters) => ReturnType | undefined; + +export { after }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.js new file mode 100644 index 0000000000000000000000000000000000000000..cac3477bfdb61867b8c0425d329d7b30195abee1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function after(n, func) { + if (!Number.isInteger(n) || n < 0) { + throw new Error(`n must be a non-negative integer.`); + } + let counter = 0; + return (...args) => { + if (++counter >= n) { + return func(...args); + } + return undefined; + }; +} + +exports.after = after; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1c515a4e55a58b24db1ab8b8e56d72925a69a337 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/after.mjs @@ -0,0 +1,14 @@ +function after(n, func) { + if (!Number.isInteger(n) || n < 0) { + throw new Error(`n must be a non-negative integer.`); + } + let counter = 0; + return (...args) => { + if (++counter >= n) { + return func(...args); + } + return undefined; + }; +} + +export { after }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8cf0aa3eac49075f1b9978bdf2abc8da742a3936 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.d.mts @@ -0,0 +1,21 @@ +/** + * Creates a function that invokes func, with up to n arguments, ignoring any additional arguments. + * + * @template F - The type of the function. + * @param {F} func - The function to cap arguments for. + * @param {number} n - The arity cap. + * @returns {(...args: any[]) => ReturnType} Returns the new capped function. + * + * @example + * function fn(a: number, b: number, c: number) { + * return Array.from(arguments); + * } + * + * ary(fn, 0)(1, 2, 3) // [] + * ary(fn, 1)(1, 2, 3) // [1] + * ary(fn, 2)(1, 2, 3) // [1, 2] + * ary(fn, 3)(1, 2, 3) // [1, 2, 3] + */ +declare function ary any>(func: F, n: number): (...args: any[]) => ReturnType; + +export { ary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8cf0aa3eac49075f1b9978bdf2abc8da742a3936 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.d.ts @@ -0,0 +1,21 @@ +/** + * Creates a function that invokes func, with up to n arguments, ignoring any additional arguments. + * + * @template F - The type of the function. + * @param {F} func - The function to cap arguments for. + * @param {number} n - The arity cap. + * @returns {(...args: any[]) => ReturnType} Returns the new capped function. + * + * @example + * function fn(a: number, b: number, c: number) { + * return Array.from(arguments); + * } + * + * ary(fn, 0)(1, 2, 3) // [] + * ary(fn, 1)(1, 2, 3) // [1] + * ary(fn, 2)(1, 2, 3) // [1, 2] + * ary(fn, 3)(1, 2, 3) // [1, 2, 3] + */ +declare function ary any>(func: F, n: number): (...args: any[]) => ReturnType; + +export { ary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.js new file mode 100644 index 0000000000000000000000000000000000000000..480c9202bfdb2e6f9a0fafbd6db4601ea5123653 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function ary(func, n) { + return function (...args) { + return func.apply(this, args.slice(0, n)); + }; +} + +exports.ary = ary; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3166b58dcbdd65cd4d76688bd275152cadd54f8d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/ary.mjs @@ -0,0 +1,7 @@ +function ary(func, n) { + return function (...args) { + return func.apply(this, args.slice(0, n)); + }; +} + +export { ary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d32bb35be13f65198a24b58c404b317140accd11 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.d.mts @@ -0,0 +1,12 @@ +/** + * An asynchronous no-operation function that does nothing. + * This can be used as a placeholder or default function. + * + * @example + * asyncNoop(); // Does nothing + * + * @returns {Promise} This function returns a Promise that resolves to undefined. + */ +declare function asyncNoop(): Promise; + +export { asyncNoop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d32bb35be13f65198a24b58c404b317140accd11 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.d.ts @@ -0,0 +1,12 @@ +/** + * An asynchronous no-operation function that does nothing. + * This can be used as a placeholder or default function. + * + * @example + * asyncNoop(); // Does nothing + * + * @returns {Promise} This function returns a Promise that resolves to undefined. + */ +declare function asyncNoop(): Promise; + +export { asyncNoop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.js new file mode 100644 index 0000000000000000000000000000000000000000..57272a40c05e704991326debb9a8cab43551ce4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.js @@ -0,0 +1,7 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +async function asyncNoop() { } + +exports.asyncNoop = asyncNoop; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.mjs new file mode 100644 index 0000000000000000000000000000000000000000..349ad940d06fa577fdbb02e97d6c16088bdb6e90 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/asyncNoop.mjs @@ -0,0 +1,3 @@ +async function asyncNoop() { } + +export { asyncNoop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..124e1adfc8e961dae498b0c6531a1c8850205f76 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.d.mts @@ -0,0 +1,31 @@ +/** + * Creates a function that limits the number of times the given function (`func`) can be called. + * + * @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 | undefined} - A new function that: + * - Tracks the number of calls. + * - Invokes `func` until the `n-1`-th call. + * - Returns `undefined` if the number of calls reaches or exceeds `n`, stopping further calls. + * @throws {Error} - Throw an error if `n` is negative. + * @example + * + * const beforeFn = before(3, () => { + * console.log("called"); + * }) + * + * // Will log 'called'. + * beforeFn(); + * + * // Will log 'called'. + * beforeFn(); + * + * // Will not log anything. + * beforeFn(); + */ +declare function before any>(n: number, func: F): (...args: Parameters) => ReturnType | undefined; + +export { before }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..124e1adfc8e961dae498b0c6531a1c8850205f76 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.d.ts @@ -0,0 +1,31 @@ +/** + * Creates a function that limits the number of times the given function (`func`) can be called. + * + * @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 | undefined} - A new function that: + * - Tracks the number of calls. + * - Invokes `func` until the `n-1`-th call. + * - Returns `undefined` if the number of calls reaches or exceeds `n`, stopping further calls. + * @throws {Error} - Throw an error if `n` is negative. + * @example + * + * const beforeFn = before(3, () => { + * console.log("called"); + * }) + * + * // Will log 'called'. + * beforeFn(); + * + * // Will log 'called'. + * beforeFn(); + * + * // Will not log anything. + * beforeFn(); + */ +declare function before any>(n: number, func: F): (...args: Parameters) => ReturnType | undefined; + +export { before }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.js new file mode 100644 index 0000000000000000000000000000000000000000..7a119b982fc25ed660386adc2866c3ba80112156 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function before(n, func) { + if (!Number.isInteger(n) || n < 0) { + throw new Error('n must be a non-negative integer.'); + } + let counter = 0; + return (...args) => { + if (++counter < n) { + return func(...args); + } + return undefined; + }; +} + +exports.before = before; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6faeb208b2ec998e7f4d1241498cac538e259188 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/before.mjs @@ -0,0 +1,14 @@ +function before(n, func) { + if (!Number.isInteger(n) || n < 0) { + throw new Error('n must be a non-negative integer.'); + } + let counter = 0; + return (...args) => { + if (++counter < n) { + return func(...args); + } + return undefined; + }; +} + +export { before }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2e22be5c1663e5407a9b09bef10538a2f716a64a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.d.mts @@ -0,0 +1,126 @@ +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {() => R} func - The function to curry. + * @returns {() => R} A curried function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const curriedNoArgFunc = curry(noArgFunc); + * console.log(curriedNoArgFunc()); // 42 + */ +declare function curry(func: () => R): () => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p: P) => R} func - The function to curry. + * @returns {(p: P) => R} A curried function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const curriedOneArgFunc = curry(oneArgFunc); + * console.log(curriedOneArgFunc(5)); // 10 + */ +declare function curry(func: (p: P) => R): (p: P) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p1: P1, p2: P2) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => R} A curried function. + * + * @example + * function twoArgFunc(a: number, b: number) { + * return a + b; + * } + * const curriedTwoArgFunc = curry(twoArgFunc); + * const add5 = curriedTwoArgFunc(5); + * console.log(add5(10)); // 15 + */ +declare function curry(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => R} A curried function. + * + * @example + * function threeArgFunc(a: number, b: number, c: number) { + * return a + b + c; + * } + * const curriedThreeArgFunc = curry(threeArgFunc); + * const add1 = curriedThreeArgFunc(1); + * const add3 = add1(2); + * console.log(add3(3)); // 6 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function. + * + * @example + * function fourArgFunc(a: number, b: number, c: number, d: number) { + * return a + b + c + d; + * } + * const curriedFourArgFunc = curry(fourArgFunc); + * const add1 = curriedFourArgFunc(1); + * const add3 = add1(2); + * const add6 = add3(3); + * console.log(add6(4)); // 10 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function. + * + * @example + * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) { + * return a + b + c + d + e; + * } + * const curriedFiveArgFunc = curry(fiveArgFunc); + * const add1 = curriedFiveArgFunc(1); + * const add3 = add1(2); + * const add6 = add3(3); + * const add10 = add6(4); + * console.log(add10(5)); // 15 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(...args: any[]) => any} func - The function to curry. + * @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time. + * + * @example + * function sum(a: number, b: number, c: number) { + * return a + b + c; + * } + * + * const curriedSum = curry(sum); + * + * // The parameter `a` should be given the value `10`. + * const add10 = curriedSum(10); + * + * // The parameter `b` should be given the value `15`. + * const add25 = add10(15); + * + * // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value. + * const result = add25(5); + */ +declare function curry(func: (...args: any[]) => any): (...args: any[]) => any; + +export { curry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2e22be5c1663e5407a9b09bef10538a2f716a64a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.d.ts @@ -0,0 +1,126 @@ +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {() => R} func - The function to curry. + * @returns {() => R} A curried function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const curriedNoArgFunc = curry(noArgFunc); + * console.log(curriedNoArgFunc()); // 42 + */ +declare function curry(func: () => R): () => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p: P) => R} func - The function to curry. + * @returns {(p: P) => R} A curried function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const curriedOneArgFunc = curry(oneArgFunc); + * console.log(curriedOneArgFunc(5)); // 10 + */ +declare function curry(func: (p: P) => R): (p: P) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p1: P1, p2: P2) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => R} A curried function. + * + * @example + * function twoArgFunc(a: number, b: number) { + * return a + b; + * } + * const curriedTwoArgFunc = curry(twoArgFunc); + * const add5 = curriedTwoArgFunc(5); + * console.log(add5(10)); // 15 + */ +declare function curry(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => R} A curried function. + * + * @example + * function threeArgFunc(a: number, b: number, c: number) { + * return a + b + c; + * } + * const curriedThreeArgFunc = curry(threeArgFunc); + * const add1 = curriedThreeArgFunc(1); + * const add3 = add1(2); + * console.log(add3(3)); // 6 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function. + * + * @example + * function fourArgFunc(a: number, b: number, c: number, d: number) { + * return a + b + c + d; + * } + * const curriedFourArgFunc = curry(fourArgFunc); + * const add1 = curriedFourArgFunc(1); + * const add3 = add1(2); + * const add6 = add3(3); + * console.log(add6(4)); // 10 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry. + * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function. + * + * @example + * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) { + * return a + b + c + d + e; + * } + * const curriedFiveArgFunc = curry(fiveArgFunc); + * const add1 = curriedFiveArgFunc(1); + * const add3 = add1(2); + * const add6 = add3(3); + * const add10 = add6(4); + * console.log(add10(5)); // 15 + */ +declare function curry(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * @param {(...args: any[]) => any} func - The function to curry. + * @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time. + * + * @example + * function sum(a: number, b: number, c: number) { + * return a + b + c; + * } + * + * const curriedSum = curry(sum); + * + * // The parameter `a` should be given the value `10`. + * const add10 = curriedSum(10); + * + * // The parameter `b` should be given the value `15`. + * const add25 = add10(15); + * + * // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value. + * const result = add25(5); + */ +declare function curry(func: (...args: any[]) => any): (...args: any[]) => any; + +export { curry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.js new file mode 100644 index 0000000000000000000000000000000000000000..2c3e092736e371f0a5959712815e724a3ad15879 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function curry(func) { + if (func.length === 0 || func.length === 1) { + return func; + } + return function (arg) { + return makeCurry(func, func.length, [arg]); + }; +} +function makeCurry(origin, argsLength, args) { + if (args.length === argsLength) { + return origin(...args); + } + else { + const next = function (arg) { + return makeCurry(origin, argsLength, [...args, arg]); + }; + return next; + } +} + +exports.curry = curry; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.mjs new file mode 100644 index 0000000000000000000000000000000000000000..35e183693f66e71f1b87543a2673e63dc687b7a4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curry.mjs @@ -0,0 +1,21 @@ +function curry(func) { + if (func.length === 0 || func.length === 1) { + return func; + } + return function (arg) { + return makeCurry(func, func.length, [arg]); + }; +} +function makeCurry(origin, argsLength, args) { + if (args.length === argsLength) { + return origin(...args); + } + else { + const next = function (arg) { + return makeCurry(origin, argsLength, [...args, arg]); + }; + return next; + } +} + +export { curry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..96a2b6c4ea662615ad1caa47cbbb44dbedbdb798 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.d.mts @@ -0,0 +1,140 @@ +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {() => R} func - The function to curry. + * @returns {() => R} A curried function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const curriedNoArgFunc = curryRight(noArgFunc); + * console.log(curriedNoArgFunc()); // 42 + */ +declare function curryRight(func: () => R): () => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p: P) => R} func - The function to curry. + * @returns {(p: P) => R} A curried function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const curriedOneArgFunc = curryRight(oneArgFunc); + * console.log(curriedOneArgFunc(5)); // 10 + */ +declare function curryRight(func: (p: P) => R): (p: P) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p1: P1, p2: P2) => R} func - The function to curry. + * @returns {(p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function twoArgFunc(a: number, b: number) { + * return [a, b]; + * } + * const curriedTwoArgFunc = curryRight(twoArgFunc); + * const func = curriedTwoArgFunc(1); + * console.log(func(2)); // [2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2) => R): (p2: P2) => (p1: P1) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry. + * @returns {(p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function threeArgFunc(a: number, b: number, c: number) { + * return [a, b, c]; + * } + * const curriedThreeArgFunc = curryRight(threeArgFunc); + * const func = curriedThreeArgFunc(1); + * const func2 = func(2); + * console.log(func2(3)); // [3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3) => R): (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry. + * @returns {(p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function fourArgFunc(a: number, b: number, c: number, d: number) { + * return [a, b, c, d]; + * } + * const curriedFourArgFunc = curryRight(fourArgFunc); + * const func = curriedFourArgFunc(1); + * const func2 = func(2); + * const func3 = func2(3); + * console.log(func3(4)); // [4, 3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry. + * @returns {(p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) { + * return [a, b, c, d, e]; + * } + * const curriedFiveArgFunc = curryRight(fiveArgFunc); + * const func = curriedFiveArgFunc(1); + * const func2 = func(2); + * const func3 = func2(3); + * const func4 = func3(4); + * console.log(func4(5)); // [5, 4, 3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(...args: any[]) => any} func - The function to curry. + * @returns {(...args: any[]) => any} A curried function. + * + * @example + * function sum(a: number, b: number, c: number) { + * return a + b + c; + * } + * + * const curriedSum = curryRight(sum); + * + * // The parameter `c` should be given the value `10`. + * const add10 = curriedSum(10); + * + * // The parameter `b` should be given the value `15`. + * const add25 = add10(15); + * + * // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value. + * const result = add25(5); // 30 + */ +declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any; + +export { curryRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..96a2b6c4ea662615ad1caa47cbbb44dbedbdb798 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.d.ts @@ -0,0 +1,140 @@ +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {() => R} func - The function to curry. + * @returns {() => R} A curried function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const curriedNoArgFunc = curryRight(noArgFunc); + * console.log(curriedNoArgFunc()); // 42 + */ +declare function curryRight(func: () => R): () => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p: P) => R} func - The function to curry. + * @returns {(p: P) => R} A curried function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const curriedOneArgFunc = curryRight(oneArgFunc); + * console.log(curriedOneArgFunc(5)); // 10 + */ +declare function curryRight(func: (p: P) => R): (p: P) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p1: P1, p2: P2) => R} func - The function to curry. + * @returns {(p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function twoArgFunc(a: number, b: number) { + * return [a, b]; + * } + * const curriedTwoArgFunc = curryRight(twoArgFunc); + * const func = curriedTwoArgFunc(1); + * console.log(func(2)); // [2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2) => R): (p2: P2) => (p1: P1) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry. + * @returns {(p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function threeArgFunc(a: number, b: number, c: number) { + * return [a, b, c]; + * } + * const curriedThreeArgFunc = curryRight(threeArgFunc); + * const func = curriedThreeArgFunc(1); + * const func2 = func(2); + * console.log(func2(3)); // [3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3) => R): (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry. + * @returns {(p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function fourArgFunc(a: number, b: number, c: number, d: number) { + * return [a, b, c, d]; + * } + * const curriedFourArgFunc = curryRight(fourArgFunc); + * const func = curriedFourArgFunc(1); + * const func2 = func(2); + * const func3 = func2(3); + * console.log(func3(4)); // [4, 3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry. + * @returns {(p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function. + * + * @example + * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) { + * return [a, b, c, d, e]; + * } + * const curriedFiveArgFunc = curryRight(fiveArgFunc); + * const func = curriedFiveArgFunc(1); + * const func2 = func(2); + * const func3 = func2(3); + * const func4 = func3(4); + * console.log(func4(5)); // [5, 4, 3, 2, 1] + */ +declare function curryRight(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R; +/** + * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument. + * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments. + * + * Unlike `curry`, this function curries the function from right to left. + * + * @param {(...args: any[]) => any} func - The function to curry. + * @returns {(...args: any[]) => any} A curried function. + * + * @example + * function sum(a: number, b: number, c: number) { + * return a + b + c; + * } + * + * const curriedSum = curryRight(sum); + * + * // The parameter `c` should be given the value `10`. + * const add10 = curriedSum(10); + * + * // The parameter `b` should be given the value `15`. + * const add25 = add10(15); + * + * // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value. + * const result = add25(5); // 30 + */ +declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any; + +export { curryRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.js new file mode 100644 index 0000000000000000000000000000000000000000..1bca60883d0eabc93776cf0663824077510c3a3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.js @@ -0,0 +1,25 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function curryRight(func) { + if (func.length === 0 || func.length === 1) { + return func; + } + return function (arg) { + return makeCurryRight(func, func.length, [arg]); + }; +} +function makeCurryRight(origin, argsLength, args) { + if (args.length === argsLength) { + return origin(...args); + } + else { + const next = function (arg) { + return makeCurryRight(origin, argsLength, [arg, ...args]); + }; + return next; + } +} + +exports.curryRight = curryRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..894a99c4f056d67aba846f4a736c046827bcabd9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/curryRight.mjs @@ -0,0 +1,21 @@ +function curryRight(func) { + if (func.length === 0 || func.length === 1) { + return func; + } + return function (arg) { + return makeCurryRight(func, func.length, [arg]); + }; +} +function makeCurryRight(origin, argsLength, args) { + if (args.length === argsLength) { + return origin(...args); + } + else { + const next = function (arg) { + return makeCurryRight(origin, argsLength, [arg, ...args]); + }; + return next; + } +} + +export { curryRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..10c43b110df83882e865ed28ff3c997afab36ed4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.d.mts @@ -0,0 +1,74 @@ +interface DebounceOptions { + /** + * An optional AbortSignal to cancel the debounced function. + */ + signal?: AbortSignal; + /** + * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both. + * If `edges` includes "leading", the function will be invoked at the start of the delay period. + * If `edges` includes "trailing", the function will be invoked at the end of the delay period. + * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period. + * @default ["trailing"] + */ + edges?: Array<'leading' | 'trailing'>; +} +interface DebouncedFunction void> { + (...args: Parameters): void; + /** + * Schedules the execution of the debounced function after the specified debounce delay. + * This method resets any existing timer, ensuring that the function is only invoked + * after the delay has elapsed since the last call to the debounced function. + * It is typically called internally whenever the debounced function is invoked. + * + * @returns {void} + */ + schedule: () => void; + /** + * Cancels any pending execution of the debounced function. + * This method clears the active timer and resets any stored context or arguments. + */ + cancel: () => void; + /** + * Immediately invokes the debounced function if there is a pending execution. + * This method also cancels the current timer, ensuring that the function executes right away. + */ + flush: () => void; +} +/** + * 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. + * + * @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. + * @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 void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction; + +export { type DebouncedFunction, debounce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..10c43b110df83882e865ed28ff3c997afab36ed4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.d.ts @@ -0,0 +1,74 @@ +interface DebounceOptions { + /** + * An optional AbortSignal to cancel the debounced function. + */ + signal?: AbortSignal; + /** + * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both. + * If `edges` includes "leading", the function will be invoked at the start of the delay period. + * If `edges` includes "trailing", the function will be invoked at the end of the delay period. + * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period. + * @default ["trailing"] + */ + edges?: Array<'leading' | 'trailing'>; +} +interface DebouncedFunction void> { + (...args: Parameters): void; + /** + * Schedules the execution of the debounced function after the specified debounce delay. + * This method resets any existing timer, ensuring that the function is only invoked + * after the delay has elapsed since the last call to the debounced function. + * It is typically called internally whenever the debounced function is invoked. + * + * @returns {void} + */ + schedule: () => void; + /** + * Cancels any pending execution of the debounced function. + * This method clears the active timer and resets any stored context or arguments. + */ + cancel: () => void; + /** + * Immediately invokes the debounced function if there is a pending execution. + * This method also cancels the current timer, ensuring that the function executes right away. + */ + flush: () => void; +} +/** + * 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. + * + * @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. + * @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 void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction; + +export { type DebouncedFunction, debounce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.js new file mode 100644 index 0000000000000000000000000000000000000000..2fcb8eed394feb9b80a354e6e920d2e22e33ed9e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.js @@ -0,0 +1,67 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function debounce(func, debounceMs, { signal, edges } = {}) { + let pendingThis = undefined; + let pendingArgs = null; + const leading = edges != null && edges.includes('leading'); + const trailing = edges == null || edges.includes('trailing'); + const invoke = () => { + if (pendingArgs !== null) { + func.apply(pendingThis, pendingArgs); + pendingThis = undefined; + pendingArgs = null; + } + }; + const onTimerEnd = () => { + if (trailing) { + invoke(); + } + cancel(); + }; + let timeoutId = null; + const schedule = () => { + if (timeoutId != null) { + clearTimeout(timeoutId); + } + timeoutId = setTimeout(() => { + timeoutId = null; + onTimerEnd(); + }, debounceMs); + }; + const cancelTimer = () => { + if (timeoutId !== null) { + clearTimeout(timeoutId); + timeoutId = null; + } + }; + const cancel = () => { + cancelTimer(); + pendingThis = undefined; + pendingArgs = null; + }; + const flush = () => { + cancelTimer(); + invoke(); + }; + const debounced = function (...args) { + if (signal?.aborted) { + return; + } + pendingThis = this; + pendingArgs = args; + const isFirstCall = timeoutId == null; + schedule(); + if (leading && isFirstCall) { + invoke(); + } + }; + debounced.schedule = schedule; + debounced.cancel = cancel; + debounced.flush = flush; + signal?.addEventListener('abort', cancel, { once: true }); + return debounced; +} + +exports.debounce = debounce; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3666122302bcc09d03ca76a6d7c77426a76e782b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/debounce.mjs @@ -0,0 +1,63 @@ +function debounce(func, debounceMs, { signal, edges } = {}) { + let pendingThis = undefined; + let pendingArgs = null; + const leading = edges != null && edges.includes('leading'); + const trailing = edges == null || edges.includes('trailing'); + const invoke = () => { + if (pendingArgs !== null) { + func.apply(pendingThis, pendingArgs); + pendingThis = undefined; + pendingArgs = null; + } + }; + const onTimerEnd = () => { + if (trailing) { + invoke(); + } + cancel(); + }; + let timeoutId = null; + const schedule = () => { + if (timeoutId != null) { + clearTimeout(timeoutId); + } + timeoutId = setTimeout(() => { + timeoutId = null; + onTimerEnd(); + }, debounceMs); + }; + const cancelTimer = () => { + if (timeoutId !== null) { + clearTimeout(timeoutId); + timeoutId = null; + } + }; + const cancel = () => { + cancelTimer(); + pendingThis = undefined; + pendingArgs = null; + }; + const flush = () => { + cancelTimer(); + invoke(); + }; + const debounced = function (...args) { + if (signal?.aborted) { + return; + } + pendingThis = this; + pendingArgs = args; + const isFirstCall = timeoutId == null; + schedule(); + if (leading && isFirstCall) { + invoke(); + } + }; + debounced.schedule = schedule; + debounced.cancel = cancel; + debounced.flush = flush; + signal?.addEventListener('abort', cancel, { once: true }); + return debounced; +} + +export { debounce }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..757d6fa4e52e2608667baef677cf279197ba8f5a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.d.mts @@ -0,0 +1,132 @@ +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {() => R} f The function to invoke. + * @returns {() => R} Returns the new composite function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * + * const combined = flow(noArgFunc); + * console.log(combined()); // 42 + */ +declare function flow(f: () => R): () => R; +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R} f1 The function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * + * const combined = flow(oneArgFunc); + * console.log(combined(5)); // 10 + */ +declare function flow(f1: (...args: A) => R): (...args: A) => R; +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R1} f1 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @returns {(...args: A) => R2} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const combined = flow(add, square); + * console.log(combined(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 the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R1} f1 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @returns {(...args: A) => R3} Returns the new composite 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 the given functions in sequence. The return value of the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R1} f1 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R3) => R4} f4 The function to invoke. + * @returns {(...args: A) => R4} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toStr = (n: number) => n.toString(); + * + * const combined = flow(add, square, double, toStr); + * 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 the given functions in sequence. The return value of the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R1} f1 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R3) => R4} f4 The function to invoke. + * @param {(a: R4) => R5} f5 The function to invoke. + * @returns {(...args: A) => R5} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toStr = (n: number) => n.toString(); + * const split = (s: string) => s.split(''); + * + * const combined = flow(add, square, double, toStr, split); + * console.log(combined(1, 2)); // ['1', '8'] + */ +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 the given functions in sequence. The return value of the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {Array<(...args: any[]) => any>} funcs The functions to invoke. + * @returns {(...args: any[]) => any} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const combined = flow(add, square); + * console.log(combined(1, 2)); // 9 + */ +declare function flow(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any; + +export { flow }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..757d6fa4e52e2608667baef677cf279197ba8f5a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.d.ts @@ -0,0 +1,132 @@ +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {() => R} f The function to invoke. + * @returns {() => R} Returns the new composite function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * + * const combined = flow(noArgFunc); + * console.log(combined()); // 42 + */ +declare function flow(f: () => R): () => R; +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R} f1 The function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * + * const combined = flow(oneArgFunc); + * console.log(combined(5)); // 10 + */ +declare function flow(f1: (...args: A) => R): (...args: A) => R; +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R1} f1 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @returns {(...args: A) => R2} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const combined = flow(add, square); + * console.log(combined(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 the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R1} f1 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @returns {(...args: A) => R3} Returns the new composite 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 the given functions in sequence. The return value of the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R1} f1 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R3) => R4} f4 The function to invoke. + * @returns {(...args: A) => R4} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toStr = (n: number) => n.toString(); + * + * const combined = flow(add, square, double, toStr); + * 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 the given functions in sequence. The return value of the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {(...args: A) => R1} f1 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R3) => R4} f4 The function to invoke. + * @param {(a: R4) => R5} f5 The function to invoke. + * @returns {(...args: A) => R5} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toStr = (n: number) => n.toString(); + * const split = (s: string) => s.split(''); + * + * const combined = flow(add, square, double, toStr, split); + * console.log(combined(1, 2)); // ['1', '8'] + */ +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 the given functions in sequence. The return value of the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * @param {Array<(...args: any[]) => any>} funcs The functions to invoke. + * @returns {(...args: any[]) => any} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * + * const combined = flow(add, square); + * console.log(combined(1, 2)); // 9 + */ +declare function flow(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any; + +export { flow }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.js new file mode 100644 index 0000000000000000000000000000000000000000..ad56d502154c5abd22b3c3649f912f0465a01b29 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function flow(...funcs) { + return function (...args) { + let result = funcs.length ? funcs[0].apply(this, args) : args[0]; + for (let i = 1; i < funcs.length; i++) { + result = funcs[i].call(this, result); + } + return result; + }; +} + +exports.flow = flow; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a14553189c29d1bcc153670955d9a361a68bd1f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flow.mjs @@ -0,0 +1,11 @@ +function flow(...funcs) { + return function (...args) { + let result = funcs.length ? funcs[0].apply(this, args) : args[0]; + for (let i = 1; i < funcs.length; i++) { + result = funcs[i].call(this, result); + } + return result; + }; +} + +export { flow }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e3d8346099ae9c2d4df5bcc86b59930acf27748b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.d.mts @@ -0,0 +1,144 @@ +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {() => R} f The function to invoke. + * @returns {() => R} Returns the new composite function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const combined = flowRight(noArgFunc); + * console.log(combined()); // 42 + */ +declare function flowRight(f: () => R): () => R; +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(...args: A) => R} f1 The function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const combined = flowRight(oneArgFunc); + * console.log(combined(5)); // 10 + */ +declare function flowRight(f1: (...args: A) => R): (...args: A) => R; +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(...args: A) => R1} f1 The function to invoke. + * @returns {(...args: A) => R2} Returns the new composite 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 the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(...args: A) => R1} f1 The function to invoke. + * @returns {(...args: A) => R3} Returns the new composite 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 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(a: R3) => R4} f4 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(...args: A) => R1} f1 The function to invoke. + * @returns {(...args: A) => R4} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toStr = (n: number) => n.toString(); + * + * const combined = flowRight(toStr, 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 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(a: R4) => R5} f5 The function to invoke. + * @param {(a: R3) => R4} f4 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(...args: A) => R1} f1 The function to invoke. + * @returns {(...args: A) => R5} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toStr = (n: number) => n.toString(); + * const split = (s: string) => s.split(''); + * + * const combined = flowRight(split, toStr, double, square, add); + * console.log(combined(1, 2)); // ['1', '8'] + */ +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 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(...args: any[]) => any} funcs The functions to invoke. + * @returns {(...args: any[]) => any} Returns the new composite 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(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any; + +export { flowRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e3d8346099ae9c2d4df5bcc86b59930acf27748b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.d.ts @@ -0,0 +1,144 @@ +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {() => R} f The function to invoke. + * @returns {() => R} Returns the new composite function. + * + * @example + * function noArgFunc() { + * return 42; + * } + * const combined = flowRight(noArgFunc); + * console.log(combined()); // 42 + */ +declare function flowRight(f: () => R): () => R; +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(...args: A) => R} f1 The function to invoke. + * @returns {(...args: A) => R} Returns the new composite function. + * + * @example + * function oneArgFunc(a: number) { + * return a * 2; + * } + * const combined = flowRight(oneArgFunc); + * console.log(combined(5)); // 10 + */ +declare function flowRight(f1: (...args: A) => R): (...args: A) => R; +/** + * 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(...args: A) => R1} f1 The function to invoke. + * @returns {(...args: A) => R2} Returns the new composite 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 the previous function is passed as an argument to the next function. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(...args: A) => R1} f1 The function to invoke. + * @returns {(...args: A) => R3} Returns the new composite 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 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(a: R3) => R4} f4 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(...args: A) => R1} f1 The function to invoke. + * @returns {(...args: A) => R4} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toStr = (n: number) => n.toString(); + * + * const combined = flowRight(toStr, 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 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(a: R4) => R5} f5 The function to invoke. + * @param {(a: R3) => R4} f4 The function to invoke. + * @param {(a: R2) => R3} f3 The function to invoke. + * @param {(a: R1) => R2} f2 The function to invoke. + * @param {(...args: A) => R1} f1 The function to invoke. + * @returns {(...args: A) => R5} Returns the new composite function. + * + * @example + * const add = (x: number, y: number) => x + y; + * const square = (n: number) => n * n; + * const double = (n: number) => n * 2; + * const toStr = (n: number) => n.toString(); + * const split = (s: string) => s.split(''); + * + * const combined = flowRight(split, toStr, double, square, add); + * console.log(combined(1, 2)); // ['1', '8'] + */ +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 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. + * + * The `this` context of the returned function is also passed to the functions provided as parameters. + * + * This method is like `flow` except that it creates a function that invokes the given functions from right to left. + * + * @param {(...args: any[]) => any} funcs The functions to invoke. + * @returns {(...args: any[]) => any} Returns the new composite 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(...funcs: Array<(...args: any[]) => any>): (...args: any[]) => any; + +export { flowRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.js new file mode 100644 index 0000000000000000000000000000000000000000..2b4b6003df56826ce1b8049fb49cee27e6b621bc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const flow = require('./flow.js'); + +function flowRight(...funcs) { + return flow.flow(...funcs.reverse()); +} + +exports.flowRight = flowRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..116afdfd6d0db6b6b6bcc0f90a2fad447e7bbe14 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/flowRight.mjs @@ -0,0 +1,7 @@ +import { flow } from './flow.mjs'; + +function flowRight(...funcs) { + return flow(...funcs.reverse()); +} + +export { flowRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..34f9827222bc80c6f71513a24c19e7474cdb5591 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.d.mts @@ -0,0 +1,22 @@ +/** + * 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(x: T): T; + +export { identity }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..34f9827222bc80c6f71513a24c19e7474cdb5591 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.d.ts @@ -0,0 +1,22 @@ +/** + * 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(x: T): T; + +export { identity }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.js new file mode 100644 index 0000000000000000000000000000000000000000..6341454e9097280502d96720879e630cd1973a5b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/function/identity.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/identity.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0ef39394d51b4a023d416b1744a3dd9f19a2b507 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/function/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4f36b157d823e4590d6579f38f7d17448b7ed30b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.d.mts @@ -0,0 +1,21 @@ +export { after } from './after.mjs'; +export { ary } from './ary.mjs'; +export { asyncNoop } from './asyncNoop.mjs'; +export { before } from './before.mjs'; +export { curry } from './curry.mjs'; +export { curryRight } from './curryRight.mjs'; +export { DebouncedFunction, debounce } from './debounce.mjs'; +export { flow } from './flow.mjs'; +export { flowRight } from './flowRight.mjs'; +export { identity } from './identity.mjs'; +export { MemoizeCache, memoize } from './memoize.mjs'; +export { negate } from './negate.mjs'; +export { noop } from './noop.mjs'; +export { once } from './once.mjs'; +export { partial } from './partial.mjs'; +export { partialRight } from './partialRight.mjs'; +export { rest } from './rest.mjs'; +export { retry } from './retry.mjs'; +export { spread } from './spread.mjs'; +export { ThrottledFunction, throttle } from './throttle.mjs'; +export { unary } from './unary.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..107b8fec9c2b9c66f4412aaca6cad3a4dfeefdf0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.d.ts @@ -0,0 +1,21 @@ +export { after } from './after.js'; +export { ary } from './ary.js'; +export { asyncNoop } from './asyncNoop.js'; +export { before } from './before.js'; +export { curry } from './curry.js'; +export { curryRight } from './curryRight.js'; +export { DebouncedFunction, debounce } from './debounce.js'; +export { flow } from './flow.js'; +export { flowRight } from './flowRight.js'; +export { identity } from './identity.js'; +export { MemoizeCache, memoize } from './memoize.js'; +export { negate } from './negate.js'; +export { noop } from './noop.js'; +export { once } from './once.js'; +export { partial } from './partial.js'; +export { partialRight } from './partialRight.js'; +export { rest } from './rest.js'; +export { retry } from './retry.js'; +export { spread } from './spread.js'; +export { ThrottledFunction, throttle } from './throttle.js'; +export { unary } from './unary.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.js new file mode 100644 index 0000000000000000000000000000000000000000..4eb6c16c6c8e359a682b9f24a206b99768875974 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.js @@ -0,0 +1,49 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const after = require('./after.js'); +const ary = require('./ary.js'); +const asyncNoop = require('./asyncNoop.js'); +const before = require('./before.js'); +const curry = require('./curry.js'); +const curryRight = require('./curryRight.js'); +const debounce = require('./debounce.js'); +const flow = require('./flow.js'); +const flowRight = require('./flowRight.js'); +const identity = require('./identity.js'); +const memoize = require('./memoize.js'); +const negate = require('./negate.js'); +const noop = require('./noop.js'); +const once = require('./once.js'); +const partial = require('./partial.js'); +const partialRight = require('./partialRight.js'); +const rest = require('./rest.js'); +const retry = require('./retry.js'); +const spread = require('./spread.js'); +const throttle = require('./throttle.js'); +const unary = require('./unary.js'); + + + +exports.after = after.after; +exports.ary = ary.ary; +exports.asyncNoop = asyncNoop.asyncNoop; +exports.before = before.before; +exports.curry = curry.curry; +exports.curryRight = curryRight.curryRight; +exports.debounce = debounce.debounce; +exports.flow = flow.flow; +exports.flowRight = flowRight.flowRight; +exports.identity = identity.identity; +exports.memoize = memoize.memoize; +exports.negate = negate.negate; +exports.noop = noop.noop; +exports.once = once.once; +exports.partial = partial.partial; +exports.partialRight = partialRight.partialRight; +exports.rest = rest.rest; +exports.retry = retry.retry; +exports.spread = spread.spread; +exports.throttle = throttle.throttle; +exports.unary = unary.unary; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..40e5406767625bc5ff2d7ea67d8cf6e2ce69a809 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/index.mjs @@ -0,0 +1,21 @@ +export { after } from './after.mjs'; +export { ary } from './ary.mjs'; +export { asyncNoop } from './asyncNoop.mjs'; +export { before } from './before.mjs'; +export { curry } from './curry.mjs'; +export { curryRight } from './curryRight.mjs'; +export { debounce } from './debounce.mjs'; +export { flow } from './flow.mjs'; +export { flowRight } from './flowRight.mjs'; +export { identity } from './identity.mjs'; +export { memoize } from './memoize.mjs'; +export { negate } from './negate.mjs'; +export { noop } from './noop.mjs'; +export { once } from './once.mjs'; +export { partial } from './partial.mjs'; +export { partialRight } from './partialRight.mjs'; +export { rest } from './rest.mjs'; +export { retry } from './retry.mjs'; +export { spread } from './spread.mjs'; +export { throttle } from './throttle.mjs'; +export { unary } from './unary.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..3266b2c5d577f116b6cbab0ef4f314868126aef3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.d.mts @@ -0,0 +1,124 @@ +/** + * Creates a memoized version of the provided function. The memoized function caches + * results based on the argument it receives, so if the same argument is passed again, + * it returns the cached result instead of recomputing it. + * + * This function works with functions that take zero or just one argument. If your function + * originally takes multiple arguments, you should refactor it to take a single object or array + * that combines those arguments. + * + * If the argument is not primitive (e.g., arrays or objects), provide a + * `getCacheKey` function to generate a unique cache key for proper caching. + * + * @template F - The type of the function to be memoized. + * @param {F} fn - The function to be memoized. It should accept a single argument and return a value. + * @param {MemoizeOptions[0], ReturnType>} [options={}] - Optional configuration for the memoization. + * @param {MemoizeCache} [options.cache] - The cache object used to store results. Defaults to a new `Map`. + * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument. + * + * @returns The memoized function with an additional `cache` property that exposes the internal cache. + * + * @example + * // Example using the default cache + * const add = (x: number) => x + 10; + * const memoizedAdd = memoize(add); + * + * console.log(memoizedAdd(5)); // 15 + * console.log(memoizedAdd(5)); // 15 (cached result) + * console.log(memoizedAdd.cache.size); // 1 + * + * @example + * // Example using a custom resolver + * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0); + * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') }); + * console.log(memoizedSum([1, 2])); // 3 + * console.log(memoizedSum([1, 2])); // 3 (cached result) + * console.log(memoizedSum.cache.size); // 1 + * + * @example + * // Example using a custom cache implementation + * class CustomCache implements MemoizeCache { + * private cache = new Map(); + * + * set(key: K, value: T): void { + * this.cache.set(key, value); + * } + * + * get(key: K): T | undefined { + * return this.cache.get(key); + * } + * + * has(key: K): boolean { + * return this.cache.has(key); + * } + * + * delete(key: K): boolean { + * return this.cache.delete(key); + * } + * + * clear(): void { + * this.cache.clear(); + * } + * + * get size(): number { + * return this.cache.size; + * } + * } + * const customCache = new CustomCache(); + * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache }); + * console.log(memoizedSumWithCustomCache([1, 2])); // 3 + * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result) + * console.log(memoizedAddWithCustomCache.cache.size); // 1 + */ +declare function memoize any>(fn: F, options?: { + cache?: MemoizeCache>; + getCacheKey?: (args: Parameters[0]) => unknown; +}): F & { + cache: MemoizeCache>; +}; +/** + * Represents a cache for memoization, allowing storage and retrieval of computed values. + * + * @template K - The type of keys used to store values in the cache. + * @template V - The type of values stored in the cache. + */ +interface MemoizeCache { + /** + * Stores a value in the cache with the specified key. + * + * @param key - The key to associate with the value. + * @param value - The value to store in the cache. + */ + set(key: K, value: V): void; + /** + * Retrieves a value from the cache by its key. + * + * @param key - The key of the value to retrieve. + * @returns The value associated with the key, or undefined if the key does not exist. + */ + get(key: K): V | undefined; + /** + * Checks if a value exists in the cache for the specified key. + * + * @param key - The key to check for existence in the cache. + * @returns True if the cache contains the key, false otherwise. + */ + has(key: K): boolean; + /** + * Deletes a value from the cache by its key. + * + * @param key - The key of the value to delete. + * @returns True if the value was successfully deleted, false otherwise. + */ + delete(key: K): boolean | void; + /** + * Clears all values from the cache. + */ + clear(): void; + /** + * The number of entries in the cache. + */ + size: number; +} + +export { type MemoizeCache, memoize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3266b2c5d577f116b6cbab0ef4f314868126aef3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.d.ts @@ -0,0 +1,124 @@ +/** + * Creates a memoized version of the provided function. The memoized function caches + * results based on the argument it receives, so if the same argument is passed again, + * it returns the cached result instead of recomputing it. + * + * This function works with functions that take zero or just one argument. If your function + * originally takes multiple arguments, you should refactor it to take a single object or array + * that combines those arguments. + * + * If the argument is not primitive (e.g., arrays or objects), provide a + * `getCacheKey` function to generate a unique cache key for proper caching. + * + * @template F - The type of the function to be memoized. + * @param {F} fn - The function to be memoized. It should accept a single argument and return a value. + * @param {MemoizeOptions[0], ReturnType>} [options={}] - Optional configuration for the memoization. + * @param {MemoizeCache} [options.cache] - The cache object used to store results. Defaults to a new `Map`. + * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument. + * + * @returns The memoized function with an additional `cache` property that exposes the internal cache. + * + * @example + * // Example using the default cache + * const add = (x: number) => x + 10; + * const memoizedAdd = memoize(add); + * + * console.log(memoizedAdd(5)); // 15 + * console.log(memoizedAdd(5)); // 15 (cached result) + * console.log(memoizedAdd.cache.size); // 1 + * + * @example + * // Example using a custom resolver + * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0); + * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') }); + * console.log(memoizedSum([1, 2])); // 3 + * console.log(memoizedSum([1, 2])); // 3 (cached result) + * console.log(memoizedSum.cache.size); // 1 + * + * @example + * // Example using a custom cache implementation + * class CustomCache implements MemoizeCache { + * private cache = new Map(); + * + * set(key: K, value: T): void { + * this.cache.set(key, value); + * } + * + * get(key: K): T | undefined { + * return this.cache.get(key); + * } + * + * has(key: K): boolean { + * return this.cache.has(key); + * } + * + * delete(key: K): boolean { + * return this.cache.delete(key); + * } + * + * clear(): void { + * this.cache.clear(); + * } + * + * get size(): number { + * return this.cache.size; + * } + * } + * const customCache = new CustomCache(); + * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache }); + * console.log(memoizedSumWithCustomCache([1, 2])); // 3 + * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result) + * console.log(memoizedAddWithCustomCache.cache.size); // 1 + */ +declare function memoize any>(fn: F, options?: { + cache?: MemoizeCache>; + getCacheKey?: (args: Parameters[0]) => unknown; +}): F & { + cache: MemoizeCache>; +}; +/** + * Represents a cache for memoization, allowing storage and retrieval of computed values. + * + * @template K - The type of keys used to store values in the cache. + * @template V - The type of values stored in the cache. + */ +interface MemoizeCache { + /** + * Stores a value in the cache with the specified key. + * + * @param key - The key to associate with the value. + * @param value - The value to store in the cache. + */ + set(key: K, value: V): void; + /** + * Retrieves a value from the cache by its key. + * + * @param key - The key of the value to retrieve. + * @returns The value associated with the key, or undefined if the key does not exist. + */ + get(key: K): V | undefined; + /** + * Checks if a value exists in the cache for the specified key. + * + * @param key - The key to check for existence in the cache. + * @returns True if the cache contains the key, false otherwise. + */ + has(key: K): boolean; + /** + * Deletes a value from the cache by its key. + * + * @param key - The key of the value to delete. + * @returns True if the value was successfully deleted, false otherwise. + */ + delete(key: K): boolean | void; + /** + * Clears all values from the cache. + */ + clear(): void; + /** + * The number of entries in the cache. + */ + size: number; +} + +export { type MemoizeCache, memoize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.js new file mode 100644 index 0000000000000000000000000000000000000000..cda55cc096d3518e4a7321595d5c3791dfd801c1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function memoize(fn, options = {}) { + const { cache = new Map(), getCacheKey } = options; + const memoizedFn = function (arg) { + const key = getCacheKey ? getCacheKey(arg) : arg; + if (cache.has(key)) { + return cache.get(key); + } + const result = fn.call(this, arg); + cache.set(key, result); + return result; + }; + memoizedFn.cache = cache; + return memoizedFn; +} + +exports.memoize = memoize; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9c82c6fed241cabe5fe42e4d85c2a4f037fa1533 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/memoize.mjs @@ -0,0 +1,16 @@ +function memoize(fn, options = {}) { + const { cache = new Map(), getCacheKey } = options; + const memoizedFn = function (arg) { + const key = getCacheKey ? getCacheKey(arg) : arg; + if (cache.has(key)) { + return cache.get(key); + } + const result = fn.call(this, arg); + cache.set(key, result); + return result; + }; + memoizedFn.cache = cache; + return memoizedFn; +} + +export { memoize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..1eec0c39cf980468cdca89d76a3cd5cd44b369da --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.d.mts @@ -0,0 +1,16 @@ +/** + * Creates a function that negates the result of the predicate function. + * + * @template F - The type of the function to negate. + * @param {F} func - The function to negate. + * @returns {F} The new negated function, which negates the boolean result of `func`. + * + * @example + * const array = [1, 2, 3, 4, 5, 6]; + * const isEven = (n: number) => n % 2 === 0; + * const result = array.filter(negate(isEven)); + * // result will be [1, 3, 5] + */ +declare function negate boolean>(func: F): F; + +export { negate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1eec0c39cf980468cdca89d76a3cd5cd44b369da --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.d.ts @@ -0,0 +1,16 @@ +/** + * Creates a function that negates the result of the predicate function. + * + * @template F - The type of the function to negate. + * @param {F} func - The function to negate. + * @returns {F} The new negated function, which negates the boolean result of `func`. + * + * @example + * const array = [1, 2, 3, 4, 5, 6]; + * const isEven = (n: number) => n % 2 === 0; + * const result = array.filter(negate(isEven)); + * // result will be [1, 3, 5] + */ +declare function negate boolean>(func: F): F; + +export { negate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.js new file mode 100644 index 0000000000000000000000000000000000000000..06ea2087e2d1bae5bde93eb9efcf14269527687e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function negate(func) { + return ((...args) => !func(...args)); +} + +exports.negate = negate; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d455fd3a68b66c76db487a938b895dd97d8812ef --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/negate.mjs @@ -0,0 +1,5 @@ +function negate(func) { + return ((...args) => !func(...args)); +} + +export { negate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/noop.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/noop.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..14ad184fac977580b7da357831064ff98fbe7d0d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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(): void; + +export { noop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/noop.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/noop.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..14ad184fac977580b7da357831064ff98fbe7d0d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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(): void; + +export { noop }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/noop.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/noop.js new file mode 100644 index 0000000000000000000000000000000000000000..1df5d3ddc462126bb34f85b6f9f5ef68bc75639c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/function/noop.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/noop.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f259c8baab932f20e51635bc193257c766e0a4f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/function/once.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..67c22e9f0a5792acd7efbec7cfe3658fbce805aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.d.mts @@ -0,0 +1,16 @@ +/** + * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value of the first invocation. + * + * @template T - The type of the function. + * @param {T} func - The function to restrict. + * @returns {T} Returns the new restricted function. + * + * @example + * var initialize = once(createApplication); + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ +declare function once any>(func: T): T; + +export { once }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..67c22e9f0a5792acd7efbec7cfe3658fbce805aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.d.ts @@ -0,0 +1,16 @@ +/** + * Creates a function that is restricted to invoking func once. Repeat calls to the function return the value of the first invocation. + * + * @template T - The type of the function. + * @param {T} func - The function to restrict. + * @returns {T} Returns the new restricted function. + * + * @example + * var initialize = once(createApplication); + * initialize(); + * initialize(); + * // => `createApplication` is invoked once + */ +declare function once any>(func: T): T; + +export { once }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.js new file mode 100644 index 0000000000000000000000000000000000000000..dd199af102cabf01156b505b67837a91ec970333 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function once(func) { + let called = false; + let cache; + return function (...args) { + if (!called) { + called = true; + cache = func(...args); + } + return cache; + }; +} + +exports.once = once; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2ef78fe73db42a23aaa5f88224662eb3994a33c3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/once.mjs @@ -0,0 +1,13 @@ +function once(func) { + let called = false; + let cache; + return function (...args) { + if (!called) { + called = true; + cache = func(...args); + } + return cache; + }; +} + +export { once }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5f29c2aa36624fecf0f8444f84e2c55c7048994f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.d.mts @@ -0,0 +1,551 @@ +/** + * 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. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {function(arg1: T1): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(): R} A new function that takes no arguments and returns the result of the original function. + * + * @example + * const addOne = (x: number) => x + 1; + * const addOneToFive = partial(addOne, 5); + * console.log(addOneToFive()); // => 6 + */ +declare function partial(func: (arg1: T1) => R, arg1: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number) => x * y; + * const double = partial(multiply, 2); + * console.log(double(5)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2) => R, arg1: T1): (arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2): R} func The function to partially apply. + * @param {Placeholder} placeholder The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithHello = partial(greet, partial.placeholder, 'John'); + * console.log(greetWithHello('Hello')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2) => R, placeholder: Placeholder, arg2: T2): (arg1: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2, arg3: T3): R} A new function that takes the second and third arguments and returns the result of the original function. + * + * @example + * const sumThree = (a: number, b: number, c: number) => a + b + c; + * const addFive = partial(sumThree, 5); + * console.log(addFive(3, 2)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1): (arg2: T2, arg3: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, partial.placeholder, 'John'); + * console.log(greetWithPlaceholder('Hello')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: Placeholder, arg2: T2): (arg1: T1, arg3: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number) => x * y * z; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2); + * console.log(multiplyWithPlaceholders(3, 4)); // => 24 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3): (arg1: T1, arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The first argument to apply. + * @param {T2} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, plc1: Placeholder, arg2: T2, arg3: T3): (arg1: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const double = partial(multiply, 2); + * console.log(double(5, 4, 3)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1): (arg2: T2, arg3: T3, arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholders(4, 5)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3, arg4: T4): (arg1: T1, arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg3: T3, arg4: T4): R} A new function that takes the third and fourth arguments and returns the result of the original function. + * + * @example + * const sumFour = (a: number, b: number, c: number, d: number) => a + b + c + d; + * const addOneAndTwo = partial(sumFour, 1, 2); + * console.log(addOneAndTwo(3, 4)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2): (arg3: T3, arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg2: T2, arg4: T4): R} A new function that takes the second and fourth arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder, '!'); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2, arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholder = partial(multiply, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholder(4)); // => 24 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3): (arg1: T1, arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholders(4, 5)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3, arg4: T4): (arg1: T1, arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg4: T4): R} A new function that takes the fourth argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3): (arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg3: T3): R} A new function that takes the third argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3, arg4: T4): (arg1: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template R The return type of the function. + * @param {function(...args: TS): R} func The function to partially apply. + * @returns {function(...args: TS): R} A new function that takes the same arguments as the original function. + * + * @example + * const add = (...numbers: number[]) => numbers.reduce((sum, n) => sum + n, 0); + * const addFive = partial(add, 5); + * console.log(addFive(1, 2, 3)); // => 11 + */ +declare function partial(func: (...args: TS) => R): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {function(arg1: T1, ...args: TS): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, ...names: string[]) => `${greeting}, ${names.join(', ')}!`; + * const greetHello = partial(greet, 'Hello'); + * console.log(greetHello('Alice', 'Bob')); // => 'Hello, Alice, Bob!' + */ +declare function partial(func: (arg1: T1, ...args: TS) => R, arg1: T1): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the 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 {function(arg1: T1, arg2: T2, ...args: TS): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', '!'); + * console.log(greetWithHello('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, ...args: TS) => R, t1: T1, arg2: T2): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the 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 {function(t1: T1, arg2: T2, arg3: T3, ...args: TS): R} func The function to partially apply. + * @param {T1} t1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', 'John', '!'); + * console.log(greetWithHello()); // => 'Hello, John!' + */ +declare function partial(func: (t1: T1, arg2: T2, arg3: T3, ...args: TS) => R, t1: T1, arg2: T2, arg3: T3): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the 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 {function(t1: T1, arg2: T2, arg3: T3, arg4: T4, ...args: TS): R} func The function to partially apply. + * @param {T1} t1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', 'John', '!'); + * console.log(greetWithHello()); // => 'Hello, John!' + */ +declare function partial(func: (t1: T1, arg2: T2, arg3: T3, arg4: T4, ...args: TS) => R, t1: T1, arg2: T2, arg3: T3, arg4: T4): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template F The type of the function to partially apply. + * @param {F} func The function to partially apply. + * @param {...any[]} partialArgs The arguments to be partially applied. + * @returns {function(...args: any[]): ReturnType} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const add = (...numbers: number[]) => numbers.reduce((sum, n) => sum + n, 0); + * const addFive = partial(add, 5); + * console.log(addFive(1, 2, 3)); // => 11 + */ +declare function partial any>(func: F, ...partialArgs: any[]): (...args: any[]) => ReturnType; +declare namespace partial { + var placeholder: typeof placeholderSymbol; +} +declare const placeholderSymbol: unique symbol; +type Placeholder = typeof placeholderSymbol; + +export { partial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5f29c2aa36624fecf0f8444f84e2c55c7048994f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.d.ts @@ -0,0 +1,551 @@ +/** + * 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. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {function(arg1: T1): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(): R} A new function that takes no arguments and returns the result of the original function. + * + * @example + * const addOne = (x: number) => x + 1; + * const addOneToFive = partial(addOne, 5); + * console.log(addOneToFive()); // => 6 + */ +declare function partial(func: (arg1: T1) => R, arg1: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number) => x * y; + * const double = partial(multiply, 2); + * console.log(double(5)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2) => R, arg1: T1): (arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2): R} func The function to partially apply. + * @param {Placeholder} placeholder The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithHello = partial(greet, partial.placeholder, 'John'); + * console.log(greetWithHello('Hello')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2) => R, placeholder: Placeholder, arg2: T2): (arg1: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2, arg3: T3): R} A new function that takes the second and third arguments and returns the result of the original function. + * + * @example + * const sumThree = (a: number, b: number, c: number) => a + b + c; + * const addFive = partial(sumThree, 5); + * console.log(addFive(3, 2)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1): (arg2: T2, arg3: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, partial.placeholder, 'John'); + * console.log(greetWithPlaceholder('Hello')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: Placeholder, arg2: T2): (arg1: T1, arg3: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number) => x * y * z; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2); + * console.log(multiplyWithPlaceholders(3, 4)); // => 24 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3): (arg1: T1, arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3): R} func The function to partially apply. + * @param {Placeholder} arg1 The first argument to apply. + * @param {T2} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3) => R, plc1: Placeholder, arg2: T2, arg3: T3): (arg1: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const double = partial(multiply, 2); + * console.log(double(5, 4, 3)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1): (arg2: T2, arg3: T3, arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholders(4, 5)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3, arg4: T4): (arg1: T1, arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @returns {function(arg3: T3, arg4: T4): R} A new function that takes the third and fourth arguments and returns the result of the original function. + * + * @example + * const sumFour = (a: number, b: number, c: number, d: number) => a + b + c + d; + * const addOneAndTwo = partial(sumFour, 1, 2); + * console.log(addOneAndTwo(3, 4)); // => 10 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2): (arg3: T3, arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg2: T2, arg4: T4): R} A new function that takes the second and fourth arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithPlaceholder = partial(greet, 'Hello', partial.placeholder, '!'); + * console.log(greetWithPlaceholder('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2, arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholder = partial(multiply, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholder(4)); // => 24 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3): (arg1: T1, arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg3: T3): R} A new function that takes the first and third arguments and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1, arg2: T2): R} A new function that takes the first and second arguments and returns the result of the original function. + * + * @example + * const multiply = (x: number, y: number, z: number, w: number) => x * y * z * w; + * const multiplyWithPlaceholders = partial(multiply, partial.placeholder, partial.placeholder, 2, 3); + * console.log(multiplyWithPlaceholders(4, 5)); // => 120 + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: Placeholder, arg3: T3, arg4: T4): (arg1: T1, arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @returns {function(arg4: T4): R} A new function that takes the fourth argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3): (arg4: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg3: T3): R} A new function that takes the third argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg2: T2): R} A new function that takes the second argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(arg1: T1, arg2: T2, arg3: T3, arg4: T4): R} func The function to partially apply. + * @param {Placeholder} arg1 The placeholder for the first argument. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(arg1: T1): R} A new function that takes the first argument and returns the result of the original function. + */ +declare function partial(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: Placeholder, arg2: T2, arg3: T3, arg4: T4): (arg1: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template R The return type of the function. + * @param {function(...args: TS): R} func The function to partially apply. + * @returns {function(...args: TS): R} A new function that takes the same arguments as the original function. + * + * @example + * const add = (...numbers: number[]) => numbers.reduce((sum, n) => sum + n, 0); + * const addFive = partial(add, 5); + * console.log(addFive(1, 2, 3)); // => 11 + */ +declare function partial(func: (...args: TS) => R): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the arguments. + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {function(arg1: T1, ...args: TS): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, ...names: string[]) => `${greeting}, ${names.join(', ')}!`; + * const greetHello = partial(greet, 'Hello'); + * console.log(greetHello('Alice', 'Bob')); // => 'Hello, Alice, Bob!' + */ +declare function partial(func: (arg1: T1, ...args: TS) => R, arg1: T1): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the 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 {function(arg1: T1, arg2: T2, ...args: TS): R} func The function to partially apply. + * @param {T1} arg1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', '!'); + * console.log(greetWithHello('John')); // => 'Hello, John!' + */ +declare function partial(func: (arg1: T1, arg2: T2, ...args: TS) => R, t1: T1, arg2: T2): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the 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 {function(t1: T1, arg2: T2, arg3: T3, ...args: TS): R} func The function to partially apply. + * @param {T1} t1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', 'John', '!'); + * console.log(greetWithHello()); // => 'Hello, John!' + */ +declare function partial(func: (t1: T1, arg2: T2, arg3: T3, ...args: TS) => R, t1: T1, arg2: T2, arg3: T3): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template TS The types of the 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 {function(t1: T1, arg2: T2, arg3: T3, arg4: T4, ...args: TS): R} func The function to partially apply. + * @param {T1} t1 The first argument to apply. + * @param {T2} arg2 The second argument to apply. + * @param {T3} arg3 The third argument to apply. + * @param {T4} arg4 The fourth argument to apply. + * @returns {function(...args: TS): R} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const greet = (greeting: string, name: string, punctuation: string) => `${greeting}, ${name}${punctuation}`; + * const greetWithHello = partial(greet, 'Hello', 'John', '!'); + * console.log(greetWithHello()); // => 'Hello, John!' + */ +declare function partial(func: (t1: T1, arg2: T2, arg3: T3, arg4: T4, ...args: TS) => R, t1: T1, arg2: T2, arg3: T3, arg4: T4): (...args: 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. + * + * The partial.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template F The type of the function to partially apply. + * @param {F} func The function to partially apply. + * @param {...any[]} partialArgs The arguments to be partially applied. + * @returns {function(...args: any[]): ReturnType} A new function that takes the remaining arguments and returns the result of the original function. + * + * @example + * const add = (...numbers: number[]) => numbers.reduce((sum, n) => sum + n, 0); + * const addFive = partial(add, 5); + * console.log(addFive(1, 2, 3)); // => 11 + */ +declare function partial any>(func: F, ...partialArgs: any[]): (...args: any[]) => ReturnType; +declare namespace partial { + var placeholder: typeof placeholderSymbol; +} +declare const placeholderSymbol: unique symbol; +type Placeholder = typeof placeholderSymbol; + +export { partial }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.js new file mode 100644 index 0000000000000000000000000000000000000000..0acfac2eb98a3f6b574ae7c854a820e93fdafff4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function partial(func, ...partialArgs) { + return partialImpl(func, placeholderSymbol, ...partialArgs); +} +function partialImpl(func, placeholder, ...partialArgs) { + const partialed = function (...providedArgs) { + let providedArgsIndex = 0; + const substitutedArgs = partialArgs + .slice() + .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg)); + const remainingArgs = providedArgs.slice(providedArgsIndex); + return func.apply(this, substitutedArgs.concat(remainingArgs)); + }; + if (func.prototype) { + partialed.prototype = Object.create(func.prototype); + } + return partialed; +} +const placeholderSymbol = Symbol('partial.placeholder'); +partial.placeholder = placeholderSymbol; + +exports.partial = partial; +exports.partialImpl = partialImpl; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f4fc91c269a52b118163ae37bff958c3670e488b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partial.mjs @@ -0,0 +1,21 @@ +function partial(func, ...partialArgs) { + return partialImpl(func, placeholderSymbol, ...partialArgs); +} +function partialImpl(func, placeholder, ...partialArgs) { + const partialed = function (...providedArgs) { + let providedArgsIndex = 0; + const substitutedArgs = partialArgs + .slice() + .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg)); + const remainingArgs = providedArgs.slice(providedArgsIndex); + return func.apply(this, substitutedArgs.concat(remainingArgs)); + }; + if (func.prototype) { + partialed.prototype = Object.create(func.prototype); + } + return partialed; +} +const placeholderSymbol = Symbol('partial.placeholder'); +partial.placeholder = placeholderSymbol; + +export { partial, partialImpl }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ac77e39ebb443fd46347f131b09ec3edc8ccd8ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.d.mts @@ -0,0 +1,628 @@ +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template R The return type of the function. + * @param {() => R} func The function to invoke. + * @returns {() => R} Returns the new function. + * @example + * const getValue = () => 42; + * const getValueFunc = partialRight(getValue); + * console.log(getValueFunc()); // => 42 + */ +declare function partialRight(func: () => R): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const addOne = (num: number) => num + 1; + * const addOneFunc = partialRight(addOne, 1); + * console.log(addOneFunc()); // => 2 + */ +declare function partialRight(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const multiplyBy = (factor: number) => (num: number) => num * factor; + * const double = partialRight(multiplyBy(2)); + * console.log(double(5)); // => 10 + */ +declare function partialRight(func: (arg1: T1) => R): (arg1: T1) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const greet = (name: string) => `Hello, ${name}!`; + * const greetJohn = partialRight(greet, 'John'); + * console.log(greetJohn()); // => 'Hello, John!' + */ +declare function partialRight(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2) => R} Returns the new partially applied function. + * @example + * const subtract = (a: number, b: number) => a - b; + * const subtractFive = partialRight(subtract); + * console.log(subtractFive(10, 5)); // => 5 + */ +declare function partialRight(func: (arg1: T1, arg2: T2) => R): (arg1: T1, arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @returns {(arg2: T2) => R} Returns the new partially applied function. + * @example + * const concat = (a: string, b: string) => a + b; + * const concatWithHello = partialRight(concat, 'Hello', partialRight.placeholder); + * console.log(concatWithHello(' World!')); // => 'Hello World!' + */ +declare function partialRight(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: Placeholder): (arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const divide = (a: number, b: number) => a / b; + * const divideByTwo = partialRight(divide, 2); + * console.log(divideByTwo(10)); // => 5 + */ +declare function partialRight(func: (arg1: T1, arg2: T2) => R, arg2: T2): (arg1: T1) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const multiply = (a: number, b: number) => a * b; + * const multiplyByThreeAndFour = partialRight(multiply, 3, 4); + * console.log(multiplyByThreeAndFour()); // => 12 + */ +declare function partialRight(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: T2): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2, arg3: T3) => R} Returns the new partially applied function. + * @example + * const sumThree = (a: number, b: number, c: number) => a + b + c; + * const sumWithFive = partialRight(sumThree); + * console.log(sumWithFive(1, 2, 5)); // => 8 + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R): (arg1: T1, arg2: T2, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg2: T2, arg3: T3) => R} Returns the new partially applied function. + * @example + * const formatDate = (day: number, month: number, year: number) => `${day}/${month}/${year}`; + * const formatDateWithDay = partialRight(formatDate, 1, partialRight.placeholder, partialRight.placeholder); + * console.log(formatDateWithDay(12, 2023)); // => '1/12/2023' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder): (arg2: T2, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg1: T1, arg3: T3) => R} Returns the new partially applied function. + * @example + * const createUser = (name: string, age: number, country: string) => `${name}, ${age} years old from ${country}`; + * const createUserFromUSA = partialRight(createUser, 'USA', partialRight.placeholder); + * console.log(createUserFromUSA('John', 30)); // => 'John, 30 years old from USA' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: Placeholder): (arg1: T1, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg3: T3) => R} Returns the new partially applied function. + * @example + * const logMessage = (level: string, message: string, timestamp: string) => `[${level}] ${message} at ${timestamp}`; + * const logError = partialRight(logMessage, 'ERROR', '2023-10-01'); + * console.log(logError('Something went wrong!')); // => '[ERROR] Something went wrong! at 2023-10-01' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: Placeholder): (arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg1: T1, arg2: T2) => R} Returns the new partially applied function. + * @example + * const calculateArea = (length: number, width: number) => length * width; + * const calculateAreaWithWidth = partialRight(calculateArea, 5); + * console.log(calculateAreaWithWidth(10)); // => 50 + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg3: T3): (arg1: T1, arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg2: T2) => R} Returns the new partially applied function. + * @example + * const formatCurrency = (amount: number, currency: string) => `${amount} ${currency}`; + * const formatUSD = partialRight(formatCurrency, 100, partialRight.placeholder); + * console.log(formatUSD('USD')); // => '100 USD' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const createProfile = (name: string, age: number, country: string) => `${name}, ${age} from ${country}`; + * const createProfileFromCanada = partialRight(createProfile, 'Canada', 'John'); + * console.log(createProfileFromCanada(30)); // => 'John, 30 from Canada' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: T3): (arg1: T1) => R; +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} Returns a new function that takes four arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg2: T2, arg3: T3, arg4: T4) => R} Returns a new function that takes the second, third, and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: Placeholder): (arg2: T2, arg3: T3, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg3: T3, arg4: T4) => R} Returns a new function that takes the first, third, and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg1: T1, arg3: T3, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg3: T3, arg4: T4) => R} Returns a new function that takes the third and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg3: T3, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg2: T2, arg4: T4) => R} Returns a new function that takes the first, second, and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: Placeholder): (arg1: T1, arg2: T2, arg4: T4) => R; +/** + * Creates a function that invokes `func` with the first argument, a placeholder for the second argument, + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg2: T2, arg4: T4) => R} Returns a new function that takes the second and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: Placeholder): (arg2: T2, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg4: T4) => R} Returns a new function that takes the first and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: Placeholder): (arg1: T1, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg4: T4) => R} Returns a new function that takes the fourth argument. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: Placeholder): (arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg2: T2, arg3: T3) => R} Returns a new function that takes the first, second, and third arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg4: T4): (arg1: T1, arg2: T2, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg2: T2, arg3: T3) => R} Returns a new function that takes the second and third arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: T4): (arg2: T2, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg3: T3) => R} Returns a new function that takes the first and third arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg3: T3) => R} Returns a new function that takes the third argument. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg2: T2) => R} Returns a new function that takes the first and second arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg2: T2) => R} Returns a new function that takes the second argument. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1) => R} Returns a new function that takes the first argument. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const concatenate = (a: string, b: string, c: string, d: string) => a + b + c + d; + * const concatenateHelloWorld = partialRight(concatenate, 'Hello', ' ', 'World', '!'); + * console.log(concatenateHelloWorld()); // => 'Hello World!' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(...args: any[]): ReturnType} Returns the new partially applied function. + * @example + * const log = (...messages: string[]) => console.log(...messages); + * const logError = partialRight(log, 'Error:'); + * logError('Something went wrong!'); // => 'Error: Something went wrong!' + */ +declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; +declare namespace partialRight { + var placeholder: typeof placeholderSymbol; +} +declare const placeholderSymbol: unique symbol; +type Placeholder = typeof placeholderSymbol; + +export { partialRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ac77e39ebb443fd46347f131b09ec3edc8ccd8ab --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.d.ts @@ -0,0 +1,628 @@ +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template R The return type of the function. + * @param {() => R} func The function to invoke. + * @returns {() => R} Returns the new function. + * @example + * const getValue = () => 42; + * const getValueFunc = partialRight(getValue); + * console.log(getValueFunc()); // => 42 + */ +declare function partialRight(func: () => R): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const addOne = (num: number) => num + 1; + * const addOneFunc = partialRight(addOne, 1); + * console.log(addOneFunc()); // => 2 + */ +declare function partialRight(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const multiplyBy = (factor: number) => (num: number) => num * factor; + * const double = partialRight(multiplyBy(2)); + * console.log(double(5)); // => 10 + */ +declare function partialRight(func: (arg1: T1) => R): (arg1: T1) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @template T1 The type of the first argument. + * @template R The return type of the function. + * @param {(arg1: T1) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const greet = (name: string) => `Hello, ${name}!`; + * const greetJohn = partialRight(greet, 'John'); + * console.log(greetJohn()); // => 'Hello, John!' + */ +declare function partialRight(func: (arg1: T1) => R, arg1: T1): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2) => R} Returns the new partially applied function. + * @example + * const subtract = (a: number, b: number) => a - b; + * const subtractFive = partialRight(subtract); + * console.log(subtractFive(10, 5)); // => 5 + */ +declare function partialRight(func: (arg1: T1, arg2: T2) => R): (arg1: T1, arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @returns {(arg2: T2) => R} Returns the new partially applied function. + * @example + * const concat = (a: string, b: string) => a + b; + * const concatWithHello = partialRight(concat, 'Hello', partialRight.placeholder); + * console.log(concatWithHello(' World!')); // => 'Hello World!' + */ +declare function partialRight(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: Placeholder): (arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const divide = (a: number, b: number) => a / b; + * const divideByTwo = partialRight(divide, 2); + * console.log(divideByTwo(10)); // => 5 + */ +declare function partialRight(func: (arg1: T1, arg2: T2) => R, arg2: T2): (arg1: T1) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const multiply = (a: number, b: number) => a * b; + * const multiplyByThreeAndFour = partialRight(multiply, 3, 4); + * console.log(multiplyByThreeAndFour()); // => 12 + */ +declare function partialRight(func: (arg1: T1, arg2: T2) => R, arg1: T1, arg2: T2): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2, arg3: T3) => R} Returns the new partially applied function. + * @example + * const sumThree = (a: number, b: number, c: number) => a + b + c; + * const sumWithFive = partialRight(sumThree); + * console.log(sumWithFive(1, 2, 5)); // => 8 + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R): (arg1: T1, arg2: T2, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg2: T2, arg3: T3) => R} Returns the new partially applied function. + * @example + * const formatDate = (day: number, month: number, year: number) => `${day}/${month}/${year}`; + * const formatDateWithDay = partialRight(formatDate, 1, partialRight.placeholder, partialRight.placeholder); + * console.log(formatDateWithDay(12, 2023)); // => '1/12/2023' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder): (arg2: T2, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg1: T1, arg3: T3) => R} Returns the new partially applied function. + * @example + * const createUser = (name: string, age: number, country: string) => `${name}, ${age} years old from ${country}`; + * const createUserFromUSA = partialRight(createUser, 'USA', partialRight.placeholder); + * console.log(createUserFromUSA('John', 30)); // => 'John, 30 years old from USA' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: Placeholder): (arg1: T1, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @returns {(arg3: T3) => R} Returns the new partially applied function. + * @example + * const logMessage = (level: string, message: string, timestamp: string) => `[${level}] ${message} at ${timestamp}`; + * const logError = partialRight(logMessage, 'ERROR', '2023-10-01'); + * console.log(logError('Something went wrong!')); // => '[ERROR] Something went wrong! at 2023-10-01' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: Placeholder): (arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg1: T1, arg2: T2) => R} Returns the new partially applied function. + * @example + * const calculateArea = (length: number, width: number) => length * width; + * const calculateAreaWithWidth = partialRight(calculateArea, 5); + * console.log(calculateAreaWithWidth(10)); // => 50 + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg3: T3): (arg1: T1, arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg2: T2) => R} Returns the new partially applied function. + * @example + * const formatCurrency = (amount: number, currency: string) => `${amount} ${currency}`; + * const formatUSD = partialRight(formatCurrency, 100, partialRight.placeholder); + * console.log(formatUSD('USD')); // => '100 USD' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: Placeholder, arg3: T3): (arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @returns {(arg1: T1) => R} Returns the new partially applied function. + * @example + * const createProfile = (name: string, age: number, country: string) => `${name}, ${age} from ${country}`; + * const createProfileFromCanada = partialRight(createProfile, 'Canada', 'John'); + * console.log(createProfileFromCanada(30)); // => 'John, 30 from Canada' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg2: T2, arg3: T3): (arg1: T1) => R; +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3) => R, arg1: T1, arg2: T2, arg3: T3): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @returns {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} Returns a new function that takes four arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg2: T2, arg3: T3, arg4: T4) => R} Returns a new function that takes the second, third, and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: Placeholder): (arg2: T2, arg3: T3, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg3: T3, arg4: T4) => R} Returns a new function that takes the first, third, and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg1: T1, arg3: T3, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg3: T3, arg4: T4) => R} Returns a new function that takes the third and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: Placeholder): (arg3: T3, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg2: T2, arg4: T4) => R} Returns a new function that takes the first, second, and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: Placeholder): (arg1: T1, arg2: T2, arg4: T4) => R; +/** + * Creates a function that invokes `func` with the first argument, a placeholder for the second argument, + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg2: T2, arg4: T4) => R} Returns a new function that takes the second and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: Placeholder): (arg2: T2, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg1: T1, arg4: T4) => R} Returns a new function that takes the first and fourth arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: Placeholder): (arg1: T1, arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {Placeholder} arg4 The placeholder for the fourth argument. + * @returns {(arg4: T4) => R} Returns a new function that takes the fourth argument. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: Placeholder): (arg4: T4) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg2: T2, arg3: T3) => R} Returns a new function that takes the first, second, and third arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg4: T4): (arg1: T1, arg2: T2, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg2: T2, arg3: T3) => R} Returns a new function that takes the second and third arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: Placeholder, arg4: T4): (arg2: T2, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg3: T3) => R} Returns a new function that takes the first and third arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: Placeholder, arg4: T4): (arg1: T1, arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {Placeholder} arg3 The placeholder for the third argument. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg3: T3) => R} Returns a new function that takes the third argument. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: Placeholder, arg4: T4): (arg3: T3) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1, arg2: T2) => R} Returns a new function that takes the first and second arguments. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg3: T3, arg4: T4): (arg1: T1, arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {Placeholder} arg2 The placeholder for the second argument. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg2: T2) => R} Returns a new function that takes the second argument. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: Placeholder, arg3: T3, arg4: T4): (arg2: T2) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {(arg1: T1) => R} Returns a new function that takes the first argument. + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg2: T2, arg3: T3, arg4: T4): (arg1: T1) => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R} func The function to partially apply arguments to. + * @param {T1} arg1 The first argument to be partially applied. + * @param {T2} arg2 The second argument to be partially applied. + * @param {T3} arg3 The third argument to be partially applied. + * @param {T4} arg4 The fourth argument to be partially applied. + * @returns {() => R} Returns the new partially applied function. + * @example + * const concatenate = (a: string, b: string, c: string, d: string) => a + b + c + d; + * const concatenateHelloWorld = partialRight(concatenate, 'Hello', ' ', 'World', '!'); + * console.log(concatenateHelloWorld()); // => 'Hello World!' + */ +declare function partialRight(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R, arg1: T1, arg2: T2, arg3: T3, arg4: T4): () => R; +/** + * This method is like `partial` except that partially applied arguments are appended to the arguments it receives. + * + * The partialRight.placeholder value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments. + * + * Note: This method doesn't set the `length` property of partially applied functions. + * + * @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 {function(...args: any[]): ReturnType} Returns the new partially applied function. + * @example + * const log = (...messages: string[]) => console.log(...messages); + * const logError = partialRight(log, 'Error:'); + * logError('Something went wrong!'); // => 'Error: Something went wrong!' + */ +declare function partialRight(func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any; +declare namespace partialRight { + var placeholder: typeof placeholderSymbol; +} +declare const placeholderSymbol: unique symbol; +type Placeholder = typeof placeholderSymbol; + +export { partialRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.js new file mode 100644 index 0000000000000000000000000000000000000000..e9bab396ca4b07decf70431729ebc46d15b220a2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.js @@ -0,0 +1,28 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function partialRight(func, ...partialArgs) { + return partialRightImpl(func, placeholderSymbol, ...partialArgs); +} +function partialRightImpl(func, placeholder, ...partialArgs) { + const partialedRight = function (...providedArgs) { + const placeholderLength = partialArgs.filter(arg => arg === placeholder).length; + const rangeLength = Math.max(providedArgs.length - placeholderLength, 0); + const remainingArgs = providedArgs.slice(0, rangeLength); + let providedArgsIndex = rangeLength; + const substitutedArgs = partialArgs + .slice() + .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg)); + return func.apply(this, remainingArgs.concat(substitutedArgs)); + }; + if (func.prototype) { + partialedRight.prototype = Object.create(func.prototype); + } + return partialedRight; +} +const placeholderSymbol = Symbol('partialRight.placeholder'); +partialRight.placeholder = placeholderSymbol; + +exports.partialRight = partialRight; +exports.partialRightImpl = partialRightImpl; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e155fb391a960bec905102267c990a43739d641c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/partialRight.mjs @@ -0,0 +1,23 @@ +function partialRight(func, ...partialArgs) { + return partialRightImpl(func, placeholderSymbol, ...partialArgs); +} +function partialRightImpl(func, placeholder, ...partialArgs) { + const partialedRight = function (...providedArgs) { + const placeholderLength = partialArgs.filter(arg => arg === placeholder).length; + const rangeLength = Math.max(providedArgs.length - placeholderLength, 0); + const remainingArgs = providedArgs.slice(0, rangeLength); + let providedArgsIndex = rangeLength; + const substitutedArgs = partialArgs + .slice() + .map(arg => (arg === placeholder ? providedArgs[providedArgsIndex++] : arg)); + return func.apply(this, remainingArgs.concat(substitutedArgs)); + }; + if (func.prototype) { + partialedRight.prototype = Object.create(func.prototype); + } + return partialedRight; +} +const placeholderSymbol = Symbol('partialRight.placeholder'); +partialRight.placeholder = placeholderSymbol; + +export { partialRight, partialRightImpl }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bf26cae97dd584e6a697e7aa6cf28b6fe5b1be0c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} [startIndex=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 any>(func: F, startIndex?: number): (...args: any[]) => ReturnType; + +export { rest }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bf26cae97dd584e6a697e7aa6cf28b6fe5b1be0c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} [startIndex=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 any>(func: F, startIndex?: number): (...args: any[]) => ReturnType; + +export { rest }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.js new file mode 100644 index 0000000000000000000000000000000000000000..d0d4d54e28700e4a5c2547ab69406f1abf84e32c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function rest(func, startIndex = func.length - 1) { + return function (...args) { + const rest = args.slice(startIndex); + const params = args.slice(0, startIndex); + while (params.length < startIndex) { + params.push(undefined); + } + return func.apply(this, [...params, rest]); + }; +} + +exports.rest = rest; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.mjs new file mode 100644 index 0000000000000000000000000000000000000000..88a48a07aa916ddf1b61db9cb8b0b6288cd9eaf1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/rest.mjs @@ -0,0 +1,12 @@ +function rest(func, startIndex = func.length - 1) { + return function (...args) { + const rest = args.slice(startIndex); + const params = args.slice(0, startIndex); + while (params.length < startIndex) { + params.push(undefined); + } + return func.apply(this, [...params, rest]); + }; +} + +export { rest }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d6102da555f6ae1fe65b9b2c7bfc5b9a366c7b23 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.d.mts @@ -0,0 +1,77 @@ +interface RetryOptions { + /** + * Delay between retries. Can be a static number (milliseconds) or a function + * that computes delay dynamically based on the current attempt. + * + * @default 0 + * @example + * delay: (attempts) => attempt * 50 + */ + delay?: number | ((attempts: number) => number); + /** + * The number of retries to attempt. + * @default Number.POSITIVE_INFINITY + */ + retries?: number; + /** + * An AbortSignal to cancel the retry operation. + */ + signal?: AbortSignal; +} +/** + * Retries a function that returns a promise until it resolves successfully. + * + * @template T + * @param {() => Promise} func - The function to retry. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Basic usage with default retry options + * retry(() => fetchData()).then(data => console.log(data)); + */ +declare function retry(func: () => Promise): Promise; +/** + * Retries a function that returns a promise a specified number of times. + * + * @template T + * @param {() => Promise} func - The function to retry. It should return a promise. + * @param {number} retries - The number of retries to attempt. Default is Infinity. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Retry a function up to 3 times + * retry(() => fetchData(), 3).then(data => console.log(data)); + */ +declare function retry(func: () => Promise, retries: number): Promise; +/** + * Retries a function that returns a promise with specified options. + * + * @template T + * @param {() => Promise} func - The function to retry. It should return a promise. + * @param {RetryOptions} options - Options to configure the retry behavior. + * @param {number | ((attempts: number) => number)} [options.delay=0] - Delay(milliseconds) between retries. + * @param {number} [options.retries=Infinity] - The number of retries to attempt. + * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Retry a function with a delay of 1000ms between attempts + * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data)); + * + * @example + * // Retry a function with a fixed delay + * retry(() => fetchData(), { delay: 1000, retries: 5 }); + * + * // Retry a function with a delay increasing linearly by 50ms per attempt + * retry(() => fetchData(), { delay: (attempts) => attempt * 50, retries: 5 }); + * + * @example + * // Retry a function with exponential backoff + jitter (max delay 10 seconds) + * retry(() => fetchData(), { + * delay: (attempts) => Math.min(Math.random() * 100 * 2 ** attempts, 10000), + * retries: 5 + * }); + */ +declare function retry(func: () => Promise, options: RetryOptions): Promise; + +export { retry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d6102da555f6ae1fe65b9b2c7bfc5b9a366c7b23 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.d.ts @@ -0,0 +1,77 @@ +interface RetryOptions { + /** + * Delay between retries. Can be a static number (milliseconds) or a function + * that computes delay dynamically based on the current attempt. + * + * @default 0 + * @example + * delay: (attempts) => attempt * 50 + */ + delay?: number | ((attempts: number) => number); + /** + * The number of retries to attempt. + * @default Number.POSITIVE_INFINITY + */ + retries?: number; + /** + * An AbortSignal to cancel the retry operation. + */ + signal?: AbortSignal; +} +/** + * Retries a function that returns a promise until it resolves successfully. + * + * @template T + * @param {() => Promise} func - The function to retry. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Basic usage with default retry options + * retry(() => fetchData()).then(data => console.log(data)); + */ +declare function retry(func: () => Promise): Promise; +/** + * Retries a function that returns a promise a specified number of times. + * + * @template T + * @param {() => Promise} func - The function to retry. It should return a promise. + * @param {number} retries - The number of retries to attempt. Default is Infinity. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Retry a function up to 3 times + * retry(() => fetchData(), 3).then(data => console.log(data)); + */ +declare function retry(func: () => Promise, retries: number): Promise; +/** + * Retries a function that returns a promise with specified options. + * + * @template T + * @param {() => Promise} func - The function to retry. It should return a promise. + * @param {RetryOptions} options - Options to configure the retry behavior. + * @param {number | ((attempts: number) => number)} [options.delay=0] - Delay(milliseconds) between retries. + * @param {number} [options.retries=Infinity] - The number of retries to attempt. + * @param {AbortSignal} [options.signal] - An AbortSignal to cancel the retry operation. + * @returns {Promise} A promise that resolves with the value of the successful function call. + * + * @example + * // Retry a function with a delay of 1000ms between attempts + * retry(() => fetchData(), { delay: 1000, times: 5 }).then(data => console.log(data)); + * + * @example + * // Retry a function with a fixed delay + * retry(() => fetchData(), { delay: 1000, retries: 5 }); + * + * // Retry a function with a delay increasing linearly by 50ms per attempt + * retry(() => fetchData(), { delay: (attempts) => attempt * 50, retries: 5 }); + * + * @example + * // Retry a function with exponential backoff + jitter (max delay 10 seconds) + * retry(() => fetchData(), { + * delay: (attempts) => Math.min(Math.random() * 100 * 2 ** attempts, 10000), + * retries: 5 + * }); + */ +declare function retry(func: () => Promise, options: RetryOptions): Promise; + +export { retry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.js new file mode 100644 index 0000000000000000000000000000000000000000..3ef72fc21aae6a0140cd154dbbeea044fd6b3a09 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const delay = require('../promise/delay.js'); + +const DEFAULT_DELAY = 0; +const DEFAULT_RETRIES = Number.POSITIVE_INFINITY; +async function retry(func, _options) { + let delay$1; + let retries; + let signal; + if (typeof _options === 'number') { + delay$1 = DEFAULT_DELAY; + retries = _options; + signal = undefined; + } + else { + delay$1 = _options?.delay ?? DEFAULT_DELAY; + retries = _options?.retries ?? DEFAULT_RETRIES; + signal = _options?.signal; + } + let error; + for (let attempts = 0; attempts < retries; attempts++) { + if (signal?.aborted) { + throw error ?? new Error(`The retry operation was aborted due to an abort signal.`); + } + try { + return await func(); + } + catch (err) { + error = err; + const currentDelay = typeof delay$1 === 'function' ? delay$1(attempts) : delay$1; + await delay.delay(currentDelay); + } + } + throw error; +} + +exports.retry = retry; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e18429d5c7566df3aa1884e80a1819e260513359 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/retry.mjs @@ -0,0 +1,36 @@ +import { delay } from '../promise/delay.mjs'; + +const DEFAULT_DELAY = 0; +const DEFAULT_RETRIES = Number.POSITIVE_INFINITY; +async function retry(func, _options) { + let delay$1; + let retries; + let signal; + if (typeof _options === 'number') { + delay$1 = DEFAULT_DELAY; + retries = _options; + signal = undefined; + } + else { + delay$1 = _options?.delay ?? DEFAULT_DELAY; + retries = _options?.retries ?? DEFAULT_RETRIES; + signal = _options?.signal; + } + let error; + for (let attempts = 0; attempts < retries; attempts++) { + if (signal?.aborted) { + throw error ?? new Error(`The retry operation was aborted due to an abort signal.`); + } + try { + return await func(); + } + catch (err) { + error = err; + const currentDelay = typeof delay$1 === 'function' ? delay$1(attempts) : delay$1; + await delay(currentDelay); + } + } + throw error; +} + +export { retry }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d8463ff0560a52d0e21a5cf6659e5a8e72535ffa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.d.mts @@ -0,0 +1,19 @@ +/** + * Creates a new function that spreads elements of an array argument into individual arguments + * for the original function. + * + * @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. + * @returns {(argsArr: Parameters) => ReturnType} - A new function that takes an array of arguments 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 + */ +declare function spread any>(func: F): (argsArr: Parameters) => ReturnType; + +export { spread }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d8463ff0560a52d0e21a5cf6659e5a8e72535ffa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.d.ts @@ -0,0 +1,19 @@ +/** + * Creates a new function that spreads elements of an array argument into individual arguments + * for the original function. + * + * @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. + * @returns {(argsArr: Parameters) => ReturnType} - A new function that takes an array of arguments 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 + */ +declare function spread any>(func: F): (argsArr: Parameters) => ReturnType; + +export { spread }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.js new file mode 100644 index 0000000000000000000000000000000000000000..5d98b370f6bdb083f81443ebea85e5c12f546dd5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function spread(func) { + return function (argsArr) { + return func.apply(this, argsArr); + }; +} + +exports.spread = spread; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a446f731f8f65ac7fa2e15d8ab905f653ee39fc8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/spread.mjs @@ -0,0 +1,7 @@ +function spread(func) { + return function (argsArr) { + return func.apply(this, argsArr); + }; +} + +export { spread }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..3e0590d10fb2f8caab7e1595a0b6583b28417289 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.d.mts @@ -0,0 +1,48 @@ +interface ThrottleOptions { + /** + * An optional AbortSignal to cancel the debounced function. + */ + signal?: AbortSignal; + /** + * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both. + * If `edges` includes "leading", the function will be invoked at the start of the delay period. + * If `edges` includes "trailing", the function will be invoked at the end of the delay period. + * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period. + * @default ["leading", "trailing"] + */ + edges?: Array<'leading' | 'trailing'>; +} +interface ThrottledFunction void> { + (...args: Parameters): void; + cancel: () => void; + flush: () => void; +} +/** + * 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. + * @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 void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction; + +export { type ThrottledFunction, throttle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3e0590d10fb2f8caab7e1595a0b6583b28417289 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.d.ts @@ -0,0 +1,48 @@ +interface ThrottleOptions { + /** + * An optional AbortSignal to cancel the debounced function. + */ + signal?: AbortSignal; + /** + * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both. + * If `edges` includes "leading", the function will be invoked at the start of the delay period. + * If `edges` includes "trailing", the function will be invoked at the end of the delay period. + * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period. + * @default ["leading", "trailing"] + */ + edges?: Array<'leading' | 'trailing'>; +} +interface ThrottledFunction void> { + (...args: Parameters): void; + cancel: () => void; + flush: () => void; +} +/** + * 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. + * @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 void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction; + +export { type ThrottledFunction, throttle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.js new file mode 100644 index 0000000000000000000000000000000000000000..d5eac24812a50935ba9060f9da79600bdc06b930 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const debounce = require('./debounce.js'); + +function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) { + let pendingAt = null; + const debounced = debounce.debounce(func, throttleMs, { signal, edges }); + const throttled = function (...args) { + if (pendingAt == null) { + pendingAt = Date.now(); + } + else { + if (Date.now() - pendingAt >= throttleMs) { + pendingAt = Date.now(); + debounced.cancel(); + } + } + debounced(...args); + }; + throttled.cancel = debounced.cancel; + throttled.flush = debounced.flush; + return throttled; +} + +exports.throttle = throttle; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9141494ba35fce9c0fdd2f9611eca9251e644212 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/throttle.mjs @@ -0,0 +1,23 @@ +import { debounce } from './debounce.mjs'; + +function throttle(func, throttleMs, { signal, edges = ['leading', 'trailing'] } = {}) { + let pendingAt = null; + const debounced = debounce(func, throttleMs, { signal, edges }); + const throttled = function (...args) { + if (pendingAt == null) { + pendingAt = Date.now(); + } + else { + if (Date.now() - pendingAt >= throttleMs) { + pendingAt = Date.now(); + debounced.cancel(); + } + } + debounced(...args); + }; + throttled.cancel = debounced.cancel; + throttled.flush = debounced.flush; + return throttled; +} + +export { throttle }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/unary.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/unary.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5973303b3b2d3fcb7c1c714d95022a53fcaf03e4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 any>(func: F): (...args: any[]) => ReturnType; + +export { unary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/unary.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/unary.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..5973303b3b2d3fcb7c1c714d95022a53fcaf03e4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 any>(func: F): (...args: any[]) => ReturnType; + +export { unary }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/unary.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/unary.js new file mode 100644 index 0000000000000000000000000000000000000000..d56f0566038ef80344587bb79411daadd1e766b2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/function/unary.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/function/unary.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f4b2cb1d6c1222069ff38e7d4de6800711609f87 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/math/clamp.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9e80fc6fe861f41859bf6aa158581f75ab478a84 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.d.mts @@ -0,0 +1,32 @@ +/** + * Clamps a number within the inclusive upper bound. + * + * This function takes a number and a maximum bound, and returns the number clamped within the specified upper bound. + * If only one bound is provided, it returns the minimum of the value and the bound. + * + * @param {number} value - The number to clamp. + * @param {number} maximum - The maximum bound to clamp the number. + * @returns {number} The clamped number within the specified upper bound. + * + * @example + * const result1 = clamp(10, 5); // result1 will be 5, as 10 is clamped to the bound 5 + */ +declare function clamp(value: number, maximum: number): number; +/** + * Clamps a number within the inclusive lower and upper bounds. + * + * This function takes a number and two bounds, and returns the number clamped within the specified bounds. + * + * @param {number} value - The number to clamp. + * @param {number} minimum - The minimum bound to clamp the number. + * @param {number} maximum - The maximum bound to clamp the number. + * @returns {number} The clamped number within the specified bounds. + * + * @example + * const result2 = clamp(10, 5, 15); // result2 will be 10, as it is within the bounds 5 and 15 + * const result3 = clamp(2, 5, 15); // result3 will be 5, as 2 is clamped to the lower bound 5 + * const result4 = clamp(20, 5, 15); // result4 will be 15, as 20 is clamped to the upper bound 15 + */ +declare function clamp(value: number, minimum: number, maximum: number): number; + +export { clamp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9e80fc6fe861f41859bf6aa158581f75ab478a84 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.d.ts @@ -0,0 +1,32 @@ +/** + * Clamps a number within the inclusive upper bound. + * + * This function takes a number and a maximum bound, and returns the number clamped within the specified upper bound. + * If only one bound is provided, it returns the minimum of the value and the bound. + * + * @param {number} value - The number to clamp. + * @param {number} maximum - The maximum bound to clamp the number. + * @returns {number} The clamped number within the specified upper bound. + * + * @example + * const result1 = clamp(10, 5); // result1 will be 5, as 10 is clamped to the bound 5 + */ +declare function clamp(value: number, maximum: number): number; +/** + * Clamps a number within the inclusive lower and upper bounds. + * + * This function takes a number and two bounds, and returns the number clamped within the specified bounds. + * + * @param {number} value - The number to clamp. + * @param {number} minimum - The minimum bound to clamp the number. + * @param {number} maximum - The maximum bound to clamp the number. + * @returns {number} The clamped number within the specified bounds. + * + * @example + * const result2 = clamp(10, 5, 15); // result2 will be 10, as it is within the bounds 5 and 15 + * const result3 = clamp(2, 5, 15); // result3 will be 5, as 2 is clamped to the lower bound 5 + * const result4 = clamp(20, 5, 15); // result4 will be 15, as 20 is clamped to the upper bound 15 + */ +declare function clamp(value: number, minimum: number, maximum: number): number; + +export { clamp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.js new file mode 100644 index 0000000000000000000000000000000000000000..44242ec5d78b217980068c9b2403e25a6b55074f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function clamp(value, bound1, bound2) { + if (bound2 == null) { + return Math.min(value, bound1); + } + return Math.min(Math.max(value, bound1), bound2); +} + +exports.clamp = clamp; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.mjs new file mode 100644 index 0000000000000000000000000000000000000000..bd15581c128ae5b4a696b36f1b6dbd49ca77df18 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/clamp.mjs @@ -0,0 +1,8 @@ +function clamp(value, bound1, bound2) { + if (bound2 == null) { + return Math.min(value, bound1); + } + return Math.min(Math.max(value, bound1), bound2); +} + +export { clamp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..dbf89d517de763f256a508ff27ab8995cda176f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.d.mts @@ -0,0 +1,27 @@ +/** + * Checks if the value is less than the maximum. + * + * @param {number} value The value to check. + * @param {number} maximum The upper bound of the range (exclusive). + * @returns {boolean} `true` if the value is less than the maximum, otherwise `false`. + * + * @example + * const result = inRange(3, 5); // result will be true. + * const result2 = inRange(5, 5); // result2 will be false. + */ +declare function inRange(value: number, maximum: number): boolean; +/** + * Checks if the value is within the range defined by minimum (inclusive) and maximum (exclusive). + * + * @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`. + * + * @example + * const result = inRange(3, 2, 5); // result will be true. + * const result2 = inRange(1, 2, 5); // result2 will be false. + */ +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/math/inRange.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dbf89d517de763f256a508ff27ab8995cda176f2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.d.ts @@ -0,0 +1,27 @@ +/** + * Checks if the value is less than the maximum. + * + * @param {number} value The value to check. + * @param {number} maximum The upper bound of the range (exclusive). + * @returns {boolean} `true` if the value is less than the maximum, otherwise `false`. + * + * @example + * const result = inRange(3, 5); // result will be true. + * const result2 = inRange(5, 5); // result2 will be false. + */ +declare function inRange(value: number, maximum: number): boolean; +/** + * Checks if the value is within the range defined by minimum (inclusive) and maximum (exclusive). + * + * @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`. + * + * @example + * const result = inRange(3, 2, 5); // result will be true. + * const result2 = inRange(1, 2, 5); // result2 will be false. + */ +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/math/inRange.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.js new file mode 100644 index 0000000000000000000000000000000000000000..fd9d89709ba5a018ed375fd039876f9076ed1df9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function inRange(value, minimum, maximum) { + if (maximum == null) { + maximum = minimum; + minimum = 0; + } + if (minimum >= maximum) { + throw new Error('The maximum value must be greater than the minimum value.'); + } + return minimum <= value && value < maximum; +} + +exports.inRange = inRange; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.mjs new file mode 100644 index 0000000000000000000000000000000000000000..80a951313edd67778ba9f4e594ecaaaddd92e9d7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/inRange.mjs @@ -0,0 +1,12 @@ +function inRange(value, minimum, maximum) { + if (maximum == null) { + maximum = minimum; + minimum = 0; + } + if (minimum >= maximum) { + throw new Error('The maximum value must be greater than the minimum value.'); + } + return minimum <= value && value < maximum; +} + +export { inRange }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b302cd51313e0a51db046884a101ca5230449bc7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.d.mts @@ -0,0 +1,13 @@ +export { clamp } from './clamp.mjs'; +export { inRange } from './inRange.mjs'; +export { mean } from './mean.mjs'; +export { meanBy } from './meanBy.mjs'; +export { median } from './median.mjs'; +export { medianBy } from './medianBy.mjs'; +export { random } from './random.mjs'; +export { randomInt } from './randomInt.mjs'; +export { range } from './range.mjs'; +export { rangeRight } from './rangeRight.mjs'; +export { round } from './round.mjs'; +export { sum } from './sum.mjs'; +export { sumBy } from './sumBy.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3cd67e7983176816d74b9fa23644e3cf7b6dc05c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.d.ts @@ -0,0 +1,13 @@ +export { clamp } from './clamp.js'; +export { inRange } from './inRange.js'; +export { mean } from './mean.js'; +export { meanBy } from './meanBy.js'; +export { median } from './median.js'; +export { medianBy } from './medianBy.js'; +export { random } from './random.js'; +export { randomInt } from './randomInt.js'; +export { range } from './range.js'; +export { rangeRight } from './rangeRight.js'; +export { round } from './round.js'; +export { sum } from './sum.js'; +export { sumBy } from './sumBy.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.js new file mode 100644 index 0000000000000000000000000000000000000000..cf399455392e4b8f65db773b76ff36a3214d0f15 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.js @@ -0,0 +1,33 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const clamp = require('./clamp.js'); +const inRange = require('./inRange.js'); +const mean = require('./mean.js'); +const meanBy = require('./meanBy.js'); +const median = require('./median.js'); +const medianBy = require('./medianBy.js'); +const random = require('./random.js'); +const randomInt = require('./randomInt.js'); +const range = require('./range.js'); +const rangeRight = require('./rangeRight.js'); +const round = require('./round.js'); +const sum = require('./sum.js'); +const sumBy = require('./sumBy.js'); + + + +exports.clamp = clamp.clamp; +exports.inRange = inRange.inRange; +exports.mean = mean.mean; +exports.meanBy = meanBy.meanBy; +exports.median = median.median; +exports.medianBy = medianBy.medianBy; +exports.random = random.random; +exports.randomInt = randomInt.randomInt; +exports.range = range.range; +exports.rangeRight = rangeRight.rangeRight; +exports.round = round.round; +exports.sum = sum.sum; +exports.sumBy = sumBy.sumBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b302cd51313e0a51db046884a101ca5230449bc7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/index.mjs @@ -0,0 +1,13 @@ +export { clamp } from './clamp.mjs'; +export { inRange } from './inRange.mjs'; +export { mean } from './mean.mjs'; +export { meanBy } from './meanBy.mjs'; +export { median } from './median.mjs'; +export { medianBy } from './medianBy.mjs'; +export { random } from './random.mjs'; +export { randomInt } from './randomInt.mjs'; +export { range } from './range.mjs'; +export { rangeRight } from './rangeRight.mjs'; +export { round } from './round.mjs'; +export { sum } from './sum.mjs'; +export { sumBy } from './sumBy.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9d760796280414db011be81212aed35191e3cd7d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {number[]} 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: readonly number[]): number; + +export { mean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9d760796280414db011be81212aed35191e3cd7d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {number[]} 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: readonly number[]): number; + +export { mean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.js new file mode 100644 index 0000000000000000000000000000000000000000..7ea8502ab98418d7178b40c26ce708e5c8900150 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const sum = require('./sum.js'); + +function mean(nums) { + return sum.sum(nums) / nums.length; +} + +exports.mean = mean; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.mjs new file mode 100644 index 0000000000000000000000000000000000000000..17910299b87376b07eb21d13b954947a5eb03446 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/mean.mjs @@ -0,0 +1,7 @@ +import { sum } from './sum.mjs'; + +function mean(nums) { + return sum(nums) / nums.length; +} + +export { mean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0fd94e72b56fe84ad30add142cfb5b8e69b54c58 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.d.mts @@ -0,0 +1,18 @@ +/** + * Calculates the average of an array of numbers when applying + * the `getValue` 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) => number} getValue A function that selects a numeric value from each element. + * @returns {number} The average of all the numbers as determined by the `getValue` function. + * + * @example + * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2 + * meanBy([], x => x.a); // Returns: NaN + */ +declare function meanBy(items: readonly T[], getValue: (element: T) => number): number; + +export { meanBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0fd94e72b56fe84ad30add142cfb5b8e69b54c58 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.d.ts @@ -0,0 +1,18 @@ +/** + * Calculates the average of an array of numbers when applying + * the `getValue` 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) => number} getValue A function that selects a numeric value from each element. + * @returns {number} The average of all the numbers as determined by the `getValue` function. + * + * @example + * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2 + * meanBy([], x => x.a); // Returns: NaN + */ +declare function meanBy(items: readonly T[], getValue: (element: T) => number): number; + +export { meanBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.js new file mode 100644 index 0000000000000000000000000000000000000000..4bac7be749216d8ce162f730a9c0f679c00ed152 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const mean = require('./mean.js'); + +function meanBy(items, getValue) { + const nums = items.map(x => getValue(x)); + return mean.mean(nums); +} + +exports.meanBy = meanBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a65c0e33ffb00d2eb644153e2f5f746bda7b8a82 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/meanBy.mjs @@ -0,0 +1,8 @@ +import { mean } from './mean.mjs'; + +function meanBy(items, getValue) { + const nums = items.map(x => getValue(x)); + return mean(nums); +} + +export { meanBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..71a2fecfe43d1b7536577e7cbad796f387a7ae6d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.d.mts @@ -0,0 +1,25 @@ +/** + * Calculates the median of an array of numbers. + * + * The median is the middle value of a sorted array. + * If the array has an odd number of elements, the median is the middle value. + * If the array has an even number of elements, it returns the average of the two middle values. + * + * If the array is empty, this function returns `NaN`. + * + * @param {number[]} nums - An array of numbers to calculate the median. + * @returns {number} The median of all the numbers in the array. + * + * @example + * const arrayWithOddNumberOfElements = [1, 2, 3, 4, 5]; + * const result = median(arrayWithOddNumberOfElements); + * // result will be 3 + * + * @example + * const arrayWithEvenNumberOfElements = [1, 2, 3, 4]; + * const result = median(arrayWithEvenNumberOfElements); + * // result will be 2.5 + */ +declare function median(nums: readonly number[]): number; + +export { median }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..71a2fecfe43d1b7536577e7cbad796f387a7ae6d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.d.ts @@ -0,0 +1,25 @@ +/** + * Calculates the median of an array of numbers. + * + * The median is the middle value of a sorted array. + * If the array has an odd number of elements, the median is the middle value. + * If the array has an even number of elements, it returns the average of the two middle values. + * + * If the array is empty, this function returns `NaN`. + * + * @param {number[]} nums - An array of numbers to calculate the median. + * @returns {number} The median of all the numbers in the array. + * + * @example + * const arrayWithOddNumberOfElements = [1, 2, 3, 4, 5]; + * const result = median(arrayWithOddNumberOfElements); + * // result will be 3 + * + * @example + * const arrayWithEvenNumberOfElements = [1, 2, 3, 4]; + * const result = median(arrayWithEvenNumberOfElements); + * // result will be 2.5 + */ +declare function median(nums: readonly number[]): number; + +export { median }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.js new file mode 100644 index 0000000000000000000000000000000000000000..5794bcc6ffe1691e7c632731969df23d05e21656 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function median(nums) { + if (nums.length === 0) { + return NaN; + } + const sorted = nums.slice().sort((a, b) => a - b); + const middleIndex = Math.floor(sorted.length / 2); + if (sorted.length % 2 === 0) { + return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2; + } + else { + return sorted[middleIndex]; + } +} + +exports.median = median; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3e9c75cb890960b453c85aec4667a11e09e2aba9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/median.mjs @@ -0,0 +1,15 @@ +function median(nums) { + if (nums.length === 0) { + return NaN; + } + const sorted = nums.slice().sort((a, b) => a - b); + const middleIndex = Math.floor(sorted.length / 2); + if (sorted.length % 2 === 0) { + return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2; + } + else { + return sorted[middleIndex]; + } +} + +export { median }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..476b71fff15b1d00d8ce5128184bdc565f750a06 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.d.mts @@ -0,0 +1,23 @@ +/** + * Calculates the median of an array of elements when applying + * the `getValue` function to each element. + * + * The median is the middle value of a sorted array. + * If the array has an odd number of elements, the median is the middle value. + * If the array has an even number of elements, it returns the average of the two middle values. + * + * 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 median. + * @param {(element: T) => number} getValue A function that selects a numeric value from each element. + * @returns {number} The median of all the numbers as determined by the `getValue` function. + * + * @example + * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }], x => x.a); // Returns: 3 + * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }], x => x.a); // Returns: 2.5 + * medianBy([], x => x.a); // Returns: NaN + */ +declare function medianBy(items: readonly T[], getValue: (element: T) => number): number; + +export { medianBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..476b71fff15b1d00d8ce5128184bdc565f750a06 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.d.ts @@ -0,0 +1,23 @@ +/** + * Calculates the median of an array of elements when applying + * the `getValue` function to each element. + * + * The median is the middle value of a sorted array. + * If the array has an odd number of elements, the median is the middle value. + * If the array has an even number of elements, it returns the average of the two middle values. + * + * 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 median. + * @param {(element: T) => number} getValue A function that selects a numeric value from each element. + * @returns {number} The median of all the numbers as determined by the `getValue` function. + * + * @example + * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }], x => x.a); // Returns: 3 + * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }], x => x.a); // Returns: 2.5 + * medianBy([], x => x.a); // Returns: NaN + */ +declare function medianBy(items: readonly T[], getValue: (element: T) => number): number; + +export { medianBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.js new file mode 100644 index 0000000000000000000000000000000000000000..d133b2f1e47eb717c6eaf92747d48add459ed67f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const median = require('./median.js'); + +function medianBy(items, getValue) { + const nums = items.map(x => getValue(x)); + return median.median(nums); +} + +exports.medianBy = medianBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..65b0526f52fb44e79d018e7876c6806ea30f64ec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/medianBy.mjs @@ -0,0 +1,8 @@ +import { median } from './median.mjs'; + +function medianBy(items, getValue) { + const nums = items.map(x => getValue(x)); + return median(nums); +} + +export { medianBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fb520a99d93a7859ca434a2650abfb91f27528b7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.d.mts @@ -0,0 +1,30 @@ +/** + * Generate a random number within the given range. + * + * If only one argument is provided, a number between `0` and the given number is returned. + * + * @param {number} maximum - The upper bound (exclusive). + * @returns {number} A random number between 0 (inclusive) and maximum (exclusive). The number can be an integer or a decimal. + * @throws {Error} Throws an error if `maximum` is not greater than `0`. + * + * @example + * const result1 = random(5); // Returns a random number between 0 and 5. + * const result2 = random(0); // If the `maximum` is less than or equal to 0, an error is thrown. + */ +declare function random(maximum: number): number; +/** + * Generate a random number within the given range. + * + * @param {number} minimum - The lower bound (inclusive). + * @param {number} maximum - The upper bound (exclusive). + * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal. + * @throws {Error} Throws an error if `maximum` is not greater than `minimum`. + * + * @example + * const result1 = random(0, 5); // Returns a random number between 0 and 5. + * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown. + * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown. + */ +declare function random(minimum: number, maximum: number): number; + +export { random }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fb520a99d93a7859ca434a2650abfb91f27528b7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.d.ts @@ -0,0 +1,30 @@ +/** + * Generate a random number within the given range. + * + * If only one argument is provided, a number between `0` and the given number is returned. + * + * @param {number} maximum - The upper bound (exclusive). + * @returns {number} A random number between 0 (inclusive) and maximum (exclusive). The number can be an integer or a decimal. + * @throws {Error} Throws an error if `maximum` is not greater than `0`. + * + * @example + * const result1 = random(5); // Returns a random number between 0 and 5. + * const result2 = random(0); // If the `maximum` is less than or equal to 0, an error is thrown. + */ +declare function random(maximum: number): number; +/** + * Generate a random number within the given range. + * + * @param {number} minimum - The lower bound (inclusive). + * @param {number} maximum - The upper bound (exclusive). + * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal. + * @throws {Error} Throws an error if `maximum` is not greater than `minimum`. + * + * @example + * const result1 = random(0, 5); // Returns a random number between 0 and 5. + * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown. + * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown. + */ +declare function random(minimum: number, maximum: number): number; + +export { random }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.js new file mode 100644 index 0000000000000000000000000000000000000000..458a9a6e8e31137f4c1a516d24a476621e7f8705 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function random(minimum, maximum) { + if (maximum == null) { + maximum = minimum; + minimum = 0; + } + if (minimum >= maximum) { + throw new Error('Invalid input: The maximum value must be greater than the minimum value.'); + } + return Math.random() * (maximum - minimum) + minimum; +} + +exports.random = random; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.mjs new file mode 100644 index 0000000000000000000000000000000000000000..833da4b24799ae40e0578cb3bf57ddb6414f97b0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/random.mjs @@ -0,0 +1,12 @@ +function random(minimum, maximum) { + if (maximum == null) { + maximum = minimum; + minimum = 0; + } + if (minimum >= maximum) { + throw new Error('Invalid input: The maximum value must be greater than the minimum value.'); + } + return Math.random() * (maximum - minimum) + minimum; +} + +export { random }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2cb644d07968024ba59e7dbb858838302082d7ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.d.mts @@ -0,0 +1,26 @@ +/** + * Generates a random integer between 0 (inclusive) and the given maximum (exclusive). + * + * @param {number} maximum - The upper bound (exclusive). + * @returns {number} A random integer between 0 (inclusive) and maximum (exclusive). + * @throws {Error} Throws an error if `maximum` is not greater than `0`. + * + * @example + * const result = randomInt(5); // result will be a random integer between 0 (inclusive) and 5 (exclusive) + */ +declare function randomInt(maximum: number): number; +/** + * Generates a random integer between minimum (inclusive) and maximum (exclusive). + * + * @param {number} minimum - The lower bound (inclusive). + * @param {number} maximum - The upper bound (exclusive). + * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive). + * @throws {Error} Throws an error if `maximum` is not greater than `minimum`. + * + * @example + * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive) + * const result2 = randomInt(5, 0); // This will throw an error + */ +declare function randomInt(minimum: number, maximum: number): number; + +export { randomInt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2cb644d07968024ba59e7dbb858838302082d7ed --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.d.ts @@ -0,0 +1,26 @@ +/** + * Generates a random integer between 0 (inclusive) and the given maximum (exclusive). + * + * @param {number} maximum - The upper bound (exclusive). + * @returns {number} A random integer between 0 (inclusive) and maximum (exclusive). + * @throws {Error} Throws an error if `maximum` is not greater than `0`. + * + * @example + * const result = randomInt(5); // result will be a random integer between 0 (inclusive) and 5 (exclusive) + */ +declare function randomInt(maximum: number): number; +/** + * Generates a random integer between minimum (inclusive) and maximum (exclusive). + * + * @param {number} minimum - The lower bound (inclusive). + * @param {number} maximum - The upper bound (exclusive). + * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive). + * @throws {Error} Throws an error if `maximum` is not greater than `minimum`. + * + * @example + * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive) + * const result2 = randomInt(5, 0); // This will throw an error + */ +declare function randomInt(minimum: number, maximum: number): number; + +export { randomInt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.js new file mode 100644 index 0000000000000000000000000000000000000000..51a4f47f6a4a459ce449f4ceee0678dc6c65aa68 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const random = require('./random.js'); + +function randomInt(minimum, maximum) { + return Math.floor(random.random(minimum, maximum)); +} + +exports.randomInt = randomInt; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d6e825225ed80f2c7f2c6996937688fb617806d2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/randomInt.mjs @@ -0,0 +1,7 @@ +import { random } from './random.mjs'; + +function randomInt(minimum, maximum) { + return Math.floor(random(minimum, maximum)); +} + +export { randomInt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a3559645a21fc25a681837e990d3c5de864a3206 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.d.mts @@ -0,0 +1,38 @@ +/** + * Returns an array of numbers from `0` (inclusive) to `end` (exclusive), incrementing by `1`. + * + * @param {number} end - The end number of the range (exclusive). + * @returns {number[]} An array of numbers from `0` (inclusive) to `end` (exclusive) with a step of `1`. + * + * @example + * // Returns [0, 1, 2, 3] + * range(4); + */ +declare function range(end: number): number[]; +/** + * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `1`. + * + * @param {number} start - The starting number of the range (inclusive). + * @param {number} end - The end number of the range (exclusive). + * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with a step of `1`. + * + * @example + * // Returns [1, 2, 3] + * range(1, 4); + */ +declare function range(start: number, end: number): number[]; +/** + * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `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` (inclusive) to `end` (exclusive) with the specified `step`. + * + * @example + * // Returns [0, 5, 10, 15] + * range(0, 20, 5); + */ +declare function range(start: number, end: number, step: number): number[]; + +export { range }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a3559645a21fc25a681837e990d3c5de864a3206 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.d.ts @@ -0,0 +1,38 @@ +/** + * Returns an array of numbers from `0` (inclusive) to `end` (exclusive), incrementing by `1`. + * + * @param {number} end - The end number of the range (exclusive). + * @returns {number[]} An array of numbers from `0` (inclusive) to `end` (exclusive) with a step of `1`. + * + * @example + * // Returns [0, 1, 2, 3] + * range(4); + */ +declare function range(end: number): number[]; +/** + * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `1`. + * + * @param {number} start - The starting number of the range (inclusive). + * @param {number} end - The end number of the range (exclusive). + * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with a step of `1`. + * + * @example + * // Returns [1, 2, 3] + * range(1, 4); + */ +declare function range(start: number, end: number): number[]; +/** + * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `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` (inclusive) to `end` (exclusive) with the specified `step`. + * + * @example + * // Returns [0, 5, 10, 15] + * range(0, 20, 5); + */ +declare function range(start: number, end: number, step: number): number[]; + +export { range }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.js new file mode 100644 index 0000000000000000000000000000000000000000..e6e2d0e72fa9cb494b525532d1ed10ac1504d921 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.js @@ -0,0 +1,21 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function range(start, end, step = 1) { + if (end == null) { + end = start; + start = 0; + } + if (!Number.isInteger(step) || step === 0) { + throw new Error(`The step value must be a non-zero integer.`); + } + const length = Math.max(Math.ceil((end - start) / step), 0); + const result = new Array(length); + for (let i = 0; i < length; i++) { + result[i] = start + i * step; + } + return result; +} + +exports.range = range; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.mjs new file mode 100644 index 0000000000000000000000000000000000000000..63e71f3f6a38e861f8d8b8b77d4806d3acbefea8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/range.mjs @@ -0,0 +1,17 @@ +function range(start, end, step = 1) { + if (end == null) { + end = start; + start = 0; + } + if (!Number.isInteger(step) || step === 0) { + throw new Error(`The step value must be a non-zero integer.`); + } + const length = Math.max(Math.ceil((end - start) / step), 0); + const result = new Array(length); + for (let i = 0; i < length; i++) { + result[i] = start + i * step; + } + return result; +} + +export { range }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9312f744ce207c152cc5ed94a6e1a2fa6519945b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.d.mts @@ -0,0 +1,38 @@ +/** + * Returns an array of numbers from `end` (exclusive) to `0` (inclusive), decrementing by `1`. + * + * @param {number} end - The end number of the range (exclusive). + * @returns {number[]} An array of numbers from `end` (exclusive) to `0` (inclusive) with a step of `1`. + * + * @example + * // Returns [3, 2, 1, 0] + * rangeRight(4); + */ +declare function rangeRight(end: number): number[]; +/** + * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `1`. + * + * @param {number} start - The starting number of the range (inclusive). + * @param {number} end - The end number of the range (exclusive). + * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with a step of `1`. + * + * @example + * // Returns [3, 2, 1] + * rangeRight(1, 4); + */ +declare function rangeRight(start: number, end: number): number[]; +/** + * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `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 `end` (exclusive) to `start` (inclusive) with the specified `step`. + * + * @example + * // Returns [15, 10, 5, 0] + * rangeRight(0, 20, 5); + */ +declare function rangeRight(start: number, end: number, step: number): number[]; + +export { rangeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9312f744ce207c152cc5ed94a6e1a2fa6519945b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.d.ts @@ -0,0 +1,38 @@ +/** + * Returns an array of numbers from `end` (exclusive) to `0` (inclusive), decrementing by `1`. + * + * @param {number} end - The end number of the range (exclusive). + * @returns {number[]} An array of numbers from `end` (exclusive) to `0` (inclusive) with a step of `1`. + * + * @example + * // Returns [3, 2, 1, 0] + * rangeRight(4); + */ +declare function rangeRight(end: number): number[]; +/** + * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `1`. + * + * @param {number} start - The starting number of the range (inclusive). + * @param {number} end - The end number of the range (exclusive). + * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with a step of `1`. + * + * @example + * // Returns [3, 2, 1] + * rangeRight(1, 4); + */ +declare function rangeRight(start: number, end: number): number[]; +/** + * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `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 `end` (exclusive) to `start` (inclusive) with the specified `step`. + * + * @example + * // Returns [15, 10, 5, 0] + * rangeRight(0, 20, 5); + */ +declare function rangeRight(start: number, end: number, step: number): number[]; + +export { rangeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.js new file mode 100644 index 0000000000000000000000000000000000000000..7434f1c8676db2a4bbba159fbcc2b77fc340318f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.js @@ -0,0 +1,21 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function rangeRight(start, end, step = 1) { + if (end == null) { + end = start; + start = 0; + } + if (!Number.isInteger(step) || step === 0) { + throw new Error(`The step value must be a non-zero integer.`); + } + const length = Math.max(Math.ceil((end - start) / step), 0); + const result = new Array(length); + for (let i = 0; i < length; i++) { + result[i] = start + (length - i - 1) * step; + } + return result; +} + +exports.rangeRight = rangeRight; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3e62ed665e4966be827fef858bd4947f01db6ff1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/rangeRight.mjs @@ -0,0 +1,17 @@ +function rangeRight(start, end, step = 1) { + if (end == null) { + end = start; + start = 0; + } + if (!Number.isInteger(step) || step === 0) { + throw new Error(`The step value must be a non-zero integer.`); + } + const length = Math.max(Math.ceil((end - start) / step), 0); + const result = new Array(length); + for (let i = 0; i < length; i++) { + result[i] = start + (length - i - 1) * step; + } + return result; +} + +export { rangeRight }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0334d0ab1b7d6424bca5f68bad16f60bc217bfdd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.d.mts @@ -0,0 +1,20 @@ +/** + * Rounds a number to a specified precision. + * + * This function takes a number and an optional precision value, and returns the number rounded + * to the specified number of decimal places. + * + * @param {number} value - The number to round. + * @param {number} [precision=0] - The number of decimal places to round to. Defaults to 0. + * @returns {number} The rounded number. + * @throws {Error} Throws an error if `Precision` is not integer. + * + * @example + * const result1 = round(1.2345); // result1 will be 1 + * const result2 = round(1.2345, 2); // result2 will be 1.23 + * const result3 = round(1.2345, 3); // result3 will be 1.235 + * const result4 = round(1.2345, 3.1); // This will throw an error + */ +declare function round(value: number, precision?: number): number; + +export { round }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0334d0ab1b7d6424bca5f68bad16f60bc217bfdd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.d.ts @@ -0,0 +1,20 @@ +/** + * Rounds a number to a specified precision. + * + * This function takes a number and an optional precision value, and returns the number rounded + * to the specified number of decimal places. + * + * @param {number} value - The number to round. + * @param {number} [precision=0] - The number of decimal places to round to. Defaults to 0. + * @returns {number} The rounded number. + * @throws {Error} Throws an error if `Precision` is not integer. + * + * @example + * const result1 = round(1.2345); // result1 will be 1 + * const result2 = round(1.2345, 2); // result2 will be 1.23 + * const result3 = round(1.2345, 3); // result3 will be 1.235 + * const result4 = round(1.2345, 3.1); // This will throw an error + */ +declare function round(value: number, precision?: number): number; + +export { round }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.js new file mode 100644 index 0000000000000000000000000000000000000000..ade7798e964122d06bc4ae300652ce866ebf6133 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function round(value, precision = 0) { + if (!Number.isInteger(precision)) { + throw new Error('Precision must be an integer.'); + } + const multiplier = Math.pow(10, precision); + return Math.round(value * multiplier) / multiplier; +} + +exports.round = round; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6fc599571d89f74bb0c5a37837b360729ea03196 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/round.mjs @@ -0,0 +1,9 @@ +function round(value, precision = 0) { + if (!Number.isInteger(precision)) { + throw new Error('Precision must be an integer.'); + } + const multiplier = Math.pow(10, precision); + return Math.round(value * multiplier) / multiplier; +} + +export { round }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2813d6d2866e31d91f61a872f015837fff06ecff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.d.mts @@ -0,0 +1,16 @@ +/** + * Calculates the sum of an array of numbers. + * + * This function takes an array of numbers and returns the sum of all the elements in the array. + * + * @param {number[]} nums - An array of numbers to be summed. + * @returns {number} The sum of all the numbers in the array. + * + * @example + * const numbers = [1, 2, 3, 4, 5]; + * const result = sum(numbers); + * // result will be 15 + */ +declare function sum(nums: readonly number[]): number; + +export { sum }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2813d6d2866e31d91f61a872f015837fff06ecff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.d.ts @@ -0,0 +1,16 @@ +/** + * Calculates the sum of an array of numbers. + * + * This function takes an array of numbers and returns the sum of all the elements in the array. + * + * @param {number[]} nums - An array of numbers to be summed. + * @returns {number} The sum of all the numbers in the array. + * + * @example + * const numbers = [1, 2, 3, 4, 5]; + * const result = sum(numbers); + * // result will be 15 + */ +declare function sum(nums: readonly number[]): number; + +export { sum }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.js new file mode 100644 index 0000000000000000000000000000000000000000..be01c52a89054da1146ade27ded8a42987e8f424 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function sum(nums) { + let result = 0; + for (let i = 0; i < nums.length; i++) { + result += nums[i]; + } + return result; +} + +exports.sum = sum; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1d056809923753a1c1fee0375b82e6fdbbdd5c32 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sum.mjs @@ -0,0 +1,9 @@ +function sum(nums) { + let result = 0; + for (let i = 0; i < nums.length; i++) { + result += nums[i]; + } + return result; +} + +export { sum }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6f940f26211c0d1fba3a6c98384b337f5f3eacd7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.d.mts @@ -0,0 +1,18 @@ +/** + * Calculates the sum of an array of numbers when applying + * the `getValue` function to each element. + * + * If the array is empty, this function returns `0`. + * + * @template T - The type of elements in the array. + * @param {T[]} items An array to calculate the sum. + * @param {(element: T) => number} getValue A function that selects a numeric value from each element. + * @returns {number} The sum of all the numbers as determined by the `getValue` function. + * + * @example + * sumBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 6 + * sumBy([], x => x.a); // Returns: 0 + */ +declare function sumBy(items: readonly T[], getValue: (element: T) => number): number; + +export { sumBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6f940f26211c0d1fba3a6c98384b337f5f3eacd7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.d.ts @@ -0,0 +1,18 @@ +/** + * Calculates the sum of an array of numbers when applying + * the `getValue` function to each element. + * + * If the array is empty, this function returns `0`. + * + * @template T - The type of elements in the array. + * @param {T[]} items An array to calculate the sum. + * @param {(element: T) => number} getValue A function that selects a numeric value from each element. + * @returns {number} The sum of all the numbers as determined by the `getValue` function. + * + * @example + * sumBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 6 + * sumBy([], x => x.a); // Returns: 0 + */ +declare function sumBy(items: readonly T[], getValue: (element: T) => number): number; + +export { sumBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.js new file mode 100644 index 0000000000000000000000000000000000000000..1fe9e974ca287a9489c71bb5dcce9ae6222a54ea --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function sumBy(items, getValue) { + let result = 0; + for (let i = 0; i < items.length; i++) { + result += getValue(items[i]); + } + return result; +} + +exports.sumBy = sumBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3fd02373ffef37f27560224961115b5f69b90020 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/math/sumBy.mjs @@ -0,0 +1,9 @@ +function sumBy(items, getValue) { + let result = 0; + for (let i = 0; i < items.length; i++) { + result += getValue(items[i]); + } + return result; +} + +export { sumBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/clone.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/clone.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..dda9436244d0cebf02de739de1cd79dcda174d61 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 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 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/object/clone.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/clone.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dda9436244d0cebf02de739de1cd79dcda174d61 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 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 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/object/clone.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/clone.js new file mode 100644 index 0000000000000000000000000000000000000000..9fdb3a739332f3f04ea943a8003fc826f346b7dc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/clone.js @@ -0,0 +1,49 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isPrimitive = require('../predicate/isPrimitive.js'); +const isTypedArray = require('../predicate/isTypedArray.js'); + +function clone(obj) { + if (isPrimitive.isPrimitive(obj)) { + return obj; + } + if (Array.isArray(obj) || + isTypedArray.isTypedArray(obj) || + obj instanceof ArrayBuffer || + (typeof SharedArrayBuffer !== 'undefined' && obj instanceof SharedArrayBuffer)) { + return obj.slice(0); + } + const prototype = Object.getPrototypeOf(obj); + const Constructor = prototype.constructor; + if (obj instanceof Date || obj instanceof Map || obj instanceof Set) { + return new Constructor(obj); + } + if (obj instanceof RegExp) { + const newRegExp = new Constructor(obj); + newRegExp.lastIndex = obj.lastIndex; + return newRegExp; + } + if (obj instanceof DataView) { + return new Constructor(obj.buffer.slice(0)); + } + if (obj instanceof Error) { + const newError = new Constructor(obj.message); + newError.stack = obj.stack; + newError.name = obj.name; + newError.cause = obj.cause; + return newError; + } + if (typeof File !== 'undefined' && obj instanceof File) { + const newFile = new Constructor([obj], obj.name, { type: obj.type, lastModified: obj.lastModified }); + return newFile; + } + if (typeof obj === 'object') { + const newObject = Object.create(prototype); + return Object.assign(newObject, obj); + } + return obj; +} + +exports.clone = clone; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/clone.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/clone.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5c78dc73c8abe844e5ace2f795f4e5d47ac14a26 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/clone.mjs @@ -0,0 +1,45 @@ +import { isPrimitive } from '../predicate/isPrimitive.mjs'; +import { isTypedArray } from '../predicate/isTypedArray.mjs'; + +function clone(obj) { + if (isPrimitive(obj)) { + return obj; + } + if (Array.isArray(obj) || + isTypedArray(obj) || + obj instanceof ArrayBuffer || + (typeof SharedArrayBuffer !== 'undefined' && obj instanceof SharedArrayBuffer)) { + return obj.slice(0); + } + const prototype = Object.getPrototypeOf(obj); + const Constructor = prototype.constructor; + if (obj instanceof Date || obj instanceof Map || obj instanceof Set) { + return new Constructor(obj); + } + if (obj instanceof RegExp) { + const newRegExp = new Constructor(obj); + newRegExp.lastIndex = obj.lastIndex; + return newRegExp; + } + if (obj instanceof DataView) { + return new Constructor(obj.buffer.slice(0)); + } + if (obj instanceof Error) { + const newError = new Constructor(obj.message); + newError.stack = obj.stack; + newError.name = obj.name; + newError.cause = obj.cause; + return newError; + } + if (typeof File !== 'undefined' && obj instanceof File) { + const newFile = new Constructor([obj], obj.name, { type: obj.type, lastModified: obj.lastModified }); + return newFile; + } + if (typeof obj === 'object') { + const newObject = Object.create(prototype); + return Object.assign(newObject, obj); + } + return obj; +} + +export { clone }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeep.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/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/object/cloneDeep.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/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/object/cloneDeep.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeep.js new file mode 100644 index 0000000000000000000000000000000000000000..12954ae0f8fadf9fe8354b9eab391d848b7577e2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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.cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined); +} + +exports.cloneDeep = cloneDeep; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeep.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeep.mjs new file mode 100644 index 0000000000000000000000000000000000000000..626b1f26a3fd4b74999fabae6c5110e71f798fcb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeep.mjs @@ -0,0 +1,7 @@ +import { cloneDeepWithImpl } from './cloneDeepWith.mjs'; + +function cloneDeep(obj) { + return cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined); +} + +export { cloneDeep }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9ac0b31bf948c8b091c083235884087db2fd6088 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.d.mts @@ -0,0 +1,43 @@ +/** + * Deeply clones the given object. + * + * You can customize the deep cloning process using the `cloneValue` function. + * The function takes the current value `value`, the property name `key`, and the entire object `obj` as arguments. + * If the function returns a value, that value is used; + * if it returns `undefined`, the default cloning method is used. + * + * @template T - The type of the object. + * @param {T} obj - The object to clone. + * @param {Function} [cloneValue] - A function to customize the cloning process. + * @returns {T} - A deep clone of the given object. + * + * @example + * // Clone a primitive value + * const num = 29; + * const clonedNum = cloneDeepWith(num); + * console.log(clonedNum); // 29 + * console.log(clonedNum === num); // true + * + * @example + * // Clone an object with a customizer + * const obj = { a: 1, b: 2 }; + * const clonedObj = cloneDeepWith(obj, (value) => { + * if (typeof value === 'number') { + * return value * 2; // Double the number + * } + * }); + * console.log(clonedObj); // { a: 2, b: 4 } + * console.log(clonedObj === obj); // false + * + * @example + * // Clone an array with a customizer + * const arr = [1, 2, 3]; + * const clonedArr = cloneDeepWith(arr, (value) => { + * return value + 1; // Increment each value + * }); + * console.log(clonedArr); // [2, 3, 4] + * console.log(clonedArr === arr); // false + */ +declare function cloneDeepWith(obj: T, cloneValue: (value: any, key: PropertyKey | undefined, obj: T, stack: Map) => any): T; + +export { cloneDeepWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9ac0b31bf948c8b091c083235884087db2fd6088 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.d.ts @@ -0,0 +1,43 @@ +/** + * Deeply clones the given object. + * + * You can customize the deep cloning process using the `cloneValue` function. + * The function takes the current value `value`, the property name `key`, and the entire object `obj` as arguments. + * If the function returns a value, that value is used; + * if it returns `undefined`, the default cloning method is used. + * + * @template T - The type of the object. + * @param {T} obj - The object to clone. + * @param {Function} [cloneValue] - A function to customize the cloning process. + * @returns {T} - A deep clone of the given object. + * + * @example + * // Clone a primitive value + * const num = 29; + * const clonedNum = cloneDeepWith(num); + * console.log(clonedNum); // 29 + * console.log(clonedNum === num); // true + * + * @example + * // Clone an object with a customizer + * const obj = { a: 1, b: 2 }; + * const clonedObj = cloneDeepWith(obj, (value) => { + * if (typeof value === 'number') { + * return value * 2; // Double the number + * } + * }); + * console.log(clonedObj); // { a: 2, b: 4 } + * console.log(clonedObj === obj); // false + * + * @example + * // Clone an array with a customizer + * const arr = [1, 2, 3]; + * const clonedArr = cloneDeepWith(arr, (value) => { + * return value + 1; // Increment each value + * }); + * console.log(clonedArr); // [2, 3, 4] + * console.log(clonedArr === arr); // false + */ +declare function cloneDeepWith(obj: T, cloneValue: (value: any, key: PropertyKey | undefined, obj: T, stack: Map) => any): T; + +export { cloneDeepWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.js new file mode 100644 index 0000000000000000000000000000000000000000..a70a52ac36d935c430cf2989ddeb006229819b91 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.js @@ -0,0 +1,160 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const getSymbols = require('../compat/_internal/getSymbols.js'); +const getTag = require('../compat/_internal/getTag.js'); +const tags = require('../compat/_internal/tags.js'); +const isPrimitive = require('../predicate/isPrimitive.js'); +const isTypedArray = require('../predicate/isTypedArray.js'); + +function cloneDeepWith(obj, cloneValue) { + return cloneDeepWithImpl(obj, undefined, obj, new Map(), cloneValue); +} +function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) { + const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack); + if (cloned != null) { + return cloned; + } + if (isPrimitive.isPrimitive(valueToClone)) { + return valueToClone; + } + if (stack.has(valueToClone)) { + return stack.get(valueToClone); + } + if (Array.isArray(valueToClone)) { + const result = new Array(valueToClone.length); + stack.set(valueToClone, result); + for (let i = 0; i < valueToClone.length; i++) { + result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue); + } + if (Object.hasOwn(valueToClone, 'index')) { + result.index = valueToClone.index; + } + if (Object.hasOwn(valueToClone, 'input')) { + result.input = valueToClone.input; + } + return result; + } + if (valueToClone instanceof Date) { + return new Date(valueToClone.getTime()); + } + if (valueToClone instanceof RegExp) { + const result = new RegExp(valueToClone.source, valueToClone.flags); + result.lastIndex = valueToClone.lastIndex; + return result; + } + if (valueToClone instanceof Map) { + const result = new Map(); + stack.set(valueToClone, result); + for (const [key, value] of valueToClone) { + result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue)); + } + return result; + } + if (valueToClone instanceof Set) { + const result = new Set(); + stack.set(valueToClone, result); + for (const value of valueToClone) { + result.add(cloneDeepWithImpl(value, undefined, objectToClone, stack, cloneValue)); + } + return result; + } + if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) { + return valueToClone.subarray(); + } + if (isTypedArray.isTypedArray(valueToClone)) { + const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length); + stack.set(valueToClone, result); + for (let i = 0; i < valueToClone.length; i++) { + result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue); + } + return result; + } + if (valueToClone instanceof ArrayBuffer || + (typeof SharedArrayBuffer !== 'undefined' && valueToClone instanceof SharedArrayBuffer)) { + return valueToClone.slice(0); + } + if (valueToClone instanceof DataView) { + const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength); + stack.set(valueToClone, result); + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + if (typeof File !== 'undefined' && valueToClone instanceof File) { + const result = new File([valueToClone], valueToClone.name, { + type: valueToClone.type, + }); + stack.set(valueToClone, result); + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + if (valueToClone instanceof Blob) { + const result = new Blob([valueToClone], { type: valueToClone.type }); + stack.set(valueToClone, result); + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + if (valueToClone instanceof Error) { + const result = new valueToClone.constructor(); + stack.set(valueToClone, result); + result.message = valueToClone.message; + result.name = valueToClone.name; + result.stack = valueToClone.stack; + result.cause = valueToClone.cause; + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + if (typeof valueToClone === 'object' && isCloneableObject(valueToClone)) { + const result = Object.create(Object.getPrototypeOf(valueToClone)); + stack.set(valueToClone, result); + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + return valueToClone; +} +function copyProperties(target, source, objectToClone = target, stack, cloneValue) { + const keys = [...Object.keys(source), ...getSymbols.getSymbols(source)]; + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const descriptor = Object.getOwnPropertyDescriptor(target, key); + if (descriptor == null || descriptor.writable) { + target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue); + } + } +} +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; + } + } +} + +exports.cloneDeepWith = cloneDeepWith; +exports.cloneDeepWithImpl = cloneDeepWithImpl; +exports.copyProperties = copyProperties; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0d2817512a8d79400669a735c1a8001cd9bb0edb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/cloneDeepWith.mjs @@ -0,0 +1,154 @@ +import { getSymbols } from '../compat/_internal/getSymbols.mjs'; +import { getTag } from '../compat/_internal/getTag.mjs'; +import { uint32ArrayTag, uint16ArrayTag, uint8ClampedArrayTag, uint8ArrayTag, symbolTag, stringTag, setTag, regexpTag, objectTag, numberTag, mapTag, int32ArrayTag, int16ArrayTag, int8ArrayTag, float64ArrayTag, float32ArrayTag, dateTag, booleanTag, dataViewTag, arrayBufferTag, arrayTag, argumentsTag } from '../compat/_internal/tags.mjs'; +import { isPrimitive } from '../predicate/isPrimitive.mjs'; +import { isTypedArray } from '../predicate/isTypedArray.mjs'; + +function cloneDeepWith(obj, cloneValue) { + return cloneDeepWithImpl(obj, undefined, obj, new Map(), cloneValue); +} +function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) { + const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack); + if (cloned != null) { + return cloned; + } + if (isPrimitive(valueToClone)) { + return valueToClone; + } + if (stack.has(valueToClone)) { + return stack.get(valueToClone); + } + if (Array.isArray(valueToClone)) { + const result = new Array(valueToClone.length); + stack.set(valueToClone, result); + for (let i = 0; i < valueToClone.length; i++) { + result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue); + } + if (Object.hasOwn(valueToClone, 'index')) { + result.index = valueToClone.index; + } + if (Object.hasOwn(valueToClone, 'input')) { + result.input = valueToClone.input; + } + return result; + } + if (valueToClone instanceof Date) { + return new Date(valueToClone.getTime()); + } + if (valueToClone instanceof RegExp) { + const result = new RegExp(valueToClone.source, valueToClone.flags); + result.lastIndex = valueToClone.lastIndex; + return result; + } + if (valueToClone instanceof Map) { + const result = new Map(); + stack.set(valueToClone, result); + for (const [key, value] of valueToClone) { + result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue)); + } + return result; + } + if (valueToClone instanceof Set) { + const result = new Set(); + stack.set(valueToClone, result); + for (const value of valueToClone) { + result.add(cloneDeepWithImpl(value, undefined, objectToClone, stack, cloneValue)); + } + return result; + } + if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) { + return valueToClone.subarray(); + } + if (isTypedArray(valueToClone)) { + const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length); + stack.set(valueToClone, result); + for (let i = 0; i < valueToClone.length; i++) { + result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue); + } + return result; + } + if (valueToClone instanceof ArrayBuffer || + (typeof SharedArrayBuffer !== 'undefined' && valueToClone instanceof SharedArrayBuffer)) { + return valueToClone.slice(0); + } + if (valueToClone instanceof DataView) { + const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength); + stack.set(valueToClone, result); + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + if (typeof File !== 'undefined' && valueToClone instanceof File) { + const result = new File([valueToClone], valueToClone.name, { + type: valueToClone.type, + }); + stack.set(valueToClone, result); + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + if (valueToClone instanceof Blob) { + const result = new Blob([valueToClone], { type: valueToClone.type }); + stack.set(valueToClone, result); + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + if (valueToClone instanceof Error) { + const result = new valueToClone.constructor(); + stack.set(valueToClone, result); + result.message = valueToClone.message; + result.name = valueToClone.name; + result.stack = valueToClone.stack; + result.cause = valueToClone.cause; + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + if (typeof valueToClone === 'object' && isCloneableObject(valueToClone)) { + const result = Object.create(Object.getPrototypeOf(valueToClone)); + stack.set(valueToClone, result); + copyProperties(result, valueToClone, objectToClone, stack, cloneValue); + return result; + } + return valueToClone; +} +function copyProperties(target, source, objectToClone = target, stack, cloneValue) { + const keys = [...Object.keys(source), ...getSymbols(source)]; + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const descriptor = Object.getOwnPropertyDescriptor(target, key); + if (descriptor == null || descriptor.writable) { + target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue); + } + } +} +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; + } + } +} + +export { cloneDeepWith, cloneDeepWithImpl, copyProperties }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..79e21a574c69f9e27841d8f499dc00dcd2913eca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.d.mts @@ -0,0 +1,21 @@ +/** + * Finds the key of the first element in the object that satisfies the provided testing function. + * + * @param {T} obj - The object to search. + * @param {(value: T[keyof T], key: keyof T, obj: T) => boolean} predicate - The function to execute on each value in the object. It takes three arguments: + * - value: The current value being processed in the object. + * - key: The key of the current value being processed in the object. + * - obj: The object that findKey was called upon. + * @returns {keyof T | undefined} The key of the first element in the object that passes the test, or undefined if no element passes. + * + * @example + * const users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * findKey(users, function(o) { return o.age < 40; }); => 'barney' + */ +declare function findKey>(obj: T, predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean): keyof T | undefined; + +export { findKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..79e21a574c69f9e27841d8f499dc00dcd2913eca --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.d.ts @@ -0,0 +1,21 @@ +/** + * Finds the key of the first element in the object that satisfies the provided testing function. + * + * @param {T} obj - The object to search. + * @param {(value: T[keyof T], key: keyof T, obj: T) => boolean} predicate - The function to execute on each value in the object. It takes three arguments: + * - value: The current value being processed in the object. + * - key: The key of the current value being processed in the object. + * - obj: The object that findKey was called upon. + * @returns {keyof T | undefined} The key of the first element in the object that passes the test, or undefined if no element passes. + * + * @example + * const users = { + * 'barney': { 'age': 36, 'active': true }, + * 'fred': { 'age': 40, 'active': false }, + * 'pebbles': { 'age': 1, 'active': true } + * }; + * findKey(users, function(o) { return o.age < 40; }); => 'barney' + */ +declare function findKey>(obj: T, predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean): keyof T | undefined; + +export { findKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.js new file mode 100644 index 0000000000000000000000000000000000000000..3874ebe5cfbab132a7f2a90d42cd49cd7e6a3338 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.js @@ -0,0 +1,10 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function findKey(obj, predicate) { + const keys = Object.keys(obj); + return keys.find(key => predicate(obj[key], key, obj)); +} + +exports.findKey = findKey; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.mjs new file mode 100644 index 0000000000000000000000000000000000000000..09eb3a655537d970d9e2b3221e09ccfef1f27e16 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/findKey.mjs @@ -0,0 +1,6 @@ +function findKey(obj, predicate) { + const keys = Object.keys(obj); + return keys.find(key => predicate(obj[key], key, obj)); +} + +export { findKey }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2078612ca67f4efbd9a92b8c4fee6468047585f6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.d.mts @@ -0,0 +1,36 @@ +interface FlattenObjectOptions { + /** + * The delimiter to use between nested keys. + * @default '.' + */ + delimiter?: string; +} +/** + * Flattens a nested object into a single level object with delimiter-separated keys. + * + * @param {object} object - The object to flatten. + * @param {string} [options.delimiter='.'] - The delimiter to use between nested keys. + * @returns {Record} - The flattened object. + * + * @example + * const nestedObject = { + * a: { + * b: { + * c: 1 + * } + * }, + * d: [2, 3] + * }; + * + * const flattened = flattenObject(nestedObject); + * console.log(flattened); + * // Output: + * // { + * // 'a.b.c': 1, + * // 'd.0': 2, + * // 'd.1': 3 + * // } + */ +declare function flattenObject(object: object, { delimiter }?: FlattenObjectOptions): Record; + +export { flattenObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2078612ca67f4efbd9a92b8c4fee6468047585f6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.d.ts @@ -0,0 +1,36 @@ +interface FlattenObjectOptions { + /** + * The delimiter to use between nested keys. + * @default '.' + */ + delimiter?: string; +} +/** + * Flattens a nested object into a single level object with delimiter-separated keys. + * + * @param {object} object - The object to flatten. + * @param {string} [options.delimiter='.'] - The delimiter to use between nested keys. + * @returns {Record} - The flattened object. + * + * @example + * const nestedObject = { + * a: { + * b: { + * c: 1 + * } + * }, + * d: [2, 3] + * }; + * + * const flattened = flattenObject(nestedObject); + * console.log(flattened); + * // Output: + * // { + * // 'a.b.c': 1, + * // 'd.0': 2, + * // 'd.1': 3 + * // } + */ +declare function flattenObject(object: object, { delimiter }?: FlattenObjectOptions): Record; + +export { flattenObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.js new file mode 100644 index 0000000000000000000000000000000000000000..b4cb8dc74e3a82189ab26a8d90f18a9a05dbd62b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isPlainObject = require('../predicate/isPlainObject.js'); + +function flattenObject(object, { delimiter = '.' } = {}) { + return flattenObjectImpl(object, '', delimiter); +} +function flattenObjectImpl(object, prefix = '', delimiter = '.') { + const result = {}; + const keys = Object.keys(object); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key; + if (isPlainObject.isPlainObject(value) && Object.keys(value).length > 0) { + Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter)); + continue; + } + if (Array.isArray(value)) { + Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter)); + continue; + } + result[prefixedKey] = value; + } + return result; +} + +exports.flattenObject = flattenObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e6ed02bd8c149d9d718831cc27cac8e851533942 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/flattenObject.mjs @@ -0,0 +1,26 @@ +import { isPlainObject } from '../predicate/isPlainObject.mjs'; + +function flattenObject(object, { delimiter = '.' } = {}) { + return flattenObjectImpl(object, '', delimiter); +} +function flattenObjectImpl(object, prefix = '', delimiter = '.') { + const result = {}; + const keys = Object.keys(object); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key; + if (isPlainObject(value) && Object.keys(value).length > 0) { + Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter)); + continue; + } + if (Array.isArray(value)) { + Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter)); + continue; + } + result[prefixedKey] = value; + } + return result; +} + +export { flattenObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ec0417a9fd2702ef5611486d9703f66ac93815dd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.d.mts @@ -0,0 +1,17 @@ +export { clone } from './clone.mjs'; +export { cloneDeep } from './cloneDeep.mjs'; +export { cloneDeepWith } from './cloneDeepWith.mjs'; +export { findKey } from './findKey.mjs'; +export { flattenObject } from './flattenObject.mjs'; +export { invert } from './invert.mjs'; +export { mapKeys } from './mapKeys.mjs'; +export { mapValues } from './mapValues.mjs'; +export { merge } from './merge.mjs'; +export { mergeWith } from './mergeWith.mjs'; +export { omit } from './omit.mjs'; +export { omitBy } from './omitBy.mjs'; +export { pick } from './pick.mjs'; +export { pickBy } from './pickBy.mjs'; +export { toCamelCaseKeys } from './toCamelCaseKeys.mjs'; +export { toMerged } from './toMerged.mjs'; +export { toSnakeCaseKeys } from './toSnakeCaseKeys.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c3b8c2d9f01f708d68489901e50bf8a9bfb72e18 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.d.ts @@ -0,0 +1,17 @@ +export { clone } from './clone.js'; +export { cloneDeep } from './cloneDeep.js'; +export { cloneDeepWith } from './cloneDeepWith.js'; +export { findKey } from './findKey.js'; +export { flattenObject } from './flattenObject.js'; +export { invert } from './invert.js'; +export { mapKeys } from './mapKeys.js'; +export { mapValues } from './mapValues.js'; +export { merge } from './merge.js'; +export { mergeWith } from './mergeWith.js'; +export { omit } from './omit.js'; +export { omitBy } from './omitBy.js'; +export { pick } from './pick.js'; +export { pickBy } from './pickBy.js'; +export { toCamelCaseKeys } from './toCamelCaseKeys.js'; +export { toMerged } from './toMerged.js'; +export { toSnakeCaseKeys } from './toSnakeCaseKeys.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d2a7309bd12b728a14263d4f27cafc47adcf44a0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.js @@ -0,0 +1,41 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const clone = require('./clone.js'); +const cloneDeep = require('./cloneDeep.js'); +const cloneDeepWith = require('./cloneDeepWith.js'); +const findKey = require('./findKey.js'); +const flattenObject = require('./flattenObject.js'); +const invert = require('./invert.js'); +const mapKeys = require('./mapKeys.js'); +const mapValues = require('./mapValues.js'); +const merge = require('./merge.js'); +const mergeWith = require('./mergeWith.js'); +const omit = require('./omit.js'); +const omitBy = require('./omitBy.js'); +const pick = require('./pick.js'); +const pickBy = require('./pickBy.js'); +const toCamelCaseKeys = require('./toCamelCaseKeys.js'); +const toMerged = require('./toMerged.js'); +const toSnakeCaseKeys = require('./toSnakeCaseKeys.js'); + + + +exports.clone = clone.clone; +exports.cloneDeep = cloneDeep.cloneDeep; +exports.cloneDeepWith = cloneDeepWith.cloneDeepWith; +exports.findKey = findKey.findKey; +exports.flattenObject = flattenObject.flattenObject; +exports.invert = invert.invert; +exports.mapKeys = mapKeys.mapKeys; +exports.mapValues = mapValues.mapValues; +exports.merge = merge.merge; +exports.mergeWith = mergeWith.mergeWith; +exports.omit = omit.omit; +exports.omitBy = omitBy.omitBy; +exports.pick = pick.pick; +exports.pickBy = pickBy.pickBy; +exports.toCamelCaseKeys = toCamelCaseKeys.toCamelCaseKeys; +exports.toMerged = toMerged.toMerged; +exports.toSnakeCaseKeys = toSnakeCaseKeys.toSnakeCaseKeys; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ec0417a9fd2702ef5611486d9703f66ac93815dd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/index.mjs @@ -0,0 +1,17 @@ +export { clone } from './clone.mjs'; +export { cloneDeep } from './cloneDeep.mjs'; +export { cloneDeepWith } from './cloneDeepWith.mjs'; +export { findKey } from './findKey.mjs'; +export { flattenObject } from './flattenObject.mjs'; +export { invert } from './invert.mjs'; +export { mapKeys } from './mapKeys.mjs'; +export { mapValues } from './mapValues.mjs'; +export { merge } from './merge.mjs'; +export { mergeWith } from './mergeWith.mjs'; +export { omit } from './omit.mjs'; +export { omitBy } from './omitBy.mjs'; +export { pick } from './pick.mjs'; +export { pickBy } from './pickBy.mjs'; +export { toCamelCaseKeys } from './toCamelCaseKeys.mjs'; +export { toMerged } from './toMerged.mjs'; +export { toSnakeCaseKeys } from './toSnakeCaseKeys.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0f9bf6f231483b008cc622d45c61d73b74b5230d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.d.mts @@ -0,0 +1,21 @@ +/** + * Inverts the keys and values of an object. The keys of the input object become the values of the output object and vice versa. + * + * This function takes an object and creates a new object by inverting its keys and values. If the input object has duplicate values, + * the key of the last occurrence will be used as the value for the new key in the output object. It effectively creates a reverse mapping + * of the input object's key-value pairs. + * + * @template K - Type of the keys in the input object (string, number, symbol) + * @template V - Type of the values in the input object (string, number, symbol) + * @param {Record} obj - The input object whose keys and values are to be inverted + * @returns {Record} - A new object with keys and values inverted + * + * @example + * invert({ a: 1, b: 2, c: 3 }); // { 1: 'a', 2: 'b', 3: 'c' } + * invert({ 1: 'a', 2: 'b', 3: 'c' }); // { a: '1', b: '2', c: '3' } + * invert({ a: 1, 2: 'b', c: 3, 4: 'd' }); // { 1: 'a', b: '2', 3: 'c', d: '4' } + * invert({ a: Symbol('sym1'), b: Symbol('sym2') }); // { [Symbol('sym1')]: 'a', [Symbol('sym2')]: 'b' } + */ +declare function invert(obj: Record): Record; + +export { invert }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0f9bf6f231483b008cc622d45c61d73b74b5230d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.d.ts @@ -0,0 +1,21 @@ +/** + * Inverts the keys and values of an object. The keys of the input object become the values of the output object and vice versa. + * + * This function takes an object and creates a new object by inverting its keys and values. If the input object has duplicate values, + * the key of the last occurrence will be used as the value for the new key in the output object. It effectively creates a reverse mapping + * of the input object's key-value pairs. + * + * @template K - Type of the keys in the input object (string, number, symbol) + * @template V - Type of the values in the input object (string, number, symbol) + * @param {Record} obj - The input object whose keys and values are to be inverted + * @returns {Record} - A new object with keys and values inverted + * + * @example + * invert({ a: 1, b: 2, c: 3 }); // { 1: 'a', 2: 'b', 3: 'c' } + * invert({ 1: 'a', 2: 'b', 3: 'c' }); // { a: '1', b: '2', c: '3' } + * invert({ a: 1, 2: 'b', c: 3, 4: 'd' }); // { 1: 'a', b: '2', 3: 'c', d: '4' } + * invert({ a: Symbol('sym1'), b: Symbol('sym2') }); // { [Symbol('sym1')]: 'a', [Symbol('sym2')]: 'b' } + */ +declare function invert(obj: Record): Record; + +export { invert }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.js new file mode 100644 index 0000000000000000000000000000000000000000..f2485bd5ac3ffe69cb61cdd5491a391b0475862f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function invert(obj) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = obj[key]; + result[value] = key; + } + return result; +} + +exports.invert = invert; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a5248fe04296e0d15388aa19a71253621f141306 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/invert.mjs @@ -0,0 +1,12 @@ +function invert(obj) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = obj[key]; + result[value] = key; + } + return result; +} + +export { invert }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8639c1cb6e3bdc905409dd4a666fa2af633c3071 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.d.mts @@ -0,0 +1,20 @@ +/** + * Creates a new object with the same values as the given object, but with keys generated + * by running each own enumerable property of the object through the iteratee function. + * + * @template T - The type of the object. + * @template K - The type of the new keys generated by the iteratee function. + * + * @param {T} object - The object to iterate over. + * @param {(value: T[keyof T], key: keyof T, object: T) => K} getNewKey - The function invoked per own enumerable property. + * @returns {Record} - Returns the new mapped object. + * + * @example + * // Example usage: + * const obj = { a: 1, b: 2 }; + * const result = mapKeys(obj, (value, key) => key + value); + * console.log(result); // { a1: 1, b2: 2 } + */ +declare function mapKeys, K extends PropertyKey>(object: T, getNewKey: (value: T[keyof T], key: keyof T, object: T) => K): Record; + +export { mapKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8639c1cb6e3bdc905409dd4a666fa2af633c3071 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.d.ts @@ -0,0 +1,20 @@ +/** + * Creates a new object with the same values as the given object, but with keys generated + * by running each own enumerable property of the object through the iteratee function. + * + * @template T - The type of the object. + * @template K - The type of the new keys generated by the iteratee function. + * + * @param {T} object - The object to iterate over. + * @param {(value: T[keyof T], key: keyof T, object: T) => K} getNewKey - The function invoked per own enumerable property. + * @returns {Record} - Returns the new mapped object. + * + * @example + * // Example usage: + * const obj = { a: 1, b: 2 }; + * const result = mapKeys(obj, (value, key) => key + value); + * console.log(result); // { a1: 1, b2: 2 } + */ +declare function mapKeys, K extends PropertyKey>(object: T, getNewKey: (value: T[keyof T], key: keyof T, object: T) => K): Record; + +export { mapKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.js new file mode 100644 index 0000000000000000000000000000000000000000..c18c6ddbaad94886ae155c5a9dda491611cc3e71 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function mapKeys(object, getNewKey) { + const result = {}; + const keys = Object.keys(object); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + result[getNewKey(value, key, object)] = value; + } + return result; +} + +exports.mapKeys = mapKeys; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.mjs new file mode 100644 index 0000000000000000000000000000000000000000..06b6b443efbbcf694d4b174a91bf85624dfa8161 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapKeys.mjs @@ -0,0 +1,12 @@ +function mapKeys(object, getNewKey) { + const result = {}; + const keys = Object.keys(object); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + result[getNewKey(value, key, object)] = value; + } + return result; +} + +export { mapKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..bb9f9fe9feffd02eefbdbf100d3493de3b87d6b5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.d.mts @@ -0,0 +1,21 @@ +/** + * Creates a new object with the same keys as the given object, but with values generated + * by running each own enumerable property of the object through the iteratee function. + * + * @template T - The type of the object. + * @template K - The type of the keys in the object. + * @template V - The type of the new values generated by the iteratee function. + * + * @param {T} object - The object to iterate over. + * @param {(value: T[K], key: K, object: T) => V} getNewValue - The function invoked per own enumerable property. + * @returns {Record} - Returns the new mapped object. + * + * @example + * // Example usage: + * const obj = { a: 1, b: 2 }; + * const result = mapValues(obj, (value) => value * 2); + * console.log(result); // { a: 2, b: 4 } + */ +declare function mapValues(object: T, getNewValue: (value: T[K], key: K, object: T) => V): Record; + +export { mapValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..bb9f9fe9feffd02eefbdbf100d3493de3b87d6b5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.d.ts @@ -0,0 +1,21 @@ +/** + * Creates a new object with the same keys as the given object, but with values generated + * by running each own enumerable property of the object through the iteratee function. + * + * @template T - The type of the object. + * @template K - The type of the keys in the object. + * @template V - The type of the new values generated by the iteratee function. + * + * @param {T} object - The object to iterate over. + * @param {(value: T[K], key: K, object: T) => V} getNewValue - The function invoked per own enumerable property. + * @returns {Record} - Returns the new mapped object. + * + * @example + * // Example usage: + * const obj = { a: 1, b: 2 }; + * const result = mapValues(obj, (value) => value * 2); + * console.log(result); // { a: 2, b: 4 } + */ +declare function mapValues(object: T, getNewValue: (value: T[K], key: K, object: T) => V): Record; + +export { mapValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.js new file mode 100644 index 0000000000000000000000000000000000000000..9b457d397d4c177beedaecce397f7c9ff10e7175 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function mapValues(object, getNewValue) { + const result = {}; + const keys = Object.keys(object); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + result[key] = getNewValue(value, key, object); + } + return result; +} + +exports.mapValues = mapValues; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3d3254cbd2a955a5516a2c2f121b77edffc2836f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mapValues.mjs @@ -0,0 +1,12 @@ +function mapValues(object, getNewValue) { + const result = {}; + const keys = Object.keys(object); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = object[key]; + result[key] = getNewValue(value, key, object); + } + return result; +} + +export { mapValues }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7365248f7dd4ab79e1cec896519bedf01db9178b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.d.mts @@ -0,0 +1,43 @@ +/** + * Merges the properties of the source object into the target object. + * + * This function performs a deep merge, meaning nested objects and arrays are merged recursively. + * If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged. + * If a property in the source object is undefined, it will not overwrite a defined property in the target object. + * + * Note that this function mutates the target object. + * + * @param {T} target - The target object into which the source object properties will be merged. This object is modified in place. + * @param {S} source - The source object whose properties will be merged into the target object. + * @returns {T & S} The updated target object with properties from the source object merged in. + * + * @template T - Type of the target object. + * @template S - Type of the source object. + * + * @example + * const target = { a: 1, b: { x: 1, y: 2 } }; + * const source = { b: { y: 3, z: 4 }, c: 5 }; + * + * const result = merge(target, source); + * console.log(result); + * // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 } + * + * @example + * const target = { a: [1, 2], b: { x: 1 } }; + * const source = { a: [3], b: { y: 2 } }; + * + * const result = merge(target, source); + * console.log(result); + * // Output: { a: [3, 2], b: { x: 1, y: 2 } } + * + * @example + * const target = { a: null }; + * const source = { a: [1, 2, 3] }; + * + * const result = merge(target, source); + * console.log(result); + * // Output: { a: [1, 2, 3] } + */ +declare function merge, S extends Record>(target: T, source: S): T & S; + +export { merge }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7365248f7dd4ab79e1cec896519bedf01db9178b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.d.ts @@ -0,0 +1,43 @@ +/** + * Merges the properties of the source object into the target object. + * + * This function performs a deep merge, meaning nested objects and arrays are merged recursively. + * If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged. + * If a property in the source object is undefined, it will not overwrite a defined property in the target object. + * + * Note that this function mutates the target object. + * + * @param {T} target - The target object into which the source object properties will be merged. This object is modified in place. + * @param {S} source - The source object whose properties will be merged into the target object. + * @returns {T & S} The updated target object with properties from the source object merged in. + * + * @template T - Type of the target object. + * @template S - Type of the source object. + * + * @example + * const target = { a: 1, b: { x: 1, y: 2 } }; + * const source = { b: { y: 3, z: 4 }, c: 5 }; + * + * const result = merge(target, source); + * console.log(result); + * // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 } + * + * @example + * const target = { a: [1, 2], b: { x: 1 } }; + * const source = { a: [3], b: { y: 2 } }; + * + * const result = merge(target, source); + * console.log(result); + * // Output: { a: [3, 2], b: { x: 1, y: 2 } } + * + * @example + * const target = { a: null }; + * const source = { a: [1, 2, 3] }; + * + * const result = merge(target, source); + * console.log(result); + * // Output: { a: [1, 2, 3] } + */ +declare function merge, S extends Record>(target: T, source: S): T & S; + +export { merge }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.js new file mode 100644 index 0000000000000000000000000000000000000000..7a742954e98215ae2ac8bf3e695da42e4c378d94 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isUnsafeProperty = require('../_internal/isUnsafeProperty.js'); +const isPlainObject = require('../predicate/isPlainObject.js'); + +function merge(target, source) { + const sourceKeys = Object.keys(source); + for (let i = 0; i < sourceKeys.length; i++) { + const key = sourceKeys[i]; + if (isUnsafeProperty.isUnsafeProperty(key)) { + continue; + } + const sourceValue = source[key]; + const targetValue = target[key]; + if (Array.isArray(sourceValue)) { + if (Array.isArray(targetValue)) { + target[key] = merge(targetValue, sourceValue); + } + else { + target[key] = merge([], sourceValue); + } + } + else if (isPlainObject.isPlainObject(sourceValue)) { + if (isPlainObject.isPlainObject(targetValue)) { + target[key] = merge(targetValue, sourceValue); + } + else { + target[key] = merge({}, sourceValue); + } + } + else if (targetValue === undefined || sourceValue !== undefined) { + target[key] = sourceValue; + } + } + return target; +} + +exports.merge = merge; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.mjs new file mode 100644 index 0000000000000000000000000000000000000000..91cfb44704a077e1a754f4bc08e74ba7feb54b3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/merge.mjs @@ -0,0 +1,36 @@ +import { isUnsafeProperty } from '../_internal/isUnsafeProperty.mjs'; +import { isPlainObject } from '../predicate/isPlainObject.mjs'; + +function merge(target, source) { + const sourceKeys = Object.keys(source); + for (let i = 0; i < sourceKeys.length; i++) { + const key = sourceKeys[i]; + if (isUnsafeProperty(key)) { + continue; + } + const sourceValue = source[key]; + const targetValue = target[key]; + if (Array.isArray(sourceValue)) { + if (Array.isArray(targetValue)) { + target[key] = merge(targetValue, sourceValue); + } + else { + target[key] = merge([], sourceValue); + } + } + else if (isPlainObject(sourceValue)) { + if (isPlainObject(targetValue)) { + target[key] = merge(targetValue, sourceValue); + } + else { + target[key] = merge({}, sourceValue); + } + } + else if (targetValue === undefined || sourceValue !== undefined) { + target[key] = sourceValue; + } + } + return target; +} + +export { merge }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6bd698ae70cd1ba6c625415db79869d65e569a7a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.d.mts @@ -0,0 +1,51 @@ +/** + * Merges the properties of the source object into the target object. + * + * You can provide a custom `merge` function to control how properties are merged. It should return the value to be set in the target object. + * + * If it returns `undefined`, a default deep merge will be applied for arrays and objects: + * + * - If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged. + * - If a property in the source object is undefined, it will not overwrite a defined property in the target object. + * + * Note that this function mutates the target object. + * + * @param {T} target - The target object into which the source object properties will be merged. This object is modified in place. + * @param {S} source - The source object whose properties will be merged into the target object. + * @param {(targetValue: any, sourceValue: any, key: string, target: T, source: S) => any} merge - A custom merge function that defines how properties should be combined. It receives the following arguments: + * - `targetValue`: The current value of the property in the target object. + * - `sourceValue`: The value of the property in the source object. + * - `key`: The key of the property being merged. + * - `target`: The target object. + * - `source`: The source object. + * + * @returns {T & S} The updated target object with properties from the source object merged in. + * + * @template T - Type of the target object. + * @template S - Type of the source object. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * + * mergeWith(target, source, (targetValue, sourceValue) => { + * if (typeof targetValue === 'number' && typeof sourceValue === 'number') { + * return targetValue + sourceValue; + * } + * }); + * // Returns { a: 1, b: 5, c: 4 } + * @example + * const target = { a: [1], b: [2] }; + * const source = { a: [3], b: [4] }; + * + * const result = mergeWith(target, source, (objValue, srcValue) => { + * if (Array.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * }); + * + * expect(result).toEqual({ a: [1, 3], b: [2, 4] }); + */ +declare function mergeWith, S extends Record>(target: T, source: S, merge: (targetValue: any, sourceValue: any, key: string, target: T, source: S) => any): T & S; + +export { mergeWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6bd698ae70cd1ba6c625415db79869d65e569a7a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.d.ts @@ -0,0 +1,51 @@ +/** + * Merges the properties of the source object into the target object. + * + * You can provide a custom `merge` function to control how properties are merged. It should return the value to be set in the target object. + * + * If it returns `undefined`, a default deep merge will be applied for arrays and objects: + * + * - If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged. + * - If a property in the source object is undefined, it will not overwrite a defined property in the target object. + * + * Note that this function mutates the target object. + * + * @param {T} target - The target object into which the source object properties will be merged. This object is modified in place. + * @param {S} source - The source object whose properties will be merged into the target object. + * @param {(targetValue: any, sourceValue: any, key: string, target: T, source: S) => any} merge - A custom merge function that defines how properties should be combined. It receives the following arguments: + * - `targetValue`: The current value of the property in the target object. + * - `sourceValue`: The value of the property in the source object. + * - `key`: The key of the property being merged. + * - `target`: The target object. + * - `source`: The source object. + * + * @returns {T & S} The updated target object with properties from the source object merged in. + * + * @template T - Type of the target object. + * @template S - Type of the source object. + * + * @example + * const target = { a: 1, b: 2 }; + * const source = { b: 3, c: 4 }; + * + * mergeWith(target, source, (targetValue, sourceValue) => { + * if (typeof targetValue === 'number' && typeof sourceValue === 'number') { + * return targetValue + sourceValue; + * } + * }); + * // Returns { a: 1, b: 5, c: 4 } + * @example + * const target = { a: [1], b: [2] }; + * const source = { a: [3], b: [4] }; + * + * const result = mergeWith(target, source, (objValue, srcValue) => { + * if (Array.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * }); + * + * expect(result).toEqual({ a: [1, 3], b: [2, 4] }); + */ +declare function mergeWith, S extends Record>(target: T, source: S, merge: (targetValue: any, sourceValue: any, key: string, target: T, source: S) => any): T & S; + +export { mergeWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.js new file mode 100644 index 0000000000000000000000000000000000000000..edd6d693c30a34890e95c732f07219b3faafeb2d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isUnsafeProperty = require('../_internal/isUnsafeProperty.js'); +const isObjectLike = require('../compat/predicate/isObjectLike.js'); + +function mergeWith(target, source, merge) { + const sourceKeys = Object.keys(source); + for (let i = 0; i < sourceKeys.length; i++) { + const key = sourceKeys[i]; + if (isUnsafeProperty.isUnsafeProperty(key)) { + continue; + } + const sourceValue = source[key]; + const targetValue = target[key]; + const merged = merge(targetValue, sourceValue, key, target, source); + if (merged != null) { + target[key] = merged; + } + else if (Array.isArray(sourceValue)) { + target[key] = mergeWith(targetValue ?? [], sourceValue, merge); + } + else if (isObjectLike.isObjectLike(targetValue) && isObjectLike.isObjectLike(sourceValue)) { + target[key] = mergeWith(targetValue ?? {}, sourceValue, merge); + } + 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/object/mergeWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ed90963aefc6e94cab85a33d7b75562a472b036e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/mergeWith.mjs @@ -0,0 +1,30 @@ +import { isUnsafeProperty } from '../_internal/isUnsafeProperty.mjs'; +import { isObjectLike } from '../compat/predicate/isObjectLike.mjs'; + +function mergeWith(target, source, merge) { + const sourceKeys = Object.keys(source); + for (let i = 0; i < sourceKeys.length; i++) { + const key = sourceKeys[i]; + if (isUnsafeProperty(key)) { + continue; + } + const sourceValue = source[key]; + const targetValue = target[key]; + const merged = merge(targetValue, sourceValue, key, target, source); + if (merged != null) { + target[key] = merged; + } + else if (Array.isArray(sourceValue)) { + target[key] = mergeWith(targetValue ?? [], sourceValue, merge); + } + else if (isObjectLike(targetValue) && isObjectLike(sourceValue)) { + target[key] = mergeWith(targetValue ?? {}, sourceValue, merge); + } + 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/object/omit.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e1ea43051b774e0be5b48dfd563fa71f576ed666 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.d.mts @@ -0,0 +1,20 @@ +/** + * Creates a new object with specified keys omitted. + * + * This function takes an object and an array of keys, and returns a new object that + * excludes the properties corresponding to the specified keys. + * + * @template T - The type of object. + * @template K - The type of keys in object. + * @param {T} obj - The object to omit keys from. + * @param {K[]} keys - An array of keys to be omitted from the object. + * @returns {Omit} A new object with the specified keys omitted. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * const result = omit(obj, ['b', 'c']); + * // result will be { a: 1 } + */ +declare function omit, K extends keyof T>(obj: T, keys: readonly K[]): Omit; + +export { omit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e1ea43051b774e0be5b48dfd563fa71f576ed666 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.d.ts @@ -0,0 +1,20 @@ +/** + * Creates a new object with specified keys omitted. + * + * This function takes an object and an array of keys, and returns a new object that + * excludes the properties corresponding to the specified keys. + * + * @template T - The type of object. + * @template K - The type of keys in object. + * @param {T} obj - The object to omit keys from. + * @param {K[]} keys - An array of keys to be omitted from the object. + * @returns {Omit} A new object with the specified keys omitted. + * + * @example + * const obj = { a: 1, b: 2, c: 3 }; + * const result = omit(obj, ['b', 'c']); + * // result will be { a: 1 } + */ +declare function omit, K extends keyof T>(obj: T, keys: readonly K[]): Omit; + +export { omit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.js new file mode 100644 index 0000000000000000000000000000000000000000..5ec79ccd089de5641dee95ad8d30c59bffd212a1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function omit(obj, keys) { + const result = { ...obj }; + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + delete result[key]; + } + return result; +} + +exports.omit = omit; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e7a8ca99b0ee05a3caff473e0e15bf4a014a3ecd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omit.mjs @@ -0,0 +1,10 @@ +function omit(obj, keys) { + const result = { ...obj }; + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + delete result[key]; + } + return result; +} + +export { omit }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c6af3672e6b8668d63100e76d7938a535535977a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.d.mts @@ -0,0 +1,22 @@ +/** + * Creates a new object composed of the properties that do not satisfy the predicate function. + * + * This function takes an object and a predicate function, and returns a new object that + * includes only the properties for which the predicate function returns false. + * + * @template T - The type of object. + * @param {T} obj - The object to omit properties from. + * @param {(value: T[string], key: keyof T) => boolean} shouldOmit - A predicate function that determines + * whether a property should be omitted. It takes the property's key and value as arguments and returns `true` + * if the property should be omitted, and `false` otherwise. + * @returns {Partial} A new object with the properties that do not satisfy the predicate function. + * + * @example + * const obj = { a: 1, b: 'omit', c: 3 }; + * const shouldOmit = (value) => typeof value === 'string'; + * const result = omitBy(obj, shouldOmit); + * // result will be { a: 1, c: 3 } + */ +declare function omitBy>(obj: T, shouldOmit: (value: T[keyof T], key: keyof T) => boolean): Partial; + +export { omitBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c6af3672e6b8668d63100e76d7938a535535977a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.d.ts @@ -0,0 +1,22 @@ +/** + * Creates a new object composed of the properties that do not satisfy the predicate function. + * + * This function takes an object and a predicate function, and returns a new object that + * includes only the properties for which the predicate function returns false. + * + * @template T - The type of object. + * @param {T} obj - The object to omit properties from. + * @param {(value: T[string], key: keyof T) => boolean} shouldOmit - A predicate function that determines + * whether a property should be omitted. It takes the property's key and value as arguments and returns `true` + * if the property should be omitted, and `false` otherwise. + * @returns {Partial} A new object with the properties that do not satisfy the predicate function. + * + * @example + * const obj = { a: 1, b: 'omit', c: 3 }; + * const shouldOmit = (value) => typeof value === 'string'; + * const result = omitBy(obj, shouldOmit); + * // result will be { a: 1, c: 3 } + */ +declare function omitBy>(obj: T, shouldOmit: (value: T[keyof T], key: keyof T) => boolean): Partial; + +export { omitBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.js new file mode 100644 index 0000000000000000000000000000000000000000..426abe59b070785192b70fb5bcd3fa31c880646c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function omitBy(obj, shouldOmit) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = obj[key]; + if (!shouldOmit(value, key)) { + result[key] = value; + } + } + return result; +} + +exports.omitBy = omitBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..0e203a0de5b58c9fae464b7d7bc0ab46866b51eb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/omitBy.mjs @@ -0,0 +1,14 @@ +function omitBy(obj, shouldOmit) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = obj[key]; + if (!shouldOmit(value, key)) { + result[key] = value; + } + } + return result; +} + +export { omitBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4e664386ae136a92ce2b4a2c79ad38fb25a64566 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.d.mts @@ -0,0 +1,20 @@ +/** + * Creates a new object composed of the picked object properties. + * + * This function takes an object and an array of keys, and returns a new object that + * includes only the properties corresponding to the specified keys. + * + * @template T - The type of object. + * @template K - The type of keys in object. + * @param {T} obj - The object to pick keys from. + * @param {K[]} keys - 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, K extends keyof T>(obj: T, keys: readonly K[]): Pick; + +export { pick }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e664386ae136a92ce2b4a2c79ad38fb25a64566 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.d.ts @@ -0,0 +1,20 @@ +/** + * Creates a new object composed of the picked object properties. + * + * This function takes an object and an array of keys, and returns a new object that + * includes only the properties corresponding to the specified keys. + * + * @template T - The type of object. + * @template K - The type of keys in object. + * @param {T} obj - The object to pick keys from. + * @param {K[]} keys - 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, K extends keyof T>(obj: T, keys: readonly K[]): Pick; + +export { pick }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.js new file mode 100644 index 0000000000000000000000000000000000000000..9da14925648ffac3e9b6fe5dc52b3360d2534b73 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function pick(obj, keys) { + const result = {}; + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (Object.hasOwn(obj, key)) { + result[key] = obj[key]; + } + } + return result; +} + +exports.pick = pick; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.mjs new file mode 100644 index 0000000000000000000000000000000000000000..dfe94c8027224abdd6336efbd7978b0b8c023aa4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pick.mjs @@ -0,0 +1,12 @@ +function pick(obj, keys) { + const result = {}; + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (Object.hasOwn(obj, key)) { + result[key] = obj[key]; + } + } + return result; +} + +export { pick }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0bd2f2b8510515ce2e78fd64d2d3f79b60825c58 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.d.mts @@ -0,0 +1,22 @@ +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * This function takes an object and a predicate function, and returns a new object that + * includes only the properties for which the predicate function returns true. + * + * @template T - The type of object. + * @param {T} obj - The object to pick properties from. + * @param {(value: T[keyof T], key: keyof T) => boolean} shouldPick - A predicate function that determines + * whether a property should be picked. It takes the property's key and value as arguments and returns `true` + * if the property should be picked, and `false` otherwise. + * @returns {Partial} A new object with the properties that satisfy the predicate function. + * + * @example + * const obj = { a: 1, b: 'pick', c: 3 }; + * const shouldPick = (value) => typeof value === 'string'; + * const result = pickBy(obj, shouldPick); + * // result will be { b: 'pick' } + */ +declare function pickBy>(obj: T, shouldPick: (value: T[keyof T], key: keyof T) => boolean): Partial; + +export { pickBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0bd2f2b8510515ce2e78fd64d2d3f79b60825c58 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.d.ts @@ -0,0 +1,22 @@ +/** + * Creates a new object composed of the properties that satisfy the predicate function. + * + * This function takes an object and a predicate function, and returns a new object that + * includes only the properties for which the predicate function returns true. + * + * @template T - The type of object. + * @param {T} obj - The object to pick properties from. + * @param {(value: T[keyof T], key: keyof T) => boolean} shouldPick - A predicate function that determines + * whether a property should be picked. It takes the property's key and value as arguments and returns `true` + * if the property should be picked, and `false` otherwise. + * @returns {Partial} A new object with the properties that satisfy the predicate function. + * + * @example + * const obj = { a: 1, b: 'pick', c: 3 }; + * const shouldPick = (value) => typeof value === 'string'; + * const result = pickBy(obj, shouldPick); + * // result will be { b: 'pick' } + */ +declare function pickBy>(obj: T, shouldPick: (value: T[keyof T], key: keyof T) => boolean): Partial; + +export { pickBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.js new file mode 100644 index 0000000000000000000000000000000000000000..f84ea24518be66853b05358b610b0510b5c81c2b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function pickBy(obj, shouldPick) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = obj[key]; + if (shouldPick(value, key)) { + result[key] = value; + } + } + return result; +} + +exports.pickBy = pickBy; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d5d8a0fa132b0b7f501ac4e0fe69e3031a87d8a5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/pickBy.mjs @@ -0,0 +1,14 @@ +function pickBy(obj, shouldPick) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = obj[key]; + if (shouldPick(value, key)) { + result[key] = value; + } + } + return result; +} + +export { pickBy }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..539f8533e658dacddf2fb8930aa24d1d13d916d6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.d.mts @@ -0,0 +1,53 @@ +type CamelCase = S extends `${infer P1}_${infer P2}${infer P3}` ? `${Lowercase}${Uppercase}${CamelCase}` : Lowercase; +type ToCamelCaseKeys = T extends any[] ? Array> : T extends Record ? { + [K in keyof T as CamelCase]: ToCamelCaseKeys; +} : T; +/** + * Creates a new object composed of the properties with keys converted to camelCase. + * + * This function takes an object and returns a new object that includes the same properties, + * but with all keys converted to camelCase format. + * + * @template T - The type of object. + * @param {T} obj - The object to convert keys from. + * @returns {ToCamelCaseKeys} A new object with all keys converted to camelCase. + * + * @example + * // Example with objects + * const obj = { user_id: 1, first_name: 'John' }; + * const result = toCamelCaseKeys(obj); + * // result will be { userId: 1, firstName: 'John' } + * + * // Example with arrays of objects + * const arr = [ + * { user_id: 1, first_name: 'John' }, + * { user_id: 2, first_name: 'Jane' } + * ]; + * const arrResult = toCamelCaseKeys(arr); + * // arrResult will be [{ userId: 1, firstName: 'John' }, { userId: 2, firstName: 'Jane' }] + * + * // Example with nested objects + * const nested = { + * user_data: { + * user_id: 1, + * user_address: { + * street_name: 'Main St', + * zip_code: '12345' + * } + * } + * }; + * const nestedResult = toCamelCaseKeys(nested); + * // nestedResult will be: + * // { + * // userData: { + * // userId: 1, + * // userAddress: { + * // streetName: 'Main St', + * // zipCode: '12345' + * // } + * // } + * // } + */ +declare function toCamelCaseKeys(obj: T): ToCamelCaseKeys; + +export { toCamelCaseKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..539f8533e658dacddf2fb8930aa24d1d13d916d6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.d.ts @@ -0,0 +1,53 @@ +type CamelCase = S extends `${infer P1}_${infer P2}${infer P3}` ? `${Lowercase}${Uppercase}${CamelCase}` : Lowercase; +type ToCamelCaseKeys = T extends any[] ? Array> : T extends Record ? { + [K in keyof T as CamelCase]: ToCamelCaseKeys; +} : T; +/** + * Creates a new object composed of the properties with keys converted to camelCase. + * + * This function takes an object and returns a new object that includes the same properties, + * but with all keys converted to camelCase format. + * + * @template T - The type of object. + * @param {T} obj - The object to convert keys from. + * @returns {ToCamelCaseKeys} A new object with all keys converted to camelCase. + * + * @example + * // Example with objects + * const obj = { user_id: 1, first_name: 'John' }; + * const result = toCamelCaseKeys(obj); + * // result will be { userId: 1, firstName: 'John' } + * + * // Example with arrays of objects + * const arr = [ + * { user_id: 1, first_name: 'John' }, + * { user_id: 2, first_name: 'Jane' } + * ]; + * const arrResult = toCamelCaseKeys(arr); + * // arrResult will be [{ userId: 1, firstName: 'John' }, { userId: 2, firstName: 'Jane' }] + * + * // Example with nested objects + * const nested = { + * user_data: { + * user_id: 1, + * user_address: { + * street_name: 'Main St', + * zip_code: '12345' + * } + * } + * }; + * const nestedResult = toCamelCaseKeys(nested); + * // nestedResult will be: + * // { + * // userData: { + * // userId: 1, + * // userAddress: { + * // streetName: 'Main St', + * // zipCode: '12345' + * // } + * // } + * // } + */ +declare function toCamelCaseKeys(obj: T): ToCamelCaseKeys; + +export { toCamelCaseKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.js new file mode 100644 index 0000000000000000000000000000000000000000..0810d6f272dbf958d972caf75dcb1c38b59b4dfc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArray = require('../compat/predicate/isArray.js'); +const isPlainObject = require('../predicate/isPlainObject.js'); +const camelCase = require('../string/camelCase.js'); + +function toCamelCaseKeys(obj) { + if (isArray.isArray(obj)) { + return obj.map(item => toCamelCaseKeys(item)); + } + if (isPlainObject.isPlainObject(obj)) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const camelKey = camelCase.camelCase(key); + const camelCaseKeys = toCamelCaseKeys(obj[key]); + result[camelKey] = camelCaseKeys; + } + return result; + } + return obj; +} + +exports.toCamelCaseKeys = toCamelCaseKeys; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b61fe04d09b41083c4a6a1587ed1c81ef268c291 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toCamelCaseKeys.mjs @@ -0,0 +1,23 @@ +import { isArray } from '../compat/predicate/isArray.mjs'; +import { isPlainObject } from '../predicate/isPlainObject.mjs'; +import { camelCase } from '../string/camelCase.mjs'; + +function toCamelCaseKeys(obj) { + if (isArray(obj)) { + return obj.map(item => toCamelCaseKeys(item)); + } + if (isPlainObject(obj)) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const camelKey = camelCase(key); + const camelCaseKeys = toCamelCaseKeys(obj[key]); + result[camelKey] = camelCaseKeys; + } + return result; + } + return obj; +} + +export { toCamelCaseKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a7a21177c82d46b1c1f1154fa8177ce2c4136bd2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.d.mts @@ -0,0 +1,45 @@ +/** + * Merges the properties of the source object into a deep clone of the target object. + * Unlike `merge`, This function does not modify the original target object. + * + * This function performs a deep merge, meaning nested objects and arrays are merged recursively. + * + * - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged. + * - If a property in the source object is undefined, it will not overwrite a defined property in the target object. + * + * Note that this function does not mutate the target object. + * + * @param {T} target - The target object to be cloned and merged into. This object is not modified directly. + * @param {S} source - The source object whose properties will be merged into the cloned target object. + * @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object. + * + * @template T - Type of the target object. + * @template S - Type of the source object. + * + * @example + * const target = { a: 1, b: { x: 1, y: 2 } }; + * const source = { b: { y: 3, z: 4 }, c: 5 }; + * + * const result = toMerged(target, source); + * console.log(result); + * // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 } + * + * @example + * const target = { a: [1, 2], b: { x: 1 } }; + * const source = { a: [3], b: { y: 2 } }; + * + * const result = toMerged(target, source); + * console.log(result); + * // Output: { a: [3, 2], b: { x: 1, y: 2 } } + * + * @example + * const target = { a: null }; + * const source = { a: [1, 2, 3] }; + * + * const result = toMerged(target, source); + * console.log(result); + * // Output: { a: [1, 2, 3] } + */ +declare function toMerged, S extends Record>(target: T, source: S): T & S; + +export { toMerged }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a7a21177c82d46b1c1f1154fa8177ce2c4136bd2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.d.ts @@ -0,0 +1,45 @@ +/** + * Merges the properties of the source object into a deep clone of the target object. + * Unlike `merge`, This function does not modify the original target object. + * + * This function performs a deep merge, meaning nested objects and arrays are merged recursively. + * + * - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged. + * - If a property in the source object is undefined, it will not overwrite a defined property in the target object. + * + * Note that this function does not mutate the target object. + * + * @param {T} target - The target object to be cloned and merged into. This object is not modified directly. + * @param {S} source - The source object whose properties will be merged into the cloned target object. + * @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object. + * + * @template T - Type of the target object. + * @template S - Type of the source object. + * + * @example + * const target = { a: 1, b: { x: 1, y: 2 } }; + * const source = { b: { y: 3, z: 4 }, c: 5 }; + * + * const result = toMerged(target, source); + * console.log(result); + * // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 } + * + * @example + * const target = { a: [1, 2], b: { x: 1 } }; + * const source = { a: [3], b: { y: 2 } }; + * + * const result = toMerged(target, source); + * console.log(result); + * // Output: { a: [3, 2], b: { x: 1, y: 2 } } + * + * @example + * const target = { a: null }; + * const source = { a: [1, 2, 3] }; + * + * const result = toMerged(target, source); + * console.log(result); + * // Output: { a: [1, 2, 3] } + */ +declare function toMerged, S extends Record>(target: T, source: S): T & S; + +export { toMerged }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.js new file mode 100644 index 0000000000000000000000000000000000000000..9bf3043776822b91c3371cc86abd5feb52466df0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const cloneDeep = require('./cloneDeep.js'); +const merge = require('./merge.js'); + +function toMerged(target, source) { + return merge.merge(cloneDeep.cloneDeep(target), source); +} + +exports.toMerged = toMerged; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.mjs new file mode 100644 index 0000000000000000000000000000000000000000..be3352c48156d2f789ebcb0e25044f1df4c06a36 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toMerged.mjs @@ -0,0 +1,8 @@ +import { cloneDeep } from './cloneDeep.mjs'; +import { merge } from './merge.mjs'; + +function toMerged(target, source) { + return merge(cloneDeep(target), source); +} + +export { toMerged }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c2aec4fa31d41a64ff9d252cb22b28fca96547bb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.d.mts @@ -0,0 +1,53 @@ +type SnakeCase = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize ? `${Lowercase}${SnakeCase}` : `${Lowercase}_${SnakeCase>}` : Lowercase; +type ToSnakeCaseKeys = T extends any[] ? Array> : T extends Record ? { + [K in keyof T as SnakeCase]: ToSnakeCaseKeys; +} : T; +/** + * Creates a new object composed of the properties with keys converted to snake_case. + * + * This function takes an object and returns a new object that includes the same properties, + * but with all keys converted to snake_case format. + * + * @template T - The type of object. + * @param {T} obj - The object to convert keys from. + * @returns {ToSnakeCaseKeys} A new object with all keys converted to snake_case. + * + * @example + * // Example with objects + * const obj = { userId: 1, firstName: 'John' }; + * const result = toSnakeCaseKeys(obj); + * // result will be { user_id: 1, first_name: 'John' } + * + * // Example with arrays of objects + * const arr = [ + * { userId: 1, firstName: 'John' }, + * { userId: 2, firstName: 'Jane' } + * ]; + * const arrResult = toSnakeCaseKeys(arr); + * // arrResult will be [{ user_id: 1, first_name: 'John' }, { user_id: 2, first_name: 'Jane' }] + * + * // Example with nested objects + * const nested = { + * userData: { + * userId: 1, + * userAddress: { + * streetName: 'Main St', + * zipCode: '12345' + * } + * } + * }; + * const nestedResult = toSnakeCaseKeys(nested); + * // nestedResult will be: + * // { + * // user_data: { + * // user_id: 1, + * // user_address: { + * // street_name: 'Main St', + * // zip_code: '12345' + * // } + * // } + * // } + */ +declare function toSnakeCaseKeys(obj: T): ToSnakeCaseKeys; + +export { type ToSnakeCaseKeys, toSnakeCaseKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c2aec4fa31d41a64ff9d252cb22b28fca96547bb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.d.ts @@ -0,0 +1,53 @@ +type SnakeCase = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize ? `${Lowercase}${SnakeCase}` : `${Lowercase}_${SnakeCase>}` : Lowercase; +type ToSnakeCaseKeys = T extends any[] ? Array> : T extends Record ? { + [K in keyof T as SnakeCase]: ToSnakeCaseKeys; +} : T; +/** + * Creates a new object composed of the properties with keys converted to snake_case. + * + * This function takes an object and returns a new object that includes the same properties, + * but with all keys converted to snake_case format. + * + * @template T - The type of object. + * @param {T} obj - The object to convert keys from. + * @returns {ToSnakeCaseKeys} A new object with all keys converted to snake_case. + * + * @example + * // Example with objects + * const obj = { userId: 1, firstName: 'John' }; + * const result = toSnakeCaseKeys(obj); + * // result will be { user_id: 1, first_name: 'John' } + * + * // Example with arrays of objects + * const arr = [ + * { userId: 1, firstName: 'John' }, + * { userId: 2, firstName: 'Jane' } + * ]; + * const arrResult = toSnakeCaseKeys(arr); + * // arrResult will be [{ user_id: 1, first_name: 'John' }, { user_id: 2, first_name: 'Jane' }] + * + * // Example with nested objects + * const nested = { + * userData: { + * userId: 1, + * userAddress: { + * streetName: 'Main St', + * zipCode: '12345' + * } + * } + * }; + * const nestedResult = toSnakeCaseKeys(nested); + * // nestedResult will be: + * // { + * // user_data: { + * // user_id: 1, + * // user_address: { + * // street_name: 'Main St', + * // zip_code: '12345' + * // } + * // } + * // } + */ +declare function toSnakeCaseKeys(obj: T): ToSnakeCaseKeys; + +export { type ToSnakeCaseKeys, toSnakeCaseKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.js new file mode 100644 index 0000000000000000000000000000000000000000..6b0a30736e2d6a03a58b27d7dddee38706b4be54 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArray = require('../compat/predicate/isArray.js'); +const isPlainObject = require('../compat/predicate/isPlainObject.js'); +const snakeCase = require('../string/snakeCase.js'); + +function toSnakeCaseKeys(obj) { + if (isArray.isArray(obj)) { + return obj.map(item => toSnakeCaseKeys(item)); + } + if (isPlainObject.isPlainObject(obj)) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const snakeKey = snakeCase.snakeCase(key); + const snakeCaseKeys = toSnakeCaseKeys(obj[key]); + result[snakeKey] = snakeCaseKeys; + } + return result; + } + return obj; +} + +exports.toSnakeCaseKeys = toSnakeCaseKeys; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4a3a9d9fa547ab7b323b0c9996e714d6a4d697e2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/object/toSnakeCaseKeys.mjs @@ -0,0 +1,23 @@ +import { isArray } from '../compat/predicate/isArray.mjs'; +import { isPlainObject } from '../compat/predicate/isPlainObject.mjs'; +import { snakeCase } from '../string/snakeCase.mjs'; + +function toSnakeCaseKeys(obj) { + if (isArray(obj)) { + return obj.map(item => toSnakeCaseKeys(item)); + } + if (isPlainObject(obj)) { + const result = {}; + const keys = Object.keys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const snakeKey = snakeCase(key); + const snakeCaseKeys = toSnakeCaseKeys(obj[key]); + result[snakeKey] = snakeCaseKeys; + } + return result; + } + return obj; +} + +export { toSnakeCaseKeys }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8533495bac1306d0cc09dca2c1d2c101bdc13738 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.d.mts @@ -0,0 +1,30 @@ +export { isArrayBuffer } from './isArrayBuffer.mjs'; +export { isBlob } from './isBlob.mjs'; +export { isBoolean } from './isBoolean.mjs'; +export { isBrowser } from './isBrowser.mjs'; +export { isBuffer } from './isBuffer.mjs'; +export { isDate } from './isDate.mjs'; +export { isEqual } from './isEqual.mjs'; +export { isEqualWith } from './isEqualWith.mjs'; +export { isError } from './isError.mjs'; +export { isFile } from './isFile.mjs'; +export { isFunction } from './isFunction.mjs'; +export { isJSON } from './isJSON.mjs'; +export { isJSONArray, isJSONObject, isJSONValue } from './isJSONValue.mjs'; +export { isLength } from './isLength.mjs'; +export { isMap } from './isMap.mjs'; +export { isNil } from './isNil.mjs'; +export { isNode } from './isNode.mjs'; +export { isNotNil } from './isNotNil.mjs'; +export { isNull } from './isNull.mjs'; +export { isPlainObject } from './isPlainObject.mjs'; +export { isPrimitive } from './isPrimitive.mjs'; +export { isPromise } from './isPromise.mjs'; +export { isRegExp } from './isRegExp.mjs'; +export { isSet } from './isSet.mjs'; +export { isString } from './isString.mjs'; +export { isSymbol } from './isSymbol.mjs'; +export { isTypedArray } from './isTypedArray.mjs'; +export { isUndefined } from './isUndefined.mjs'; +export { isWeakMap } from './isWeakMap.mjs'; +export { isWeakSet } from './isWeakSet.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fca702969390e6bfbce1d8843e212bba5de3f748 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.d.ts @@ -0,0 +1,30 @@ +export { isArrayBuffer } from './isArrayBuffer.js'; +export { isBlob } from './isBlob.js'; +export { isBoolean } from './isBoolean.js'; +export { isBrowser } from './isBrowser.js'; +export { isBuffer } from './isBuffer.js'; +export { isDate } from './isDate.js'; +export { isEqual } from './isEqual.js'; +export { isEqualWith } from './isEqualWith.js'; +export { isError } from './isError.js'; +export { isFile } from './isFile.js'; +export { isFunction } from './isFunction.js'; +export { isJSON } from './isJSON.js'; +export { isJSONArray, isJSONObject, isJSONValue } from './isJSONValue.js'; +export { isLength } from './isLength.js'; +export { isMap } from './isMap.js'; +export { isNil } from './isNil.js'; +export { isNode } from './isNode.js'; +export { isNotNil } from './isNotNil.js'; +export { isNull } from './isNull.js'; +export { isPlainObject } from './isPlainObject.js'; +export { isPrimitive } from './isPrimitive.js'; +export { isPromise } from './isPromise.js'; +export { isRegExp } from './isRegExp.js'; +export { isSet } from './isSet.js'; +export { isString } from './isString.js'; +export { isSymbol } from './isSymbol.js'; +export { isTypedArray } from './isTypedArray.js'; +export { isUndefined } from './isUndefined.js'; +export { isWeakMap } from './isWeakMap.js'; +export { isWeakSet } from './isWeakSet.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.js new file mode 100644 index 0000000000000000000000000000000000000000..635b0fb3482bc70d7c964d4d83b1c5aaf6a1ce5d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.js @@ -0,0 +1,69 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isArrayBuffer = require('./isArrayBuffer.js'); +const isBlob = require('./isBlob.js'); +const isBoolean = require('./isBoolean.js'); +const isBrowser = require('./isBrowser.js'); +const isBuffer = require('./isBuffer.js'); +const isDate = require('./isDate.js'); +const isEqual = require('./isEqual.js'); +const isEqualWith = require('./isEqualWith.js'); +const isError = require('./isError.js'); +const isFile = require('./isFile.js'); +const isFunction = require('./isFunction.js'); +const isJSON = require('./isJSON.js'); +const isJSONValue = require('./isJSONValue.js'); +const isLength = require('./isLength.js'); +const isMap = require('./isMap.js'); +const isNil = require('./isNil.js'); +const isNode = require('./isNode.js'); +const isNotNil = require('./isNotNil.js'); +const isNull = require('./isNull.js'); +const isPlainObject = require('./isPlainObject.js'); +const isPrimitive = require('./isPrimitive.js'); +const isPromise = require('./isPromise.js'); +const isRegExp = require('./isRegExp.js'); +const isSet = require('./isSet.js'); +const isString = require('./isString.js'); +const isSymbol = require('./isSymbol.js'); +const isTypedArray = require('./isTypedArray.js'); +const isUndefined = require('./isUndefined.js'); +const isWeakMap = require('./isWeakMap.js'); +const isWeakSet = require('./isWeakSet.js'); + + + +exports.isArrayBuffer = isArrayBuffer.isArrayBuffer; +exports.isBlob = isBlob.isBlob; +exports.isBoolean = isBoolean.isBoolean; +exports.isBrowser = isBrowser.isBrowser; +exports.isBuffer = isBuffer.isBuffer; +exports.isDate = isDate.isDate; +exports.isEqual = isEqual.isEqual; +exports.isEqualWith = isEqualWith.isEqualWith; +exports.isError = isError.isError; +exports.isFile = isFile.isFile; +exports.isFunction = isFunction.isFunction; +exports.isJSON = isJSON.isJSON; +exports.isJSONArray = isJSONValue.isJSONArray; +exports.isJSONObject = isJSONValue.isJSONObject; +exports.isJSONValue = isJSONValue.isJSONValue; +exports.isLength = isLength.isLength; +exports.isMap = isMap.isMap; +exports.isNil = isNil.isNil; +exports.isNode = isNode.isNode; +exports.isNotNil = isNotNil.isNotNil; +exports.isNull = isNull.isNull; +exports.isPlainObject = isPlainObject.isPlainObject; +exports.isPrimitive = isPrimitive.isPrimitive; +exports.isPromise = isPromise.isPromise; +exports.isRegExp = isRegExp.isRegExp; +exports.isSet = isSet.isSet; +exports.isString = isString.isString; +exports.isSymbol = isSymbol.isSymbol; +exports.isTypedArray = isTypedArray.isTypedArray; +exports.isUndefined = isUndefined.isUndefined; +exports.isWeakMap = isWeakMap.isWeakMap; +exports.isWeakSet = isWeakSet.isWeakSet; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8533495bac1306d0cc09dca2c1d2c101bdc13738 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/index.mjs @@ -0,0 +1,30 @@ +export { isArrayBuffer } from './isArrayBuffer.mjs'; +export { isBlob } from './isBlob.mjs'; +export { isBoolean } from './isBoolean.mjs'; +export { isBrowser } from './isBrowser.mjs'; +export { isBuffer } from './isBuffer.mjs'; +export { isDate } from './isDate.mjs'; +export { isEqual } from './isEqual.mjs'; +export { isEqualWith } from './isEqualWith.mjs'; +export { isError } from './isError.mjs'; +export { isFile } from './isFile.mjs'; +export { isFunction } from './isFunction.mjs'; +export { isJSON } from './isJSON.mjs'; +export { isJSONArray, isJSONObject, isJSONValue } from './isJSONValue.mjs'; +export { isLength } from './isLength.mjs'; +export { isMap } from './isMap.mjs'; +export { isNil } from './isNil.mjs'; +export { isNode } from './isNode.mjs'; +export { isNotNil } from './isNotNil.mjs'; +export { isNull } from './isNull.mjs'; +export { isPlainObject } from './isPlainObject.mjs'; +export { isPrimitive } from './isPrimitive.mjs'; +export { isPromise } from './isPromise.mjs'; +export { isRegExp } from './isRegExp.mjs'; +export { isSet } from './isSet.mjs'; +export { isString } from './isString.mjs'; +export { isSymbol } from './isSymbol.mjs'; +export { isTypedArray } from './isTypedArray.mjs'; +export { isUndefined } from './isUndefined.mjs'; +export { isWeakMap } from './isWeakMap.mjs'; +export { isWeakSet } from './isWeakSet.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7bca09962f964d724885bd4de2302f20346c6119 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} 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: unknown): value is ArrayBuffer; + +export { isArrayBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7bca09962f964d724885bd4de2302f20346c6119 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} 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: unknown): value is ArrayBuffer; + +export { isArrayBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..e33ecd01601c582f635730d05c16a1e8df5161ff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isArrayBuffer(value) { + return value instanceof ArrayBuffer; +} + +exports.isArrayBuffer = isArrayBuffer; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.mjs new file mode 100644 index 0000000000000000000000000000000000000000..64a15ed2007505c925d51dd69507eda679d368c4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isArrayBuffer.mjs @@ -0,0 +1,5 @@ +function isArrayBuffer(value) { + return value instanceof ArrayBuffer; +} + +export { isArrayBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8960eb318826b29dcd103640179a810ff2ce27d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.d.mts @@ -0,0 +1,19 @@ +/** + * Checks if the given value is a Blob. + * + * This function tests whether the provided value is an instance of `Blob`. + * It returns `true` if the value is an instance of `Blob`, and `false` otherwise. + * + * @param {unknown} x - The value to test if it is a Blob. + * @returns {x is Blob} True if the value is a Blob, false otherwise. + * + * @example + * const value1 = new Blob(); + * const value2 = {}; + * + * console.log(isBlob(value1)); // true + * console.log(isBlob(value2)); // false + */ +declare function isBlob(x: unknown): x is Blob; + +export { isBlob }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8960eb318826b29dcd103640179a810ff2ce27d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.d.ts @@ -0,0 +1,19 @@ +/** + * Checks if the given value is a Blob. + * + * This function tests whether the provided value is an instance of `Blob`. + * It returns `true` if the value is an instance of `Blob`, and `false` otherwise. + * + * @param {unknown} x - The value to test if it is a Blob. + * @returns {x is Blob} True if the value is a Blob, false otherwise. + * + * @example + * const value1 = new Blob(); + * const value2 = {}; + * + * console.log(isBlob(value1)); // true + * console.log(isBlob(value2)); // false + */ +declare function isBlob(x: unknown): x is Blob; + +export { isBlob }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.js new file mode 100644 index 0000000000000000000000000000000000000000..42e96f924a8ab0a89a79bafba720db0677acb8d0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isBlob(x) { + if (typeof Blob === 'undefined') { + return false; + } + return x instanceof Blob; +} + +exports.isBlob = isBlob; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8d503ac3d7e0caadd03434d068357dc2ca9272c1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBlob.mjs @@ -0,0 +1,8 @@ +function isBlob(x) { + if (typeof Blob === 'undefined') { + return false; + } + return x instanceof Blob; +} + +export { isBlob }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..dc6dbeeb3860312fdf60e5181d01de57878b02f7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} x - The Value to test if it is boolean. + * @returns {x 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(x: unknown): x is boolean; + +export { isBoolean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dc6dbeeb3860312fdf60e5181d01de57878b02f7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} x - The Value to test if it is boolean. + * @returns {x 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(x: unknown): x is boolean; + +export { isBoolean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.js new file mode 100644 index 0000000000000000000000000000000000000000..e1aeb581044c25766527686ab938d770b3c49254 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isBoolean(x) { + return typeof x === 'boolean'; +} + +exports.isBoolean = isBoolean; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9f8eafa278c837ca270d438c3854a241f672c14d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBoolean.mjs @@ -0,0 +1,5 @@ +function isBoolean(x) { + return typeof x === 'boolean'; +} + +export { isBoolean }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2355a9fca1257906168b9a8cced101af08b0c43d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.d.mts @@ -0,0 +1,17 @@ +/** + * Checks if the current environment is a browser. + * + * This function checks for the existence of the `window.document` property, + * which only exists in browser environments. + * + * @returns {boolean} `true` if the current environment is a browser, otherwise `false`. + * + * @example + * if (isBrowser()) { + * console.log("This is running in a browser"); + * document.getElementById('app').innerHTML = 'Hello World'; + * } + */ +declare function isBrowser(): boolean; + +export { isBrowser }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2355a9fca1257906168b9a8cced101af08b0c43d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.d.ts @@ -0,0 +1,17 @@ +/** + * Checks if the current environment is a browser. + * + * This function checks for the existence of the `window.document` property, + * which only exists in browser environments. + * + * @returns {boolean} `true` if the current environment is a browser, otherwise `false`. + * + * @example + * if (isBrowser()) { + * console.log("This is running in a browser"); + * document.getElementById('app').innerHTML = 'Hello World'; + * } + */ +declare function isBrowser(): boolean; + +export { isBrowser }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.js new file mode 100644 index 0000000000000000000000000000000000000000..fc23babc6602030699b22b22b9d40f73bdf7ff3b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isBrowser() { + return typeof window !== 'undefined' && window?.document != null; +} + +exports.isBrowser = isBrowser; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.mjs new file mode 100644 index 0000000000000000000000000000000000000000..cf261b654a9e782126a70949ccb29e0ca2fa4c05 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBrowser.mjs @@ -0,0 +1,5 @@ +function isBrowser() { + return typeof window !== 'undefined' && window?.document != null; +} + +export { isBrowser }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ffb16bf90a057f5761ea4328e2097e42f4c5eff4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} 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: unknown): boolean; + +export { isBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ffb16bf90a057f5761ea4328e2097e42f4c5eff4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} 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: unknown): boolean; + +export { isBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.js new file mode 100644 index 0000000000000000000000000000000000000000..b3adbbb3fe6ce2fb09df2c309643bdf6f4a9e78d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isBuffer(x) { + return typeof Buffer !== 'undefined' && Buffer.isBuffer(x); +} + +exports.isBuffer = isBuffer; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2447789d9fae353b408cdca35c2bf2a4be59a63f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isBuffer.mjs @@ -0,0 +1,5 @@ +function isBuffer(x) { + return typeof Buffer !== 'undefined' && Buffer.isBuffer(x); +} + +export { isBuffer }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..472d2050610dba05c5d5fcf792e72f59c3a1c018 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.d.mts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a Date object. + * + * @param {unknown} 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: unknown): value is Date; + +export { isDate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..472d2050610dba05c5d5fcf792e72f59c3a1c018 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.d.ts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a Date object. + * + * @param {unknown} 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: unknown): value is Date; + +export { isDate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.js new file mode 100644 index 0000000000000000000000000000000000000000..782546ee529f030d8127029b3c4c9fdf4123c857 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isDate(value) { + return value instanceof Date; +} + +exports.isDate = isDate; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.mjs new file mode 100644 index 0000000000000000000000000000000000000000..ed0b444b67bd4db8b30c1fa603cbd73a38fc30a9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isDate.mjs @@ -0,0 +1,5 @@ +function isDate(value) { + return value instanceof Date; +} + +export { isDate }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d5d6a12b9fd0278f5229a8f728a05aaefaba900b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.d.mts @@ -0,0 +1,17 @@ +/** + * Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison. + * + * @param {unknown} a - The first value to compare. + * @param {unknown} b - The second value to compare. + * @returns {boolean} `true` if the values are equal, otherwise `false`. + * + * @example + * isEqual(1, 1); // true + * isEqual({ a: 1 }, { a: 1 }); // true + * isEqual(/abc/g, /abc/g); // true + * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true + * isEqual([1, 2, 3], [1, 2, 3]); // true + */ +declare function isEqual(a: any, b: any): boolean; + +export { isEqual }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d5d6a12b9fd0278f5229a8f728a05aaefaba900b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.d.ts @@ -0,0 +1,17 @@ +/** + * Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison. + * + * @param {unknown} a - The first value to compare. + * @param {unknown} b - The second value to compare. + * @returns {boolean} `true` if the values are equal, otherwise `false`. + * + * @example + * isEqual(1, 1); // true + * isEqual({ a: 1 }, { a: 1 }); // true + * isEqual(/abc/g, /abc/g); // true + * isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true + * isEqual([1, 2, 3], [1, 2, 3]); // true + */ +declare function isEqual(a: any, b: any): boolean; + +export { isEqual }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.js new file mode 100644 index 0000000000000000000000000000000000000000..b49d671576b34beec38724ef23a9f015cd083115 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isEqualWith = require('./isEqualWith.js'); +const noop = require('../function/noop.js'); + +function isEqual(a, b) { + return isEqualWith.isEqualWith(a, b, noop.noop); +} + +exports.isEqual = isEqual; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a587e63e0fe5407f9fd23260aaae39e660759289 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqual.mjs @@ -0,0 +1,8 @@ +import { isEqualWith } from './isEqualWith.mjs'; +import { noop } from '../function/noop.mjs'; + +function isEqual(a, b) { + return isEqualWith(a, b, noop); +} + +export { isEqual }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..53c8d306c43fd4b7bef5c76da9049527938a076e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.d.mts @@ -0,0 +1,38 @@ +/** + * 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 - 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: (x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map) => boolean | void): boolean; + +export { isEqualWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..53c8d306c43fd4b7bef5c76da9049527938a076e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.d.ts @@ -0,0 +1,38 @@ +/** + * 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 - 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: (x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map) => boolean | void): boolean; + +export { isEqualWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.js new file mode 100644 index 0000000000000000000000000000000000000000..6140eddb0b5d6764752641ab65e191565fd32afe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.js @@ -0,0 +1,189 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isPlainObject = require('./isPlainObject.js'); +const getSymbols = require('../compat/_internal/getSymbols.js'); +const getTag = require('../compat/_internal/getTag.js'); +const tags = require('../compat/_internal/tags.js'); +const eq = require('../compat/util/eq.js'); + +function isEqualWith(a, b, areValuesEqual) { + return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual); +} +function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) { + const result = areValuesEqual(a, b, property, aParent, bParent, stack); + if (result !== undefined) { + return result; + } + if (typeof a === typeof b) { + switch (typeof a) { + case 'bigint': + case 'string': + case 'boolean': + case 'symbol': + case 'undefined': { + return a === b; + } + case 'number': { + return a === b || Object.is(a, b); + } + case 'function': { + return a === b; + } + case 'object': { + return areObjectsEqual(a, b, stack, areValuesEqual); + } + } + } + return areObjectsEqual(a, b, stack, areValuesEqual); +} +function areObjectsEqual(a, b, stack, areValuesEqual) { + if (Object.is(a, b)) { + return true; + } + let aTag = getTag.getTag(a); + let bTag = getTag.getTag(b); + if (aTag === tags.argumentsTag) { + aTag = tags.objectTag; + } + if (bTag === tags.argumentsTag) { + bTag = tags.objectTag; + } + if (aTag !== bTag) { + return false; + } + switch (aTag) { + case tags.stringTag: + return a.toString() === b.toString(); + case tags.numberTag: { + const x = a.valueOf(); + const y = b.valueOf(); + return eq.eq(x, y); + } + case tags.booleanTag: + case tags.dateTag: + case tags.symbolTag: + return Object.is(a.valueOf(), b.valueOf()); + case tags.regexpTag: { + return a.source === b.source && a.flags === b.flags; + } + case tags.functionTag: { + return a === b; + } + } + stack = stack ?? new Map(); + const aStack = stack.get(a); + const bStack = stack.get(b); + if (aStack != null && bStack != null) { + return aStack === b; + } + stack.set(a, b); + stack.set(b, a); + try { + switch (aTag) { + case tags.mapTag: { + if (a.size !== b.size) { + return false; + } + for (const [key, value] of a.entries()) { + if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) { + return false; + } + } + return true; + } + case tags.setTag: { + if (a.size !== b.size) { + return false; + } + const aValues = Array.from(a.values()); + const bValues = Array.from(b.values()); + for (let i = 0; i < aValues.length; i++) { + const aValue = aValues[i]; + const index = bValues.findIndex(bValue => { + return isEqualWithImpl(aValue, bValue, undefined, a, b, stack, areValuesEqual); + }); + if (index === -1) { + return false; + } + bValues.splice(index, 1); + } + return true; + } + case tags.arrayTag: + case tags.uint8ArrayTag: + case tags.uint8ClampedArrayTag: + case tags.uint16ArrayTag: + case tags.uint32ArrayTag: + case tags.bigUint64ArrayTag: + case tags.int8ArrayTag: + case tags.int16ArrayTag: + case tags.int32ArrayTag: + case tags.bigInt64ArrayTag: + case tags.float32ArrayTag: + case tags.float64ArrayTag: { + if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) { + return false; + } + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i++) { + if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) { + return false; + } + } + return true; + } + case tags.arrayBufferTag: { + if (a.byteLength !== b.byteLength) { + return false; + } + return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual); + } + case tags.dataViewTag: { + if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) { + return false; + } + return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual); + } + case tags.errorTag: { + return a.name === b.name && a.message === b.message; + } + case tags.objectTag: { + const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || + (isPlainObject.isPlainObject(a) && isPlainObject.isPlainObject(b)); + if (!areEqualInstances) { + return false; + } + const aKeys = [...Object.keys(a), ...getSymbols.getSymbols(a)]; + const bKeys = [...Object.keys(b), ...getSymbols.getSymbols(b)]; + if (aKeys.length !== bKeys.length) { + return false; + } + for (let i = 0; i < aKeys.length; i++) { + const propKey = aKeys[i]; + const aProp = a[propKey]; + if (!Object.hasOwn(b, propKey)) { + return false; + } + const bProp = b[propKey]; + if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) { + return false; + } + } + return true; + } + default: { + return false; + } + } + } + finally { + stack.delete(a); + stack.delete(b); + } +} + +exports.isEqualWith = isEqualWith; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs new file mode 100644 index 0000000000000000000000000000000000000000..22fad853a0b94adba1aa4ca7b87be97134d06181 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs @@ -0,0 +1,185 @@ +import { isPlainObject } from './isPlainObject.mjs'; +import { getSymbols } from '../compat/_internal/getSymbols.mjs'; +import { getTag } from '../compat/_internal/getTag.mjs'; +import { functionTag, regexpTag, symbolTag, dateTag, booleanTag, numberTag, stringTag, objectTag, errorTag, dataViewTag, arrayBufferTag, float64ArrayTag, float32ArrayTag, bigInt64ArrayTag, int32ArrayTag, int16ArrayTag, int8ArrayTag, bigUint64ArrayTag, uint32ArrayTag, uint16ArrayTag, uint8ClampedArrayTag, uint8ArrayTag, arrayTag, setTag, mapTag, argumentsTag } from '../compat/_internal/tags.mjs'; +import { eq } from '../compat/util/eq.mjs'; + +function isEqualWith(a, b, areValuesEqual) { + return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual); +} +function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) { + const result = areValuesEqual(a, b, property, aParent, bParent, stack); + if (result !== undefined) { + return result; + } + if (typeof a === typeof b) { + switch (typeof a) { + case 'bigint': + case 'string': + case 'boolean': + case 'symbol': + case 'undefined': { + return a === b; + } + case 'number': { + return a === b || Object.is(a, b); + } + case 'function': { + return a === b; + } + case 'object': { + return areObjectsEqual(a, b, stack, areValuesEqual); + } + } + } + return areObjectsEqual(a, b, stack, areValuesEqual); +} +function areObjectsEqual(a, b, stack, areValuesEqual) { + if (Object.is(a, b)) { + return true; + } + let aTag = getTag(a); + let bTag = getTag(b); + if (aTag === argumentsTag) { + aTag = objectTag; + } + if (bTag === argumentsTag) { + bTag = objectTag; + } + if (aTag !== bTag) { + return false; + } + switch (aTag) { + case stringTag: + return a.toString() === b.toString(); + case numberTag: { + const x = a.valueOf(); + const y = b.valueOf(); + return eq(x, y); + } + case booleanTag: + case dateTag: + case symbolTag: + return Object.is(a.valueOf(), b.valueOf()); + case regexpTag: { + return a.source === b.source && a.flags === b.flags; + } + case functionTag: { + return a === b; + } + } + stack = stack ?? new Map(); + const aStack = stack.get(a); + const bStack = stack.get(b); + if (aStack != null && bStack != null) { + return aStack === b; + } + stack.set(a, b); + stack.set(b, a); + try { + switch (aTag) { + case mapTag: { + if (a.size !== b.size) { + return false; + } + for (const [key, value] of a.entries()) { + if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) { + return false; + } + } + return true; + } + case setTag: { + if (a.size !== b.size) { + return false; + } + const aValues = Array.from(a.values()); + const bValues = Array.from(b.values()); + for (let i = 0; i < aValues.length; i++) { + const aValue = aValues[i]; + const index = bValues.findIndex(bValue => { + return isEqualWithImpl(aValue, bValue, undefined, a, b, stack, areValuesEqual); + }); + if (index === -1) { + return false; + } + bValues.splice(index, 1); + } + return true; + } + case arrayTag: + case uint8ArrayTag: + case uint8ClampedArrayTag: + case uint16ArrayTag: + case uint32ArrayTag: + case bigUint64ArrayTag: + case int8ArrayTag: + case int16ArrayTag: + case int32ArrayTag: + case bigInt64ArrayTag: + case float32ArrayTag: + case float64ArrayTag: { + if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) { + return false; + } + if (a.length !== b.length) { + return false; + } + for (let i = 0; i < a.length; i++) { + if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) { + return false; + } + } + return true; + } + case arrayBufferTag: { + if (a.byteLength !== b.byteLength) { + return false; + } + return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual); + } + case dataViewTag: { + if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) { + return false; + } + return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual); + } + case errorTag: { + return a.name === b.name && a.message === b.message; + } + case objectTag: { + const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || + (isPlainObject(a) && isPlainObject(b)); + if (!areEqualInstances) { + return false; + } + const aKeys = [...Object.keys(a), ...getSymbols(a)]; + const bKeys = [...Object.keys(b), ...getSymbols(b)]; + if (aKeys.length !== bKeys.length) { + return false; + } + for (let i = 0; i < aKeys.length; i++) { + const propKey = aKeys[i]; + const aProp = a[propKey]; + if (!Object.hasOwn(b, propKey)) { + return false; + } + const bProp = b[propKey]; + if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) { + return false; + } + } + return true; + } + default: { + return false; + } + } + } + finally { + stack.delete(a); + stack.delete(b); + } +} + +export { isEqualWith }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..586813a2d237232f6fb7684da7a99aaf43759354 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.d.mts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is an Error object. + * + * @param {unknown} 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: unknown): value is Error; + +export { isError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..586813a2d237232f6fb7684da7a99aaf43759354 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.d.ts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is an Error object. + * + * @param {unknown} 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: unknown): value is Error; + +export { isError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.js new file mode 100644 index 0000000000000000000000000000000000000000..41468415de93626a1a32ccaadac011080eba1cdb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isError(value) { + return value instanceof Error; +} + +exports.isError = isError; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b34968b38e48b895f6cc52ff87b7b341100b2094 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isError.mjs @@ -0,0 +1,5 @@ +function isError(value) { + return value instanceof Error; +} + +export { isError }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..32505c61fbdf29255bd047530a9ab051d0b23a03 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.d.mts @@ -0,0 +1,21 @@ +/** + * Checks if the given value is a File. + * + * This function tests whether the provided value is an instance of `File`. + * It returns `true` if the value is an instance of `File`, and `false` otherwise. + * + * @param {unknown} x - The value to test if it is a File. + * @returns {x is File} True if the value is a File, false otherwise. + * + * @example + * const value1 = new File(["content"], "example.txt"); + * const value2 = {}; + * const value3 = new Blob(["content"], { type: "text/plain" }); + * + * console.log(isFile(value1)); // true + * console.log(isFile(value2)); // false + * console.log(isFile(value3)); // false + */ +declare function isFile(x: unknown): x is File; + +export { isFile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..32505c61fbdf29255bd047530a9ab051d0b23a03 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.d.ts @@ -0,0 +1,21 @@ +/** + * Checks if the given value is a File. + * + * This function tests whether the provided value is an instance of `File`. + * It returns `true` if the value is an instance of `File`, and `false` otherwise. + * + * @param {unknown} x - The value to test if it is a File. + * @returns {x is File} True if the value is a File, false otherwise. + * + * @example + * const value1 = new File(["content"], "example.txt"); + * const value2 = {}; + * const value3 = new Blob(["content"], { type: "text/plain" }); + * + * console.log(isFile(value1)); // true + * console.log(isFile(value2)); // false + * console.log(isFile(value3)); // false + */ +declare function isFile(x: unknown): x is File; + +export { isFile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.js new file mode 100644 index 0000000000000000000000000000000000000000..a5c94d4a0500ff17c1bbc8fc0f71b23d10e0a865 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isBlob = require('./isBlob.js'); + +function isFile(x) { + if (typeof File === 'undefined') { + return false; + } + return isBlob.isBlob(x) && x instanceof File; +} + +exports.isFile = isFile; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f883530a2218c98482e4c39257808000e3e90a7a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFile.mjs @@ -0,0 +1,10 @@ +import { isBlob } from './isBlob.mjs'; + +function isFile(x) { + if (typeof File === 'undefined') { + return false; + } + return isBlob(x) && x instanceof File; +} + +export { isFile }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFunction.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFunction.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..46e4ff23c12083991f6dc486fa25bc5cb9fa96fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFunction.d.mts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a function. + * + * @param {any} value The value to check. + * @returns {boolean} 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/predicate/isFunction.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFunction.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..46e4ff23c12083991f6dc486fa25bc5cb9fa96fd --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFunction.d.ts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a function. + * + * @param {any} value The value to check. + * @returns {boolean} 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/predicate/isFunction.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFunction.js new file mode 100644 index 0000000000000000000000000000000000000000..07a19dfd8a6633d6dedb7bd43034c637a533f05f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/predicate/isFunction.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isFunction.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b9a4a2eb82a9c017aec2b54927c2fccedc9e4ba6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/predicate/isJSON.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..b9d30e5d9de4e790c835ce7444162a1ed7c127d2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.d.mts @@ -0,0 +1,31 @@ +/** + * Checks if a given value is a valid JSON string. + * + * A valid JSON string is one that can be successfully parsed using `JSON.parse()`. According to JSON + * specifications, valid JSON can represent: + * - Objects (with string keys and valid JSON values) + * - Arrays (containing valid JSON values) + * - Strings + * - Numbers + * - Booleans + * - null + * + * String values like `"null"`, `"true"`, `"false"`, and numeric strings (e.g., `"42"`) are considered + * valid JSON and will return true. + * + * This function serves as a type guard in TypeScript, narrowing the type of the argument to `string`. + * + * @param {unknown} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid JSON string, else `false`. + * + * @example + * isJSON('{"name":"John","age":30}'); // true + * isJSON('[1,2,3]'); // true + * isJSON('true'); // true + * isJSON('invalid json'); // false + * isJSON({ name: 'John' }); // false (not a string) + * isJSON(null); // false (not a string) + */ +declare function isJSON(value: unknown): value is string; + +export { isJSON }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b9d30e5d9de4e790c835ce7444162a1ed7c127d2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.d.ts @@ -0,0 +1,31 @@ +/** + * Checks if a given value is a valid JSON string. + * + * A valid JSON string is one that can be successfully parsed using `JSON.parse()`. According to JSON + * specifications, valid JSON can represent: + * - Objects (with string keys and valid JSON values) + * - Arrays (containing valid JSON values) + * - Strings + * - Numbers + * - Booleans + * - null + * + * String values like `"null"`, `"true"`, `"false"`, and numeric strings (e.g., `"42"`) are considered + * valid JSON and will return true. + * + * This function serves as a type guard in TypeScript, narrowing the type of the argument to `string`. + * + * @param {unknown} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid JSON string, else `false`. + * + * @example + * isJSON('{"name":"John","age":30}'); // true + * isJSON('[1,2,3]'); // true + * isJSON('true'); // true + * isJSON('invalid json'); // false + * isJSON({ name: 'John' }); // false (not a string) + * isJSON(null); // false (not a string) + */ +declare function isJSON(value: unknown): value is string; + +export { isJSON }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.js new file mode 100644 index 0000000000000000000000000000000000000000..eb73eb59ab6076e0704af3fa0648da185fe7a6d4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.js @@ -0,0 +1,18 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isJSON(value) { + if (typeof value !== 'string') { + return false; + } + try { + JSON.parse(value); + return true; + } + catch { + return false; + } +} + +exports.isJSON = isJSON; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.mjs new file mode 100644 index 0000000000000000000000000000000000000000..895d59ee5805a82ed4fd07f9f6de2c802f3a8799 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSON.mjs @@ -0,0 +1,14 @@ +function isJSON(value) { + if (typeof value !== 'string') { + return false; + } + try { + JSON.parse(value); + return true; + } + catch { + return false; + } +} + +export { isJSON }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9dfdf9ec5a79cd7bd3e6e0fb7e33462535b7ac51 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.d.mts @@ -0,0 +1,56 @@ +/** + * Checks if a given value is a valid JSON value. + * + * A valid JSON value can be: + * - null + * - a JSON object (an object with string keys and valid JSON values) + * - a JSON array (an array of valid JSON values) + * - a string + * - a number + * - a boolean + * + * @param {unknown} value - The value to check. + * @returns {boolean} - True if the value is a valid JSON value, otherwise false. + * + * @example + * console.log(isJSONValue(null)); // true + * console.log(isJSONValue({ key: "value" })); // true + * console.log(isJSONValue([1, 2, 3])); // true + * console.log(isJSONValue("Hello")); // true + * console.log(isJSONValue(42)); // true + * console.log(isJSONValue(true)); // true + * console.log(isJSONValue(undefined)); // false + * console.log(isJSONValue(() => {})); // false + */ +declare function isJSONValue(value: unknown): value is Record | any[] | string | number | boolean | null; +/** + * Checks if a given value is a valid JSON array. + * + * A valid JSON array is defined as an array where all items are valid JSON values. + * + * @param {unknown} value - The value to check. + * @returns {value is any[]} - True if the value is a valid JSON array, otherwise false. + * + * @example + * console.log(isJSONArray([1, 2, 3])); // true + * console.log(isJSONArray(["string", null, true])); // true + * console.log(isJSONArray([1, 2, () => {}])); // false + * console.log(isJSONArray("not an array")); // false + */ +declare function isJSONArray(value: unknown): value is any[]; +/** + * Checks if a value is a JSON object. + * + * A valid JSON object is defined as an object with string keys and valid JSON values. + * + * @param {unknown} obj The value to check. + * @returns {obj is Record} True if `obj` is a JSON object, false otherwise. + * + * @example + * isJSONObject({ nested: { boolean: true, array: [1, 2, 3], string: 'test', null: null } }); // true + * isJSONObject({ regexp: /test/ }); // false + * isJSONObject(123); // false + */ +declare function isJSONObject(obj: unknown): obj is Record; + +export { isJSONArray, isJSONObject, isJSONValue }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9dfdf9ec5a79cd7bd3e6e0fb7e33462535b7ac51 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.d.ts @@ -0,0 +1,56 @@ +/** + * Checks if a given value is a valid JSON value. + * + * A valid JSON value can be: + * - null + * - a JSON object (an object with string keys and valid JSON values) + * - a JSON array (an array of valid JSON values) + * - a string + * - a number + * - a boolean + * + * @param {unknown} value - The value to check. + * @returns {boolean} - True if the value is a valid JSON value, otherwise false. + * + * @example + * console.log(isJSONValue(null)); // true + * console.log(isJSONValue({ key: "value" })); // true + * console.log(isJSONValue([1, 2, 3])); // true + * console.log(isJSONValue("Hello")); // true + * console.log(isJSONValue(42)); // true + * console.log(isJSONValue(true)); // true + * console.log(isJSONValue(undefined)); // false + * console.log(isJSONValue(() => {})); // false + */ +declare function isJSONValue(value: unknown): value is Record | any[] | string | number | boolean | null; +/** + * Checks if a given value is a valid JSON array. + * + * A valid JSON array is defined as an array where all items are valid JSON values. + * + * @param {unknown} value - The value to check. + * @returns {value is any[]} - True if the value is a valid JSON array, otherwise false. + * + * @example + * console.log(isJSONArray([1, 2, 3])); // true + * console.log(isJSONArray(["string", null, true])); // true + * console.log(isJSONArray([1, 2, () => {}])); // false + * console.log(isJSONArray("not an array")); // false + */ +declare function isJSONArray(value: unknown): value is any[]; +/** + * Checks if a value is a JSON object. + * + * A valid JSON object is defined as an object with string keys and valid JSON values. + * + * @param {unknown} obj The value to check. + * @returns {obj is Record} True if `obj` is a JSON object, false otherwise. + * + * @example + * isJSONObject({ nested: { boolean: true, array: [1, 2, 3], string: 'test', null: null } }); // true + * isJSONObject({ regexp: /test/ }); // false + * isJSONObject(123); // false + */ +declare function isJSONObject(obj: unknown): obj is Record; + +export { isJSONArray, isJSONObject, isJSONValue }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.js new file mode 100644 index 0000000000000000000000000000000000000000..8f6d11b915157b7681b760ee451efffa78bca9c2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.js @@ -0,0 +1,48 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const isPlainObject = require('./isPlainObject.js'); + +function isJSONValue(value) { + switch (typeof value) { + case 'object': { + return value === null || isJSONArray(value) || isJSONObject(value); + } + case 'string': + case 'number': + case 'boolean': { + return true; + } + default: { + return false; + } + } +} +function isJSONArray(value) { + if (!Array.isArray(value)) { + return false; + } + return value.every(item => isJSONValue(item)); +} +function isJSONObject(obj) { + if (!isPlainObject.isPlainObject(obj)) { + return false; + } + const keys = Reflect.ownKeys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = obj[key]; + if (typeof key !== 'string') { + return false; + } + if (!isJSONValue(value)) { + return false; + } + } + return true; +} + +exports.isJSONArray = isJSONArray; +exports.isJSONObject = isJSONObject; +exports.isJSONValue = isJSONValue; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c24a5ca989efcb365325e8c9368f0e0b97cbd6ac --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isJSONValue.mjs @@ -0,0 +1,42 @@ +import { isPlainObject } from './isPlainObject.mjs'; + +function isJSONValue(value) { + switch (typeof value) { + case 'object': { + return value === null || isJSONArray(value) || isJSONObject(value); + } + case 'string': + case 'number': + case 'boolean': { + return true; + } + default: { + return false; + } + } +} +function isJSONArray(value) { + if (!Array.isArray(value)) { + return false; + } + return value.every(item => isJSONValue(item)); +} +function isJSONObject(obj) { + if (!isPlainObject(obj)) { + return false; + } + const keys = Reflect.ownKeys(obj); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const value = obj[key]; + if (typeof key !== 'string') { + return false; + } + if (!isJSONValue(value)) { + return false; + } + } + return true; +} + +export { isJSONArray, isJSONObject, isJSONValue }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isLength.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/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/predicate/isLength.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/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/predicate/isLength.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isLength.js new file mode 100644 index 0000000000000000000000000000000000000000..62787d830f3cc71a67ccd175e1730680618b62fc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/predicate/isLength.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isLength.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a4e39989f6e2fc62bd44fd2a1bbe26f1436eed94 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/predicate/isMap.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..16f86585e8d07714a791f38cd4a4f65055dce214 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is Map; + +export { isMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..16f86585e8d07714a791f38cd4a4f65055dce214 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is Map; + +export { isMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.js new file mode 100644 index 0000000000000000000000000000000000000000..13b6374ee75bb66d43b1210dcab2684dc9eb073b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isMap(value) { + return value instanceof Map; +} + +exports.isMap = isMap; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3a5d6060b4154d0bf2192bc2473de35226b2ad83 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isMap.mjs @@ -0,0 +1,5 @@ +function isMap(value) { + return value instanceof Map; +} + +export { isMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNil.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNil.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e95a932981bf4be724a99680afd5da559f547608 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} x - The value to test for null or undefined. + * @returns {boolean} `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: unknown): x is null | undefined; + +export { isNil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNil.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNil.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e95a932981bf4be724a99680afd5da559f547608 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} x - The value to test for null or undefined. + * @returns {boolean} `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: unknown): x is null | undefined; + +export { isNil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNil.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNil.js new file mode 100644 index 0000000000000000000000000000000000000000..81ed466830afc4a09e4de7553be1419e15ca5a4c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/predicate/isNil.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNil.mjs new file mode 100644 index 0000000000000000000000000000000000000000..963a002d35f8596ef94c7b21b52d8121bff7a01e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/predicate/isNode.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..686e845ef23a8a30355ee1eaef29bddbdfb65d20 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.d.mts @@ -0,0 +1,17 @@ +/** + * Checks if the current environment is Node.js. + * + * This function checks for the existence of the `process.versions.node` property, + * which only exists in Node.js environments. + * + * @returns {boolean} `true` if the current environment is Node.js, otherwise `false`. + * + * @example + * if (isNode()) { + * console.log('This is running in Node.js'); + * const fs = import('node:fs'); + * } + */ +declare function isNode(): boolean; + +export { isNode }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..686e845ef23a8a30355ee1eaef29bddbdfb65d20 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.d.ts @@ -0,0 +1,17 @@ +/** + * Checks if the current environment is Node.js. + * + * This function checks for the existence of the `process.versions.node` property, + * which only exists in Node.js environments. + * + * @returns {boolean} `true` if the current environment is Node.js, otherwise `false`. + * + * @example + * if (isNode()) { + * console.log('This is running in Node.js'); + * const fs = import('node:fs'); + * } + */ +declare function isNode(): boolean; + +export { isNode }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.js new file mode 100644 index 0000000000000000000000000000000000000000..f6de214a1ebd4b4dd6636fe8e97a75d19834c78d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isNode() { + return typeof process !== 'undefined' && process?.versions?.node != null; +} + +exports.isNode = isNode; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1bbf464ecced83684c9bfe1f76fbdc989eb9a5c8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNode.mjs @@ -0,0 +1,5 @@ +function isNode() { + return typeof process !== 'undefined' && process?.versions?.node != null; +} + +export { isNode }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cda4f9e4625ea6f5f7db48ef19375112121b953a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.d.mts @@ -0,0 +1,19 @@ +/** + * Checks if the given value is not null nor undefined. + * + * The main use of this function is to be used with TypeScript as a type predicate. + * + * @template T - The type of value. + * @param {T | null | undefined} x - The value to test if it is not null nor undefined. + * @returns {x is T} True if the value is not null nor undefined, false otherwise. + * + * @example + * // Here the type of `arr` is (number | undefined)[] + * const arr = [1, undefined, 3]; + * // Here the type of `result` is number[] + * const result = arr.filter(isNotNil); + * // result will be [1, 3] + */ +declare function isNotNil(x: T | null | undefined): x is T; + +export { isNotNil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cda4f9e4625ea6f5f7db48ef19375112121b953a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.d.ts @@ -0,0 +1,19 @@ +/** + * Checks if the given value is not null nor undefined. + * + * The main use of this function is to be used with TypeScript as a type predicate. + * + * @template T - The type of value. + * @param {T | null | undefined} x - The value to test if it is not null nor undefined. + * @returns {x is T} True if the value is not null nor undefined, false otherwise. + * + * @example + * // Here the type of `arr` is (number | undefined)[] + * const arr = [1, undefined, 3]; + * // Here the type of `result` is number[] + * const result = arr.filter(isNotNil); + * // result will be [1, 3] + */ +declare function isNotNil(x: T | null | undefined): x is T; + +export { isNotNil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.js new file mode 100644 index 0000000000000000000000000000000000000000..f07fb30c28966d611f902a8c4ab510837f3762f4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isNotNil(x) { + return x != null; +} + +exports.isNotNil = isNotNil; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.mjs new file mode 100644 index 0000000000000000000000000000000000000000..919684d1160dde22510ebaf8a8f58ba2969c8f24 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNotNil.mjs @@ -0,0 +1,5 @@ +function isNotNil(x) { + return x != null; +} + +export { isNotNil }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a51103a7093225a76f8c0a7240db9856b9552619 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.d.mts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is null. + * + * This function tests whether the provided value is strictly equal to `null`. + * It returns `true` if the value is `null`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null`. + * + * @param {unknown} x - The value to test if it is null. + * @returns {x is null} True if the value is null, false otherwise. + * + * @example + * const value1 = null; + * const value2 = undefined; + * const value3 = 42; + * + * console.log(isNull(value1)); // true + * console.log(isNull(value2)); // false + * console.log(isNull(value3)); // false + */ +declare function isNull(x: unknown): x is null; + +export { isNull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a51103a7093225a76f8c0a7240db9856b9552619 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.d.ts @@ -0,0 +1,23 @@ +/** + * Checks if the given value is null. + * + * This function tests whether the provided value is strictly equal to `null`. + * It returns `true` if the value is `null`, and `false` otherwise. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null`. + * + * @param {unknown} x - The value to test if it is null. + * @returns {x is null} True if the value is null, false otherwise. + * + * @example + * const value1 = null; + * const value2 = undefined; + * const value3 = 42; + * + * console.log(isNull(value1)); // true + * console.log(isNull(value2)); // false + * console.log(isNull(value3)); // false + */ +declare function isNull(x: unknown): x is null; + +export { isNull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.js new file mode 100644 index 0000000000000000000000000000000000000000..1936673215dd0bf59c43e9d9781be6860431b95b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isNull(x) { + return x === null; +} + +exports.isNull = isNull; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.mjs new file mode 100644 index 0000000000000000000000000000000000000000..837f2676d07e78525b74f04bbc0c13fe50cb2e92 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isNull.mjs @@ -0,0 +1,5 @@ +function isNull(x) { + return x === null; +} + +export { isNull }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8a3412891dc75b2f296f8b7648b1154f27e4a2e2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.d.mts @@ -0,0 +1,45 @@ +/** + * Checks if a given value is a plain object. + * + * @param {object} value - The value to check. + * @returns {value is Record} - True if the value is a plain object, otherwise false. + * + * @example + * ```typescript + * // ✅👇 True + * + * isPlainObject({ }); // ✅ + * isPlainObject({ key: 'value' }); // ✅ + * isPlainObject({ key: new Date() }); // ✅ + * isPlainObject(new Object()); // ✅ + * isPlainObject(Object.create(null)); // ✅ + * isPlainObject({ nested: { key: true} }); // ✅ + * isPlainObject(new Proxy({}, {})); // ✅ + * isPlainObject({ [Symbol('tag')]: 'A' }); // ✅ + * + * // ✅👇 (cross-realms, node context, workers, ...) + * const runInNewContext = await import('node:vm').then( + * (mod) => mod.runInNewContext + * ); + * isPlainObject(runInNewContext('({})')); // ✅ + * + * // ❌👇 False + * + * class Test { }; + * isPlainObject(new Test()) // ❌ + * isPlainObject(10); // ❌ + * isPlainObject(null); // ❌ + * isPlainObject('hello'); // ❌ + * isPlainObject([]); // ❌ + * isPlainObject(new Date()); // ❌ + * isPlainObject(new Uint8Array([1])); // ❌ + * isPlainObject(Buffer.from('ABC')); // ❌ + * isPlainObject(Promise.resolve({})); // ❌ + * isPlainObject(Object.create({})); // ❌ + * isPlainObject(new (class Cls {})); // ❌ + * isPlainObject(globalThis); // ❌, + * ``` + */ +declare function isPlainObject(value: unknown): value is Record; + +export { isPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8a3412891dc75b2f296f8b7648b1154f27e4a2e2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.d.ts @@ -0,0 +1,45 @@ +/** + * Checks if a given value is a plain object. + * + * @param {object} value - The value to check. + * @returns {value is Record} - True if the value is a plain object, otherwise false. + * + * @example + * ```typescript + * // ✅👇 True + * + * isPlainObject({ }); // ✅ + * isPlainObject({ key: 'value' }); // ✅ + * isPlainObject({ key: new Date() }); // ✅ + * isPlainObject(new Object()); // ✅ + * isPlainObject(Object.create(null)); // ✅ + * isPlainObject({ nested: { key: true} }); // ✅ + * isPlainObject(new Proxy({}, {})); // ✅ + * isPlainObject({ [Symbol('tag')]: 'A' }); // ✅ + * + * // ✅👇 (cross-realms, node context, workers, ...) + * const runInNewContext = await import('node:vm').then( + * (mod) => mod.runInNewContext + * ); + * isPlainObject(runInNewContext('({})')); // ✅ + * + * // ❌👇 False + * + * class Test { }; + * isPlainObject(new Test()) // ❌ + * isPlainObject(10); // ❌ + * isPlainObject(null); // ❌ + * isPlainObject('hello'); // ❌ + * isPlainObject([]); // ❌ + * isPlainObject(new Date()); // ❌ + * isPlainObject(new Uint8Array([1])); // ❌ + * isPlainObject(Buffer.from('ABC')); // ❌ + * isPlainObject(Promise.resolve({})); // ❌ + * isPlainObject(Object.create({})); // ❌ + * isPlainObject(new (class Cls {})); // ❌ + * isPlainObject(globalThis); // ❌, + * ``` + */ +declare function isPlainObject(value: unknown): value is Record; + +export { isPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.js new file mode 100644 index 0000000000000000000000000000000000000000..5c4dea4a8bc6226643f7d184f094bdbccba76ed8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isPlainObject(value) { + if (!value || typeof value !== 'object') { + return false; + } + const proto = Object.getPrototypeOf(value); + const hasObjectPrototype = proto === null || + proto === Object.prototype || + Object.getPrototypeOf(proto) === null; + if (!hasObjectPrototype) { + return false; + } + return Object.prototype.toString.call(value) === '[object Object]'; +} + +exports.isPlainObject = isPlainObject; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fee4fba39715ae5f9397f4482a68f5a2f76b4a17 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs @@ -0,0 +1,15 @@ +function isPlainObject(value) { + if (!value || typeof value !== 'object') { + return false; + } + const proto = Object.getPrototypeOf(value); + const hasObjectPrototype = proto === null || + proto === Object.prototype || + Object.getPrototypeOf(proto) === null; + if (!hasObjectPrototype) { + return false; + } + return Object.prototype.toString.call(value) === '[object Object]'; +} + +export { isPlainObject }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..92b8df4736f1810064ecb2098e4e1b15ac0017b4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.d.mts @@ -0,0 +1,31 @@ +/** + * Checks whether a value is a JavaScript primitive. + * JavaScript primitives include null, undefined, strings, numbers, booleans, symbols, and bigints. + * + * @param {unknown} value The value to check. + * @returns {value is + * null + * | undefined + * | string + * | number + * | boolean + * | symbol + * | bigint} Returns true if `value` is a primitive, false otherwise. + * + * @example + * isPrimitive(null); // true + * isPrimitive(undefined); // true + * isPrimitive('123'); // true + * isPrimitive(false); // true + * isPrimitive(true); // true + * isPrimitive(Symbol('a')); // true + * isPrimitive(123n); // true + * isPrimitive({}); // false + * isPrimitive(new Date()); // false + * isPrimitive(new Map()); // false + * isPrimitive(new Set()); // false + * isPrimitive([1, 2, 3]); // false + */ +declare function isPrimitive(value: unknown): value is null | undefined | string | number | boolean | symbol | bigint; + +export { isPrimitive }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..92b8df4736f1810064ecb2098e4e1b15ac0017b4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.d.ts @@ -0,0 +1,31 @@ +/** + * Checks whether a value is a JavaScript primitive. + * JavaScript primitives include null, undefined, strings, numbers, booleans, symbols, and bigints. + * + * @param {unknown} value The value to check. + * @returns {value is + * null + * | undefined + * | string + * | number + * | boolean + * | symbol + * | bigint} Returns true if `value` is a primitive, false otherwise. + * + * @example + * isPrimitive(null); // true + * isPrimitive(undefined); // true + * isPrimitive('123'); // true + * isPrimitive(false); // true + * isPrimitive(true); // true + * isPrimitive(Symbol('a')); // true + * isPrimitive(123n); // true + * isPrimitive({}); // false + * isPrimitive(new Date()); // false + * isPrimitive(new Map()); // false + * isPrimitive(new Set()); // false + * isPrimitive([1, 2, 3]); // false + */ +declare function isPrimitive(value: unknown): value is null | undefined | string | number | boolean | symbol | bigint; + +export { isPrimitive }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.js new file mode 100644 index 0000000000000000000000000000000000000000..a7e765e752118dc75fc250e3fbd8c65eb7bc7797 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isPrimitive(value) { + return value == null || (typeof value !== 'object' && typeof value !== 'function'); +} + +exports.isPrimitive = isPrimitive; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b68e20da514aee76a03fd837b1dd9257a031ed3e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs @@ -0,0 +1,5 @@ +function isPrimitive(value) { + return value == null || (typeof value !== 'object' && typeof value !== 'function'); +} + +export { isPrimitive }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..ee47be3934133664c5a6da1e89ea9fecb2d20aa7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.d.mts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is `Promise`. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Promise`. + * + * @param {unknown} value The value to check if it is a `Promise`. + * @returns {value is Promise} Returns `true` if `value` is a `Promise`, else `false`. + * + * @example + * const value1 = new Promise((resolve) => resolve()); + * const value2 = {}; + * const value3 = 123; + * + * console.log(isPromise(value1)); // true + * console.log(isPromise(value2)); // false + * console.log(isPromise(value3)); // false + */ +declare function isPromise(value: unknown): value is Promise; + +export { isPromise }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee47be3934133664c5a6da1e89ea9fecb2d20aa7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.d.ts @@ -0,0 +1,20 @@ +/** + * Checks if a given value is `Promise`. + * + * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Promise`. + * + * @param {unknown} value The value to check if it is a `Promise`. + * @returns {value is Promise} Returns `true` if `value` is a `Promise`, else `false`. + * + * @example + * const value1 = new Promise((resolve) => resolve()); + * const value2 = {}; + * const value3 = 123; + * + * console.log(isPromise(value1)); // true + * console.log(isPromise(value2)); // false + * console.log(isPromise(value3)); // false + */ +declare function isPromise(value: unknown): value is Promise; + +export { isPromise }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.js new file mode 100644 index 0000000000000000000000000000000000000000..6e5984de42ce6cd950f0106ae9c6f97a14a0a330 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isPromise(value) { + return value instanceof Promise; +} + +exports.isPromise = isPromise; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5474d36e39277414229013386cd1f6db3ac067e1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isPromise.mjs @@ -0,0 +1,5 @@ +function isPromise(value) { + return value instanceof Promise; +} + +export { isPromise }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a8ad27de6e92a1d144abf522e1c77b93e740e09c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.d.mts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a RegExp. + * + * @param {unknown} value The value to check. + * @returns {value is RegExp} 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: unknown): value is RegExp; + +export { isRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a8ad27de6e92a1d144abf522e1c77b93e740e09c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.d.ts @@ -0,0 +1,16 @@ +/** + * Checks if `value` is a RegExp. + * + * @param {unknown} value The value to check. + * @returns {value is RegExp} 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: unknown): value is RegExp; + +export { isRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.js new file mode 100644 index 0000000000000000000000000000000000000000..c73bd87410fe178fa8e514276542c151c935a57c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isRegExp(value) { + return value instanceof RegExp; +} + +exports.isRegExp = isRegExp; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a133f95072f1664b9da51917fb6bd8460b0dbfb2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isRegExp.mjs @@ -0,0 +1,5 @@ +function isRegExp(value) { + return value instanceof RegExp; +} + +export { isRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d5ed16820f3d3767d4c82eaf6283bb4c890832f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is Set; + +export { isSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d5ed16820f3d3767d4c82eaf6283bb4c890832f9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is Set; + +export { isSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.js new file mode 100644 index 0000000000000000000000000000000000000000..ca092074a7c7bbcb04d88637aa19b0e699504200 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isSet(value) { + return value instanceof Set; +} + +exports.isSet = isSet; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2a177c1d201eced8383c1c57d6a73d5bdab3ef30 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSet.mjs @@ -0,0 +1,5 @@ +function isSet(value) { + return value instanceof Set; +} + +export { isSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..4a304c2d948fd08b8e66c346c67b706c80af5087 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is string; + +export { isString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4a304c2d948fd08b8e66c346c67b706c80af5087 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is string; + +export { isString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.js new file mode 100644 index 0000000000000000000000000000000000000000..981d12de9aa5e40c1c841bf879e49c108b87a78d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isString(value) { + return typeof value === 'string'; +} + +exports.isString = isString; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.mjs new file mode 100644 index 0000000000000000000000000000000000000000..671146f2d71cc3c6517d754d56d7c6374ae2603a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isString.mjs @@ -0,0 +1,5 @@ +function isString(value) { + return typeof value === 'string'; +} + +export { isString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2ce4db9938ad609d2dcdc0c7099a151e4f271499 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.d.mts @@ -0,0 +1,26 @@ +/** + * 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 + * import { isSymbol } from 'es-toolkit/predicate'; + * + * isSymbol(Symbol('a')); // true + * isSymbol(Symbol.for('a')); // true + * isSymbol(Symbol.iterator); // true + * + * isSymbol(null); // false + * isSymbol(undefined); // false + * isSymbol('123'); // false + * isSymbol(false); // false + * isSymbol(123n); // false + * isSymbol({}); // false + * isSymbol([1, 2, 3]); // false + */ +declare function isSymbol(value: unknown): value is symbol; + +export { isSymbol }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2ce4db9938ad609d2dcdc0c7099a151e4f271499 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.d.ts @@ -0,0 +1,26 @@ +/** + * 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 + * import { isSymbol } from 'es-toolkit/predicate'; + * + * isSymbol(Symbol('a')); // true + * isSymbol(Symbol.for('a')); // true + * isSymbol(Symbol.iterator); // true + * + * isSymbol(null); // false + * isSymbol(undefined); // false + * isSymbol('123'); // false + * isSymbol(false); // false + * isSymbol(123n); // false + * isSymbol({}); // false + * isSymbol([1, 2, 3]); // false + */ +declare function isSymbol(value: unknown): value is symbol; + +export { isSymbol }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.js new file mode 100644 index 0000000000000000000000000000000000000000..4311f82a76e0da5caa0c829924d2ad0f380b9bc6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isSymbol(value) { + return typeof value === 'symbol'; +} + +exports.isSymbol = isSymbol; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.mjs new file mode 100644 index 0000000000000000000000000000000000000000..90637550f69ccdf8f7362bf307d78c6d5d003359 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isSymbol.mjs @@ -0,0 +1,5 @@ +function isSymbol(value) { + return typeof value === 'symbol'; +} + +export { isSymbol }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7ccddd5bc85c8757bdd2a00e2208f3a07efdadaf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.d.mts @@ -0,0 +1,29 @@ +/** + * Checks if a value is a TypedArray. + * @param {unknown} x The value to check. + * @returns {x is + * Uint8Array + * | Uint8ClampedArray + * | Uint16Array + * | Uint32Array + * | BigUint64Array + * | Int8Array + * | Int16Array + * | Int32Array + * | BigInt64Array + * | Float32Array + * | Float64Array} 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: unknown): x is Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array; + +export { isTypedArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7ccddd5bc85c8757bdd2a00e2208f3a07efdadaf --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.d.ts @@ -0,0 +1,29 @@ +/** + * Checks if a value is a TypedArray. + * @param {unknown} x The value to check. + * @returns {x is + * Uint8Array + * | Uint8ClampedArray + * | Uint16Array + * | Uint32Array + * | BigUint64Array + * | Int8Array + * | Int16Array + * | Int32Array + * | BigInt64Array + * | Float32Array + * | Float64Array} 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: unknown): x is Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | BigUint64Array | Int8Array | Int16Array | Int32Array | BigInt64Array | Float32Array | Float64Array; + +export { isTypedArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.js new file mode 100644 index 0000000000000000000000000000000000000000..d210645a804fcd34d80d2531bbf9825b356eb200 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isTypedArray(x) { + return ArrayBuffer.isView(x) && !(x instanceof DataView); +} + +exports.isTypedArray = isTypedArray; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6d5793b447ac79b35b759a7762d58c88b0d13ec3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs @@ -0,0 +1,5 @@ +function isTypedArray(x) { + return ArrayBuffer.isView(x) && !(x instanceof DataView); +} + +export { isTypedArray }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isUndefined.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isUndefined.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..8cdb036175d959d416c04211eebcec8114d444e5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} 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/predicate/isUndefined.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isUndefined.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8cdb036175d959d416c04211eebcec8114d444e5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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 {unknown} 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/predicate/isUndefined.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isUndefined.js new file mode 100644 index 0000000000000000000000000000000000000000..4e7c144e793473beb006cf0ee52f9de7e7fa8260 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isUndefined.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isUndefined(x) { + return x === undefined; +} + +exports.isUndefined = isUndefined; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isUndefined.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isUndefined.mjs new file mode 100644 index 0000000000000000000000000000000000000000..c0b63b3085d6283aaf857f22288829eaaf0c7681 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isUndefined.mjs @@ -0,0 +1,5 @@ +function isUndefined(x) { + return x === undefined; +} + +export { isUndefined }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..599be6930cd18e0b591d809e21101bff79eccbbe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is WeakMap; + +export { isWeakMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..599be6930cd18e0b591d809e21101bff79eccbbe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is WeakMap; + +export { isWeakMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.js new file mode 100644 index 0000000000000000000000000000000000000000..8cca867247e5e6504733fb0516f51eebcc182162 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isWeakMap(value) { + return value instanceof WeakMap; +} + +exports.isWeakMap = isWeakMap; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.mjs new file mode 100644 index 0000000000000000000000000000000000000000..33630ef6fcbbc850570f4befc6df7c921a897a01 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakMap.mjs @@ -0,0 +1,5 @@ +function isWeakMap(value) { + return value instanceof WeakMap; +} + +export { isWeakMap }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..442583dd20b18c1434a31553c9e4afed4c2b2d27 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is WeakSet; + +export { isWeakSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..442583dd20b18c1434a31553c9e4afed4c2b2d27 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: unknown): value is WeakSet; + +export { isWeakSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.js new file mode 100644 index 0000000000000000000000000000000000000000..0a9dcd973969c6efea2bd85a0291d0ae33515d3a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function isWeakSet(value) { + return value instanceof WeakSet; +} + +exports.isWeakSet = isWeakSet; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2f64fe3ef063af5f7cc38e17c0a156187aede305 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/predicate/isWeakSet.mjs @@ -0,0 +1,5 @@ +function isWeakSet(value) { + return value instanceof WeakSet; +} + +export { isWeakSet }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..29bbef94849488719feab336dc53d21abe8bdfba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.d.mts @@ -0,0 +1,38 @@ +interface DelayOptions { + signal?: AbortSignal; +} +/** + * Delays the execution of code for a specified number of milliseconds. + * + * This function returns a Promise that resolves after the specified delay, allowing you to use it + * with async/await to pause execution. + * + * @param {number} ms - The number of milliseconds to delay. + * @param {DelayOptions} options - The options object. + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the delay. + * @returns {Promise} A Promise that resolves after the specified delay. + * + * @example + * async function foo() { + * console.log('Start'); + * await delay(1000); // Delays execution for 1 second + * console.log('End'); + * } + * + * foo(); + * + * // With AbortSignal + * const controller = new AbortController(); + * const { signal } = controller; + * + * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms + * try { + * await delay(100, { signal }); + * } catch (error) { + * console.error(error); // Will log 'AbortError' + * } + * } + */ +declare function delay(ms: number, { signal }?: DelayOptions): Promise; + +export { delay }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..29bbef94849488719feab336dc53d21abe8bdfba --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.d.ts @@ -0,0 +1,38 @@ +interface DelayOptions { + signal?: AbortSignal; +} +/** + * Delays the execution of code for a specified number of milliseconds. + * + * This function returns a Promise that resolves after the specified delay, allowing you to use it + * with async/await to pause execution. + * + * @param {number} ms - The number of milliseconds to delay. + * @param {DelayOptions} options - The options object. + * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the delay. + * @returns {Promise} A Promise that resolves after the specified delay. + * + * @example + * async function foo() { + * console.log('Start'); + * await delay(1000); // Delays execution for 1 second + * console.log('End'); + * } + * + * foo(); + * + * // With AbortSignal + * const controller = new AbortController(); + * const { signal } = controller; + * + * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms + * try { + * await delay(100, { signal }); + * } catch (error) { + * console.error(error); // Will log 'AbortError' + * } + * } + */ +declare function delay(ms: number, { signal }?: DelayOptions): Promise; + +export { delay }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.js new file mode 100644 index 0000000000000000000000000000000000000000..db3c0269deed2141ef5695dfc393312fabaa6dff --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.js @@ -0,0 +1,27 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const AbortError = require('../error/AbortError.js'); + +function delay(ms, { signal } = {}) { + return new Promise((resolve, reject) => { + const abortError = () => { + reject(new AbortError.AbortError()); + }; + const abortHandler = () => { + clearTimeout(timeoutId); + abortError(); + }; + if (signal?.aborted) { + return abortError(); + } + const timeoutId = setTimeout(() => { + signal?.removeEventListener('abort', abortHandler); + resolve(); + }, ms); + signal?.addEventListener('abort', abortHandler, { once: true }); + }); +} + +exports.delay = delay; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1ac7d396eb6b5632953fbd1dcf6ce2f974ff01a2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/delay.mjs @@ -0,0 +1,23 @@ +import { AbortError } from '../error/AbortError.mjs'; + +function delay(ms, { signal } = {}) { + return new Promise((resolve, reject) => { + const abortError = () => { + reject(new AbortError()); + }; + const abortHandler = () => { + clearTimeout(timeoutId); + abortError(); + }; + if (signal?.aborted) { + return abortError(); + } + const timeoutId = setTimeout(() => { + signal?.removeEventListener('abort', abortHandler); + resolve(); + }, ms); + signal?.addEventListener('abort', abortHandler, { once: true }); + }); +} + +export { delay }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..5a59d48db0df02349701956b5bd4649e5d90e857 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.d.mts @@ -0,0 +1,5 @@ +export { delay } from './delay.mjs'; +export { Mutex } from './mutex.mjs'; +export { Semaphore } from './semaphore.mjs'; +export { timeout } from './timeout.mjs'; +export { withTimeout } from './withTimeout.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..82b663969b362c0d0c7c71aa1caa687e6d60894e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.d.ts @@ -0,0 +1,5 @@ +export { delay } from './delay.js'; +export { Mutex } from './mutex.js'; +export { Semaphore } from './semaphore.js'; +export { timeout } from './timeout.js'; +export { withTimeout } from './withTimeout.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.js new file mode 100644 index 0000000000000000000000000000000000000000..1b966612cccc726de283af7aa5a1bbb94bfd4c38 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const delay = require('./delay.js'); +const mutex = require('./mutex.js'); +const semaphore = require('./semaphore.js'); +const timeout = require('./timeout.js'); +const withTimeout = require('./withTimeout.js'); + + + +exports.delay = delay.delay; +exports.Mutex = mutex.Mutex; +exports.Semaphore = semaphore.Semaphore; +exports.timeout = timeout.timeout; +exports.withTimeout = withTimeout.withTimeout; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5a59d48db0df02349701956b5bd4649e5d90e857 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/index.mjs @@ -0,0 +1,5 @@ +export { delay } from './delay.mjs'; +export { Mutex } from './mutex.mjs'; +export { Semaphore } from './semaphore.mjs'; +export { timeout } from './timeout.mjs'; +export { withTimeout } from './withTimeout.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..84fe614892b6d5517ca5eda5ab86008f83bef3a6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.d.mts @@ -0,0 +1,64 @@ +/** + * A Mutex (mutual exclusion lock) for async functions. + * It allows only one async task to access a critical section at a time. + * + * @example + * const mutex = new Mutex(); + * + * async function criticalSection() { + * await mutex.acquire(); + * try { + * // This code section cannot be executed simultaneously + * } finally { + * mutex.release(); + * } + * } + * + * criticalSection(); + * criticalSection(); // This call will wait until the first call releases the mutex. + */ +declare class Mutex { + private semaphore; + /** + * Checks if the mutex is currently locked. + * @returns {boolean} True if the mutex is locked, false otherwise. + * + * @example + * const mutex = new Mutex(); + * console.log(mutex.isLocked); // false + * await mutex.acquire(); + * console.log(mutex.isLocked); // true + * mutex.release(); + * console.log(mutex.isLocked); // false + */ + get isLocked(): boolean; + /** + * Acquires the mutex, blocking if necessary until it is available. + * @returns {Promise} A promise that resolves when the mutex is acquired. + * + * @example + * const mutex = new Mutex(); + * await mutex.acquire(); + * try { + * // This code section cannot be executed simultaneously + * } finally { + * mutex.release(); + * } + */ + acquire(): Promise; + /** + * Releases the mutex, allowing another waiting task to proceed. + * + * @example + * const mutex = new Mutex(); + * await mutex.acquire(); + * try { + * // This code section cannot be executed simultaneously + * } finally { + * mutex.release(); // Allows another waiting task to proceed. + * } + */ + release(): void; +} + +export { Mutex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..84fe614892b6d5517ca5eda5ab86008f83bef3a6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.d.ts @@ -0,0 +1,64 @@ +/** + * A Mutex (mutual exclusion lock) for async functions. + * It allows only one async task to access a critical section at a time. + * + * @example + * const mutex = new Mutex(); + * + * async function criticalSection() { + * await mutex.acquire(); + * try { + * // This code section cannot be executed simultaneously + * } finally { + * mutex.release(); + * } + * } + * + * criticalSection(); + * criticalSection(); // This call will wait until the first call releases the mutex. + */ +declare class Mutex { + private semaphore; + /** + * Checks if the mutex is currently locked. + * @returns {boolean} True if the mutex is locked, false otherwise. + * + * @example + * const mutex = new Mutex(); + * console.log(mutex.isLocked); // false + * await mutex.acquire(); + * console.log(mutex.isLocked); // true + * mutex.release(); + * console.log(mutex.isLocked); // false + */ + get isLocked(): boolean; + /** + * Acquires the mutex, blocking if necessary until it is available. + * @returns {Promise} A promise that resolves when the mutex is acquired. + * + * @example + * const mutex = new Mutex(); + * await mutex.acquire(); + * try { + * // This code section cannot be executed simultaneously + * } finally { + * mutex.release(); + * } + */ + acquire(): Promise; + /** + * Releases the mutex, allowing another waiting task to proceed. + * + * @example + * const mutex = new Mutex(); + * await mutex.acquire(); + * try { + * // This code section cannot be executed simultaneously + * } finally { + * mutex.release(); // Allows another waiting task to proceed. + * } + */ + release(): void; +} + +export { Mutex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.js new file mode 100644 index 0000000000000000000000000000000000000000..5b383afff4637949895770108f7b1f8af7f22e36 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const semaphore = require('./semaphore.js'); + +class Mutex { + semaphore = new semaphore.Semaphore(1); + get isLocked() { + return this.semaphore.available === 0; + } + async acquire() { + return this.semaphore.acquire(); + } + release() { + this.semaphore.release(); + } +} + +exports.Mutex = Mutex; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f995f0f8d8ed351e2af5a0679b223d935ba8cd65 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/mutex.mjs @@ -0,0 +1,16 @@ +import { Semaphore } from './semaphore.mjs'; + +class Mutex { + semaphore = new Semaphore(1); + get isLocked() { + return this.semaphore.available === 0; + } + async acquire() { + return this.semaphore.acquire(); + } + release() { + this.semaphore.release(); + } +} + +export { Mutex }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..31be57a27ad21e924e57cef37cee2f4ece7eeed0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.d.mts @@ -0,0 +1,81 @@ +/** + * A counting semaphore for async functions that manages available permits. + * Semaphores are mainly used to limit the number of concurrent async tasks. + * + * Each `acquire` operation takes a permit or waits until one is available. + * Each `release` operation adds a permit, potentially allowing a waiting task to proceed. + * + * The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers. + * + * @example + * const sema = new Semaphore(2); + * + * async function task() { + * await sema.acquire(); + * try { + * // This code can only be executed by two tasks at the same time + * } finally { + * sema.release(); + * } + * } + * + * task(); + * task(); + * task(); // This task will wait until one of the previous tasks releases the semaphore. + */ +declare class Semaphore { + /** + * The maximum number of concurrent operations allowed. + * @type {number} + */ + capacity: number; + /** + * The number of available permits. + * @type {number} + */ + available: number; + private deferredTasks; + /** + * Creates an instance of Semaphore. + * @param {number} capacity - The maximum number of concurrent operations allowed. + * + * @example + * const sema = new Semaphore(3); // Allows up to 3 concurrent operations. + */ + constructor(capacity: number); + /** + * Acquires a semaphore, blocking if necessary until one is available. + * @returns {Promise} A promise that resolves when the semaphore is acquired. + * + * @example + * const sema = new Semaphore(1); + * + * async function criticalSection() { + * await sema.acquire(); + * try { + * // This code section cannot be executed simultaneously + * } finally { + * sema.release(); + * } + * } + */ + acquire(): Promise; + /** + * Releases a semaphore, allowing one more operation to proceed. + * + * @example + * const sema = new Semaphore(1); + * + * async function task() { + * await sema.acquire(); + * try { + * // This code can only be executed by two tasks at the same time + * } finally { + * sema.release(); // Allows another waiting task to proceed. + * } + * } + */ + release(): void; +} + +export { Semaphore }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..31be57a27ad21e924e57cef37cee2f4ece7eeed0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.d.ts @@ -0,0 +1,81 @@ +/** + * A counting semaphore for async functions that manages available permits. + * Semaphores are mainly used to limit the number of concurrent async tasks. + * + * Each `acquire` operation takes a permit or waits until one is available. + * Each `release` operation adds a permit, potentially allowing a waiting task to proceed. + * + * The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers. + * + * @example + * const sema = new Semaphore(2); + * + * async function task() { + * await sema.acquire(); + * try { + * // This code can only be executed by two tasks at the same time + * } finally { + * sema.release(); + * } + * } + * + * task(); + * task(); + * task(); // This task will wait until one of the previous tasks releases the semaphore. + */ +declare class Semaphore { + /** + * The maximum number of concurrent operations allowed. + * @type {number} + */ + capacity: number; + /** + * The number of available permits. + * @type {number} + */ + available: number; + private deferredTasks; + /** + * Creates an instance of Semaphore. + * @param {number} capacity - The maximum number of concurrent operations allowed. + * + * @example + * const sema = new Semaphore(3); // Allows up to 3 concurrent operations. + */ + constructor(capacity: number); + /** + * Acquires a semaphore, blocking if necessary until one is available. + * @returns {Promise} A promise that resolves when the semaphore is acquired. + * + * @example + * const sema = new Semaphore(1); + * + * async function criticalSection() { + * await sema.acquire(); + * try { + * // This code section cannot be executed simultaneously + * } finally { + * sema.release(); + * } + * } + */ + acquire(): Promise; + /** + * Releases a semaphore, allowing one more operation to proceed. + * + * @example + * const sema = new Semaphore(1); + * + * async function task() { + * await sema.acquire(); + * try { + * // This code can only be executed by two tasks at the same time + * } finally { + * sema.release(); // Allows another waiting task to proceed. + * } + * } + */ + release(): void; +} + +export { Semaphore }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.js new file mode 100644 index 0000000000000000000000000000000000000000..a0f40f3770359c0645e24c9eb5bb949248f3107f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.js @@ -0,0 +1,34 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +class Semaphore { + capacity; + available; + deferredTasks = []; + constructor(capacity) { + this.capacity = capacity; + this.available = capacity; + } + async acquire() { + if (this.available > 0) { + this.available--; + return; + } + return new Promise(resolve => { + this.deferredTasks.push(resolve); + }); + } + release() { + const deferredTask = this.deferredTasks.shift(); + if (deferredTask != null) { + deferredTask(); + return; + } + if (this.available < this.capacity) { + this.available++; + } + } +} + +exports.Semaphore = Semaphore; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.mjs new file mode 100644 index 0000000000000000000000000000000000000000..9fa0fced1c6af2ddf898e41e0297e2be5683e50b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/semaphore.mjs @@ -0,0 +1,30 @@ +class Semaphore { + capacity; + available; + deferredTasks = []; + constructor(capacity) { + this.capacity = capacity; + this.available = capacity; + } + async acquire() { + if (this.available > 0) { + this.available--; + return; + } + return new Promise(resolve => { + this.deferredTasks.push(resolve); + }); + } + release() { + const deferredTask = this.deferredTasks.shift(); + if (deferredTask != null) { + deferredTask(); + return; + } + if (this.available < this.capacity) { + this.available++; + } + } +} + +export { Semaphore }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..249ae20cdb697ffef2b0fab44f4e61322d289a01 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.d.mts @@ -0,0 +1,17 @@ +/** + * Returns a promise that rejects with a `TimeoutError` after a specified delay. + * + * @param {number} ms - The delay duration in milliseconds. + * @returns {Promise} A promise that rejects with a `TimeoutError` after the specified delay. + * @throws {TimeoutError} Throws a `TimeoutError` after the specified delay. + * + * @example + * try { + * await timeout(1000); // Timeout exception after 1 second + * } catch (error) { + * console.error(error); // Will log 'The operation was timed out' + * } + */ +declare function timeout(ms: number): Promise; + +export { timeout }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..249ae20cdb697ffef2b0fab44f4e61322d289a01 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.d.ts @@ -0,0 +1,17 @@ +/** + * Returns a promise that rejects with a `TimeoutError` after a specified delay. + * + * @param {number} ms - The delay duration in milliseconds. + * @returns {Promise} A promise that rejects with a `TimeoutError` after the specified delay. + * @throws {TimeoutError} Throws a `TimeoutError` after the specified delay. + * + * @example + * try { + * await timeout(1000); // Timeout exception after 1 second + * } catch (error) { + * console.error(error); // Will log 'The operation was timed out' + * } + */ +declare function timeout(ms: number): Promise; + +export { timeout }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.js new file mode 100644 index 0000000000000000000000000000000000000000..0430d9dbff8ba3bf8433142ffaac1303fa6d2d7b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const delay = require('./delay.js'); +const TimeoutError = require('../error/TimeoutError.js'); + +async function timeout(ms) { + await delay.delay(ms); + throw new TimeoutError.TimeoutError(); +} + +exports.timeout = timeout; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.mjs new file mode 100644 index 0000000000000000000000000000000000000000..7fe67fd92f636925f0cb7939578004af74865bf7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/timeout.mjs @@ -0,0 +1,9 @@ +import { delay } from './delay.mjs'; +import { TimeoutError } from '../error/TimeoutError.mjs'; + +async function timeout(ms) { + await delay(ms); + throw new TimeoutError(); +} + +export { timeout }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2fdf872ee39058fbc849f6efaf76b210a0cca6f3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.d.mts @@ -0,0 +1,28 @@ +/** + * Executes an async function and enforces a timeout. + * + * If the promise does not resolve within the specified time, + * the timeout will trigger and the returned promise will be rejected. + * + * + * @template T + * @param {() => Promise} run - A function that returns a promise to be executed. + * @param {number} ms - The timeout duration in milliseconds. + * @returns {Promise} A promise that resolves with the result of the `run` function or rejects if the timeout is reached. + * + * @example + * async function fetchData() { + * const response = await fetch('https://example.com/data'); + * return response.json(); + * } + * + * try { + * const data = await withTimeout(fetchData, 1000); + * console.log(data); // Logs the fetched data if `fetchData` is resolved within 1 second. + * } catch (error) { + * console.error(error); // Will log 'TimeoutError' if `fetchData` is not resolved within 1 second. + * } + */ +declare function withTimeout(run: () => Promise, ms: number): Promise; + +export { withTimeout }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2fdf872ee39058fbc849f6efaf76b210a0cca6f3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.d.ts @@ -0,0 +1,28 @@ +/** + * Executes an async function and enforces a timeout. + * + * If the promise does not resolve within the specified time, + * the timeout will trigger and the returned promise will be rejected. + * + * + * @template T + * @param {() => Promise} run - A function that returns a promise to be executed. + * @param {number} ms - The timeout duration in milliseconds. + * @returns {Promise} A promise that resolves with the result of the `run` function or rejects if the timeout is reached. + * + * @example + * async function fetchData() { + * const response = await fetch('https://example.com/data'); + * return response.json(); + * } + * + * try { + * const data = await withTimeout(fetchData, 1000); + * console.log(data); // Logs the fetched data if `fetchData` is resolved within 1 second. + * } catch (error) { + * console.error(error); // Will log 'TimeoutError' if `fetchData` is not resolved within 1 second. + * } + */ +declare function withTimeout(run: () => Promise, ms: number): Promise; + +export { withTimeout }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.js new file mode 100644 index 0000000000000000000000000000000000000000..24c045603ac74d798f5aaed5f649dc5a534b3a19 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const timeout = require('./timeout.js'); + +async function withTimeout(run, ms) { + return Promise.race([run(), timeout.timeout(ms)]); +} + +exports.withTimeout = withTimeout; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.mjs new file mode 100644 index 0000000000000000000000000000000000000000..cb4d42af420c8c8cbdd32a77ea1eae6c2da466e4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/promise/withTimeout.mjs @@ -0,0 +1,7 @@ +import { timeout } from './timeout.mjs'; + +async function withTimeout(run, ms) { + return Promise.race([run(), timeout(ms)]); +} + +export { withTimeout }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..7e49894adbde9d0486eee5c2947d52edc7e335c4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.d.mts @@ -0,0 +1,19 @@ +/** + * 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} 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' + * const convertedStr5 = camelCase('Keep unicode 😅') // returns 'keepUnicode😅' + */ +declare function camelCase(str: string): string; + +export { camelCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7e49894adbde9d0486eee5c2947d52edc7e335c4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.d.ts @@ -0,0 +1,19 @@ +/** + * 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} 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' + * const convertedStr5 = camelCase('Keep unicode 😅') // returns 'keepUnicode😅' + */ +declare function camelCase(str: string): string; + +export { camelCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.js new file mode 100644 index 0000000000000000000000000000000000000000..18e682417ada1408c4024aebe4fae15b55922c1c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.js @@ -0,0 +1,17 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const capitalize = require('./capitalize.js'); +const words = require('./words.js'); + +function camelCase(str) { + const words$1 = words.words(str); + if (words$1.length === 0) { + return ''; + } + const [first, ...rest] = words$1; + return `${first.toLowerCase()}${rest.map(word => capitalize.capitalize(word)).join('')}`; +} + +exports.camelCase = camelCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2c2b64cf4a636a1ec398ced73e7a26402abcffe1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/camelCase.mjs @@ -0,0 +1,13 @@ +import { capitalize } from './capitalize.mjs'; +import { words } from './words.mjs'; + +function camelCase(str) { + const words$1 = words(str); + if (words$1.length === 0) { + return ''; + } + const [first, ...rest] = words$1; + return `${first.toLowerCase()}${rest.map(word => capitalize(word)).join('')}`; +} + +export { camelCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0f2b4066ef1593db0bd8211c4a56e0f10e7d0b3c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.d.mts @@ -0,0 +1,15 @@ +/** + * Converts the first character of string to upper case and the remaining to lower case. + * + * @template T - Literal type of the string. + * @param {T} str - The string to be converted to uppercase. + * @returns {Capitalize} - The capitalized string. + * + * @example + * const result = capitalize('fred') // returns 'Fred' + * const result2 = capitalize('FRED') // returns 'Fred' + */ +declare function capitalize(str: T): Capitalize; +type Capitalize = T extends `${infer F}${infer R}` ? `${Uppercase}${Lowercase}` : T; + +export { capitalize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0f2b4066ef1593db0bd8211c4a56e0f10e7d0b3c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.d.ts @@ -0,0 +1,15 @@ +/** + * Converts the first character of string to upper case and the remaining to lower case. + * + * @template T - Literal type of the string. + * @param {T} str - The string to be converted to uppercase. + * @returns {Capitalize} - The capitalized string. + * + * @example + * const result = capitalize('fred') // returns 'Fred' + * const result2 = capitalize('FRED') // returns 'Fred' + */ +declare function capitalize(str: T): Capitalize; +type Capitalize = T extends `${infer F}${infer R}` ? `${Uppercase}${Lowercase}` : T; + +export { capitalize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.js new file mode 100644 index 0000000000000000000000000000000000000000..3c511f78e7ea7f8716102e84aff709e90ddfe690 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function capitalize(str) { + return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()); +} + +exports.capitalize = capitalize; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.mjs new file mode 100644 index 0000000000000000000000000000000000000000..573a6c7030c409e9f6ab37fe5d4925830b727f9e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/capitalize.mjs @@ -0,0 +1,5 @@ +function capitalize(str) { + return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()); +} + +export { capitalize }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..169bf6990a7e1778d26c3ffdea1c3b0db3bcb15c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.d.mts @@ -0,0 +1,17 @@ +/** + * Converts a string to constant case. + * + * Constant case is a naming convention where each word is written in uppercase letters and separated by an underscore (`_`). For example, `CONSTANT_CASE`. + * + * @param {string} str - The string that is to be changed to constant case. + * @returns {string} - The converted string to constant case. + * + * @example + * const convertedStr1 = constantCase('camelCase') // returns 'CAMEL_CASE' + * const convertedStr2 = constantCase('some whitespace') // returns 'SOME_WHITESPACE' + * const convertedStr3 = constantCase('hyphen-text') // returns 'HYPHEN_TEXT' + * const convertedStr4 = constantCase('HTTPRequest') // returns 'HTTP_REQUEST' + */ +declare function constantCase(str: string): string; + +export { constantCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..169bf6990a7e1778d26c3ffdea1c3b0db3bcb15c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.d.ts @@ -0,0 +1,17 @@ +/** + * Converts a string to constant case. + * + * Constant case is a naming convention where each word is written in uppercase letters and separated by an underscore (`_`). For example, `CONSTANT_CASE`. + * + * @param {string} str - The string that is to be changed to constant case. + * @returns {string} - The converted string to constant case. + * + * @example + * const convertedStr1 = constantCase('camelCase') // returns 'CAMEL_CASE' + * const convertedStr2 = constantCase('some whitespace') // returns 'SOME_WHITESPACE' + * const convertedStr3 = constantCase('hyphen-text') // returns 'HYPHEN_TEXT' + * const convertedStr4 = constantCase('HTTPRequest') // returns 'HTTP_REQUEST' + */ +declare function constantCase(str: string): string; + +export { constantCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.js new file mode 100644 index 0000000000000000000000000000000000000000..0df5c4c8cb6c3dd0217b4cc6b7d8a88bf9289683 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const words = require('./words.js'); + +function constantCase(str) { + const words$1 = words.words(str); + return words$1.map(word => word.toUpperCase()).join('_'); +} + +exports.constantCase = constantCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5fdfa14d897f9845cdc880b9a095ae17e848881d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/constantCase.mjs @@ -0,0 +1,8 @@ +import { words } from './words.mjs'; + +function constantCase(str) { + const words$1 = words(str); + return words$1.map(word => word.toUpperCase()).join('_'); +} + +export { constantCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/deburr.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/deburr.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..32669bff7a68a32cc20fc90f1215d493ca232ac3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/string/deburr.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/deburr.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..32669bff7a68a32cc20fc90f1215d493ca232ac3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/string/deburr.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/deburr.js new file mode 100644 index 0000000000000000000000000000000000000000..749e838dc20cd44a080ffd858e5930479615fbfe --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/deburr.js @@ -0,0 +1,49 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const deburrMap = new Map(Object.entries({ + Æ: 'Ae', + Ð: 'D', + Ø: 'O', + Þ: 'Th', + ß: 'ss', + æ: 'ae', + ð: 'd', + ø: 'o', + þ: 'th', + Đ: 'D', + đ: 'd', + Ħ: 'H', + ħ: 'h', + ı: 'i', + IJ: 'IJ', + ij: 'ij', + ĸ: 'k', + Ŀ: 'L', + ŀ: 'l', + Ł: 'L', + ł: 'l', + ʼn: "'n", + Ŋ: 'N', + ŋ: 'n', + Œ: 'Oe', + œ: 'oe', + Ŧ: 'T', + ŧ: 't', + ſ: 's', +})); +function deburr(str) { + str = str.normalize('NFD'); + let result = ''; + for (let i = 0; i < str.length; i++) { + const char = str[i]; + if ((char >= '\u0300' && char <= '\u036f') || (char >= '\ufe20' && char <= '\ufe23')) { + continue; + } + result += deburrMap.get(char) ?? char; + } + return result; +} + +exports.deburr = deburr; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/deburr.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/deburr.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4f976f3ac5a32146549cd1a884535b2658e364be --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/deburr.mjs @@ -0,0 +1,45 @@ +const deburrMap = new Map(Object.entries({ + Æ: 'Ae', + Ð: 'D', + Ø: 'O', + Þ: 'Th', + ß: 'ss', + æ: 'ae', + ð: 'd', + ø: 'o', + þ: 'th', + Đ: 'D', + đ: 'd', + Ħ: 'H', + ħ: 'h', + ı: 'i', + IJ: 'IJ', + ij: 'ij', + ĸ: 'k', + Ŀ: 'L', + ŀ: 'l', + Ł: 'L', + ł: 'l', + ʼn: "'n", + Ŋ: 'N', + ŋ: 'n', + Œ: 'Oe', + œ: 'oe', + Ŧ: 'T', + ŧ: 't', + ſ: 's', +})); +function deburr(str) { + str = str.normalize('NFD'); + let result = ''; + for (let i = 0; i < str.length; i++) { + const char = str[i]; + if ((char >= '\u0300' && char <= '\u036f') || (char >= '\ufe20' && char <= '\ufe23')) { + continue; + } + result += deburrMap.get(char) ?? char; + } + return result; +} + +export { deburr }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..67c3515743082188d2ad64de15c9436c295dee42 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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(str: string): string; + +export { escape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..67c3515743082188d2ad64de15c9436c295dee42 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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(str: string): string; + +export { escape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.js new file mode 100644 index 0000000000000000000000000000000000000000..c0bf01859189c8b70f18137063b51f8e8c8fb7a4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const htmlEscapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', +}; +function escape(str) { + return str.replace(/[&<>"']/g, match => htmlEscapes[match]); +} + +exports.escape = escape; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.mjs new file mode 100644 index 0000000000000000000000000000000000000000..730c332b14496ffa660258f5f9fc2278b6fca43d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escape.mjs @@ -0,0 +1,12 @@ +const htmlEscapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', +}; +function escape(str) { + return str.replace(/[&<>"']/g, match => htmlEscapes[match]); +} + +export { escape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escapeRegExp.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escapeRegExp.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f9eba6b8fb69b3b56fefeed394f77e68c584c23d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/string/escapeRegExp.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escapeRegExp.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9eba6b8fb69b3b56fefeed394f77e68c584c23d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/string/escapeRegExp.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escapeRegExp.js new file mode 100644 index 0000000000000000000000000000000000000000..ba37585b6268057446e7325f59a282f6cb71f41c --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escapeRegExp.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function escapeRegExp(str) { + return str.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&'); +} + +exports.escapeRegExp = escapeRegExp; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escapeRegExp.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escapeRegExp.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5ddd8c8d6dad8d1aaf8f2d3abf9fffcaa124cf91 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/escapeRegExp.mjs @@ -0,0 +1,5 @@ +function escapeRegExp(str) { + return str.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&'); +} + +export { escapeRegExp }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..76fe381a6ca12392005fda6b37a483a188a1b3aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.d.mts @@ -0,0 +1,21 @@ +export { camelCase } from './camelCase.mjs'; +export { capitalize } from './capitalize.mjs'; +export { constantCase } from './constantCase.mjs'; +export { deburr } from './deburr.mjs'; +export { escape } from './escape.mjs'; +export { escapeRegExp } from './escapeRegExp.mjs'; +export { kebabCase } from './kebabCase.mjs'; +export { lowerCase } from './lowerCase.mjs'; +export { lowerFirst } from './lowerFirst.mjs'; +export { pad } from './pad.mjs'; +export { pascalCase } from './pascalCase.mjs'; +export { reverseString } from './reverseString.mjs'; +export { snakeCase } from './snakeCase.mjs'; +export { startCase } from './startCase.mjs'; +export { trim } from './trim.mjs'; +export { trimEnd } from './trimEnd.mjs'; +export { trimStart } from './trimStart.mjs'; +export { unescape } from './unescape.mjs'; +export { upperCase } from './upperCase.mjs'; +export { upperFirst } from './upperFirst.mjs'; +export { words } from './words.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..23efd014cbc49e91dca67ebb00ea40f62e2634b5 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.d.ts @@ -0,0 +1,21 @@ +export { camelCase } from './camelCase.js'; +export { capitalize } from './capitalize.js'; +export { constantCase } from './constantCase.js'; +export { deburr } from './deburr.js'; +export { escape } from './escape.js'; +export { escapeRegExp } from './escapeRegExp.js'; +export { kebabCase } from './kebabCase.js'; +export { lowerCase } from './lowerCase.js'; +export { lowerFirst } from './lowerFirst.js'; +export { pad } from './pad.js'; +export { pascalCase } from './pascalCase.js'; +export { reverseString } from './reverseString.js'; +export { snakeCase } from './snakeCase.js'; +export { startCase } from './startCase.js'; +export { trim } from './trim.js'; +export { trimEnd } from './trimEnd.js'; +export { trimStart } from './trimStart.js'; +export { unescape } from './unescape.js'; +export { upperCase } from './upperCase.js'; +export { upperFirst } from './upperFirst.js'; +export { words } from './words.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6d8b5fc6db3d60afcaad01b211dc74966568cff6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.js @@ -0,0 +1,49 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const camelCase = require('./camelCase.js'); +const capitalize = require('./capitalize.js'); +const constantCase = require('./constantCase.js'); +const deburr = require('./deburr.js'); +const escape = require('./escape.js'); +const escapeRegExp = require('./escapeRegExp.js'); +const kebabCase = require('./kebabCase.js'); +const lowerCase = require('./lowerCase.js'); +const lowerFirst = require('./lowerFirst.js'); +const pad = require('./pad.js'); +const pascalCase = require('./pascalCase.js'); +const reverseString = require('./reverseString.js'); +const snakeCase = require('./snakeCase.js'); +const startCase = require('./startCase.js'); +const trim = require('./trim.js'); +const trimEnd = require('./trimEnd.js'); +const trimStart = require('./trimStart.js'); +const unescape = require('./unescape.js'); +const upperCase = require('./upperCase.js'); +const upperFirst = require('./upperFirst.js'); +const words = require('./words.js'); + + + +exports.camelCase = camelCase.camelCase; +exports.capitalize = capitalize.capitalize; +exports.constantCase = constantCase.constantCase; +exports.deburr = deburr.deburr; +exports.escape = escape.escape; +exports.escapeRegExp = escapeRegExp.escapeRegExp; +exports.kebabCase = kebabCase.kebabCase; +exports.lowerCase = lowerCase.lowerCase; +exports.lowerFirst = lowerFirst.lowerFirst; +exports.pad = pad.pad; +exports.pascalCase = pascalCase.pascalCase; +exports.reverseString = reverseString.reverseString; +exports.snakeCase = snakeCase.snakeCase; +exports.startCase = startCase.startCase; +exports.trim = trim.trim; +exports.trimEnd = trimEnd.trimEnd; +exports.trimStart = trimStart.trimStart; +exports.unescape = unescape.unescape; +exports.upperCase = upperCase.upperCase; +exports.upperFirst = upperFirst.upperFirst; +exports.words = words.words; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..76fe381a6ca12392005fda6b37a483a188a1b3aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/index.mjs @@ -0,0 +1,21 @@ +export { camelCase } from './camelCase.mjs'; +export { capitalize } from './capitalize.mjs'; +export { constantCase } from './constantCase.mjs'; +export { deburr } from './deburr.mjs'; +export { escape } from './escape.mjs'; +export { escapeRegExp } from './escapeRegExp.mjs'; +export { kebabCase } from './kebabCase.mjs'; +export { lowerCase } from './lowerCase.mjs'; +export { lowerFirst } from './lowerFirst.mjs'; +export { pad } from './pad.mjs'; +export { pascalCase } from './pascalCase.mjs'; +export { reverseString } from './reverseString.mjs'; +export { snakeCase } from './snakeCase.mjs'; +export { startCase } from './startCase.mjs'; +export { trim } from './trim.mjs'; +export { trimEnd } from './trimEnd.mjs'; +export { trimStart } from './trimStart.mjs'; +export { unescape } from './unescape.mjs'; +export { upperCase } from './upperCase.mjs'; +export { upperFirst } from './upperFirst.mjs'; +export { words } from './words.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/kebabCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/kebabCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..471716d7867b53d0350f3f805b8878f41feffe5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/kebabCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/kebabCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..471716d7867b53d0350f3f805b8878f41feffe5e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/kebabCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/kebabCase.js new file mode 100644 index 0000000000000000000000000000000000000000..1d44a3dfa45c670d1edd244dfcf6e82a1fab25cc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/kebabCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const words = require('./words.js'); + +function kebabCase(str) { + const words$1 = words.words(str); + return words$1.map(word => word.toLowerCase()).join('-'); +} + +exports.kebabCase = kebabCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/kebabCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/kebabCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..05bb1ce76fdbe42d6a6953869e1b575dac32c2b2 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/kebabCase.mjs @@ -0,0 +1,8 @@ +import { words } from './words.mjs'; + +function kebabCase(str) { + const words$1 = words(str); + return words$1.map(word => word.toLowerCase()).join('-'); +} + +export { kebabCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c8f18d00ac105926d441ec05e07830de7c3a33e8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/lowerCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c8f18d00ac105926d441ec05e07830de7c3a33e8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/lowerCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerCase.js new file mode 100644 index 0000000000000000000000000000000000000000..5ed3e7b00f0a7df54aeb3acfe5ef09fc512fd9b4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const words = require('./words.js'); + +function lowerCase(str) { + const words$1 = words.words(str); + return words$1.map(word => word.toLowerCase()).join(' '); +} + +exports.lowerCase = lowerCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..738274fb4e5a9bb6c5039c0166d4997d7cccd97b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerCase.mjs @@ -0,0 +1,8 @@ +import { words } from './words.mjs'; + +function lowerCase(str) { + const words$1 = words(str); + return words$1.map(word => word.toLowerCase()).join(' '); +} + +export { lowerCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f9cf7124dd6fee67123eb080e481a96ef9f1535a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: string): string; + +export { lowerFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9cf7124dd6fee67123eb080e481a96ef9f1535a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: string): string; + +export { lowerFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.js new file mode 100644 index 0000000000000000000000000000000000000000..f2c3d6697f7c9b3274e0bc6c9c899de8ee8849f3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function lowerFirst(str) { + return str.substring(0, 1).toLowerCase() + str.substring(1); +} + +exports.lowerFirst = lowerFirst; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.mjs new file mode 100644 index 0000000000000000000000000000000000000000..08fbf435f698368b3fd7a991d048786c8db60d4a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/lowerFirst.mjs @@ -0,0 +1,5 @@ +function lowerFirst(str) { + return str.substring(0, 1).toLowerCase() + str.substring(1); +} + +export { lowerFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pad.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pad.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9fd4281fbde3b62140e6780ad2b49e7effb55b0b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/string/pad.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pad.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9fd4281fbde3b62140e6780ad2b49e7effb55b0b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/string/pad.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pad.js new file mode 100644 index 0000000000000000000000000000000000000000..9e97ad0dbc72b7bc6d17fabf4240825698a37b1f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pad.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function pad(str, length, chars = ' ') { + return str.padStart(Math.floor((length - str.length) / 2) + str.length, chars).padEnd(length, chars); +} + +exports.pad = pad; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pad.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pad.mjs new file mode 100644 index 0000000000000000000000000000000000000000..02188eb91ad537e875e629e221dd4ab7daf1170a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pad.mjs @@ -0,0 +1,5 @@ +function pad(str, length, chars = ' ') { + return str.padStart(Math.floor((length - str.length) / 2) + str.length, chars).padEnd(length, chars); +} + +export { pad }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..fc90606424ecb28b9f3e7a8a237b45638e799408 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.d.mts @@ -0,0 +1,17 @@ +/** + * Converts a string to Pascal case. + * + * Pascal case is the naming convention in which each word is capitalized and concatenated without any separator characters. + * + * @param {string} str - The string that is to be changed to pascal case. + * @returns {string} - The converted string to Pascal case. + * + * @example + * const convertedStr1 = pascalCase('pascalCase') // returns 'PascalCase' + * const convertedStr2 = pascalCase('some whitespace') // returns 'SomeWhitespace' + * const convertedStr3 = pascalCase('hyphen-text') // returns 'HyphenText' + * const convertedStr4 = pascalCase('HTTPRequest') // returns 'HttpRequest' + */ +declare function pascalCase(str: string): string; + +export { pascalCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..fc90606424ecb28b9f3e7a8a237b45638e799408 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.d.ts @@ -0,0 +1,17 @@ +/** + * Converts a string to Pascal case. + * + * Pascal case is the naming convention in which each word is capitalized and concatenated without any separator characters. + * + * @param {string} str - The string that is to be changed to pascal case. + * @returns {string} - The converted string to Pascal case. + * + * @example + * const convertedStr1 = pascalCase('pascalCase') // returns 'PascalCase' + * const convertedStr2 = pascalCase('some whitespace') // returns 'SomeWhitespace' + * const convertedStr3 = pascalCase('hyphen-text') // returns 'HyphenText' + * const convertedStr4 = pascalCase('HTTPRequest') // returns 'HttpRequest' + */ +declare function pascalCase(str: string): string; + +export { pascalCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.js new file mode 100644 index 0000000000000000000000000000000000000000..2ae3b9381f34ef1dab43313b86b203dfcfcf681f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.js @@ -0,0 +1,13 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const capitalize = require('./capitalize.js'); +const words = require('./words.js'); + +function pascalCase(str) { + const words$1 = words.words(str); + return words$1.map(word => capitalize.capitalize(word)).join(''); +} + +exports.pascalCase = pascalCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..02cf5909f0abe8a479f65e695e90adc68353e39b --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/pascalCase.mjs @@ -0,0 +1,9 @@ +import { capitalize } from './capitalize.mjs'; +import { words } from './words.mjs'; + +function pascalCase(str) { + const words$1 = words(str); + return words$1.map(word => capitalize(word)).join(''); +} + +export { pascalCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e082150937eb164d173f4ee024783a98058ce01d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.d.mts @@ -0,0 +1,16 @@ +/** + * Reverses a given string. + * + * This function takes a string as input and returns a new string that is the reverse of the input. + * + * @param {string} value - The string that is to be reversed. + * @returns {string} - The reversed string. + * + * @example + * const reversedStr1 = reverseString('hello') // returns 'olleh' + * const reversedStr2 = reverseString('PascalCase') // returns 'esaClacsaP' + * const reversedStr3 = reverseString('foo 😄 bar') // returns 'rab 😄 oof' + */ +declare function reverseString(value: string): string; + +export { reverseString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e082150937eb164d173f4ee024783a98058ce01d --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.d.ts @@ -0,0 +1,16 @@ +/** + * Reverses a given string. + * + * This function takes a string as input and returns a new string that is the reverse of the input. + * + * @param {string} value - The string that is to be reversed. + * @returns {string} - The reversed string. + * + * @example + * const reversedStr1 = reverseString('hello') // returns 'olleh' + * const reversedStr2 = reverseString('PascalCase') // returns 'esaClacsaP' + * const reversedStr3 = reverseString('foo 😄 bar') // returns 'rab 😄 oof' + */ +declare function reverseString(value: string): string; + +export { reverseString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.js new file mode 100644 index 0000000000000000000000000000000000000000..156a7214356301255676ab19e1788c05b7bfcb41 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function reverseString(value) { + return [...value].reverse().join(''); +} + +exports.reverseString = reverseString; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.mjs new file mode 100644 index 0000000000000000000000000000000000000000..db347cf676313e38cfe497271c3ee57bd6403743 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/reverseString.mjs @@ -0,0 +1,5 @@ +function reverseString(value) { + return [...value].reverse().join(''); +} + +export { reverseString }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/snakeCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/snakeCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d921ad8bf2b9547d237f8d40ddb6e1fb36045804 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/snakeCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/snakeCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d921ad8bf2b9547d237f8d40ddb6e1fb36045804 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/snakeCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/snakeCase.js new file mode 100644 index 0000000000000000000000000000000000000000..20ff283d396571d8997fc42d569152e4fb79642f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/snakeCase.js @@ -0,0 +1,12 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const words = require('./words.js'); + +function snakeCase(str) { + const words$1 = words.words(str); + return words$1.map(word => word.toLowerCase()).join('_'); +} + +exports.snakeCase = snakeCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/snakeCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/snakeCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..a06b6aef2a3948b41f405833d6fbd9cd8a65da16 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/snakeCase.mjs @@ -0,0 +1,8 @@ +import { words } from './words.mjs'; + +function snakeCase(str) { + const words$1 = words(str); + return words$1.map(word => word.toLowerCase()).join('_'); +} + +export { snakeCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/startCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/startCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..106a965306358e973daea0a58f366f04cd8d53b6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/startCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/startCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..106a965306358e973daea0a58f366f04cd8d53b6 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/startCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/startCase.js new file mode 100644 index 0000000000000000000000000000000000000000..2daac3187cd71fadc7f98c51727b7f779c18d8eb --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/startCase.js @@ -0,0 +1,20 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const words = require('./words.js'); + +function startCase(str) { + const words$1 = words.words(str.trim()); + let result = ''; + for (let i = 0; i < words$1.length; i++) { + const word = words$1[i]; + if (result) { + result += ' '; + } + 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/string/startCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/startCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b360d9ae2439ee69317fbb0f521168e380833ef7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/startCase.mjs @@ -0,0 +1,16 @@ +import { words } from './words.mjs'; + +function startCase(str) { + const words$1 = words(str.trim()); + let result = ''; + for (let i = 0; i < words$1.length; i++) { + const word = words$1[i]; + if (result) { + result += ' '; + } + 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/string/trim.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..cb78e00e9db10ca253be58eb7fb72927e355d690 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.d.mts @@ -0,0 +1,15 @@ +/** + * Removes leading and trailing whitespace or specified characters from a string. + * + * @param {string} str - The string from which characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the string. Can be a single character or an array of characters. + * @returns {string} - The resulting string after the specified characters have been removed. + * + * @example + * trim(" hello "); // "hello" + * trim("--hello--", "-"); // "hello" + * trim("##hello##", ["#", "o"]); // "hell" + */ +declare function trim(str: string, chars?: string | string[]): string; + +export { trim }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb78e00e9db10ca253be58eb7fb72927e355d690 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.d.ts @@ -0,0 +1,15 @@ +/** + * Removes leading and trailing whitespace or specified characters from a string. + * + * @param {string} str - The string from which characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the string. Can be a single character or an array of characters. + * @returns {string} - The resulting string after the specified characters have been removed. + * + * @example + * trim(" hello "); // "hello" + * trim("--hello--", "-"); // "hello" + * trim("##hello##", ["#", "o"]); // "hell" + */ +declare function trim(str: string, chars?: string | string[]): string; + +export { trim }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.js new file mode 100644 index 0000000000000000000000000000000000000000..5a7686cfb6d782e5dd4fe88d4df4078b359f3fc4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const trimEnd = require('./trimEnd.js'); +const trimStart = require('./trimStart.js'); + +function trim(str, chars) { + if (chars === undefined) { + return str.trim(); + } + return trimStart.trimStart(trimEnd.trimEnd(str, chars), chars); +} + +exports.trim = trim; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.mjs new file mode 100644 index 0000000000000000000000000000000000000000..293485c7a1c271b6a183e5bf6b9cff7d59d67bf9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trim.mjs @@ -0,0 +1,11 @@ +import { trimEnd } from './trimEnd.mjs'; +import { trimStart } from './trimStart.mjs'; + +function trim(str, chars) { + if (chars === undefined) { + return str.trim(); + } + return trimStart(trimEnd(str, chars), chars); +} + +export { trim }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..688c7638c7915df8e6896a28c11a7c9dbc92e9d3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.d.mts @@ -0,0 +1,19 @@ +/** + * Removes trailing whitespace or specified characters from a string. + * + * If `chars` is a string, it should be a single character. To trim a string with multiple characters, + * provide an array instead. + * + * @param {string} str - The string from which trailing characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the end of the string. + * @returns {string} - The resulting string after the specified trailing character has been removed. + * + * @example + * const trimmedStr1 = trimEnd('hello---', '-') // returns 'hello' + * const trimmedStr2 = trimEnd('123000', '0') // returns '123' + * const trimmedStr3 = trimEnd('abcabcabc', 'c') // returns 'abcabcab' + * const trimmedStr4 = trimEnd('trimmedxxx', 'x') // returns 'trimmed' + */ +declare function trimEnd(str: string, chars?: string | string[]): string; + +export { trimEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..688c7638c7915df8e6896a28c11a7c9dbc92e9d3 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.d.ts @@ -0,0 +1,19 @@ +/** + * Removes trailing whitespace or specified characters from a string. + * + * If `chars` is a string, it should be a single character. To trim a string with multiple characters, + * provide an array instead. + * + * @param {string} str - The string from which trailing characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the end of the string. + * @returns {string} - The resulting string after the specified trailing character has been removed. + * + * @example + * const trimmedStr1 = trimEnd('hello---', '-') // returns 'hello' + * const trimmedStr2 = trimEnd('123000', '0') // returns '123' + * const trimmedStr3 = trimEnd('abcabcabc', 'c') // returns 'abcabcab' + * const trimmedStr4 = trimEnd('trimmedxxx', 'x') // returns 'trimmed' + */ +declare function trimEnd(str: string, chars?: string | string[]): string; + +export { trimEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.js new file mode 100644 index 0000000000000000000000000000000000000000..984ede42192cdf9abc1da9135563415b0a01d453 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.js @@ -0,0 +1,29 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function trimEnd(str, chars) { + if (chars === undefined) { + return str.trimEnd(); + } + let endIndex = str.length; + switch (typeof chars) { + case 'string': { + if (chars.length !== 1) { + throw new Error(`The 'chars' parameter should be a single character string.`); + } + while (endIndex > 0 && str[endIndex - 1] === chars) { + endIndex--; + } + break; + } + case 'object': { + while (endIndex > 0 && chars.includes(str[endIndex - 1])) { + endIndex--; + } + } + } + return str.substring(0, endIndex); +} + +exports.trimEnd = trimEnd; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.mjs new file mode 100644 index 0000000000000000000000000000000000000000..aaf6d1b9fa669356d2a9c581f11be9cbb97da542 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimEnd.mjs @@ -0,0 +1,25 @@ +function trimEnd(str, chars) { + if (chars === undefined) { + return str.trimEnd(); + } + let endIndex = str.length; + switch (typeof chars) { + case 'string': { + if (chars.length !== 1) { + throw new Error(`The 'chars' parameter should be a single character string.`); + } + while (endIndex > 0 && str[endIndex - 1] === chars) { + endIndex--; + } + break; + } + case 'object': { + while (endIndex > 0 && chars.includes(str[endIndex - 1])) { + endIndex--; + } + } + } + return str.substring(0, endIndex); +} + +export { trimEnd }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..9cb60af97bcb46d4798d6453b9e67a30a1b40a95 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.d.mts @@ -0,0 +1,19 @@ +/** + * Removes leading whitespace or specified characters from a string. + * + * If `chars` is a string, it should be a single character. To trim a string with multiple characters, + * provide an array instead. + * + * @param {string} str - The string from which leading characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the start of the string. + * @returns {string} - The resulting string after the specified leading character has been removed. + * + * @example + * const trimmedStr1 = trimStart('---hello', '-') // returns 'hello' + * const trimmedStr2 = trimStart('000123', '0') // returns '123' + * const trimmedStr3 = trimStart('abcabcabc', 'a') // returns 'bcabcabc' + * const trimmedStr4 = trimStart('xxxtrimmed', 'x') // returns 'trimmed' + */ +declare function trimStart(str: string, chars?: string | string[]): string; + +export { trimStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9cb60af97bcb46d4798d6453b9e67a30a1b40a95 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.d.ts @@ -0,0 +1,19 @@ +/** + * Removes leading whitespace or specified characters from a string. + * + * If `chars` is a string, it should be a single character. To trim a string with multiple characters, + * provide an array instead. + * + * @param {string} str - The string from which leading characters will be trimmed. + * @param {string | string[]} chars - The character(s) to remove from the start of the string. + * @returns {string} - The resulting string after the specified leading character has been removed. + * + * @example + * const trimmedStr1 = trimStart('---hello', '-') // returns 'hello' + * const trimmedStr2 = trimStart('000123', '0') // returns '123' + * const trimmedStr3 = trimStart('abcabcabc', 'a') // returns 'bcabcabc' + * const trimmedStr4 = trimStart('xxxtrimmed', 'x') // returns 'trimmed' + */ +declare function trimStart(str: string, chars?: string | string[]): string; + +export { trimStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.js new file mode 100644 index 0000000000000000000000000000000000000000..b80b16cb3ecee3f6d69c59a4e6c279808aca2810 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.js @@ -0,0 +1,26 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function trimStart(str, chars) { + if (chars === undefined) { + return str.trimStart(); + } + let startIndex = 0; + switch (typeof chars) { + case 'string': { + while (startIndex < str.length && str[startIndex] === chars) { + startIndex++; + } + break; + } + case 'object': { + while (startIndex < str.length && chars.includes(str[startIndex])) { + startIndex++; + } + } + } + return str.substring(startIndex); +} + +exports.trimStart = trimStart; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.mjs new file mode 100644 index 0000000000000000000000000000000000000000..1d03d39397a3df7e74559c5f2d4d06bf6216c9db --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/trimStart.mjs @@ -0,0 +1,22 @@ +function trimStart(str, chars) { + if (chars === undefined) { + return str.trimStart(); + } + let startIndex = 0; + switch (typeof chars) { + case 'string': { + while (startIndex < str.length && str[startIndex] === chars) { + startIndex++; + } + break; + } + case 'object': { + while (startIndex < str.length && chars.includes(str[startIndex])) { + startIndex++; + } + } + } + return str.substring(startIndex); +} + +export { trimStart }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/unescape.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/unescape.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f92ee59bf46c130cfc06fa0f56c56c2f6f62a9e1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/string/unescape.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/unescape.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f92ee59bf46c130cfc06fa0f56c56c2f6f62a9e1 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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/string/unescape.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/unescape.js new file mode 100644 index 0000000000000000000000000000000000000000..6bdb8ec48ad24ca97041f4c8934a2b2471d12f8e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/unescape.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const htmlUnescapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + ''': "'", +}; +function unescape(str) { + return str.replace(/&(?:amp|lt|gt|quot|#(0+)?39);/g, match => htmlUnescapes[match] || "'"); +} + +exports.unescape = unescape; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/unescape.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/unescape.mjs new file mode 100644 index 0000000000000000000000000000000000000000..11a6939ba086d4e08f71b5cc1cbcda9af03ff55f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/unescape.mjs @@ -0,0 +1,12 @@ +const htmlUnescapes = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + ''': "'", +}; +function unescape(str) { + return str.replace(/&(?:amp|lt|gt|quot|#(0+)?39);/g, match => htmlUnescapes[match] || "'"); +} + +export { unescape }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperCase.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperCase.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..817cd8f1086c6d4ce63ec05898897088cdc137f0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/upperCase.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperCase.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..817cd8f1086c6d4ce63ec05898897088cdc137f0 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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} 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/string/upperCase.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperCase.js new file mode 100644 index 0000000000000000000000000000000000000000..9840483874feab71fa20701910fb8bdb85923eec --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperCase.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const words = require('./words.js'); + +function upperCase(str) { + const words$1 = words.words(str); + let result = ''; + for (let i = 0; i < words$1.length; i++) { + result += words$1[i].toUpperCase(); + if (i < words$1.length - 1) { + result += ' '; + } + } + return result; +} + +exports.upperCase = upperCase; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperCase.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperCase.mjs new file mode 100644 index 0000000000000000000000000000000000000000..8141c3a6aaa4f3540895f190bb9a93bcb62a6a67 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperCase.mjs @@ -0,0 +1,15 @@ +import { words } from './words.mjs'; + +function upperCase(str) { + const words$1 = words(str); + let result = ''; + for (let i = 0; i < words$1.length; i++) { + result += words$1[i].toUpperCase(); + if (i < words$1.length - 1) { + result += ' '; + } + } + return result; +} + +export { upperCase }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..2e318cc16e60b60a1bd450667841c98f35f08d88 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: string): string; + +export { upperFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2e318cc16e60b60a1bd450667841c98f35f08d88 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/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: string): string; + +export { upperFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.js new file mode 100644 index 0000000000000000000000000000000000000000..194654064968505e759a352592f11ac6858e9aa7 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.js @@ -0,0 +1,9 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function upperFirst(str) { + return str.substring(0, 1).toUpperCase() + str.substring(1); +} + +exports.upperFirst = upperFirst; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3e58d4a37362eaa6b64ee61cd5c0c512fd46d630 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/upperFirst.mjs @@ -0,0 +1,5 @@ +function upperFirst(str) { + return str.substring(0, 1).toUpperCase() + str.substring(1); +} + +export { upperFirst }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..702cb5d963f0bc2983f9110721f646b45200b442 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.d.mts @@ -0,0 +1,20 @@ +/** + * Splits `string` into an array of its words, treating spaces and punctuation marks as separators. + * + * @param {string} str The string to inspect. + * @param {RegExp | string} [pattern] The pattern to match words. + * @returns {string[]} Returns the words of `string`. + * + * @example + * words('fred, barney, & pebbles'); + * // => ['fred', 'barney', 'pebbles'] + * + * words('camelCaseHTTPRequest🚀'); + * // => ['camel', 'Case', 'HTTP', 'Request', '🚀'] + * + * words('Lunedì 18 Set') + * // => ['Lunedì', '18', 'Set'] + */ +declare function words(str: string): string[]; + +export { words }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..702cb5d963f0bc2983f9110721f646b45200b442 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.d.ts @@ -0,0 +1,20 @@ +/** + * Splits `string` into an array of its words, treating spaces and punctuation marks as separators. + * + * @param {string} str The string to inspect. + * @param {RegExp | string} [pattern] The pattern to match words. + * @returns {string[]} Returns the words of `string`. + * + * @example + * words('fred, barney, & pebbles'); + * // => ['fred', 'barney', 'pebbles'] + * + * words('camelCaseHTTPRequest🚀'); + * // => ['camel', 'Case', 'HTTP', 'Request', '🚀'] + * + * words('Lunedì 18 Set') + * // => ['Lunedì', '18', 'Set'] + */ +declare function words(str: string): string[]; + +export { words }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.js new file mode 100644 index 0000000000000000000000000000000000000000..71520e79cd820be8beb527403e2f618f5972eba4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.js @@ -0,0 +1,11 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const CASE_SPLIT_PATTERN = /\p{Lu}?\p{Ll}+|[0-9]+|\p{Lu}+(?!\p{Ll})|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu; +function words(str) { + return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []); +} + +exports.CASE_SPLIT_PATTERN = CASE_SPLIT_PATTERN; +exports.words = words; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6c837d79726131d91006b04f0361505634ea640e --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/string/words.mjs @@ -0,0 +1,6 @@ +const CASE_SPLIT_PATTERN = /\p{Lu}?\p{Ll}+|[0-9]+|\p{Lu}+(?!\p{Ll})|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu; +function words(str) { + return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []); +} + +export { CASE_SPLIT_PATTERN, words }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..6e3505c7883c3005c0e063ccf2334c65e804055a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.d.mts @@ -0,0 +1,42 @@ +/** + * Attempt to execute a function and return the result or error. + * Returns a tuple where: + * - On success: [null, Result] - First element is null, second is the result + * - On error: [Error, null] - First element is the caught error, second is null + * + * @template {unknown} T - The type of the result of the function. + * @template {unknown} E - The type of the error that can be thrown by the function. + * @param {() => T} func - The function to execute. + * @returns {[null, T] | [E, null]} A tuple containing either [null, result] or [error, null]. + * + * @example + * // Successful execution + * const [error, result] = attempt(() => 42); + * // [null, 42] + * + * // Failed execution + * const [error, result] = attempt(() => { + * throw new Error('Something went wrong'); + * }); + * // [Error, null] + * + * // With type parameter + * const [error, names] = attempt(() => ['Alice', 'Bob']); + * // [null, ['Alice', 'Bob']] + * + * @note + * Important: This function is not suitable for async functions (functions that return a `Promise`). + * When passing an async function, it will return `[null, Promise]`, but won't catch any + * errors if the Promise is rejected later. + * + * For handling async functions, use the `attemptAsync` function instead: + * ``` + * const [error, data] = await attemptAsync(async () => { + * const response = await fetch('https://api.example.com/data'); + * return response.json(); + * }); + * ``` + */ +declare function attempt(func: () => T): [null, T] | [E, null]; + +export { attempt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6e3505c7883c3005c0e063ccf2334c65e804055a --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.d.ts @@ -0,0 +1,42 @@ +/** + * Attempt to execute a function and return the result or error. + * Returns a tuple where: + * - On success: [null, Result] - First element is null, second is the result + * - On error: [Error, null] - First element is the caught error, second is null + * + * @template {unknown} T - The type of the result of the function. + * @template {unknown} E - The type of the error that can be thrown by the function. + * @param {() => T} func - The function to execute. + * @returns {[null, T] | [E, null]} A tuple containing either [null, result] or [error, null]. + * + * @example + * // Successful execution + * const [error, result] = attempt(() => 42); + * // [null, 42] + * + * // Failed execution + * const [error, result] = attempt(() => { + * throw new Error('Something went wrong'); + * }); + * // [Error, null] + * + * // With type parameter + * const [error, names] = attempt(() => ['Alice', 'Bob']); + * // [null, ['Alice', 'Bob']] + * + * @note + * Important: This function is not suitable for async functions (functions that return a `Promise`). + * When passing an async function, it will return `[null, Promise]`, but won't catch any + * errors if the Promise is rejected later. + * + * For handling async functions, use the `attemptAsync` function instead: + * ``` + * const [error, data] = await attemptAsync(async () => { + * const response = await fetch('https://api.example.com/data'); + * return response.json(); + * }); + * ``` + */ +declare function attempt(func: () => T): [null, T] | [E, null]; + +export { attempt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.js new file mode 100644 index 0000000000000000000000000000000000000000..82381f58d268434e6aed85c07ffa851b1c48f617 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function attempt(func) { + try { + return [null, func()]; + } + catch (error) { + return [error, null]; + } +} + +exports.attempt = attempt; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e13ab0c57d3051538c915456aa1042d76ae34b11 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attempt.mjs @@ -0,0 +1,10 @@ +function attempt(func) { + try { + return [null, func()]; + } + catch (error) { + return [error, null]; + } +} + +export { attempt }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..a97d75a906752a3149a0c5100d7e070616e6796f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.d.mts @@ -0,0 +1,35 @@ +/** + * Attempt to execute an async function and return the result or error. + * Returns a Promise that resolves to a tuple where: + * - On success: [null, Result] - First element is null, second is the result + * - On error: [Error, null] - First element is the caught error, second is null + * + * @template {unknown} T - The type of the result of the async function. + * @template {unknown} E - The type of the error that can be thrown by the async function. + * @param {() => Promise} func - The async function to execute. + * @returns {Promise<[null, T] | [E, null]>} A Promise that resolves to a tuple containing either [null, result] or [error, null]. + * + * @example + * // Successful execution + * const [error, data] = await attemptAsync(async () => { + * const response = await fetch('https://api.example.com/data'); + * return response.json(); + * }); + * // If successful: [null, { ... data ... }] + * + * // Failed execution + * const [error, data] = await attemptAsync(async () => { + * throw new Error('Network error'); + * }); + * // [Error, null] + * + * // With type parameter + * const [error, users] = await attemptAsync(async () => { + * const response = await fetch('https://api.example.com/users'); + * return response.json(); + * }); + * // users is typed as User[] + */ +declare function attemptAsync(func: () => Promise): Promise<[null, T] | [E, null]>; + +export { attemptAsync }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a97d75a906752a3149a0c5100d7e070616e6796f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.d.ts @@ -0,0 +1,35 @@ +/** + * Attempt to execute an async function and return the result or error. + * Returns a Promise that resolves to a tuple where: + * - On success: [null, Result] - First element is null, second is the result + * - On error: [Error, null] - First element is the caught error, second is null + * + * @template {unknown} T - The type of the result of the async function. + * @template {unknown} E - The type of the error that can be thrown by the async function. + * @param {() => Promise} func - The async function to execute. + * @returns {Promise<[null, T] | [E, null]>} A Promise that resolves to a tuple containing either [null, result] or [error, null]. + * + * @example + * // Successful execution + * const [error, data] = await attemptAsync(async () => { + * const response = await fetch('https://api.example.com/data'); + * return response.json(); + * }); + * // If successful: [null, { ... data ... }] + * + * // Failed execution + * const [error, data] = await attemptAsync(async () => { + * throw new Error('Network error'); + * }); + * // [Error, null] + * + * // With type parameter + * const [error, users] = await attemptAsync(async () => { + * const response = await fetch('https://api.example.com/users'); + * return response.json(); + * }); + * // users is typed as User[] + */ +declare function attemptAsync(func: () => Promise): Promise<[null, T] | [E, null]>; + +export { attemptAsync }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.js new file mode 100644 index 0000000000000000000000000000000000000000..54b986d1244814a7fa8e9641db9a8f2d8a0657aa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +async function attemptAsync(func) { + try { + const result = await func(); + return [null, result]; + } + catch (error) { + return [error, null]; + } +} + +exports.attemptAsync = attemptAsync; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.mjs new file mode 100644 index 0000000000000000000000000000000000000000..32fa5fc40f47cfd760ffdd22e3a7f4e5344065fc --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/attemptAsync.mjs @@ -0,0 +1,11 @@ +async function attemptAsync(func) { + try { + const result = await func(); + return [null, result]; + } + catch (error) { + return [error, null]; + } +} + +export { attemptAsync }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..e58e2697cb00aac49d95d74dcd301f7c73880eb4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.d.mts @@ -0,0 +1,3 @@ +export { attempt } from './attempt.mjs'; +export { attemptAsync } from './attemptAsync.mjs'; +export { invariant as assert, invariant } from './invariant.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9a1d17a8eb132868d40226bc6ebbb304e1add1d9 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.d.ts @@ -0,0 +1,3 @@ +export { attempt } from './attempt.js'; +export { attemptAsync } from './attemptAsync.js'; +export { invariant as assert, invariant } from './invariant.js'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.js new file mode 100644 index 0000000000000000000000000000000000000000..7136b33da74413d005730836e85ed99a36a4fc3f --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.js @@ -0,0 +1,14 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +const attempt = require('./attempt.js'); +const attemptAsync = require('./attemptAsync.js'); +const invariant = require('./invariant.js'); + + + +exports.attempt = attempt.attempt; +exports.attemptAsync = attemptAsync.attemptAsync; +exports.assert = invariant.invariant; +exports.invariant = invariant.invariant; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..e58e2697cb00aac49d95d74dcd301f7c73880eb4 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/index.mjs @@ -0,0 +1,3 @@ +export { attempt } from './attempt.mjs'; +export { attemptAsync } from './attemptAsync.mjs'; +export { invariant as assert, invariant } from './invariant.mjs'; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.d.mts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..0554a87bdacb4c37e1b0441dc444e00d24ef8ee8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.d.mts @@ -0,0 +1,40 @@ +/** + * Asserts that a given condition is true. If the condition is false, an error is thrown with the provided message. + * + * @param {unknown} condition - The condition to evaluate. + * @param {string} message - The error message to throw if the condition is false. + * @returns {void} Returns void if the condition is true. + * @throws {Error} Throws an error if the condition is false. + * + * @example + * // This call will succeed without any errors + * invariant(true, 'This should not throw'); + * + * // This call will fail and throw an error with the message 'This should throw' + * invariant(false, 'This should throw'); + */ +declare function invariant(condition: unknown, message: string): asserts condition; +/** + * Asserts that a given condition is true. If the condition is false, an error is thrown with the provided error. + * + * @param {unknown} condition - The condition to evaluate. + * @param {Error} error - The error to throw if the condition is false. + * @returns {void} Returns void if the condition is true. + * @throws {Error} Throws an error if the condition is false. + * + * @example + * // This call will succeed without any errors + * invariant(true, new Error('This should not throw')); + * + * class CustomError extends Error { + * constructor(message: string) { + * super(message); + * } + * } + * + * // This call will fail and throw an error with the message 'This should throw' + * invariant(false, new CustomError('This should throw')); + */ +declare function invariant(condition: unknown, error: Error): asserts condition; + +export { invariant }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.d.ts b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..0554a87bdacb4c37e1b0441dc444e00d24ef8ee8 --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.d.ts @@ -0,0 +1,40 @@ +/** + * Asserts that a given condition is true. If the condition is false, an error is thrown with the provided message. + * + * @param {unknown} condition - The condition to evaluate. + * @param {string} message - The error message to throw if the condition is false. + * @returns {void} Returns void if the condition is true. + * @throws {Error} Throws an error if the condition is false. + * + * @example + * // This call will succeed without any errors + * invariant(true, 'This should not throw'); + * + * // This call will fail and throw an error with the message 'This should throw' + * invariant(false, 'This should throw'); + */ +declare function invariant(condition: unknown, message: string): asserts condition; +/** + * Asserts that a given condition is true. If the condition is false, an error is thrown with the provided error. + * + * @param {unknown} condition - The condition to evaluate. + * @param {Error} error - The error to throw if the condition is false. + * @returns {void} Returns void if the condition is true. + * @throws {Error} Throws an error if the condition is false. + * + * @example + * // This call will succeed without any errors + * invariant(true, new Error('This should not throw')); + * + * class CustomError extends Error { + * constructor(message: string) { + * super(message); + * } + * } + * + * // This call will fail and throw an error with the message 'This should throw' + * invariant(false, new CustomError('This should throw')); + */ +declare function invariant(condition: unknown, error: Error): asserts condition; + +export { invariant }; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.js b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.js new file mode 100644 index 0000000000000000000000000000000000000000..edfece6f70d8e3fd8d4d4e1fda4b42a1c713ddfa --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.js @@ -0,0 +1,15 @@ +'use strict'; + +Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + +function invariant(condition, message) { + if (condition) { + return; + } + if (typeof message === 'string') { + throw new Error(message); + } + throw message; +} + +exports.invariant = invariant; diff --git a/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.mjs b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b4a5c61bd839bd5614b4d867fafc616a598162ee --- /dev/null +++ b/novas/novacore-zephyr/groq-code-cli/node_modules/es-toolkit/dist/util/invariant.mjs @@ -0,0 +1,11 @@ +function invariant(condition, message) { + if (condition) { + return; + } + if (typeof message === 'string') { + throw new Error(message); + } + throw message; +} + +export { invariant };