ut2 1.7.1 → 1.8.0

package/types/internals/createForEach.d.ts

@@ -1,4 +1,10 @@
 import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './types';
+export interface ForEach {
+    <T>(collection: WithNullable<T[]>, iteratee?: ArrayIterator<T, any>): T[];
+    (collection: WithNullable<string>, iteratee?: StringIterator<any>): string;
+    <T>(collection: WithNullable<ArrayLike<T>>, iteratee?: ArrayLikeIterator<T, any>): ArrayLike<T>;
+    <T extends object>(collection: WithNullable<T>, iteratee?: ObjectIterator<T, any>): T;
+}
 /**
  * 创建迭代集合方法
  *
@@ -6,10 +12,5 @@ import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithN
  * @param dir 迭代方向
  * @returns 迭代集合方法
  */
-declare function createForEach(dir: 1 | -1): {
-    <T>(collection: WithNullable<T[]>, iteratee?: ArrayIterator<T, any> | undefined): T[];
-    (collection: WithNullable<string>, iteratee?: StringIterator<any>): string;
-    <T_1>(collection: WithNullable<ArrayLike<T_1>>, iteratee?: ArrayLikeIterator<T_1, any> | undefined): ArrayLike<T_1>;
-    <T_2 extends object>(collection: WithNullable<T_2>, iteratee?: ObjectIterator<T_2, any> | undefined): T_2;
-};
+declare function createForEach(dir: 1 | -1): ForEach;
 export default createForEach;

package/types/internals/createReduce.d.ts

@@ -1,4 +1,14 @@
 import { ReduceArrayIterator, ReduceArrayLikeIterator, ReduceObjectIterator, ReduceStringIterator, WithNullable } from './types';
+export interface Reduce {
+    <T, R>(collection: WithNullable<T[]>, iteratee: ReduceArrayIterator<T, R>, initialValue: R): R;
+    <R>(collection: WithNullable<string>, iteratee: ReduceStringIterator<R>, initialValue: R): R;
+    <T, R>(collection: WithNullable<ArrayLike<T>>, iteratee: ReduceArrayLikeIterator<T, R>, initialValue: R): R;
+    <T extends object, R>(collection: WithNullable<T>, iteratee: ReduceObjectIterator<T, R>, initialValue: R): R;
+    <T>(collection: WithNullable<T[]>, iteratee?: ReduceArrayIterator<T, T>): T | undefined;
+    (collection: WithNullable<string>, iteratee?: ReduceStringIterator<string>): string | undefined;
+    <T>(collection: WithNullable<ArrayLike<T>>, iteratee?: ReduceArrayLikeIterator<T, T>): T | undefined;
+    <T extends object>(collection: WithNullable<T>, iteratee?: ReduceObjectIterator<T, T[keyof T]>): T[keyof T] | undefined;
+}
 /**
  * 创建 reducer 函数
  *
@@ -6,14 +16,5 @@ import { ReduceArrayIterator, ReduceArrayLikeIterator, ReduceObjectIterator, Red
  * @param dir 迭代方向
  * @returns reduce 方法
  */
-declare function createReduce(dir: 1 | -1): {
-    <T, R>(collection: WithNullable<T[]>, iteratee: ReduceArrayIterator<T, R>, initialValue: R): R;
-    <R_1>(collection: WithNullable<string>, iteratee: ReduceStringIterator<R_1>, initialValue: R_1): R_1;
-    <T_1, R_2>(collection: WithNullable<ArrayLike<T_1>>, iteratee: ReduceArrayLikeIterator<T_1, R_2>, initialValue: R_2): R_2;
-    <T_2 extends object, R_3>(collection: WithNullable<T_2>, iteratee: ReduceObjectIterator<T_2, R_3>, initialValue: R_3): R_3;
-    <T_3>(collection: WithNullable<T_3[]>, iteratee?: ReduceArrayIterator<T_3, T_3> | undefined): T_3 | undefined;
-    (collection: WithNullable<string>, iteratee?: ReduceStringIterator<string>): string | undefined;
-    <T_4>(collection: WithNullable<ArrayLike<T_4>>, iteratee?: ReduceArrayLikeIterator<T_4, T_4> | undefined): T_4 | undefined;
-    <T_5 extends object>(collection: WithNullable<T_5>, iteratee?: ReduceObjectIterator<T_5, T_5[keyof T_5]> | undefined): T_5[keyof T_5] | undefined;
-};
+declare function createReduce(dir: 1 | -1): Reduce;
 export default createReduce;

package/types/internals/helpers.d.ts

@@ -9,3 +9,4 @@ export declare const supportedArgumentsType: boolean;
 export declare const FUNC_ERROR_TEXT = "Expected a function";
 export declare function toSource(func: any): string;
 export declare const stubFlase: () => boolean;
+export declare const stubTrue: () => boolean;

package/types/internals/native.d.ts

@@ -49,6 +49,7 @@ export declare const MIN_SAFE_INTEGER: number;
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/length | length}
  */
 export declare const MAX_ARRAY_LENGTH = 4294967295;
+export declare const bigIntTag = "[object BigInt]";
 export declare const numberTag = "[object Number]";
 export declare const booleanTag = "[object Boolean]";
 export declare const stringTag = "[object String]";

package/types/internals/types.d.ts

@@ -1,8 +1,11 @@
+export type FunctionAny = (...args: any[]) => any;
 /**
  * 工具辅助类型
  */
 export type Many<T> = T | T[];
 export type WithNullable<T> = T | null | undefined;
+export type PropertyName = string | number | symbol;
+export type ObjectPredicate<T extends object, K extends keyof T = keyof T> = (value: T[K], key: K) => boolean;
 /**
  * 迭代参数
  */

package/types/invert.d.ts

@@ -0,0 +1,19 @@
+import { ObjectPredicate, PropertyName, WithNullable } from './internals/types';
+/**
+ * 创建一个对象，该对象由 `object` 自身可枚举属性（不包含 `Symbol` 属性）和值反转组成。
+ *
+ * @static
+ * @alias module:Object.invert
+ * @since 1.8.0
+ * @param {Object} object 来源对象。
+ * @param {Function} [predicate] 调用每一个属性的函数，返回 `truthy` 表示要反转，否则不反转。
+ * @returns {Object} 新对象。
+ * @example
+ *
+ * invert({ a: 1, b: 2 }); // { 1: 'a', 2: 'b' }
+ *
+ * invert({ a: undefined, b: null }); // { undefined: 'a', null: 'b' }
+ *
+ */
+declare function invert<T extends object>(object: WithNullable<T>, predicate?: ObjectPredicate<T>): Record<PropertyName, any>;
+export default invert;

package/types/isBigInt.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 检查值是否为 bigint 类型或对象。
+ *
+ * @static
+ * @alias module:Language.isBigInt
+ * @since 1.8.0
+ * @param {*} value 要检查的值。
+ * @returns {boolean} 如果值为 bigint 类型或对象，返回 `true` 否则返回 `false` 。
+ * @example
+ *
+ * isBigInt(0n); // true
+ *
+ * isBigInt(1n); // true
+ *
+ * isBigInt(BigInt(1)); // true
+ *
+ * isBigInt(Object(1n)); // true
+ *
+ * isBigInt(1); // false
+ */
+declare function isBigInt(value: any): value is bigint;
+export default isBigInt;

package/types/isFunction.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 检查值是否为 `Function` 对象 。
  *
@@ -15,5 +16,5 @@
  * isFunction(/x/); // false
  *
  */
-declare function isFunction(value: any): value is (...args: any[]) => any;
+declare function isFunction(value: any): value is FunctionAny;
 export default isFunction;

package/types/keyBy.d.ts

@@ -1,4 +1,30 @@
 import { CollectionList, CollectionObject, IterateeParam } from './internals/types';
-declare function keyBy<T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): Record<string, T>;
-declare function keyBy<T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): Record<string, V>;
+interface KeyBy {
+    <T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): Record<string, T>;
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): Record<string, V>;
+}
+/**
+ * 创建一个组成聚合对象， `key` 是经过 `iteratee` 执行处理 `collection` 中每个元素后返回的结果。每个 `key` 对应的值是生成 `key` 的最后一个元素。
+ *
+ * `iteratee` 调用时会传入 1 个参数 `value` 。
+ *
+ * @function
+ * @alias module:Collection.keyBy
+ * @since 1.0.0
+ * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
+ * @param {Function | string} [iteratee=identity] 迭代函数，用来转换键。
+ * @returns {Object} 组成聚合对象。
+ * @example
+ *
+ * keyBy([6, 4, 6]); // {'6': 6, '4': 4}
+ *
+ * keyBy([6.1, 4.2, 6.3], Math.floor); // {'6': 6.3, '4': 4.2}
+ *
+ * keyBy([{n: 6.1}, {n: 4.2}, {n: 6.3}], item=>Math.floor(item.n)); // {'6': {n: 6.3}, '4': {n: 4.2}}
+ *
+ * // 迭代函数可以直接写入属性。
+ * keyBy(['one', 'two', 'three'], 'length'); // {'3': 'two', '5': 'three'}
+ *
+ */
+declare const keyBy: KeyBy;
 export default keyBy;

package/types/keys.d.ts

@@ -20,5 +20,5 @@
  * keys(new Foo); // ['a']
  *
  */
-declare function keys<T extends object>(object: T): string[];
+declare function keys(object?: any): string[];
 export default keys;

package/types/keysIn.d.ts

@@ -20,5 +20,5 @@
  * keysIn(new Foo); // ['a', 'c']
  *
  */
-declare function keysIn<T extends object>(object: T): string[];
+declare function keysIn(object?: any): string[];
 export default keysIn;

package/types/map.d.ts

@@ -1,6 +1,30 @@
 import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './internals/types';
-declare function map<T>(collection: WithNullable<T[]>, iteratee?: ArrayIterator<T, any>): T[];
-declare function map(collection: WithNullable<string>, iteratee?: StringIterator<any>): string[];
-declare function map<T>(collection: WithNullable<ArrayLike<T>>, iteratee?: ArrayLikeIterator<T, any>): T[];
-declare function map<T extends object>(collection: WithNullable<T>, iteratee?: ObjectIterator<T, any>): Array<T[keyof T]>;
+interface Map {
+    <T>(collection: WithNullable<T[]>, iteratee?: ArrayIterator<T, any>): T[];
+    (collection: WithNullable<string>, iteratee?: StringIterator<any>): string[];
+    <T>(collection: WithNullable<ArrayLike<T>>, iteratee?: ArrayLikeIterator<T, any>): T[];
+    <T extends object>(collection: WithNullable<T>, iteratee?: ObjectIterator<T, any>): Array<T[keyof T]>;
+}
+/**
+ * 创建一个新数组，这个数组的值由迭代集合每个元素调用 `iteratee` 函数的返回值组成。
+ *
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @static
+ * @alias module:Collection.map
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {function} [iteratee=identity] 每次迭代调用的函数。
+ * @returns {Array} 一个新数组。
+ * @example
+ *
+ * const arr = [1, 2, 3];
+ * map(arr, item => item * 3); // [3, 6, 9]
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * map(obj, item => item * 3); // [3, 6, 9]
+ *
+ * map([[1, 2], [3, 4]], item=>item[0]); // [1, 3]
+ */
+declare const map: Map;
 export default map;

package/types/negate.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个断言函数结果取反的函数。
  *
@@ -19,5 +20,5 @@
  * nums.filter(ne); // [1, 3, 5]
  *
  */
-declare function negate<T extends (...args: any[]) => any>(this: any, predicate: T): (...args: Parameters<T>) => boolean;
+declare function negate<T extends FunctionAny>(this: any, predicate: T): (...args: Parameters<T>) => boolean;
 export default negate;

package/types/omit.d.ts

@@ -1,3 +1,8 @@
+import { PropertyName, WithNullable } from './internals/types';
+interface OmitFunction {
+    <T extends object, K extends keyof T>(object: WithNullable<T>, fields?: K | K[]): Omit<T, K>;
+    <T extends object, K extends PropertyName>(object: WithNullable<T>, fields?: K | K[]): Omit<T, K>;
+}
 /**
  * 创建一个对象，该对象由忽略属性之外的 `object` 自身和继承的可枚举属性组成。与 [`pick`](#.pick) 相反。
  *
@@ -21,5 +26,5 @@
  * omit(obj, ['name', 'age']); // {}
  *
  */
-declare function omit<T extends object, K extends keyof T>(object: T, fields?: K | K[]): Omit<T, K>;
+declare const omit: OmitFunction;
 export default omit;

package/types/omitBy.d.ts

@@ -1,3 +1,4 @@
+import { ObjectPredicate, WithNullable } from './internals/types';
 /**
  * 创建一个对象，该对象忽略 `predicate` （断言函数）判断不是真值的属性后，`object` 自身和继承的可枚举属性组成。与 [`pickBy`](#.pickBy) 相反。
  *
@@ -7,7 +8,7 @@
  * @alias module:Object.omitBy
  * @since 1.0.0
  * @param {Object} object 来源对象。
- * @param {Function} [predicate] 调用每一个属性的函数。
+ * @param {Function} [predicate] 调用每一个属性的函数，返回 `truthy` 表示要忽略该属性，否则不忽略。
  * @returns {Object} 新对象。
  * @example
  *
@@ -20,5 +21,5 @@
  * omitBy(obj, (value) => value); // {}
  *
  */
-declare function omitBy<T extends object>(object: T, predicate?: (value: any, key: any) => any): Partial<T>;
+declare function omitBy<T extends object>(object: WithNullable<T>, predicate?: ObjectPredicate<T>): Partial<T>;
 export default omitBy;

package/types/once.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个只能调用 `func` 一次的函数。重复调用将返回第一次调用 `func` 的结果。
  *
@@ -20,5 +21,5 @@
  * increment(); // 1
  *
  */
-declare function once<T extends (...args: any[]) => any>(func: T): T;
+declare function once<T extends FunctionAny>(func: T): T;
 export default once;

package/types/orderBy.d.ts

@@ -1,5 +1,46 @@
 import { Order } from './internals/compare';
 import { CollectionList, CollectionObject, IterateeParam, Many } from './internals/types';
-declare function orderBy<T>(collection: CollectionList<T>, iteratee?: Many<IterateeParam<T>>, orders?: Many<Order>): T[];
-declare function orderBy<T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: Many<IterateeParam<V>>, orders?: Many<Order>): V[];
+interface OrderBy {
+    <T>(collection: CollectionList<T>, iteratee?: Many<IterateeParam<T>>, orders?: Many<Order>): T[];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: Many<IterateeParam<V>>, orders?: Many<Order>): V[];
+}
+/**
+ * 创建一个元素数组，以迭代函数处理的结果排序。如果没有指定排序，默认为升序排序。
+ *
+ * `asc` 升序， `desc` 降序，默认执行稳定排序，也就是说相同元素会保持原始排序。
+ *
+ * `iteratee` 调用时会传入 1 个参数 `value` 。
+ *
+ * @function
+ * @alias module:Collection.orderBy
+ * @since 1.0.0
+ * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/sort | sort}
+ * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
+ * @param {Function | string | Array} [iteratees] 排序的迭代函数。
+ * @param {'asc' | 'desc' | Array} [orders] 迭代函数的排序顺序。
+ * @returns {Array} 排序后的新数组。
+ * @example
+ *
+ * const array = [2, 1, 3, 5, 4];
+ *
+ * orderBy(array);; // [1, 2, 3, 4, 5]
+ *
+ * orderBy(array, item=>item, 'desc');; // [5, 4, 3, 2, 1]
+ *
+ * const objects = [
+ *   { a: 'x', b: 3 },
+ *   { a: 'y', b: 4 },
+ *   { a: 'x', b: 1 },
+ *   { a: 'y', b: 2 }
+ * ];
+ *
+ * orderBy(objects, 'b');
+ * // [{ a: 'x', b: 1 },{ a: 'y', b: 2 },{ a: 'x', b: 3 },{ a: 'y', b: 4 }]
+ *
+ * // 迭代函数可以直接写入属性。
+ * orderBy(objects, ['a', 'b'], ['asc', 'desc']);
+ * // [{ a: 'x', b: 3 },{ a: 'x', b: 1 },{ a: 'y', b: 4 },{ a: 'y', b: 2 }]
+ *
+ */
+declare const orderBy: OrderBy;
 export default orderBy;

package/types/partial.d.ts

@@ -1,12 +1,64 @@
-declare function partial<TS extends any[], R>(func: (...ts: TS) => R): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, R>(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, R>(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, T7, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, T7, T8, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, T7, T8, T9, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9): (...ts: TS) => R;
-declare function partial<TS extends any[], T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10): (...ts: TS) => R;
+declare const PLACEHOLDER: {
+    __ut2_partial_ph__: null;
+};
+type Placeholder = typeof PLACEHOLDER;
+type Function0<R> = () => R;
+type Function1<T1, R> = (t1: T1) => R;
+type Function2<T1, T2, R> = (t1: T1, t2: T2) => R;
+type Function3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;
+type Function4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;
+interface Partial {
+    <T1, T2, R>(func: Function2<T1, T2, R>, plc1: Placeholder, arg2: T2): Function1<T1, R>;
+    <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2): Function0<R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: Placeholder, arg2: T2): Function2<T1, T3, R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: Placeholder, plc2: Placeholder, arg3: T3): Function2<T1, T2, R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: Placeholder, arg3: T3): Function1<T2, R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, plc1: Placeholder, arg2: T2, arg3: T3): Function1<T1, R>;
+    <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): Function0<R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, arg2: T2): Function3<T1, T3, T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, plc2: Placeholder, arg3: T3): Function3<T1, T2, T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: Placeholder, arg3: T3): Function2<T2, T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, arg2: T2, arg3: T3): Function2<T1, T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3): Function1<T4, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, plc2: Placeholder, plc3: Placeholder, arg4: T4): Function3<T1, T2, T3, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: Placeholder, plc3: Placeholder, arg4: T4): Function2<T2, T3, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, arg2: T2, plc3: Placeholder, arg4: T4): Function2<T1, T3, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: Placeholder, arg4: T4): Function1<T3, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, plc2: Placeholder, arg3: T3, arg4: T4): Function2<T1, T2, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: Placeholder, arg3: T3, arg4: T4): Function1<T2, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, plc1: Placeholder, arg2: T2, arg3: T3, arg4: T4): Function1<T1, R>;
+    <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): Function0<R>;
+    <TS extends any[], R>(func: (...ts: TS) => R): (...ts: TS) => R;
+    <TS extends any[], T1, R>(func: (t1: T1, ...ts: TS) => R, arg1: T1): (...ts: TS) => R;
+    <TS extends any[], T1, T2, R>(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: T1, t2: T2): (...ts: TS) => R;
+    <TS extends any[], T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: T1, t2: T2, t3: T3): (...ts: TS) => R;
+    <TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: T1, t2: T2, t3: T3, t4: T4): (...ts: TS) => R;
+    placeholder: Placeholder;
+    _: Placeholder;
+}
+/**
+ * 创建一个函数。该函数调用 `func` ，并传入预设的 `args` 参数。
+ *
+ *  `partial._` 或 `partial.placeholder` 可用作参数的占位符。
+ *
+ * @function
+ * @alias module:Function.partial
+ * @since 1.0.0
+ * @param {Function} func 需要预设的函数。
+ * @param {...*} [args] 预设的参数。
+ * @returns {Function} 预设参数的函数。
+ * @example
+ *
+ * function greet(greeting, name){
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * const sayHelloTo = partial(greet, 'hello');
+ * sayHelloTo('jeff'); // 'hello jeff'
+ *
+ * const greetJeff = partial(greet, partial._, 'jeff');
+ * greetJeff('hi'); // 'hi jeff'
+ *
+ */
+declare const partial: Partial;
 export default partial;

package/types/partition.d.ts

@@ -1,4 +1,40 @@
 import { CollectionList, CollectionObject, IterateeParam } from './internals/types';
-declare function partition<T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): [T[], T[]];
-declare function partition<T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): [V[], V[]];
+interface Partition {
+    <T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): [T[], T[]];
+    <T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): [V[], V[]];
+}
+/**
+ * 创建一个分成两组的元素数组，第一组包含 `predicate`（断言函数）返回为 [`truthy`](https://developer.mozilla.org/zh-CN/docs/Glossary/Truthy)（真值）的元素，第二组包含 `predicate`（断言函数）返回为 [`falsy`](https://developer.mozilla.org/zh-CN/docs/Glossary/Falsy)（假值）的元素。
+ *
+ * `predicate` 调用时会传入 1 个参数 `value`。
+ *
+ * @static
+ * @alias module:Collection.partition
+ * @since 1.0.0
+ * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
+ * @param {Function | string} [predicate=identity] 每次迭代调用的断言函数。
+ * @returns {Array} 分组后的数组。
+ * @example
+ *
+ * const users = [
+ *   { user: 'barney', age: 36, active: false },
+ *   { user: 'fred', age: 40, active: true },
+ *   { user: 'pebbles', age: 1, active: false }
+ * ];
+ *
+ * partition(users, item => item.active);
+ * // [
+ * //   [{ user: 'fred', age: 40, active: true }],
+ * //   [{ user: 'barney', age: 36, active: false }, { user: 'pebbles', age: 1, active: false }]
+ * // ]
+ *
+ * // 迭代函数可以直接写入属性。
+ * partition(users, 'active');
+ * // [
+ * //   [{ user: 'fred', age: 40, active: true }],
+ * //   [{ user: 'barney', age: 36, active: false }, { user: 'pebbles', age: 1, active: false }]
+ * // ]
+ *
+ */
+declare const partition: Partition;
 export default partition;

package/types/pascalCase.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 转换字符串为帕斯卡写法。又名为大驼峰写法。
+ *
+ * @static
+ * @alias module:String.pascalCase
+ * @since 1.8.0
+ * @see {@link https://en.wikipedia.org/wiki/Camel_case | Camel_case}
+ * @param {string} string 要转换的字符串。
+ * @param {RegExp | string} [pattern] 拆分词组的匹配模式。
+ * @returns {string} 帕斯卡写法的字符串。
+ * @example
+ *
+ * pascalCase('foo bar'); // 'FooBar'
+ *
+ * pascalCase('foo-bar'); // 'FooBar'
+ *
+ * pascalCase('Foo Bar'); // 'FooBar'
+ *
+ * pascalCase('FOO BAR'); // 'FooBar'
+ *
+ * pascalCase('--FOO-BAR--'); // 'FooBar'
+ *
+ * pascalCase('__FOO_BAR__'); // 'FooBar'
+ *
+ */
+declare function pascalCase(string: string, pattern?: RegExp | string): string;
+export default pascalCase;

package/types/pick.d.ts

@@ -1,3 +1,8 @@
+import { PropertyName, WithNullable } from './internals/types';
+interface PickFunction {
+    <T extends object, K extends keyof T>(object: WithNullable<T>, fields?: K | K[]): Pick<T, K>;
+    <T extends object, K extends PropertyName>(object: WithNullable<T>, fields?: K | K[]): Record<PropertyName, any>;
+}
 /**
  * 创建一个从 `object` 选中的属性的对象。
  *
@@ -21,5 +26,5 @@
  * // 选取多个属性
  * pick(obj, ['name', 'age']); // { name: "jeff", age: 18 }
  */
-declare function pick<T extends object, K extends keyof T>(object: T, fields?: K | K[]): Pick<T, K>;
+declare const pick: PickFunction;
 export default pick;

package/types/pickBy.d.ts

@@ -1,3 +1,4 @@
+import { ObjectPredicate, WithNullable } from './internals/types';
 /**
  * 创建一个对象，该对象的属性从 `object` 中经 `predicate` （断言函数）判断为真值的属性。
  *
@@ -7,7 +8,7 @@
  * @alias module:Object.pickBy
  * @since 1.0.0
  * @param {Object} obj 来源对象。
- * @param {Function} [predicate] 调用每一个属性的函数。
+ * @param {Function} [predicate] 调用每一个属性的函数，返回 `truthy` 表示要提取该属性，否则不提取。
  * @returns {Object} 新对象。
  * @example
  *
@@ -20,5 +21,5 @@
  * pickBy(obj, (value) => value); // { name: "jeff", age: 18 }
  *
  */
-declare function pickBy<T extends object>(object: T, predicate?: (value: any, key: any) => any): Partial<T>;
+declare function pickBy<T extends object>(object: WithNullable<T>, predicate?: ObjectPredicate<T>): Partial<T>;
 export default pickBy;

package/types/range.d.ts

@@ -1,4 +1,29 @@
-declare function range(start: number, end: number, step: number): number[];
-declare function range(start: number, end: number): number[];
-declare function range(end: number): number[];
+interface Range {
+    (start: number, end: number, step: number): number[];
+    (start: number, end: number): number[];
+    (end: number): number[];
+}
+/**
+ * 创建一个升序或降序的数字数组。
+ *
+ * 如果省略 `start` 默认为 0 。
+ *
+ * @function
+ * @alias module:Util.range
+ * @since 1.6.0
+ * @param {number} [start=0] 开始值。
+ * @param {number} end 结束值。
+ * @param {number} [step] 要增加或减少的值。如果值为 `0` ，将视为无效参数。如果 `start` 在 `end` 之前，默认为 1 ，否则默认为 -1。
+ * @return {number[]} 从开始值（包含）到结束值（不包含）逐步递增或递减的数字数组。
+ * @example
+ *
+ * range(4); // [0, 1, 2, 3]
+ * range(-4); // [0, -1, -2, -3]
+ * range(1, 5); // [1, 2, 3, 4]
+ * range(0, 20, 5); // [0, 5, 10, 15]
+ * range(0, -4, -1); // [1, 2, 3]
+ * range(1, 4, 0); // [1, 2, 3]
+ * range(0); // []
+ */
+declare const range: Range;
 export default range;

package/types/reduce.d.ts

@@ -25,14 +25,5 @@
  * // 6
  *
  */
-declare const reduce: {
-    <T, R>(collection: import("./internals/types").WithNullable<T[]>, iteratee: import("./internals/types").ReduceArrayIterator<T, R>, initialValue: R): R;
-    <R_1>(collection: import("./internals/types").WithNullable<string>, iteratee: import("./internals/types").ReduceStringIterator<R_1>, initialValue: R_1): R_1;
-    <T_1, R_2>(collection: import("./internals/types").WithNullable<ArrayLike<T_1>>, iteratee: import("./internals/types").ReduceArrayLikeIterator<T_1, R_2>, initialValue: R_2): R_2;
-    <T_2 extends object, R_3>(collection: import("./internals/types").WithNullable<T_2>, iteratee: import("./internals/types").ReduceObjectIterator<T_2, R_3>, initialValue: R_3): R_3;
-    <T_3>(collection: import("./internals/types").WithNullable<T_3[]>, iteratee?: import("./internals/types").ReduceArrayIterator<T_3, T_3> | undefined): T_3 | undefined;
-    (collection: import("./internals/types").WithNullable<string>, iteratee?: import("./internals/types").ReduceStringIterator<string> | undefined): string | undefined;
-    <T_4>(collection: import("./internals/types").WithNullable<ArrayLike<T_4>>, iteratee?: import("./internals/types").ReduceArrayLikeIterator<T_4, T_4> | undefined): T_4 | undefined;
-    <T_5 extends object>(collection: import("./internals/types").WithNullable<T_5>, iteratee?: import("./internals/types").ReduceObjectIterator<T_5, T_5[keyof T_5]> | undefined): T_5[keyof T_5] | undefined;
-};
+declare const reduce: import("./internals/createReduce").Reduce;
 export default reduce;

package/types/reduceRight.d.ts

@@ -25,14 +25,5 @@
  * // 6
  *
  */
-declare const reduceRight: {
-    <T, R>(collection: import("./internals/types").WithNullable<T[]>, iteratee: import("./internals/types").ReduceArrayIterator<T, R>, initialValue: R): R;
-    <R_1>(collection: import("./internals/types").WithNullable<string>, iteratee: import("./internals/types").ReduceStringIterator<R_1>, initialValue: R_1): R_1;
-    <T_1, R_2>(collection: import("./internals/types").WithNullable<ArrayLike<T_1>>, iteratee: import("./internals/types").ReduceArrayLikeIterator<T_1, R_2>, initialValue: R_2): R_2;
-    <T_2 extends object, R_3>(collection: import("./internals/types").WithNullable<T_2>, iteratee: import("./internals/types").ReduceObjectIterator<T_2, R_3>, initialValue: R_3): R_3;
-    <T_3>(collection: import("./internals/types").WithNullable<T_3[]>, iteratee?: import("./internals/types").ReduceArrayIterator<T_3, T_3> | undefined): T_3 | undefined;
-    (collection: import("./internals/types").WithNullable<string>, iteratee?: import("./internals/types").ReduceStringIterator<string> | undefined): string | undefined;
-    <T_4>(collection: import("./internals/types").WithNullable<ArrayLike<T_4>>, iteratee?: import("./internals/types").ReduceArrayLikeIterator<T_4, T_4> | undefined): T_4 | undefined;
-    <T_5 extends object>(collection: import("./internals/types").WithNullable<T_5>, iteratee?: import("./internals/types").ReduceObjectIterator<T_5, T_5[keyof T_5]> | undefined): T_5[keyof T_5] | undefined;
-};
+declare const reduceRight: import("./internals/createReduce").Reduce;
 export default reduceRight;

package/types/some.d.ts

@@ -1,6 +1,28 @@
 import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './internals/types';
-declare function some<T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): boolean;
-declare function some(collection: WithNullable<string>, predicate?: StringIterator<any>): boolean;
-declare function some<T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): boolean;
-declare function some<T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): boolean;
+interface Some {
+    <T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): boolean;
+    (collection: WithNullable<string>, predicate?: StringIterator<any>): boolean;
+    <T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): boolean;
+    <T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): boolean;
+}
+/**
+ * 迭代集合中的元素执行 `predicate` 函数，如果任一元素通过 `predicate` 返回真值，则停止迭代并返回 `true` ，否则返回 `false` 。
+ *
+ * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @function
+ * @alias module:Collection.some
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {function} [predicate=identity] 每次迭代调用的函数。
+ * @returns {boolean} 如果任一元素通过 `predicate` 测试，则返回 `true` ，否则返回 `false` 。
+ * @example
+ *
+ * const arr = [1, 2, 3, 4, 5, 6];
+ * some(arr, item => item % 2 === 0); // false
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * some(obj, item => item > 1); // true
+ */
+declare const some: Some;
 export default some;