ut2 1.7.1 → 1.7.2

package/lib/internals/helpers.js

@@ -3,7 +3,7 @@
 var getTag = require('./getTag.js');
 var native = require('./native.js');
 
-exports.VERSION = "1.7.1";
+exports.VERSION = "1.7.2";
 exports.supportedArgumentsType = getTag((function () { return arguments; })()) === native.argumentsTag;
 exports.FUNC_ERROR_TEXT = 'Expected a function';
 function toSource(func) {

package/lib/keyBy.js

@@ -4,7 +4,7 @@ var forEach = require('./forEach.js');
 var identity = require('./identity.js');
 var createIteratee = require('./internals/createIteratee.js');
 
-function keyBy(collection, iteratee) {
+var keyBy = function (collection, iteratee) {
     if (iteratee === void 0) { iteratee = identity; }
     var result = {};
     var internalIteratee = createIteratee(iteratee);
@@ -13,6 +13,7 @@ function keyBy(collection, iteratee) {
         result[key] = item;
     });
     return result;
-}
+};
+var keyBy$1 = keyBy;
 
-module.exports = keyBy;
+module.exports = keyBy$1;

package/lib/map.js

@@ -3,13 +3,14 @@
 var forEach = require('./forEach.js');
 var identity = require('./identity.js');
 
-function map(collection, iteratee) {
+var map = function (collection, iteratee) {
     if (iteratee === void 0) { iteratee = identity; }
     var result = [];
     forEach(collection, function (item, index, arr) {
         result.push(iteratee(item, index, arr));
     });
     return result;
-}
+};
+var map$1 = map;
 
-module.exports = map;
+module.exports = map$1;

package/lib/orderBy.js

@@ -6,7 +6,7 @@ var compare = require('./internals/compare.js');
 var isArray = require('./isArray.js');
 var forEach = require('./forEach.js');
 
-function orderBy(collection, iteratees, orders) {
+var orderBy = function (collection, iteratees, orders) {
     var result = [];
     iteratees = (isArray(iteratees) ? iteratees : iteratees !== undefined ? [iteratees] : [identity]);
     orders = (isArray(orders) ? orders : orders !== undefined ? [orders] : []);
@@ -20,6 +20,7 @@ function orderBy(collection, iteratees, orders) {
         });
     });
     return result.sort(function (a, b) { return compare.compareMultiple(a, b, orders); }).map(function (item) { return item.value; });
-}
+};
+var orderBy$1 = orderBy;
 
-module.exports = orderBy;
+module.exports = orderBy$1;

package/lib/partial.js

@@ -1,17 +1,22 @@
 'use strict';
 
-function partial(func) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
+var native = require('./internals/native.js');
+
+var PLACEHOLDER = {
+    __ut2_partial__: 1
+};
+var partial = function (func) {
+    var argsOrig = native.arrayProtoSlice.call(arguments, 1);
     return function () {
-        var remainingArgs = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            remainingArgs[_i] = arguments[_i];
+        var args = [];
+        var argsPartial = native.arrayProtoSlice.call(arguments);
+        for (var i = 0; i < argsOrig.length; i++) {
+            args[i] = argsOrig[i] === PLACEHOLDER ? argsPartial.shift() : argsOrig[i];
         }
-        return func.apply(this, args.concat(remainingArgs));
+        return func.apply(this, args.concat(argsPartial));
     };
-}
+};
+partial.placeholder = partial._ = PLACEHOLDER;
+var partial$1 = partial;
 
-module.exports = partial;
+module.exports = partial$1;

package/lib/partition.js

@@ -4,7 +4,7 @@ var forEach = require('./forEach.js');
 var identity = require('./identity.js');
 var createIteratee = require('./internals/createIteratee.js');
 
-function partition(collection, predicate) {
+var partition = function (collection, predicate) {
     if (predicate === void 0) { predicate = identity; }
     var result = [[], []];
     var internalIteratee = createIteratee(predicate);
@@ -12,6 +12,7 @@ function partition(collection, predicate) {
         result[internalIteratee(item) ? 0 : 1].push(item);
     });
     return result;
-}
+};
+var partition$1 = partition;
 
-module.exports = partition;
+module.exports = partition$1;

package/lib/range.js

@@ -4,7 +4,7 @@ var native = require('./internals/native.js');
 var isNil = require('./isNil.js');
 var toFinite = require('./toFinite.js');
 
-function range(start, end, step) {
+var range = function (start, end, step) {
     start = toFinite(start);
     if (isNil(end)) {
         end = start;
@@ -25,6 +25,7 @@ function range(start, end, step) {
         start += step;
     }
     return result;
-}
+};
+var range$1 = range;
 
-module.exports = range;
+module.exports = range$1;

package/lib/some.js

@@ -3,7 +3,7 @@
 var forEach = require('./forEach.js');
 var identity = require('./identity.js');
 
-function some(collection, predicate) {
+var some = function (collection, predicate) {
     if (predicate === void 0) { predicate = identity; }
     var result = false;
     forEach(collection, function (item, index, arr) {
@@ -13,6 +13,7 @@ function some(collection, predicate) {
         }
     });
     return result;
-}
+};
+var some$1 = some;
 
-module.exports = some;
+module.exports = some$1;

package/lib/times.js

@@ -5,7 +5,7 @@ var native = require('./internals/native.js');
 var isInteger = require('./isInteger.js');
 var isFinite = require('./isFinite.js');
 
-function times(n, iteratee) {
+var times = function (n, iteratee) {
     if (iteratee === void 0) { iteratee = identity; }
     if (n < 1 || n > native.MAX_SAFE_INTEGER) {
         return [];
@@ -19,6 +19,7 @@ function times(n, iteratee) {
         index++;
     }
     return result;
-}
+};
+var times$1 = times;
 
-module.exports = times;
+module.exports = times$1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ut2",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "author": "caijf",
   "license": "MIT",
   "main": "lib/index.js",
@@ -26,7 +26,7 @@
     "commit": "cz",
     "prepublishOnly": "npm test && npm run build",
     "tsc": "tsc --noEmit",
-    "prepare": "husky install"
+    "prepare": "husky"
   },
   "repository": {
     "type": "git",
@@ -54,41 +54,43 @@
   },
   "config": {
     "commitizen": {
-      "path": "./node_modules/cz-conventional-changelog"
+      "path": "@commitlint/cz-commitlint"
     }
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@commitlint/cli": "^17.7.1",
-    "@commitlint/config-conventional": "^17.7.0",
-    "@rollup/plugin-commonjs": "^25.0.4",
-    "@rollup/plugin-node-resolve": "^15.2.1",
-    "@rollup/plugin-replace": "^5.0.2",
-    "@rollup/plugin-terser": "^0.4.3",
-    "@rollup/plugin-typescript": "^11.1.3",
-    "@types/jest": "^29.5.4",
-    "@types/node": "^20.6.2",
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "@typescript-eslint/parser": "^5.62.0",
+    "@commitlint/cli": "^19.2.1",
+    "@commitlint/config-conventional": "^19.1.0",
+    "@commitlint/cz-commitlint": "^19.2.0",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-replace": "^5.0.5",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.30",
+    "@typescript-eslint/eslint-plugin": "^7.3.1",
+    "@typescript-eslint/parser": "^7.3.1",
     "benchmark": "^2.1.4",
+    "commitizen": "^4.3.0",
     "cross-env": "^7.0.3",
-    "cz-conventional-changelog": "^3.3.0",
     "dayjs": "^1.11.10",
     "docdash": "^2.0.2",
-    "eslint": "^8.48.0",
-    "husky": "^8.0.0",
-    "jest": "^29.6.4",
-    "jest-environment-jsdom": "^29.6.4",
+    "eslint": "^8.57.0",
+    "husky": "^9.0.11",
+    "inquirer": "9",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
     "jsdoc": "^4.0.2",
-    "lint-staged": "^13.3.0",
+    "lint-staged": "^15.2.2",
     "lodash": "^4.17.21",
-    "prettier": "^2.8.8",
-    "rollup": "^3.28.1",
-    "ts-jest": "^29.1.1",
+    "prettier": "^3.2.5",
+    "rollup": "^4.13.0",
+    "ts-jest": "^29.1.2",
     "tslib": "^2.6.2",
-    "typescript": "^5.2.2",
+    "typescript": "^5.4.3",
     "underscore": "^1.13.6"
   },
   "engines": {

package/types/after.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个函数，当它被调用 `n` 或更多次之后触发 `func` 。
  *
@@ -21,5 +22,5 @@
  * // 'done saving!'
  *
  */
-declare function after<T extends (...args: any[]) => any>(n: number, func: T): T;
+declare function after<T extends FunctionAny>(n: number, func: T): T;
 export default after;

package/types/before.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个调用 `func` 的函数，调用次数少于 `n` 次。之后再调用这个函数，将返回最后一次调用 `func` 的结果。
  *
@@ -20,5 +21,5 @@
  * increment(); // 2 返回之前的结果
  *
  */
-declare function before<T extends (...args: any[]) => any>(n: number, func: T): T;
+declare function before<T extends FunctionAny>(n: number, func: T): T;
 export default before;

package/types/clamp.d.ts

@@ -1,3 +1,30 @@
-declare function clamp(number: number, upper: number): number;
-declare function clamp(number: number, lower: number, upper: number): number;
+interface Clamp {
+    (number: number, upper: number): number;
+    (number: number, lower: number, upper: number): number;
+}
+/**
+ * 数字限制在 `lower` 和 `upper` 之间的值。
+ *
+ * @function
+ * @alias module:Number.clamp
+ * @since 1.0.0
+ * @param {number} number 被限制的值。
+ * @param {number} [lower] 下限。
+ * @param {number} upper 上限。
+ * @returns {number} 被限制的值。
+ * @example
+ *
+ * clamp(-10, -5, 5); // -5
+ *
+ * clamp(-10, 0, 5); // 0
+ *
+ * clamp(10, -5, 5); // 5
+ *
+ * // 仅限制上限
+ * clamp(10, 5); // 5
+ *
+ * clamp(-10, 5); // -10
+ *
+ */
+declare const clamp: Clamp;
 export default clamp;

package/types/conformsTo.d.ts

@@ -1,4 +1,25 @@
 import { WithNullable } from './internals/types';
-declare function conformsTo<T extends object, K extends keyof T>(object: T, source: Record<K, (value: T[K]) => any>): boolean;
-declare function conformsTo<T extends WithNullable<object>>(object: T, source: Record<string | symbol, (value: any) => any>): boolean;
+interface ConformsTo {
+    <T extends object, K extends keyof T>(object: T, source: Record<K, (value: T[K]) => any>): boolean;
+    <T extends WithNullable<object>>(object: T, source: Record<string | symbol, (value: any) => any>): boolean;
+}
+/**
+ * 通过调用断言 `source` 的属性与 `object` 的相应属性值，检查 `object` 是否符合 `source` 。
+ *
+ * @function
+ * @alias module:Util.conformsTo
+ * @since 1.0.0
+ * @param {Object} object 要检查的对象。
+ * @param {Object} source 要断言属性是否符合的对象。
+ * @returns {boolean} 如果 `object` 符合，返回 `true` ，否则返回 `false` 。
+ * @example
+ *
+ * const object = { a: 1, b: 2 }
+ *
+ * conformsTo(object, { b: value => value > 1 }); // true
+ *
+ * conformsTo(object, { b: value => value > 2 }); // false
+ *
+ */
+declare const conformsTo: ConformsTo;
 export default conformsTo;

package/types/countBy.d.ts

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

package/types/debounce.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 创建一个防抖动函数，该函数会从上一次被调用后，延迟 `wait` 毫秒数后调用 `func` 方法。
  *
@@ -33,7 +34,7 @@
  * window.addEventListener('popstate', debounced.cancel);
  *
  */
-declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, immediate?: boolean): {
+declare function debounce<T extends FunctionAny>(func: T, wait?: number, immediate?: boolean): {
     (this: any, ...args: Parameters<T>): ReturnType<T>;
     cancel: () => void;
     flush: () => ReturnType<T>;

package/types/defaultTo.d.ts

@@ -1,7 +1,11 @@
+interface DefaultTo {
+    <T>(value: T | null | undefined, defaultValue: T): T;
+    <T, D>(value: T | null | undefined, defaultValue: D): T | D;
+}
 /**
  * 检查值以确定是否应在其位置返回默认值。如果值为 `NaN` `null` 或 `undefined` ，返回 `defaultValue` 。
  *
- * @static
+ * @function
  * @alias module:Util.defaultTo
  * @since 1.0.0
  * @param {*} value 要检查的值。
@@ -16,6 +20,5 @@
  * defaultTo(null, undefined); // undefined
  *
  */
-declare function defaultTo<T>(value: T | null | undefined, defaultValue: T): T;
-declare function defaultTo<T, D>(value: T | null | undefined, defaultValue: D): T | D;
+declare const defaultTo: DefaultTo;
 export default defaultTo;

package/types/delay.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { FunctionAny } from './internals/types';
 /**
  * 延迟 `wait` 毫秒后调用 `func` 。
  *
@@ -19,5 +20,5 @@
  * // 'hello world'
  *
  */
-declare function delay<T extends (...args: any[]) => any>(func: T, wait: number, ...args: Parameters<T>): NodeJS.Timeout;
+declare function delay<T extends FunctionAny>(func: T, wait: number, ...args: Parameters<T>): NodeJS.Timeout;
 export default delay;

package/types/every.d.ts

@@ -1,6 +1,30 @@
 import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './internals/types';
-declare function every<T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): boolean;
-declare function every(collection: WithNullable<string>, predicate?: StringIterator<any>): boolean;
-declare function every<T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): boolean;
-declare function every<T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): boolean;
+interface Every {
+    <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.every
+ * @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];
+ * every(arr, item => item % 2 === 0); // false
+ * every(arr); // true
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * every(obj, item => item > 1); // false
+ * every(obj, item => item > 0); // true
+ */
+declare const every: Every;
 export default every;

package/types/filter.d.ts

@@ -1,6 +1,28 @@
 import { ArrayIterator, ArrayLikeIterator, ObjectIterator, StringIterator, WithNullable } from './internals/types';
-declare function filter<T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): T[];
-declare function filter(collection: WithNullable<string>, predicate?: StringIterator<any>): string[];
-declare function filter<T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): T[];
-declare function filter<T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): Array<T[keyof T]>;
+interface Filter {
+    <T>(collection: WithNullable<T[]>, predicate?: ArrayIterator<T, any>): T[];
+    (collection: WithNullable<string>, predicate?: StringIterator<any>): string[];
+    <T>(collection: WithNullable<ArrayLike<T>>, predicate?: ArrayLikeIterator<T, any>): T[];
+    <T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): Array<T[keyof T]>;
+}
+/**
+ * 过滤集合元素，为每个元素执行 `predicate` 函数，返回真值的元素将保留在结果数组中（不改变原值）。
+ *
+ * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ *
+ * @static
+ * @alias module:Collection.filter
+ * @since 1.7.0
+ * @param {ArrayLike<any> | Object} collection 要迭代的集合。
+ * @param {function} [predicate=identity] 每次迭代调用的函数。
+ * @returns {Array} 返回新的过滤数组。
+ * @example
+ *
+ * const arr = [1, 2, 3, 4, 5, 6];
+ * filter(arr, item => item % 2 === 0); // [2, 4, 6]
+ *
+ * const obj = { one: 1, two: 2, three: 3 };
+ * filter(obj, item => item > 1); // [2, 3]
+ */
+declare const filter: Filter;
 export default filter;

package/types/find.d.ts

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

package/types/forEach.d.ts

@@ -27,10 +27,5 @@
  * // 2 'b'
  *
  */
-declare const forEach: {
-    <T>(collection: import("./internals/types").WithNullable<T[]>, iteratee?: import("./internals/types").ArrayIterator<T, any> | undefined): T[];
-    (collection: import("./internals/types").WithNullable<string>, iteratee?: import("./internals/types").StringIterator<any> | undefined): string;
-    <T_1>(collection: import("./internals/types").WithNullable<ArrayLike<T_1>>, iteratee?: import("./internals/types").ArrayLikeIterator<T_1, any> | undefined): ArrayLike<T_1>;
-    <T_2 extends object>(collection: import("./internals/types").WithNullable<T_2>, iteratee?: import("./internals/types").ObjectIterator<T_2, any> | undefined): T_2;
-};
+declare const forEach: import("./internals/createForEach").ForEach;
 export default forEach;

package/types/forEachRight.d.ts

@@ -27,10 +27,5 @@
  * // 1 'a'
  *
  */
-declare const forEachRight: {
-    <T>(collection: import("./internals/types").WithNullable<T[]>, iteratee?: import("./internals/types").ArrayIterator<T, any> | undefined): T[];
-    (collection: import("./internals/types").WithNullable<string>, iteratee?: import("./internals/types").StringIterator<any> | undefined): string;
-    <T_1>(collection: import("./internals/types").WithNullable<ArrayLike<T_1>>, iteratee?: import("./internals/types").ArrayLikeIterator<T_1, any> | undefined): ArrayLike<T_1>;
-    <T_2 extends object>(collection: import("./internals/types").WithNullable<T_2>, iteratee?: import("./internals/types").ObjectIterator<T_2, any> | undefined): T_2;
-};
+declare const forEachRight: import("./internals/createForEach").ForEach;
 export default forEachRight;

package/types/fromPairs.d.ts

@@ -1,3 +1,21 @@
-declare function fromPairs<P extends string | number | symbol, V = any>(array: [P, V][]): Record<P, V>;
-declare function fromPairs<P extends string | number | symbol>(array: any[][]): Record<P, any>;
+interface FromPairs {
+    <P extends string | number | symbol, V = any>(array: [P, V][]): Record<P, V>;
+    <P extends string | number | symbol>(array: any[][]): Record<P, any>;
+}
+/**
+ * 将键值对数组转为对象。
+ *
+ * 与 [Object.entries](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/entries) 正好相反。
+ *
+ * @static
+ * @alias module:Array.fromPairs
+ * @since 1.0.0
+ * @param {Array} array 键值对数组。
+ * @returns {Object} 新对象。
+ * @example
+ *
+ * fromPairs([['foo', 'bar'], ['baz', 42]]); // {foo: 'bar', baz: 42}
+ *
+ */
+declare const fromPairs: FromPairs;
 export default fromPairs;

package/types/groupBy.d.ts

@@ -1,4 +1,30 @@
 import { CollectionList, CollectionObject, IterateeParam } from './internals/types';
-declare function groupBy<T>(collection: CollectionList<T>, iteratee?: IterateeParam<T>): Record<string, T[]>;
-declare function groupBy<T extends object, V extends T[keyof T]>(collection: CollectionObject<T>, iteratee?: IterateeParam<V>): Record<string, V[]>;
+interface GroupBy {
+    <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` 中每个元素后返回的结果。分组值的顺序是由他们出现在 `collection` 的顺序确定的。每个键对应的值负责生成 `key` 的元素组成的数组。
+ *
+ * `iteratee` 调用时会传入 1 个参数 `value` 。
+ *
+ * @static
+ * @alias module:Collection.groupBy
+ * @since 1.0.0
+ * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
+ * @param {Function | string} [iteratee=identity] 迭代函数，用来转换键。
+ * @returns {Object} 组成聚合对象。
+ * @example
+ *
+ * groupBy([6, 4, 6]); // {'6': [6, 6], '4': [4]}
+ *
+ * groupBy([6.1, 4.2, 6.3], Math.floor); // {'6': [6.1, 6.3], '4': [4.2]}
+ *
+ * groupBy([{n: 6.1}, {n: 4.2}, {n: 6.3}], item=>Math.floor(item.n)); // {'6': [{n: 6.1}, {n: 6.3}], '4': [{n: 4.2}]}
+ *
+ * // 迭代函数可以直接写入属性。
+ * groupBy(['one', 'two', 'three'], 'length'); // {'3': ['one', 'two'], '5': ['three']}
+ *
+ */
+declare const groupBy: GroupBy;
 export default groupBy;

package/types/internals/baseDebounce.d.ts

@@ -1,4 +1,5 @@
-declare function baseDebounce<T extends (...args: any[]) => any>(func: T, wait: number, immediate: boolean, __throttle__?: boolean): {
+import { FunctionAny } from './types';
+declare function baseDebounce<T extends FunctionAny>(func: T, wait: number, immediate: boolean, __throttle__?: boolean): {
     (this: any, ...args: Parameters<T>): ReturnType<T>;
     cancel: () => void;
     flush: () => ReturnType<T>;