atomic-fns 0.4.2 → 0.4.3

package/dist/collections/index.d.ts

@@ -4,41 +4,58 @@
  * @module Collections
  */
 import { Iteratee } from '../globals/index.js';
+import { compare } from '../operators/index.js';
 export * from './abc.js';
 export * from './BTree.js';
 export * from './deque.js';
 export * from './frozenset.js';
 export * from './Heap.js';
 export * from './LRUCache.js';
-export * from './SortedSet.js';
 export * from './SortedMap.js';
+export * from './SortedSet.js';
 export * from './SortedTree.js';
 export * from './SplayTree.js';
 /**
  * Creates a new array with all falsy and empty values removed.
  * @param arr The array to compact
- * @returns A new array with the filtered values.
  * @example
 ```js
 compact([0, 1, false, 2, '', 3])
-// => [1, 2, 3]
+// [1, 2, 3]
 ```
+ * @returns A new array with the filtered values
  */
-export declare function compact(arr: any[]): any;
-export declare function compact(arr: Object): any;
-export declare function count<T>(iterable: Iterable<T> | Object, func: Iteratee<T>): {};
+export declare function compact<T>(arr: T[]): T[];
+export declare function compact<T>(arr: T): Partial<T>;
+/**
+ * Creates an object composed of keys from the results of running elements of `collection` thru `iteratee`. The corresponding value of each key is the number of times the key was returned by `iteratee`.
+ * @param iterable
+ * @param func
+ * @returns {Object} Returns an Object with the frequency values
+ * @example
+```js
+count([6.1, 4.2, 6.3], Math.floor);
+// { '4': 1, '6': 2 }
+
+// property iteratee shorthand.
+count(['one', 'two', 'three'], x => x.length);
+// { '3': 2, '5': 1 }
+```
+ */
+export declare function count<T>(obj: T[], fn: Iteratee<T>): Record<string, number>;
+export declare function count<T>(obj: Object, fn: Iteratee<T>): Record<string, number>;
 /**
  * Creates a function that can be used to create named tuple-like objects.
  * @example
 ```js
- * let Point = namedtuple('x', 'y', 'z')
- * let userObj = User(0, 0, 0)
- * // => {x: 0, y: 0, z: 0}
+let Point = namedtuple('x', 'y', 'z')
+let userObj = User(0, 0, 0)
+// {x: 0, y: 0, z: 0}
 ```
  * @param fields - A list of field names
  * @returns A function that can be called with the field values
  */
-export declare function namedtuple(...fields: string[]): (...args: any[]) => any;
+export declare const namedtuple: (...fields: string[]) => (...args: any[]) => any;
 /**
  * Iterates over elements of collection, returning an array of all elements where predicate returns truthy value.
  *
@@ -46,67 +63,62 @@ export declare function namedtuple(...fields: string[]): (...args: any[]) => any
  *
  * @example
 ```js
- * let users = [
+let users = [
   { 'user': 'barney', 'age': 36, 'active': true },
   { 'user': 'fred',   'age': 40, 'active': false }
 ]
 
 filter(users, o => !o.active)
- // => objects for ['fred']
+ // objects for ['fred']
 
 // The shape iteratee shorthand.
 filter(users, { age: 36, active: true })
-// => objects for ['barney']
+// objects for ['barney']
 
 // The property iteratee shorthand.
 filter(users, 'active')
-// => objects for ['barney']
+// objects for ['barney']
 ```
  * @param {Array} arr The collection to iterate over
  * @param {Function} fn The predicate function invoked for each item
  * @returns {Array} The new filtered array
  */
-export declare function filter(arr: any, fn?: Iteratee | PropertyKey | Object): any[];
+export declare function filter<T>(arr: T[], fn?: Iteratee<T>): T[];
+export declare function filter<T>(arr: T[], fn?: Object): T[];
+export declare function filter<T>(arr: Object, fn?: Iteratee<T>): T[];
+export declare function filter<T>(arr: Object, fn?: Object): T[];
 /**
  * Iterates over elements of collection, returning the first element where predicate returns truthy value. The predicate is invoked with three arguments: `(value, index|key, collection)`.
  * @example
 ```js
- let users = [
+let users = [
   { 'user': 'barney',  'age': 36, 'active': true },
   { 'user': 'fred',    'age': 40, 'active': false },
   { 'user': 'pebbles', 'age': 1,  'active': true }
 ]
 
 find(users, (o) => o.age < 40)
-// => object for 'barney'
+// object for 'barney'
 
 // The shape iteratee shorthand.
 find(users, { 'age': 1, 'active': true })
-// => object for 'pebbles'
+// object for 'pebbles'
 
 // The `property` iteratee shorthand.
 find(users, 'active')
-// => object for 'barney'
-```
- * @param {Array} arr The collection to iterate over.
- * @param {Function} fn The function invoked per iteration.
- * @returns {*} The matched element, else `undefined`.
- * @see {@link findRight}
- */
-export declare function find(arr: any, fn: Iteratee | PropertyKey | Object): any;
-/**
- * This method is like {@link find} except that it iterates from right to left.
- * @example
-```js
-findRight([1, 2, 3, 4], (n) => n % 2 === 1)
-//  => 3
+// object for 'barney'
 ```
  * @param {Array} arr The collection to iterate over.
  * @param {Function} fn The function invoked per iteration.
  * @returns {*} The matched element, else `undefined`.
- * @see {@link find}
+ * @see {@link findLast}
  */
-export declare function findRight(arr: any, fn: Iteratee | PropertyKey | Object): any;
+export declare function find<T>(arr: T[], fn: Iteratee<T>): T | undefined;
+export declare function find<T>(arr: T[], fn: Object): T | undefined;
+export declare function find<T>(arr: T[], fn: PropertyKey): T | undefined;
+export declare function find<T>(arr: Object, fn: Iteratee<T>): T | undefined;
+export declare function find<T>(arr: Object, fn: Object): T | undefined;
+export declare function find<T>(arr: Object, fn: PropertyKey): T | undefined;
 /**
  * Performs an efficient array insert operation in the given array. If the index or the array is invalid, it just returns the given array.
  *
@@ -117,7 +129,7 @@ export declare function findRight(arr: any, fn: Iteratee | PropertyKey | Object)
  * @param {*} value The value to insert in the array at the given `index`.
  * @returns {Array<*>} The given array.
  */
-export declare function insert(arr: any[], index: number, value: any): any[];
+export declare function insert<T>(arr: T[], index: number, value: T): T[];
 /**
  * Creates a function that performs a partial deep comparison between a given object and `shape`, returning `true` if the given object has equivalent property values, else `false`.
  * @example
@@ -128,7 +140,7 @@ let objects = [
 ]
 
 filter(objects, matches({ a: 4, c: 6 }))
-// => [{ a: 4, b: 5, c: 6 }]
+// [{ a: 4, b: 5, c: 6 }]
 ```
  * @param shape
  * @returns
@@ -141,12 +153,12 @@ export declare const matches: (shape: any) => (obj: any) => boolean;
 forEach([1, 2], (value) => {
   console.log(value)
 })
-// => Logs `1` then `2`.
+// Logs `1` then `2`.
 
 forEach({ 'a': 1, 'b': 2 }, (value, key) => {
   console.log(key)
 })
-// => Logs 'a' then 'b' (iteration order is not guaranteed).
+// Logs 'a' then 'b' (iteration order is not guaranteed).
 ```
  * @param {Array|Object} collection The collection to iterate over.
  * @param {Iteratee} fn The function invoked per iteration.
@@ -155,9 +167,24 @@ forEach({ 'a': 1, 'b': 2 }, (value, key) => {
  * @see {@link filter}
  * @see {@link map}
  */
-export declare function forEach<T>(collection: T[], fn: Iteratee<T>): any;
-export declare function forEach<T>(collection: Iterable<T>, fn: Iteratee<T>): any;
-export declare function forEach<T>(collection: Object, fn: Iteratee<T>): any;
+export declare function forEach<T>(collection: Iterable<T>, fn: Iteratee<T>): void;
+export declare function forEach<T>(collection: Object, fn: Iteratee<T>): void;
+/**
+ * This method is like {@link find} except that it iterates from right to left.
+ * @example
+```js
+findLast([1, 2, 3, 4], (n) => n % 2 === 1)
+//  => 3
+```
+ * @param {Array} arr The collection to iterate over.
+ * @param {Function} fn The function invoked per iteration.
+ * @returns {*} The matched element, else `undefined`.
+ * @see {@link find}
+ */
+export declare function findLast<T>(arr: Iterable<T>, fn: Iteratee<T>): T | undefined;
+export declare function findLast<T>(arr: Iterable<T>, fn: Object): T | undefined;
+export declare function findLast<T>(arr: Object, fn: Iteratee<T>): T | undefined;
+export declare function findLast<T>(arr: Object, fn: Object): T | undefined;
 /**
  * This method is like {@link forEach} except that it iterates over the collection from right to left.
 
@@ -166,7 +193,7 @@ export declare function forEach<T>(collection: Object, fn: Iteratee<T>): any;
 forEachRight([1, 2], (value) => {
   console.log(value)
 })
-// => Logs `2` then `1`.
+// Logs `2` then `1`.
 ```
  * @param {Array|Object} collection The collection to iterate over.
  * @param {Iteratee} fn The function invoked per iteration.
@@ -175,13 +202,14 @@ forEachRight([1, 2], (value) => {
  * @see {@link filter}
  * @see {@link map}
  */
-export declare function forEachRight(collection: any[] | Object, fn: Iteratee): Object;
+export declare function forEachRight<T>(collection: T[], fn: Iteratee<T>): void;
+export declare function forEachRight<T>(collection: Object, fn: Iteratee<T>): void;
 /**
  * Flattens an array or object. Arrays will be flattened recursively up to `depth` times. Objects will be flattened recursively.
  * @example
 ```js
 flatten([1, [2, [3, [4]], 5]])
-// => [1, 2, [3, [4]], 5]
+// [1, 2, [3, [4]], 5]
 
 flatten({
   dates: {
@@ -199,7 +227,7 @@ flatten({
     value: 1500
   }
 })
-// => {
+// {
   'dates.expiry_date': '30 sep 2018',
   'dates.available': '30 sep 2017',
   'dates.min_contract_period[0].id': 1,
@@ -213,7 +241,8 @@ flatten({
  * @returns {*} The new flattened array or object.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat Array.flat()}
  */
-export declare function flatten(arr: any[] | Object, depth?: boolean | number): Object;
+export declare function flatten<T>(arr: T[], depth?: boolean | number): T[];
+export declare function flatten<T>(arr: Object, depth?: boolean | number): Object;
 /**
  * Creates an array of values by running each element in collection thru iteratee. The iteratee is invoked with three arguments: `(value, index|key, collection)`.
  * @example
@@ -223,10 +252,10 @@ function square(n) {
 }
 
 map([4, 8], square)
-// => [16, 64]
+// [16, 64]
 
 map({ a: 4, b: 8 }, square)
-// => [16, 64] (iteration order is not guaranteed)
+// [16, 64] (iteration order is not guaranteed)
 
 let users = [
   { user: 'barney' },
@@ -235,14 +264,17 @@ let users = [
 
 // The `property` iteratee shorthand.
 map(users, 'user')
-// => ['barney', 'fred']
+// ['barney', 'fred']
 ```
  * @param {Array|Object} arr The collection to iterate over.
- * @param {Iteratee|PropertyKey} fn The function invoked per iteration.
+ * @param {Iteratee} fn The function invoked per iteration.
  * @returns Returns the new mapped array.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map Array.map()}
  */
-export declare function map(arr: any, fn: Iteratee | PropertyKey): any[];
+export declare function map<T, TResult>(arr: T[], fn: Iteratee<T, PropertyKey, TResult>): TResult[];
+export declare function map<T, TResult>(arr: T[], fn: PropertyKey): TResult[];
+export declare function map<T, TResult>(arr: Object, fn: Iteratee<T, PropertyKey, TResult>): TResult[];
+export declare function map<T, TResult>(arr: Object, fn: PropertyKey): TResult[];
 /**
  * Creates an object composed of the picked object properties.
  * @param {Object} obj The source object.
@@ -253,15 +285,16 @@ export declare function map(arr: any, fn: Iteratee | PropertyKey): any[];
 let object = { a: 1, b: '2', c: 3 }
 
 pick(object, ['a', 'c'])
-// => { a: 1, c: 3 }
+// { a: 1, c: 3 }
 
 pick(object, (x) => isNumber(x))
-// => { a: 1, c: 3 }
+// { a: 1, c: 3 }
 ```
  *
  * @see {@link omit}
  */
-export declare function pick(obj: Object, paths: Iteratee | PropertyKey[]): {};
+export declare function pick<T>(obj: T, paths: Iteratee): Partial<T>;
+export declare function pick<T>(obj: T, paths: PropertyKey[]): Partial<T>;
 /**
  * The opposite of {@link pick} - this method creates an object composed of the own and inherited enumerable property paths of `object` that are not omitted.
  * @example
@@ -269,17 +302,18 @@ export declare function pick(obj: Object, paths: Iteratee | PropertyKey[]): {};
 let object = { 'a': 1, 'b': '2', 'c': 3 }
 
 omit(object, ['a', 'c'])
-// => { 'b': '2' }
+// { 'b': '2' }
 
 omit(object, (x) => isNumber(x))
-// => { 'b': '2' }
+// { 'b': '2' }
 ```
  * @param {Object} obj The source object.
  * @param {Iteratee|PropertyKey[]} paths The property paths to omit.
  * @returns {Object} Returns the new object.
  * @see {@link pick}
  */
-export declare function omit(obj: Object, paths: Iteratee | PropertyKey[]): {};
+export declare function omit<T>(obj: T, paths: Iteratee): Partial<T>;
+export declare function omit<T>(obj: T, paths: PropertyKey[]): Partial<T>;
 /**
  * This method is like {@link find} except that it returns the index of the first element `predicate` returns truthy for instead of the element itself.
  * @param {Array} obj The array to inspect.
@@ -294,24 +328,26 @@ let users = [
   { 'user': 'pebbles', 'active': true }
 ]
 
-index(users, (o) => o.user == 'barney')
-// => 0
+findIndex(users, (o) => o.user == 'barney')
+// 0
 
 // The `shape` iteratee shorthand.
-index(users, { 'user': 'fred', 'active': false })
-// => 1
+findIndex(users, { 'user': 'fred', 'active': false })
+// 1
 
 // The `property` iteratee shorthand.
-index(users, 'active')
-// => 2
+findIndex(users, 'active')
+// 2
 ```
  * @see {@link indexOf}
- * @see {@link lastIndex}
+ * @see {@link findLastIndex}
  *
  */
-export declare function index(obj: any, fn: Iteratee | string | Object, start?: number): number;
+export declare function findIndex<T>(obj: T[], fn: Iteratee<T>, start?: number): number;
+export declare function findIndex<T>(obj: T[], fn: Object, start?: number): number;
+export declare function findIndex<T>(obj: T[], fn: PropertyKey, start?: number): number;
 /**
- * This method is like {@link index} except that it searches for a given value directly, instead of using a predicate function.
+ * This method is like {@link findIndex} except that it searches for a given value directly, instead of using a predicate function.
  * @param {Array} obj The array to inspect.
  * @param {*} value The value to find
  * @param {number} [start=0] The index to search from.
@@ -319,19 +355,19 @@ export declare function index(obj: any, fn: Iteratee | string | Object, start?:
  * @example
 ```js
 indexOf([1, 2, 1, 2], 2)
-// => 1
+// 1
 
 // Search from a `start` index.
 indexOf([1, 2, 1, 2], 2, 2)
-// => 3
+// 3
 ```
- * @see {@link index}
+ * @see {@link findIndex}
  * @see {@link lastIndexOf}
  */
-export declare function indexOf(obj: any, value: any, start?: number): any;
+export declare function indexOf<T>(obj: T[], value: T, start?: number): number;
 /**
- * This method is like {@link index} except that it iterates the collection from right to left.
- * @param {Array} obj The array to inspect.
+ * This method is like {@link findIndex} except that it iterates the collection from right to left.
+ * @param {Array} arr The array to inspect.
  * @param {string|Iteratee|Object} fn The function invoked per iteration.
  * @param {number} [start] The index to search from.
  * @returns {number} The index of the found value, else -1
@@ -344,20 +380,22 @@ let users = [
 ]
 
 findLastIndex(users, (o) => o.user == 'pebbles')
-// => 2
+// 2
 
 // The `shape` iteratee shorthand.
 findLastIndex(users, { 'user': 'barney', 'active': true })
-// => 0
+// 0
 
 // The `property` iteratee shorthand.
 findLastIndex(users, 'active')
-// => 0
+// 0
 ```
- * @see {@link index}
+ * @see {@link findIndex}
  * @see {@link lastIndexOf}
  */
-export declare function lastIndex(obj: any[], fn: string | Iteratee | Object, start?: any): any;
+export declare function findLastIndex<T>(arr: T[], fn: Iteratee<T>, start?: number): number;
+export declare function findLastIndex<T>(arr: T[], fn: Object, start?: number): number;
+export declare function findLastIndex<T>(arr: T[], fn: PropertyKey, start?: number): number;
 /**
  * This method is like {@link indexOf} except that it iterates the collection from right to left.
  * @param {Array} obj The array to inspect.
@@ -367,16 +405,16 @@ export declare function lastIndex(obj: any[], fn: string | Iteratee | Object, st
  * @example
 ```js
 lastIndexOf([1, 2, 1, 2], 2)
-// => 3
+// 3
 
 // Search from the `fromIndex`.
 lastIndexOf([1, 2, 1, 2], 2, 2)
-// => 1
+// 1
 ```
- * @see {@link lastIndex}
+ * @see {@link findLastIndex}
  * @see {@link indexOf}
  */
-export declare function lastIndexOf(obj: any[], value: any, start?: any): any;
+export declare function lastIndexOf<T>(obj: T[], value: T, start?: number): number;
 /**
  * Creates a shallow clone of `value`. If `deep` is `true` it will clone it recursively.
  * @param {*} value
@@ -385,7 +423,8 @@ export declare function lastIndexOf(obj: any[], value: any, start?: any): any;
  * @see {@link cloneArray}
  * @see {@link cloneTypedArray}
  */
-export declare function clone(value: any, deep?: boolean): any;
+export declare function clone<T>(value: T, deep?: boolean): T;
+export declare function clone<T>(value: T[], deep?: boolean): T[];
 /**
  * Clones an array. If `deep` is `false` (default) the clone will be shallow. Otherwise {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone} is used.
  * @param arr The array to clone
@@ -393,7 +432,7 @@ export declare function clone(value: any, deep?: boolean): any;
  * @returns The new array
  * @see {@link clone}
  */
-export declare function cloneArray(arr: any, deep?: boolean): any;
+export declare function cloneArray<T>(arr: T[], deep?: boolean): T[];
 /**
  * Clones a typed array. If `deep` is `false` (default) the clone will be shallow. Otherwise {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone} is used.
  * @param arr The array to clone
@@ -401,7 +440,7 @@ export declare function cloneArray(arr: any, deep?: boolean): any;
  * @returns The new array
  * @see {@link clone}
  */
-export declare function cloneTypedArray(typedArray: any, isDeep: any): any;
+export declare function cloneTypedArray(typedArray: any, isDeep?: boolean): any;
 /**
  * Creates a duplicate-free version of an array, using a `Set` for equality comparisons, in which only the first occurrence of each element is kept. The order of result values is not guaranteed.
  * @param arr The array containing duplicated elements
@@ -410,15 +449,16 @@ export declare function cloneTypedArray(typedArray: any, isDeep: any): any;
  * @example
 ```js
 uniq([2, 1, 2])
-// => [2, 1]
+// [2, 1]
 
 uniq([2.1, 1.2, 2.3], Math.floor)
-// => [2.1, 1.2]
+// [2.1, 1.2]
 ```
  *
  * @see {@link sortedUniq}
  */
-export declare function uniq<T = any>(arr: T[], fn?: PropertyKey | Iteratee): T[];
+export declare function uniq<T>(arr: Iterable<T>, fn?: Iteratee<T>): T[];
+export declare function uniq<T>(arr: Iterable<T>, fn?: PropertyKey): T[];
 /**
  * This method is like {@link uniq} except that it sorts the results in ascending order
  * @param arr The array containing duplicated elements
@@ -427,11 +467,12 @@ export declare function uniq<T = any>(arr: T[], fn?: PropertyKey | Iteratee): T[
  * @example
 ```js
 uniq([2, 1, 2])
-// => [1, 2]
+// [1, 2]
 ```
  * @see {@link uniq}
  */
-export declare function sortedUniq(arr: any, fn?: string | Iteratee): any[];
+export declare function sortedUniq<T>(arr: Iterable<T>, fn?: Iteratee<T>): T[];
+export declare function sortedUniq<T>(arr: Iterable<T>, fn?: PropertyKey): T[];
 /**
  * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. Source properties that resolve to `undefined` are skipped if a destination value exists. Array and plain object properties are merged recursively. Other objects and value types are overridden by assignment. Source objects are applied from left to right. Subsequent sources overwrite property assignments of previous sources.
  *
@@ -453,10 +494,10 @@ let other = {
 }
 
 merge(object, other)
-// => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+// { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
 ```
  */
-export declare function merge(object: any, ...sources: any[]): Object;
+export declare function merge(object: Object, ...sources: Object[]): Object;
 /**
  * Assigns own and inherited enumerable string keyed properties of source objects to the destination object for all destination properties that resolve to `undefined`. Source objects are applied from left to right. Once a property is set, additional values of the same property are ignored.
  * **Note:** This method mutates `object`.
@@ -467,7 +508,7 @@ export declare function merge(object: any, ...sources: any[]): Object;
  * @example
 ```js
 defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 })
-// => { 'a': 1, 'b': 2 }
+// { 'a': 1, 'b': 2 }
 ```
  */
 export declare function defaults(object: Object, ...sources: Object[]): Object;
@@ -477,36 +518,36 @@ export declare function defaults(object: Object, ...sources: Object[]): Object;
  * @example
 ```js
 [...difference([2, 1], [2, 3])]
-// => [1]
+// [1]
 ```
  * @see {@link union}
  * @see {@link intersection}
  */
-export declare function difference(...args: Array<Iterable<any>>): Generator<any, void, unknown>;
+export declare function difference<T>(...args: Array<Iterable<T>>): Generator<T, void, unknown>;
 /**
  * Creates a generator of unique values that are included in all given arrays.
  * @param args The arrays to inspect
  * @example
 ```js
 [...intersection([2, 1], [2, 3])]
-// => [2]
+// [2]
 ```
 * @see {@link difference}
  * @see {@link union}
  */
-export declare function intersection(...args: Array<Iterable<any>>): Generator<any, void, unknown>;
+export declare function intersection<T>(...args: Array<Iterable<T>>): Generator<T, void, unknown>;
 /**
  * Creates a generator of unique values from all given arrays using `Set` for equality comparisons.
  * @param args The arrays to perform union on.
  * @example
 ```js
 [...union([2], [1, 2])]
-// => [2, 1]
+// [2, 1]
 ```
  * @see {@link difference}
  * @see {@link intersection}
  */
-export declare function union(...args: Array<Iterable<any>>): Generator<unknown, void, unknown>;
+export declare function union<T>(...args: Array<Iterable<T>>): Generator<T, void, unknown>;
 /**
  * Creates an object composed of keys generated from the results of running each element of `arr` thru `func`. The order of grouped values is determined by the order they occur in `arr`. The corresponding value of each key is an array of elements responsible for generating the key.
  *
@@ -517,14 +558,17 @@ export declare function union(...args: Array<Iterable<any>>): Generator<unknown,
  * @example
 ```js
 groupBy([6.1, 4.2, 6.3], Math.floor)
-// => { '4': [4.2], '6': [6.1, 6.3] }
+// { '4': [4.2], '6': [6.1, 6.3] }
 
 // The `property` iteratee shorthand.
 groupBy(['one', 'two', 'three'], 'length')
-// => { '3': ['one', 'two'], '5': ['three'] }
+// { '3': ['one', 'two'], '5': ['three'] }
 ```
  */
-export declare function groupBy(arr: Iterable<any> | Object, func?: Iteratee | PropertyKey): Object;
+export declare function groupBy<T>(arr: Iterable<T>, fn: Iteratee<T>): Record<PropertyKey, T[]>;
+export declare function groupBy<T>(arr: Iterable<T>, fn: PropertyKey): Record<PropertyKey, T[]>;
+export declare function groupBy<T>(arr: Object, fn: Iteratee<T>): Record<PropertyKey, T[]>;
+export declare function groupBy<T>(arr: Object, fn: PropertyKey): Record<PropertyKey, T[]>;
 /**
  * Similar to {@link groupBy} but it returns a {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map Map} object with the results.
  *
@@ -536,18 +580,76 @@ export declare function groupBy(arr: Iterable<any> | Object, func?: Iteratee | P
  * @example
 ```js
 groupByMap([6.1, 4.2, 6.3], Math.floor)
-// => Map { 4: [4.2], 6: [6.1, 6.3] }
+// Map { 4: [4.2], 6: [6.1, 6.3] }
 
 // The `property` iteratee shorthand.
 groupByMap(['one', 'two', 'three'], 'length')
-// => Map { 3: ['one', 'two'], 5: ['three'] }
+// Map { 3: ['one', 'two'], 5: ['three'] }
 ```
  */
-export declare function groupByMap<K = any, V = any>(arr: Iterable<any> | Object, func?: Iteratee | PropertyKey): Map<K, V[]>;
+export declare function groupByMap<V>(arr: Iterable<V>, fn: Iteratee<V>): Map<any, V[]>;
+export declare function groupByMap<V>(arr: Iterable<V>, fn: PropertyKey): Map<any, V[]>;
+export declare function groupByMap<V>(arr: Object, fn: Iteratee<V>): Map<any, V[]>;
+export declare function groupByMap<V>(arr: Object, fn: PropertyKey): Map<any, V[]>;
 /**
  * Removes all elements from array that `func` returns truthy for and returns an array of the removed elements.
  * @param arr The array to remove from.
  * @param func The function invoked per iteration or value(s) or value to remove.
  * @returns
  */
-export declare function remove<T>(arr: T[], func: any): T[];
+export declare function remove<T>(arr: T[], func: T): T[];
+export declare function remove<T>(arr: T[], func: T[]): T[];
+export declare function remove<T>(arr: T[], func: Iteratee<T>): T[];
+/**
+ * Returns the index of `x` in a **sorted** array if found, in `O(log n)` using binary search.
+ * If the element is not found, returns a negative integer.
+ * @param arr The array to sort
+ * @param x The element to find
+ * @param lo The starting index
+ * @param hi The end index to search within
+ * @param comp The compare function to check for `x`
+ * @returns {number} The index if the element is found or a negative integer.
+ */
+export declare function binarySearch(arr: any[], x: any, lo?: number, hi?: any, comp?: typeof compare): number;
+/**
+ * Returns an insertion index which comes after any existing entries of `x` in a **sorted** array, using binary search.
+ * @param arr The array to sort
+ * @param x The element to find
+ * @param lo The starting index
+ * @param hi The end index to search within
+ * @param comp The compare function to check for `x`
+ * @returns {number}
+ */
+export declare function bisect(arr: any[], x: any, lo?: number, hi?: any, comp?: typeof compare): number;
+/**
+ * Returns an insertion index which comes before any existing entries of `x` in a **sorted** array, using binary search.
+ * @param arr The array to sort
+ * @param x The element to find
+ * @param lo The starting index
+ * @param hi The end index to search within
+ * @param comp The compare function to check for `x`
+ * @returns {number}
+ */
+export declare function bisectLeft(arr: any[], x: any, lo?: number, hi?: any, comp?: typeof compare): number;
+/**
+ * Runs {@link bisect} first to locate an insertion point, and inserts the value `x` in the sorted array after any existing entries of `x` to maintain sort order.
+ * Please note this method is `O(n)` because insertion resizes the array.
+ * @param arr The array to insert into
+ * @param x The element to insert
+ * @param lo The starting index
+ * @param hi The end index to search within
+ * @param comp The compare function to check for `x`
+ * @returns {Array}
+ */
+export declare function insort<T>(arr: T[], x: any, lo?: number, hi?: any, comp?: typeof compare): T[];
+/**
+ * Runs {@link bisectLeft} first to locate an insertion point, and inserts the value `x` in the sorted array before any existing entries of `x` to maintain sort order.
+ * Please note this method is `O(n)` because insertion resizes the array.
+ * @param arr The array to insert into
+ * @param x The element to insert
+ * @param lo The starting index
+ * @param hi The end index to search within
+ * @param comp The compare function to check for `x`
+ * @returns {Array}
+ */
+export declare function insortLeft<T>(arr: T[], x: any, lo?: number, hi?: any, comp?: typeof compare): T[];