moderndash 0.0.9 → 0.0.11

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/array/chunk.ts","../src/array/differenceWith.ts","../src/lang/isEqual.ts","../src/array/difference.ts","../src/helpers/typeofChecks.ts","../src/helpers/shortHands.ts","../src/lang/isEqualWith.ts","../src/array/differenceBy.ts","../src/array/dropRightWhile.ts","../src/array/dropWhile.ts","../src/array/intersectionWith.ts","../src/array/intersection.ts","../src/array/intersectionBy.ts","../src/array/sample.ts","../src/array/sampleSize.ts","../src/array/shuffle.ts","../src/array/takeRightWhile.ts","../src/array/takeWhile.ts","../src/array/uniqWith.ts","../src/array/uniq.ts","../src/array/uniqBy.ts","../src/array/unzipWith.ts","../src/array/unzip.ts","../src/array/zipWith.ts","../src/array/zip.ts","../src/helpers/collections.ts","../src/collection/countBy.ts","../src/collection/groupBy.ts","../src/collection/sortBy.ts","../src/function/after.ts","../src/function/before.ts","../src/function/debounce.ts","../src/function/memoize.ts","../src/function/once.ts","../src/function/throttle.ts","../src/function/times.ts","../src/lang/isEmpty.ts","../src/lang/isPlainObject.ts","../src/object/pick.ts","../src/string/deburr.ts","../src/helpers/stringModifiers.ts","../src/string/camelCase.ts","../src/string/capitalize.ts","../src/string/escape.ts","../src/string/escapeRegExp.ts","../src/string/kebabCase.ts","../src/string/pascalCase.ts","../src/string/snakeCase.ts","../src/string/startCase.ts","../src/string/stripSpecialChars.ts","../src/string/unescape.ts"],"sourcesContent":["export * from './array';\nexport * from './collection';\nexport * from './function';\nexport * from './lang';\nexport * from './object';\nexport * from './string';\nexport * from './types';\n","/**\n * Creates an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.\n *\n * @category Array\n * @returns Returns the new array of chunks.\n * @param chunkSize - The array to process.\n * @param array - The length of each chunk\n * @example\n * chunk(2, ['a', 'b', 'c', 'd'])\n * // => [['a', 'b'], ['c', 'd']]\n *\n * chunk(3, ['a', 'b', 'c', 'd'])\n * // => [['a', 'b', 'c'], ['d']]\n */\n\nexport function chunk<TInput>(chunkSize: number, array: TInput[]): TInput[][] {\n    const sizeInteger = Math.trunc(chunkSize);\n    if (array.length === 0 || sizeInteger < 1) {\n        return [];\n    }\n\n    const chunkedArray = [];\n    let i = 0;\n\n    while (i < array.length) {\n        chunkedArray.push(array.slice(i, i + sizeInteger));\n        i += sizeInteger;\n    }\n\n    return chunkedArray;\n}\n","import type { MinimumTwoArrays } from '../types';\n\n/**\n * This method is like `difference` except that it accepts `comparator`\n * which is invoked to compare elements of `array` to `values`. The order and\n * references of result values are determined by the first array. The comparator\n * is invoked with two arguments: (arrVal, othVal).\n *\n * **Note:** Unlike `pullAllWith`, this method returns a new array.\n *\n * @category Array\n * @param comparator - The comparator invoked per element.\n * @param arrays - First array to inspect. Others are excluded.\n * @returns Returns the new array of filtered values.\n * @example\n * differenceWith(isEqual, [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], [{ 'x': 1, 'y': 2 }])\n * // => [{ 'x': 2, 'y': 1 }]\n */\n\nexport function differenceWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[] {\n    const difference: T[] = [];\n    const [firstArray, ...restArrays] = arrays;\n\n    firstArray.forEach(element => {\n        if (!restArrays.some(array => array.some(item => comparator(item, element)))) {\n            difference.push(element);\n        }\n    });\n\n    return difference;\n}\n","import type { RecordKey } from '../types';\n\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @category Lang\n * @param value1 - The value to compare.\n * @param value2 - The other value to compare.\n * @returns Returns `true` if the values are equivalent, else `false`.\n * @example\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\n\nexport function isEqual(value1: unknown, value2: unknown): boolean {\n    if (value1 === value2) return true;\n\n    if (Array.isArray(value1) && Array.isArray(value2)) {\n        return isSameArray(value1, value2);\n    }\n\n    if (value1 instanceof RegExp && value2 instanceof RegExp) {\n        return value1.toString() === value2.toString();\n    }\n\n    if (isObject(value1) && isObject(value2)) {\n        return isSameObject(value1, value2);\n    }\n\n    return false;\n}\n\ntype KeyValueObject = Record<RecordKey, unknown>;\nfunction isObject(value: unknown): value is KeyValueObject {\n    return typeof value === 'object'\n        && value !== null\n        && !Array.isArray(value)\n        && Object.prototype.toString.call(value) === '[object Object]';\n}\n\nfunction isSameObject(value1: KeyValueObject, value2: KeyValueObject) {\n    // check if the objects have the same keys\n    const keys1 = Object.keys(value1);\n    const keys2 = Object.keys(value2);\n    if (!isEqual(keys1, keys2)) return false;\n\n    // check if the values of each key in the objects are equal\n    for (const key of keys1) {\n        if (!isEqual(value1[key], value2[key])) return false;\n    }\n\n    // the objects are deeply equal\n    return true;\n}\n\nfunction isSameArray(value1: unknown[], value2: unknown[]) {\n    // check if the arrays have the same length\n    if (value1.length !== value2.length) return false;\n\n    // check if the values of each element in the arrays are equal\n    for (const [i, element] of value1.entries()) {\n        if (!isEqual(element, value2[i])) return false;\n    }\n\n    return true;\n}\n","import type { MinimumTwoArrays } from '../types';\n\nimport { differenceWith } from '@array/differenceWith';\nimport { isEqual } from '@lang/isEqual';\n\n/**\n * Creates an array of `array` values not included in the other given arrays. The order and references of result values are determined by the first array.\n *\n * **Note:** Unlike `pullAll`, this method returns a new array.\n *\n * @category Array\n * @param arrays - First array is inspected, others are excluded.\n * @returns Returns the new array of filtered values.\n * @example\n * difference([2, 1], [2, 3])\n * // => [1]\n */\n\nexport function difference<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[] {\n    return differenceWith(isEqual, ...arrays);\n}\n","export function isObjectKey(key: unknown): key is keyof object {\n    return typeof key === 'string' || typeof key === 'number' || typeof key === 'symbol';\n}\n","import type { IterateeFunction, PropertyShorthand } from '../types';\n\nimport { isObjectKey } from '@helpers/typeofChecks';\n\nexport function getPropertyShorthand<T, K extends keyof T>(key: K): (object: T) => T[K] {\n    return object => object[key];\n}\n\nexport function getIterateFunction<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>) {\n    if (typeof iteratee === 'function') {\n        return iteratee;\n    } else if (isObjectKey(iteratee)) {\n        return getPropertyShorthand(iteratee);\n    } else {\n        throw new TypeError('Expected iteratee to be a function or a property name');\n    }\n}\n","import { isEqual } from '@lang/isEqual';\n\n/**\n * This method is like `_.isEqual` except that it accepts `customizer` which\n * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n * are handled by the method instead. The `customizer` is invoked with up to\n * six arguments: (objValue, othValue [, index|key, object, other, stack]).\n *\n * @category Lang\n * @param value1 - The value to compare.\n * @param value2 - The other value to compare.\n * @param customizer - The function to customize comparisons.\n * @returns Returns `true` if the values are equivalent, else `false`.\n * @example\n * function isGreeting(value) {\n *   return /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue, othValue) {\n *   if (isGreeting(objValue) && isGreeting(othValue)) {\n *     return true;\n *   }\n * }\n *\n * var array = ['hello', 'goodbye'];\n * var other = ['hi', 'goodbye'];\n *\n * isEqualWith(array, other, customizer);\n * // => true\n*/\n\nexport function isEqualWith<T>(a: T, b: T, customizer: (value: T) => unknown): boolean {\n    return isEqual(customizer(a), customizer(b));\n}\n","import type { IterateeFunction, MinimumTwoArrays, PropertyShorthand } from '../types';\n\nimport { differenceWith } from '@array/differenceWith';\nimport { getIterateFunction } from '@helpers/shortHands';\nimport { isEqualWith } from '@lang/isEqualWith';\n\n/**\n * This method is like `difference` except that it accepts `iteratee` which\n * is invoked for each element of `array` and `values` to generate the criterion\n * by which they're compared. The order and references of result values are\n * determined by the first array.\n *\n * **Note:** Unlike `pullAllBy`, this method returns a new array.\n *\n * @category Array\n * @param iteratee - The iteratee invoked per element. Or property shorthand.\n * @param arrays - First array to inspect. Others are excluded.\n\n * @returns Returns the new array of filtered values.\n * @example\n * differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4])\n * // => [1.2]\n * differenceBy('x', [{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }])\n * // => [{ 'x': 2 }]\n */\n\nexport function differenceBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[] {\n    const iterateeFunction = getIterateFunction(iteratee);\n    return differenceWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);\n}\n","/**\n * Creates a slice of `array` excluding elements dropped from the end.\n * Elements are dropped until `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index, array).\n *\n * @category Array\n * @param predicate - The function invoked per iteration.\n * @param array - The array to query.\n * @returns Returns the slice of `array`.\n * @example\n * const users = [\n *   { 'user': 'barney',  'active': false },\n *   { 'user': 'fred',    'active': true },\n *   { 'user': 'pebbles', 'active': true }\n * ]\n *\n * dropRightWhile(({ active }) => active, users)\n * // => objects for ['barney']\n */\n\n\nexport function dropRightWhile<T>(predicate: (value: T) => boolean, array: T[]) {\n    let i = array.length;\n    while (i > 0 && predicate(array[i - 1])) {\n        i--;\n    }\n    return array.slice(0, i);\n}\n","/**\n * Creates a slice of `array` excluding elements dropped from the beginning.\n * Elements are dropped until `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index, array).\n *\n * @category Array\n * @param predicate - The function invoked per iteration.\n * @param array - The array to query.\n * @returns Returns the slice of `array`.\n * @example\n * const users = [\n *   { 'user': 'barney',  'active': true },\n *   { 'user': 'fred',    'active': true },\n *   { 'user': 'pebbles', 'active': false }\n * ]\n *\n * dropWhile(({ active }) => active, users)\n * // => objects for ['pebbles']\n */\n\nexport function dropWhile<T>(predicate: (value: T) => boolean, array: T[]): T[] {\n    const index = array.findIndex(x => !predicate(x));\n    return array.slice(index === -1 ? array.length : index);\n}\n","import type { MinimumTwoArrays } from '../types';\n\n/**\n * This method is like `intersection` except that it accepts `comparator`\n * which is invoked to compare elements of `arrays`. The order and references\n * of result values are determined by the first array. The comparator is\n * invoked with two arguments: (arrVal, othVal).\n *\n * @category Array\n * @param comparator - The comparator invoked per element.\n * @param arrays - The arrays to inspect.\n * @returns Returns the new array of intersecting values.\n * @example\n * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]\n *\n * intersectionWith(isEqual, objects, others)\n * // => [{ 'x': 1, 'y': 2 }]\n */\n\nexport function intersectionWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[] {\n    const intersection: T[] = [];\n\n    const [firstArray, ...restArrays] = arrays;\n\n    firstArray.forEach(element => {\n        if (restArrays.every(array => array.some(item => comparator(item, element)))) {\n            intersection.push(element);\n        }\n    });\n\n    return intersection;\n}\n","import type { MinimumTwoArrays } from '../types';\n\nimport { intersectionWith } from '@array/intersectionWith';\nimport { isEqual } from '@lang/isEqual';\n\n/**\n * Creates an array of unique values that are included in all given arrays.\n * The order and references of result values are determined by the first array.\n *\n * @category Array\n * @param arrays - The arrays to inspect.\n * @returns Returns the new array of intersecting values.\n * @example\n * intersection([2, 1], [2, 3])\n * // => [2]\n */\n\nexport function intersection<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[] {\n    return intersectionWith(isEqual, ...arrays);\n}\n","import type { IterateeFunction, MinimumTwoArrays, PropertyShorthand } from '../types';\n\nimport { intersectionWith } from '@array/intersectionWith';\nimport { getIterateFunction } from '@helpers/shortHands';\nimport { isEqualWith } from '@lang/isEqualWith';\n\n/**\n * This method is like `intersection` except that it accepts `iteratee`\n * which is invoked for each element of each `arrays` to generate the criterion\n * by which they're compared. The order and references of result values are\n * determined by the first array. The iteratee is invoked with one argument:\n * (value).\n *\n * @category Array\n * @param iteratee - The iteratee invoked per element. Or property shorthand.\n * @param arrays - The arrays to inspect.\n * @returns Returns the new array of intersecting values.\n * @example\n * intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4])\n * // => [2.1]\n */\n\nexport function intersectionBy<TInput>(iteratee: IterateeFunction<TInput> | PropertyShorthand<TInput>, ...arrays: MinimumTwoArrays<TInput>): TInput[] {\n    const iterateeFunction = getIterateFunction(iteratee);\n    return intersectionWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);\n}\n","/**\n * Gets a random element from `array`.\n *\n * @category Array\n * @param array - The array to sample.\n * @returns Returns the random element.\n * @example\n * sample([1, 2, 3, 4])\n * // => 2\n */\n\nexport function sample<T>(array: T[]): T | undefined {\n    if (array.length === 0) {\n        return undefined;\n    }\n    const randomIndex = Math.floor(Math.random() * array.length);\n    return array[randomIndex];\n}\n","import { sample } from '@array/sample';\n\n/**\n * Gets `n` random elements at unique keys from `array` up to the\n * size of `array`.\n *\n * @category Array\n * @param size The number of elements to sample.\n * @param array The array to sample.\n * @returns Returns the random elements.\n * @example\n * sampleSize([1, 2, 3], 2)\n * // => [3, 1]\n *\n * sampleSize([1, 2, 3], 4)\n * // => [2, 3, 1]\n */\n\nexport function sampleSize<TInput>(size: number, array: TInput[]): TInput[] {\n    const sampleArray: TInput[] = [];\n\n    if (array.length === 0 || size <= 0) {\n        return sampleArray;\n    }\n\n    for (let i = 0; i < size; i++) {\n        sampleArray.push(sample(array) as TInput);\n    }\n\n    return sampleArray;\n}\n","/**\n * Creates an array of shuffled values, using a version of the\n * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n *\n * @since 0.1.0\n * @category Array\n * @param array - The array or object to shuffle.\n * @returns {Array} Returns the new shuffled array.\n * @example\n * shuffle([1, 2, 3, 4])\n * // => [4, 1, 3, 2]\n */\n\nexport function shuffle<TInput>(array: TInput[]): TInput[] {\n    const shuffledArray = [...array];\n    let currentIndex = shuffledArray.length;\n    let temporaryValue: TInput;\n    let randomIndex: number;\n\n    // While there remain elements to shuffle...\n    while (0 !== currentIndex) {\n        // Pick a remaining element...\n        randomIndex = Math.floor(Math.random() * currentIndex);\n        currentIndex -= 1;\n\n        // And swap it with the current element.\n        temporaryValue = shuffledArray[currentIndex];\n        shuffledArray[currentIndex] = shuffledArray[randomIndex];\n        shuffledArray[randomIndex] = temporaryValue;\n    }\n\n    return shuffledArray;\n}\n","/**\n * Creates a slice of `array` with elements taken from the end. Elements are\n * taken until `predicate` returns falsey. The predicate is invoked with\n * three arguments: (value, index, array).\n *\n * @category Array\n * @param predicate - The function invoked per iteration.\n * @param array - The array to query.\n * @returns Returns the slice of `array`.\n * @example\n * const users = [\n *   { 'user': 'barney',  'active': false },\n *   { 'user': 'fred',    'active': true },\n *   { 'user': 'pebbles', 'active': true }\n * ]\n *\n * takeRightWhile(({ active }) => active, users)\n * // => objects for ['fred', 'pebbles']\n */\n\nexport function takeRightWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[] {\n    const result: T[] = [];\n\n    for (let i = array.length - 1; i >= 0; i--) {\n        if (predicate(array[i])) {\n            result.unshift(array[i]);\n        } else {\n            break;\n        }\n    }\n\n    return result;\n}\n","/**\n * Creates a slice of `array` with elements taken from the beginning. Elements\n * are taken until `predicate` returns falsey. The predicate is invoked with\n * three arguments: (value, index, array).\n *\n * @category Array\n * @param predicate The function invoked per iteration.\n * @param array The array to query.\n * @returns Returns the slice of `array`.\n * @example\n * const users = [\n *   { 'user': 'barney',  'active': true },\n *   { 'user': 'fred',    'active': true },\n *   { 'user': 'pebbles', 'active': false }\n * ]\n *\n * takeWhile(({ active }) => active, users)\n * // => objects for ['barney', 'fred']\n */\n\nexport function takeWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[] {\n    const result: T[] = [];\n\n    for (const element of array) {\n        if (predicate(element)) {\n            result.push(element);\n        } else {\n            break;\n        }\n    }\n\n    return result;\n}\n","/**\n * This method is like `uniq` except that it accepts `comparator` which is invoked to compare elements of `array`.\n * The order of result values is determined by the order they occur in the array.\n *\n * @category Array\n * @param array - The array to inspect.\n * @param comparator - The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]\n *\n * uniqWith(isEqual, objects)\n * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n */\n\nexport function uniqWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, array: TInput[]): TInput[] {\n    return array.filter((value, index, self) => {\n        return self.findIndex(otherValue => comparator(value, otherValue)) === index;\n    });\n}\n","import { uniqWith } from '@array/uniqWith';\nimport { isEqual } from '@lang/isEqual';\n\n/**\n * Creates a duplicate-free version of an array, in which only the first occurrence of each element is kept.\n * The order of result values is determined by the order they occur in the array.\n *\n * @category Array\n * @param array - The array to inspect.\n * @returns Returns the new duplicate free array.\n * @example\n * uniq([2, 1, 2])\n * // => [2, 1]\n */\n\nexport function uniq<TInput>(array: TInput[]): TInput[] {\n    return uniqWith(isEqual, array);\n}\n","import type { IterateeFunction, PropertyShorthand } from '../types';\n\nimport { uniqWith } from '@array/uniqWith';\nimport { getIterateFunction } from '@helpers/shortHands';\n\n/**\n * This method is like `uniq` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * uniqueness is computed. The order of result values is determined by the\n * order they occur in the array.\n *\n * @category Array\n * @param array - The array to inspect.\n * @param iteratee - The iteratee invoked per element. Or property shorthand.\n * @returns Returns the new duplicate free array.\n * @example\n * uniqBy(Math.floor, [2.1, 1.2, 2.3])\n * // => [2.1, 1.2]\n */\n\nexport function uniqBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, array: T[]): T[] {\n    const iterateeFunction = getIterateFunction(iteratee);\n\n    return uniqWith((a, b) => iterateeFunction(a) === iterateeFunction(b), array);\n}\n","/**\n * This method is like `unzip` except that it accepts `iteratee` to specify\n * how regrouped values should be combined. The iteratee is invoked with the\n * elements of each group: (...group).\n *\n * @category Array\n * @param iteratee - The function to combine regrouped values.\n * @param array - The array of grouped elements to process.\n * @returns Returns the new array of regrouped elements.\n * @example\n * const zipped = zip([1, 2], [10, 20], [100, 200])\n * // => [[1, 10, 100], [2, 20, 200]]\n *\n * unzipWith(add, zipped)\n * // => [3, 30, 300]\n */\n\nexport function unzipWith<TInput extends unknown[], TOutput>(iteratee: (...t: TInput) => TOutput, array: TInput[]): TOutput[] {\n    const result: TOutput[] = [];\n\n    for (const elements of array) {\n        result.push(iteratee(...elements));\n    }\n\n    return result;\n}\n","import { unzipWith } from '@array/unzipWith';\n\n/**\n * This method is like `zip` except that it accepts an array of grouped\n * elements and creates an array regrouping the elements to their pre-zip configuration.\n *\n * @category Array\n * @param array - The array of grouped elements to process.\n * @returns Returns the new array of regrouped elements.\n * @example\n * const zipped = zip(['a', 'b'], [1, 2], [true, false])\n * // => [['a', 1, true], ['b', 2, false]]\n *\n * unzip(zipped)\n * // => [['a', 'b'], [1, 2], [true, false]]\n */\n\nexport function unzip<TInput extends unknown[]>(array: TInput[]): TInput[] {\n    return unzipWith((...t) => t, array);\n}\n","// Types from https://gist.github.com/briancavalier/c4af1538ae9b2e4ab97caf14306625ab\ntype UnZip<A extends readonly unknown[]> = {\n    [K in keyof A]: readonly A[K][]\n};\n\n/**\n * This method is like `zip` except that it accepts `iteratee` to specify\n * how grouped values should be combined. The iteratee is invoked with the\n * elements of each group: (...group).\n *\n * @category Array\n * @param combineFunc - The function to combine grouped values.\n * @param arrays - The arrays to process.\n * @returns Returns the new array of grouped elements.\n * @example\n * zipWith([1, 2], [10, 20], [100, 200], (a, b, c) => a + b + c)\n * // => [111, 222]\n */\n\nexport function zipWith<Args extends unknown[], TOutput>(combineFunc: (...args: Args) => TOutput, ...arrays: UnZip<Args>): TOutput[] {\n    const len = Math.min(...arrays.map(a => a.length));\n    const zipped: TOutput[] = [];\n    for (let i = 0; i < len; i++) {\n        // Typescript needs the Args hint, or it infers any[]\n        zipped[i] = combineFunc(...arrays.map(a => a[i]) as Args);\n    }\n    return zipped;\n}\n","import { zipWith } from '@array/zipWith';\n\n/**\n * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,\n * the second of which contains the second elements of the given arrays, and so on.\n *\n * @category Array\n * @param arrays - The arrays to process.\n * @returns Returns the new array of grouped elements.\n * @example\n * zip(['a', 'b'], [1, 2], [true, false])\n * // => [['a', 1, true], ['b', 2, false]]\n */\n\nexport function zip<TInput>(...arrays: TInput[][]): TInput[][] {\n    return zipWith((...t) => t, ...arrays);\n}\n","import type { ArrayOrRecord } from '../types';\n\nexport function getValuesFromCollection<T>(collection: ArrayOrRecord<T>): T[] {\n    return Array.isArray(collection) ? collection : Object.values(collection);\n}\n","import type { ArrayOrRecord, RecordKey } from '../types';\n\nimport { getValuesFromCollection } from '@helpers/collections';\n\n/**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The corresponding value of\n * each key is the number of times the key was returned by `iteratee`.\n *\n * @category Collection\n * @param iteratee - The iteratee to transform keys.\n * @param collection - The array or record to iterate over.\n * @returns Returns the composed aggregate object.\n * @example\n * const users = [\n *   { 'user': 'barney', 'active': true },\n *   { 'user': 'betty', 'active': true },\n *   { 'user': 'fred', 'active': false }\n * ]\n *\n * countBy(users, value => value.active);\n * // => { 'true': 2, 'false': 1 }\n */\n\nexport function countBy<TInput, TKey extends RecordKey>(collection: ArrayOrRecord<TInput>, iteratee: (value: TInput) => TKey): Record<TKey, number> {\n    const result = {} as Record<TKey, number>;\n    const values = getValuesFromCollection(collection);\n    for (const value of values) {\n        const key = iteratee(value);\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n        if (result[key] === undefined) {\n            result[key] = 1;\n        } else {\n            result[key] += 1;\n        }\n    }\n    return result;\n}\n","import type { RecordKey, ArrayOrRecord } from '../types';\n\nimport { getValuesFromCollection } from '@helpers/collections';\n\n\n/**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The order of grouped values\n * is determined by the order they occur in `collection`. The corresponding\n * value of each key is an array of elements responsible for generating the\n * key.\n *\n * @category Collection\n * @param collection - The array or object to iterate over.\n * @param iteratee - The iteratee to transform keys.\n * @returns Returns the composed aggregate object.\n * @example\n * groupBy([6.1, 4.2, 6.3], Math.floor)\n * // => { '4': [4.2], '6': [6.1, 6.3] }\n */\n\nexport function groupBy<T, U extends RecordKey>(collection: ArrayOrRecord<T>, iteratee: (value: T) => U): Record<U, T[]> {\n    const result = {} as Record<U, T[]>;\n    const values = getValuesFromCollection(collection);\n    for (const value of values) {\n        const key = iteratee(value);\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n        result[key] = result[key] ?? [];\n        result[key].push(value);\n    }\n    return result;\n}\n","import type { NoUnion } from '../types';\n\nexport function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | Date | string, U>, array: T[]): T[] {\n    return array.sort((a, b) => {\n        const aValue = iteratee(a);\n        const bValue = iteratee(b);\n        if (aValue < bValue) {\n            return -1;\n        }\n        if (aValue > bValue) {\n            return 1;\n        }\n        return 0;\n    });\n}\n","import type { GenericFunction } from '../types.js';\n\n/**\n * The opposite of `before`. This method creates a function that invokes `func` once it's called `n` or more times.\n *\n * @category Function\n * @param n The number of calls before `func` is invoked.\n * @param func The function to restrict.\n * @returns Returns the new restricted function.\n * @example\n * const caution = () => console.log(\"Caution!\");\n *\n * const afterFN = after(2, caution);\n *\n * afterFN()\n * afterFN()\n * afterFN()\n * // => `caution` is invoked after called twice\n */\n\nexport function after<TFunc extends GenericFunction<TFunc>>(n: number, func: TFunc) {\n    let count = 1;\n    return (...args: Parameters<TFunc>): ReturnType<TFunc> | undefined => {\n        if (count >= n) {\n            return func(...args);\n        }\n        count += 1;\n    };\n}\n","/**\n * Creates a function that invokes `func`, while it's called less than `n` times. Subsequent\n * calls to the created function return the result of the last `func` invocation.\n *\n * @category Function\n * @param n - The number of calls at which `func` is no longer invoked.\n * @param func - The function to restrict.\n * @returns Returns the new restricted function.\n * @example\n * const caution = () => console.log(\"Caution!\");\n *\n * // Only call caution two times\n * const reducedCaution = before(2, caution)\n *\n * reducedCaution()\n * reducedCaution()\n * reducedCaution()\n * // => `caution` is invoked twice\n */\n\nexport function before<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): TFunc {\n    let count = 0;\n    let result: ReturnType<TFunc>;\n    return ((...args: Parameters<TFunc>): ReturnType<TFunc> => {\n        if (count < n) {\n            count += 1;\n            result = func(...args);\n        }\n        return result;\n    }) as TFunc;\n}\n","import type { GenericFunction } from 'src/types.js';\n\n// TODO this is a port from lodash, it probably can be improved and shortened, also fix TS errors\nexport function debounce<TFunc extends GenericFunction<TFunc>>(\n    fn: TFunc, wait = 0, options: { leading?: boolean, maxWait?: number, trailing?: boolean } = {}\n): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc> {\n    let lastArgs: Parameters<TFunc> | undefined;\n    let lastThis: ThisParameterType<TFunc> | undefined;\n    let result: ReturnType<TFunc>;\n    let timerId: ReturnType<typeof setTimeout> | undefined;\n    let lastCallTime: number | undefined;\n    let lastInvokeTime = 0;\n    const maxing = options.maxWait ?? false;\n    const leading = options.leading ?? false;\n    const trailing = options.trailing ?? true;\n    const maxWait = options.maxWait ?? 0;\n\n    function invokeFunc(time: number) {\n        const args: Parameters<TFunc> | undefined = lastArgs;\n        const thisArg: ThisParameterType<TFunc> | undefined = lastThis;\n\n        lastArgs = lastThis = undefined;\n        lastInvokeTime = time;\n        // @ts-expect-error\n        result = fn.apply(thisArg, args);\n        return result;\n    }\n\n    function leadingEdge(time: number) {\n        // Reset any `maxWait` timer.\n        lastInvokeTime = time;\n        // Start the timer for the trailing edge.\n        timerId = setTimeout(timerExpired, wait);\n        // Invoke the leading edge.\n        return leading ? invokeFunc(time) : result;\n    }\n\n    function remainingWait(time: number) {\n        // @ts-expect-error\n        const timeSinceLastCall = time - lastCallTime;\n        const timeSinceLastInvoke = time - lastInvokeTime;\n        const timeWaiting = wait - timeSinceLastCall;\n\n        return maxing\n            ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)\n            : timeWaiting;\n    }\n\n    function shouldInvoke(time: number) {\n        if (lastCallTime === undefined)\n            return true;\n\n        const timeSinceLastCall = time - lastCallTime;\n        const timeSinceLastInvoke = time - lastInvokeTime;\n\n        // Either this is the first call, activity has stopped and we're at the\n        // trailing edge, the system time has gone backwards and we're treating\n        // it as the trailing edge, or we've hit the `maxWait` limit.\n        return timeSinceLastCall >= wait || timeSinceLastCall < 0 || (maxing && timeSinceLastInvoke >= maxWait);\n    }\n\n    function timerExpired() {\n        const time = Date.now();\n        if (shouldInvoke(time)) {\n            return trailingEdge(time);\n        }\n        // Restart the timer.\n        timerId = setTimeout(timerExpired, remainingWait(time));\n    }\n\n    function trailingEdge(time: number) {\n        timerId = undefined;\n\n        // Only invoke if we have `lastArgs` which means `fn` has been\n        // debounced at least once.\n        if (trailing && lastArgs) {\n            return invokeFunc(time);\n        }\n        lastArgs = lastThis = undefined;\n        return result;\n    }\n\n    function cancel() {\n        if (timerId !== undefined) {\n            clearTimeout(timerId);\n        }\n        lastInvokeTime = 0;\n        lastArgs = lastCallTime = lastThis = timerId = undefined;\n    }\n\n    function flush() {\n        return timerId === undefined ? result : trailingEdge(Date.now());\n    }\n\n    function debounced(this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>): ReturnType<TFunc> {\n        const time = Date.now();\n        const isInvoking = shouldInvoke(time);\n\n        lastArgs = args;\n        // TODO Fix this assignment\n        // eslint-disable-next-line @typescript-eslint/no-this-alias,unicorn/no-this-assignment\n        lastThis = this;\n        lastCallTime = time;\n\n        if (isInvoking) {\n            if (timerId === undefined) {\n                return leadingEdge(lastCallTime);\n            }\n            if (maxing) {\n                // Handle invocations in a tight loop.\n                clearTimeout(timerId);\n                timerId = setTimeout(timerExpired, wait);\n                return invokeFunc(lastCallTime);\n            }\n        }\n        if (timerId === undefined) {\n            timerId = setTimeout(timerExpired, wait);\n        }\n        return result;\n    }\n\n    debounced.cancel = cancel;\n    debounced.flush = flush;\n    return debounced;\n}\n","import type{ GenericFunction } from 'src/types.js';\n\nconst defaultResolver = (...args: unknown[]) => JSON.stringify(args);\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, all arguments\n * provided to the memoized function are used as the map cache key.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @category Function\n * @param func - The function to have its output memoized.\n * @param resolver - The function to resolve the cache key.\n * @typeParam TFunc - The input function type\n * @typeParam Cache - The cache map type\n * @returns  Returns the new memoized function.\n * @example\n * const object = \\{ 'a': 1, 'b': 2 \\}\n *\n * const values = memoize(values)\n * values(object)\n * // => [1, 2]\n *\n * values(object)\n * // => [1, 2]\n *\n * object.a = 2\n * values(object)\n * // => [2, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b'])\n * values(object)\n * // => ['a', 'b']\n *\n * // Replace `memoize.Cache`.\n * memoize.Cache = WeakMap\n */\n\nexport function memoize<TFunc extends GenericFunction<TFunc>, Cache extends Map<string | symbol, ReturnType<TFunc>>>(\n    func: TFunc, resolver: ((...args: Parameters<TFunc>) => string | symbol) = defaultResolver\n): TFunc & { cache: Cache } {\n\n    const cache = new Map() as Cache;\n    const memoizedFunc = (...args: Parameters<TFunc>): ReturnType<TFunc> => {\n        const key = resolver(...args);\n        if (cache.has(key)) {\n            // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style\n            return cache.get(key) as ReturnType<TFunc>;\n        }\n        const result = func(...args);\n        cache.set(key, result);\n        return result;\n    };\n    memoizedFunc.cache = cache;\n    return memoizedFunc as TFunc & { cache: Cache };\n}\n","import type { GenericFunction } from 'src/types.js';\n\nimport { before } from '@function/before';\n\n/**\n * Creates a function that is restricted to invoking `func` once. Repeat calls\n * to the function return the value of the first invocation. The `func` is\n * invoked with the `this` binding and arguments of the created function.\n *\n * @category Function\n * @param func - The function to restrict.\n * @returns Returns the new restricted function.\n * @example\n * const initialize = once(() => console.log('initialize'))\n * initialize()\n * initialize()\n * // => `createApplication` is invoked once\n */\n\nexport function once<TFunc extends GenericFunction<TFunc>>(func: TFunc): TFunc {\n    return before(1, func);\n}\n","import type { GenericFunction } from 'src/types.js';\n\nimport { debounce } from '@function/debounce';\n\nexport function throttle<TFunc extends GenericFunction<TFunc>>(\n    func: TFunc, wait = 0, options: { leading?: boolean, trailing?: boolean } = {}\n): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc> {\n    return debounce(func, wait, {\n        leading: options.leading ?? true,\n        maxWait: wait,\n        trailing: options.trailing ?? true\n    });\n}\n","/**\n * Invokes the iteratee `n` times, returning an array of the results of\n * each invocation. The function is invoked with one argument: (index).\n *\n * @category Function\n * @param n - The number of times to invoke `func`.\n * @param iteratee - The function invoked per iteration.\n * @returns Returns the array of results.\n * @example\n * times(3, index => console.log(\"Run\", index)))\n * // => \"Run 0\" | \"Run 1\" | \"Run 2\"\n *\n * times(3, Math.random)\n * // => [0.123, 0.456, 0.789]\n *\n * times(4, () => 0)\n * // => [0, 0, 0, 0]\n */\n\nexport function times<T>(n: number, func: (index: number) => T): T[] {\n    const result: T[] = [];\n    for (let i = 0; i < n; i++) {\n        result.push(func(i));\n    }\n    return result;\n}","/**\n * Checks if `value` is an empty object, collection, map, or set.\n *\n * Objects are considered empty if they have no own enumerable string keyed\n * properties.\n *\n * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n *\n * @category Lang\n * @param value - The value to check.\n * @returns Returns `true` if `value` is empty, else `false`.\n * @example\n * isEmpty(null)\n * // => true\n *\n * isEmpty({})\n * // => true\n *\n * isEmpty(\"\")\n * // => true\n *\n * isEmpty([1, 2, 3])\n * // => false\n *\n * isEmpty('abc')\n * // => false\n *\n * isEmpty({ 'a': 1 })\n * // => false\n */\n\nexport function isEmpty(value: string | object | null | undefined): boolean {\n    if (value === null || value === undefined) {\n        return true;\n    }\n\n    if (typeof value === 'string' || Array.isArray(value)) {\n        return value.length === 0;\n    }\n\n    if (value instanceof Map || value instanceof Set) {\n        return value.size === 0;\n    }\n\n    if (typeof value === 'object') {\n        return Object.keys(value).length === 0;\n    }\n\n    return false;\n}\n","export function isPlainObject(value: unknown): value is object {\n    return value !== null && typeof value === 'object' && value.constructor === Object;\n}\n","/**\n * Creates an object composed of the picked `object` properties.\n *\n * @category Object\n * @param object The source object.\n * @param keys The property paths to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * const object = { 'a': 1, 'b': '2', 'c': 3 }\n *\n * pick(object, ['a', 'c'])\n * // => { 'a': 1, 'c': 3 }\n */\n\nexport function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K> {\n    const result = {} as Pick<T, K>;\n    for (const key of keys) {\n        result[key] = object[key];\n    }\n    return result;\n}\n","export function deburr(str: string): string {\n    // eslint-disable-next-line no-control-regex\n    return str.replace(/[^\\u0000-\\u007E]/g, (chr: string) =>\n        chr.normalize('NFD').replace(/[\\u0300-\\u036F]/g, ''));\n}\n","import { deburr } from '@string/deburr';\n\nexport function splitWords(str: string): string[] {\n    str = deburr(str);\n\n    // Split non-alphanumeric characters with spaces and deal with camel/PascalCase\n    const regex = new RegExp(\n        '[^\\\\dA-Za-z]' +  // match any character that is not a letter or a digit\n        '|' +                    // or\n        '(?<=[a-z])' +           // lookbehind for a lowercase letter\n        '(?=[A-Z])' +            // lookahead for an uppercase letter\n        '|' +                    // or\n        '(?<=[A-Z])' +           // lookbehind for an uppercase letter\n        '(?=[A-Z][a-z])'         // lookahead for an uppercase letter followed by a lowercase letter\n    );\n\n    return str.split(regex).filter(Boolean);\n}\n","import { splitWords } from '@helpers/stringModifiers';\n\nexport function camelCase(str: string): string {\n    const words = splitWords(str);\n\n    // Capitalize the first letter of each word\n    const camelCase = words.map((word, index) => {\n        if (index === 0) {\n            return word.toLowerCase();\n        }\n        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();\n    });\n\n    return camelCase.join('');\n}\n","export function capitalize(str: string): string {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n","export function escape(str: string): string {\n    const escapeChars: Record<string, string> = {\n        '&': '&amp;',\n        '<': '&lt;',\n        '>': '&gt;',\n        '\\'': '&#39;',\n        '\"': '&quot;'\n    };\n    return str.replace(/[\"&'<>]/g, char => escapeChars[char] || char);\n}\n","export function escapeRegExp(str: string): string {\n    return str.replace(/[$()*+.?[\\\\\\]^{|}]/g, '\\\\$&');\n}\n","import { splitWords } from '@helpers/stringModifiers';\n\nexport function kebabCase(str: string): string {\n    const words = splitWords(str);\n    let kebabCase = '';\n    for (const word of words) {\n        kebabCase += word.toLowerCase() + '-';\n    }\n    return kebabCase.slice(0, -1);\n}\n","import { splitWords } from '@helpers/stringModifiers';\n\nexport function pascalCase(str: string): string {\n    const words = splitWords(str);\n    let pascalCase = '';\n    for (const word of words) {\n        pascalCase += word.charAt(0).toUpperCase() + word.slice(1);\n    }\n    return pascalCase;\n}\n","import { splitWords } from '@helpers/stringModifiers';\n\nexport function snakeCase(str: string): string {\n    const words = splitWords(str);\n    let snakeCase = '';\n    for (const word of words) {\n        if (snakeCase.length > 0) {\n            snakeCase += '_';\n        }\n        snakeCase += word.toLowerCase();\n    }\n    return snakeCase;\n}\n","import { splitWords } from '@helpers/stringModifiers';\n\nexport function startCase(str: string): string {\n    const words = splitWords(str);\n    let startCase = '';\n    for (const word of words) {\n        startCase += word.charAt(0).toUpperCase() + word.slice(1).toLowerCase() + ' ';\n    }\n    return startCase.trimEnd();\n}\n","import { deburr } from '@string/deburr';\n\nexport function stripSpecialChars(str: string): string {\n    str = deburr(str);\n    return str.replace(/[^\\s\\w]/gi, '');\n}\n","export function unescapeHTML(html: string): string {\n    const entityMap: Record<string, string> = {\n        '&amp;': '&',\n        '&lt;': '<',\n        '&gt;': '>',\n        '&quot;': '\"',\n        '&#39;': '\\''\n    };\n    return html.replace(/&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34);/g, (entity: string) => entityMap[entity] || entity);\n}\n"],"mappings":"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","names":["difference","intersection","camelCase","kebabCase","pascalCase","snakeCase","startCase"]}

package/dist/index.d.ts

@@ -14,12 +14,17 @@
  */
 declare function chunk<TInput>(chunkSize: number, array: TInput[]): TInput[][];
 
-type MinimumTwoArrays<T> = [T[], T[], ...T[][]];
+type MinimumTwoArrays<TInput> = [TInput[], TInput[], ...TInput[][]];
 type IterateeFunction<T> = (value: T) => unknown;
 type PropertyShorthand<T> = keyof T;
 type RecordKey = string | number | symbol;
-type Collection<T> = T[] | Record<RecordKey, T>;
-type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
+type ArrayOrRecord<TInput> = TInput[] | Record<RecordKey, TInput>;
+type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
+/**
+ * @description Generic function type, should fit any function
+ * @typeParam TFunc - The input function type
+ */
+type GenericFunction<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>> = (...args: Parameters<TFunc>) => ReturnType<TFunc>;
 
 /**
  * Creates an array of `array` values not included in the other given arrays. The order and references of result values are determined by the first array.
@@ -31,9 +36,9 @@ type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
  * @returns Returns the new array of filtered values.
  * @example
  * difference([2, 1], [2, 3])
- * // =\> [1]
+ * // => [1]
  */
-declare function difference<T>(...arrays: MinimumTwoArrays<T>): T[];
+declare function difference<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
 
 /**
  * This method is like `difference` except that it accepts `iteratee` which
@@ -250,54 +255,6 @@ declare function takeRightWhile<T>(predicate: (elem: T) => boolean, array: T[]):
  */
 declare function takeWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[];
 
-/**
- * Creates an array of unique values, in order, from all given arrays using for equality comparisons.
- *
- * @category Array
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of combined values.
- * @example
- * union([2, 3], [1, 2])
- * // => [2, 3, 1]
- */
-declare function union<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
-
-/**
- * This method is like `union` except that it accepts `iteratee` which is
- * invoked for each element of each `arrays` to generate the criterion by
- * which uniqueness is computed. Result values are chosen from the first
- * array in which the value occurs. The iteratee is invoked with one argument:
- * (value).
- *
- * @category Array
- * @param arrays - The arrays to inspect.
- * @param iteratee - The iteratee invoked per element. Or property shorthand.
- * @returns Returns the new array of combined values.
- * @example
- * unionBy(Math.floor, [2.1], [1.2, 2.3])
- * // => [2.1, 1.2]
- */
-declare function unionBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[];
-
-/**
- * This method is like `union` except that it accepts `comparator` which
- * is invoked to compare elements of `arrays`. Result values are chosen from
- * the first array in which the value occurs. The comparator is invoked
- * with two arguments: (arrVal, othVal).
- *
- * @category Array
- * @param comparator - The comparator invoked per element.
- * @param arrays - The arrays to inspect.
- * @returns Returns the new array of combined values.
- * @example
- * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
- * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]
- *
- * unionWith(isEqual, objects, others)
- * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
- */
-declare function unionWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, ...arrays: MinimumTwoArrays<TInput>): TInput[];
-
 /**
  * Creates a duplicate-free version of an array, in which only the first occurrence of each element is kept.
  * The order of result values is determined by the order they occur in the array.
@@ -415,7 +372,7 @@ declare function zipWith<Args extends unknown[], TOutput>(combineFunc: (...args:
  *
  * @category Collection
  * @param iteratee - The iteratee to transform keys.
- * @param collection - The array or object to iterate over.
+ * @param collection - The array or record to iterate over.
  * @returns Returns the composed aggregate object.
  * @example
  * const users = [
@@ -424,10 +381,10 @@ declare function zipWith<Args extends unknown[], TOutput>(combineFunc: (...args:
  *   { 'user': 'fred', 'active': false }
  * ]
  *
- * countBy(value => value.active, users);
+ * countBy(users, value => value.active);
  * // => { 'true': 2, 'false': 1 }
  */
-declare function countBy<TInput, TKey extends RecordKey>(iteratee: (value: TInput) => TKey, collection: Collection<TInput>): Record<TKey, number>;
+declare function countBy<TInput, TKey extends RecordKey>(collection: ArrayOrRecord<TInput>, iteratee: (value: TInput) => TKey): Record<TKey, number>;
 
 /**
  * Creates an object composed of keys generated from the results of running
@@ -437,15 +394,14 @@ declare function countBy<TInput, TKey extends RecordKey>(iteratee: (value: TInpu
  * key.
  *
  * @category Collection
- * @param collection The array or object to iterate over.
- * @param iteratee The iteratee to transform keys.
+ * @param collection - The array or object to iterate over.
+ * @param iteratee - The iteratee to transform keys.
  * @returns Returns the composed aggregate object.
  * @example
- *
- * groupBy(Math.floor, [6.1, 4.2, 6.3])
+ * groupBy([6.1, 4.2, 6.3], Math.floor)
  * // => { '4': [4.2], '6': [6.1, 6.3] }
  */
-declare function groupBy<T, U extends RecordKey>(iteratee: (value: T) => U, collection: Collection<T>): Record<U, T[]>;
+declare function groupBy<T, U extends RecordKey>(collection: ArrayOrRecord<T>, iteratee: (value: T) => U): Record<U, T[]>;
 
 declare function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | Date | string, U>, array: T[]): T[];
 
@@ -457,16 +413,19 @@ declare function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | D
  * @param func The function to restrict.
  * @returns Returns the new restricted function.
  * @example
- * const caution = () => alert("Caution!");
+ * const caution = () => console.log("Caution!");
  *
- * // Display alert only after it has been called 5 times
- * after(5, caution)
+ * const afterFN = after(2, caution);
+ *
+ * afterFN()
+ * afterFN()
+ * afterFN()
+ * // => `caution` is invoked after called twice
  */
-declare function after<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): (...args: Parameters<TFunc>) => ReturnType<TFunc> | undefined;
+declare function after<TFunc extends GenericFunction<TFunc>>(n: number, func: TFunc): (...args: Parameters<TFunc>) => ReturnType<TFunc> | undefined;
 
 /**
- * Creates a function that invokes `func`, with the `this` binding and arguments
- * of the created function, while it's called less than `n` times. Subsequent
+ * Creates a function that invokes `func`, while it's called less than `n` times. Subsequent
  * calls to the created function return the result of the last `func` invocation.
  *
  * @category Function
@@ -474,20 +433,24 @@ declare function after<TFunc extends (...args: Parameters<TFunc>) => ReturnType<
  * @param func - The function to restrict.
  * @returns Returns the new restricted function.
  * @example
- * const caution = () => alert("Caution!");
+ * const caution = () => console.log("Caution!");
  *
  * // Only call caution two times
- * before(2, caution)
+ * const reducedCaution = before(2, caution)
+ *
+ * reducedCaution()
+ * reducedCaution()
+ * reducedCaution()
+ * // => `caution` is invoked twice
  */
 declare function before<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): TFunc;
 
-declare function debounce<T extends (...args: Parameters<T>) => ReturnType<T>>(fn: T, wait?: number, options?: {
+declare function debounce<TFunc extends GenericFunction<TFunc>>(fn: TFunc, wait?: number, options?: {
     leading?: boolean;
     maxWait?: number;
     trailing?: boolean;
-}): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+}): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;
 
-type Cache = Map<string | symbol, unknown>;
 /**
  * Creates a function that memoizes the result of `func`. If `resolver` is
  * provided, it determines the cache key for storing the result based on the
@@ -503,6 +466,8 @@ type Cache = Map<string | symbol, unknown>;
  * @category Function
  * @param func - The function to have its output memoized.
  * @param resolver - The function to resolve the cache key.
+ * @typeParam TFunc - The input function type
+ * @typeParam Cache - The cache map type
  * @returns  Returns the new memoized function.
  * @example
  * const object = \{ 'a': 1, 'b': 2 \}
@@ -526,22 +491,139 @@ type Cache = Map<string | symbol, unknown>;
  * // Replace `memoize.Cache`.
  * memoize.Cache = WeakMap
  */
-declare function memoize<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(func: TFunc, resolver?: ((...args: Parameters<TFunc>) => string | symbol)): TFunc & {
+declare function memoize<TFunc extends GenericFunction<TFunc>, Cache extends Map<string | symbol, ReturnType<TFunc>>>(func: TFunc, resolver?: ((...args: Parameters<TFunc>) => string | symbol)): TFunc & {
     cache: Cache;
 };
 
-declare function once<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(func: TFunc): TFunc;
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls
+ * to the function return the value of the first invocation. The `func` is
+ * invoked with the `this` binding and arguments of the created function.
+ *
+ * @category Function
+ * @param func - The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const initialize = once(() => console.log('initialize'))
+ * initialize()
+ * initialize()
+ * // => `createApplication` is invoked once
+ */
+declare function once<TFunc extends GenericFunction<TFunc>>(func: TFunc): TFunc;
 
-declare function throttle<T extends (...args: Parameters<T>) => ReturnType<T>>(func: T, wait?: number, options?: {
+declare function throttle<TFunc extends GenericFunction<TFunc>>(func: TFunc, wait?: number, options?: {
     leading?: boolean;
     trailing?: boolean;
-}): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+}): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;
+
+/**
+ * Invokes the iteratee `n` times, returning an array of the results of
+ * each invocation. The function is invoked with one argument: (index).
+ *
+ * @category Function
+ * @param n - The number of times to invoke `func`.
+ * @param iteratee - The function invoked per iteration.
+ * @returns Returns the array of results.
+ * @example
+ * times(3, index => console.log("Run", index)))
+ * // => "Run 0" | "Run 1" | "Run 2"
+ *
+ * times(3, Math.random)
+ * // => [0.123, 0.456, 0.789]
+ *
+ * times(4, () => 0)
+ * // => [0, 0, 0, 0]
+ */
+declare function times<T>(n: number, func: (index: number) => T): T[];
 
-declare function isEmpty(value: unknown): boolean;
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @category Lang
+ * @param value - The value to check.
+ * @returns Returns `true` if `value` is empty, else `false`.
+ * @example
+ * isEmpty(null)
+ * // => true
+ *
+ * isEmpty({})
+ * // => true
+ *
+ * isEmpty("")
+ * // => true
+ *
+ * isEmpty([1, 2, 3])
+ * // => false
+ *
+ * isEmpty('abc')
+ * // => false
+ *
+ * isEmpty({ 'a': 1 })
+ * // => false
+ */
+declare function isEmpty(value: string | object | null | undefined): boolean;
 
+/**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are compared by strict equality, i.e. `===`.
+ *
+ * @category Lang
+ * @param value1 - The value to compare.
+ * @param value2 - The other value to compare.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ * @example
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
 declare function isEqual(value1: unknown, value2: unknown): boolean;
 
-declare function isEqualWith<T>(customizer: (value: T) => unknown, a: T, b: T): boolean;
+/**
+ * This method is like `_.isEqual` except that it accepts `customizer` which
+ * is invoked to compare values. If `customizer` returns `undefined`, comparisons
+ * are handled by the method instead. The `customizer` is invoked with up to
+ * six arguments: (objValue, othValue [, index|key, object, other, stack]).
+ *
+ * @category Lang
+ * @param value1 - The value to compare.
+ * @param value2 - The other value to compare.
+ * @param customizer - The function to customize comparisons.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ * @example
+ * function isGreeting(value) {
+ *   return /^h(?:i|ello)$/.test(value);
+ * }
+ *
+ * function customizer(objValue, othValue) {
+ *   if (isGreeting(objValue) && isGreeting(othValue)) {
+ *     return true;
+ *   }
+ * }
+ *
+ * var array = ['hello', 'goodbye'];
+ * var other = ['hi', 'goodbye'];
+ *
+ * isEqualWith(array, other, customizer);
+ * // => true
+*/
+declare function isEqualWith<T>(a: T, b: T, customizer: (value: T) => unknown): boolean;
 
 declare function isPlainObject(value: unknown): value is object;
 
@@ -583,4 +665,4 @@ declare function stripSpecialChars(str: string): string;
 
 declare function unescapeHTML(html: string): string;
 
-export { Collection, IterateeFunction, MinimumTwoArrays, NoUnion, PropertyShorthand, RecordKey, after, before, camelCase, capitalize, chunk, countBy, debounce, deburr, difference, differenceBy, differenceWith, dropRightWhile, dropWhile, escape, escapeRegExp, groupBy, intersection, intersectionBy, intersectionWith, isEmpty, isEqual, isEqualWith, isPlainObject, kebabCase, memoize, once, pascalCase, pick, sample, sampleSize, shuffle, snakeCase, sortBy, startCase, stripSpecialChars, takeRightWhile, takeWhile, throttle, unescapeHTML, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, zip, zipWith };
+export { ArrayOrRecord, GenericFunction, IterateeFunction, MinimumTwoArrays, NoUnion, PropertyShorthand, RecordKey, after, before, camelCase, capitalize, chunk, countBy, debounce, deburr, difference, differenceBy, differenceWith, dropRightWhile, dropWhile, escape, escapeRegExp, groupBy, intersection, intersectionBy, intersectionWith, isEmpty, isEqual, isEqualWith, isPlainObject, kebabCase, memoize, once, pascalCase, pick, sample, sampleSize, shuffle, snakeCase, sortBy, startCase, stripSpecialChars, takeRightWhile, takeWhile, throttle, times, unescapeHTML, uniq, uniqBy, uniqWith, unzip, unzipWith, zip, zipWith };

package/dist/index.js

@@ -89,14 +89,14 @@ function getIterateFunction(iteratee) {
 }
 
 // src/lang/isEqualWith.ts
-function isEqualWith(customizer, a, b) {
+function isEqualWith(a, b, customizer) {
   return isEqual(customizer(a), customizer(b));
 }
 
 // src/array/differenceBy.ts
 function differenceBy(iteratee, ...arrays) {
   const iterateeFunction = getIterateFunction(iteratee);
-  return differenceWith((a, b) => isEqualWith(iterateeFunction, a, b), ...arrays);
+  return differenceWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);
 }
 
 // src/array/dropRightWhile.ts
@@ -134,7 +134,7 @@ function intersection(...arrays) {
 // src/array/intersectionBy.ts
 function intersectionBy(iteratee, ...arrays) {
   const iterateeFunction = getIterateFunction(iteratee);
-  return intersectionWith((a, b) => isEqualWith(iterateeFunction, a, b), ...arrays);
+  return intersectionWith((a, b) => isEqualWith(a, b, iterateeFunction), ...arrays);
 }
 
 // src/array/sample.ts
@@ -200,30 +200,6 @@ function takeWhile(predicate, array) {
   return result;
 }
 
-// src/array/union.ts
-function union(...arrays) {
-  return [...new Set(arrays.flat())];
-}
-
-// src/array/unionWith.ts
-function unionWith(comparator, ...arrays) {
-  return arrays.reduce((acc, current) => {
-    for (const item of current) {
-      if (acc.some((x) => comparator(x, item))) {
-        continue;
-      }
-      acc.push(item);
-    }
-    return acc;
-  }, []);
-}
-
-// src/array/unionBy.ts
-function unionBy(iteratee, ...arrays) {
-  const iterateeFunction = getIterateFunction(iteratee);
-  return unionWith((a, b) => isEqualWith(iterateeFunction, a, b), ...arrays);
-}
-
 // src/array/uniqWith.ts
 function uniqWith(comparator, array) {
   return array.filter((value, index, self) => {
@@ -277,7 +253,7 @@ function getValuesFromCollection(collection) {
 }
 
 // src/collection/countBy.ts
-function countBy(iteratee, collection) {
+function countBy(collection, iteratee) {
   const result = {};
   const values = getValuesFromCollection(collection);
   for (const value of values) {
@@ -292,7 +268,7 @@ function countBy(iteratee, collection) {
 }
 
 // src/collection/groupBy.ts
-function groupBy(iteratee, collection) {
+function groupBy(collection, iteratee) {
   const result = {};
   const values = getValuesFromCollection(collection);
   for (const value of values) {
@@ -462,6 +438,15 @@ function throttle(func, wait = 0, options = {}) {
   });
 }
 
+// src/function/times.ts
+function times(n, func) {
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    result.push(func(i));
+  }
+  return result;
+}
+
 // src/lang/isEmpty.ts
 function isEmpty(value) {
   if (value === null || value === void 0) {
@@ -470,9 +455,6 @@ function isEmpty(value) {
   if (typeof value === "string" || Array.isArray(value)) {
     return value.length === 0;
   }
-  if (typeof value === "number") {
-    return false;
-  }
   if (value instanceof Map || value instanceof Set) {
     return value.size === 0;
   }
@@ -643,10 +625,8 @@ export {
   takeRightWhile,
   takeWhile,
   throttle,
+  times,
   unescapeHTML,
-  union,
-  unionBy,
-  unionWith,
   uniq,
   uniqBy,
   uniqWith,