ut2 1.9.3 → 1.9.4

package/es/internals/helpers.js

@@ -1,7 +1,7 @@
 import getTag from './getTag.js';
 import { argumentsTag, functionProtoToString } from './native.js';
 
-var VERSION = "1.9.3";
+var VERSION = "1.9.4";
 var supportedArgumentsType = getTag((function () { return arguments; })()) === argumentsTag;
 var FUNC_ERROR_TEXT = 'Expected a function';
 function toSource(func) {

package/es/isBuffer.js

@@ -1,9 +1,6 @@
 function isBuffer(value) {
-    if (typeof Buffer === 'function') {
-        var isBuffer_1 = Buffer.isBuffer;
-        if (typeof isBuffer_1 === 'function') {
-            return isBuffer_1(value);
-        }
+    if (typeof Buffer === 'function' && typeof Buffer.isBuffer === 'function') {
+        return Buffer.isBuffer(value);
     }
     return false;
 }

package/lib/internals/helpers.js

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

package/lib/isBuffer.js

@@ -1,11 +1,8 @@
 'use strict';
 
 function isBuffer(value) {
-    if (typeof Buffer === 'function') {
-        var isBuffer_1 = Buffer.isBuffer;
-        if (typeof isBuffer_1 === 'function') {
-            return isBuffer_1(value);
-        }
+    if (typeof Buffer === 'function' && typeof Buffer.isBuffer === 'function') {
+        return Buffer.isBuffer(value);
     }
     return false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ut2",
-  "version": "1.9.3",
+  "version": "1.9.4",
   "author": "caijf",
   "license": "MIT",
   "main": "lib/index.js",

package/types/after.d.ts

@@ -1,6 +1,6 @@
 import { FunctionAny } from './internals/types';
 /**
- * 创建一个函数，当它被调用 `n` 或更多次之后触发 `func` 。
+ * 创建一个函数，当它被调用 `n` 或更多次之后触发 `func`。
  *
  * @static
  * @alias module:Function.after

package/types/ceil.d.ts

@@ -1,5 +1,5 @@
 /**
- * 根据精度向上舍入 `number` 。
+ * 根据精度向上舍入 `number`。
  *
  * 注：精度可以理解为保留几位小数。
  *
@@ -8,7 +8,7 @@
  * @since 1.0.0
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Math/round#小数舍入 小数舍入}
  * @param {number} number 要向上舍入的值。
- * @param {number} [precision=0] 向上舍入的精度。
+ * @param {number} [precision=0] 向上舍入的精度。默认 `0`。
  * @returns {number} 向上舍入的值。
  * @example
  *

package/types/chunk.d.ts

@@ -7,7 +7,7 @@
  * @alias module:Array.chunk
  * @since 1.0.0
  * @param {Array} array 要处理的数组。
- * @param {number} [size=1] 每个数组区块的长度。
+ * @param {number} [size=1] 每个数组区块的长度。默认 `1`。
  * @returns {Array} 拆分区块的新数组。
  * @example
  *

package/types/clamp.d.ts

@@ -9,9 +9,9 @@ interface Clamp {
  * @alias module:Number.clamp
  * @since 1.0.0
  * @param {number} number 被限制的值。
- * @param {number} [lower] 下限。
- * @param {number} upper 上限。
- * @returns {number} 被限制的值。
+ * @param {number} [lower] 下限。默认 `0`。
+ * @param {number} upper 上限。默认 `0`。
+ * @returns {number} 限制后的值。
  * @example
  *
  * clamp(-10, -5, 5); // -5

package/types/conforms.d.ts

@@ -4,7 +4,7 @@ interface ConformsFunction {
     (source: object): (object: any) => boolean;
 }
 /**
- * 创建一个函数，调用 `source` 的属性名对应的断言函数与传入对象相对应属性名的值进行断言处理。如果都符合返回 `true`，否则返回 `false` 。
+ * 创建一个函数，调用 `source` 的属性名对应的断言函数与传入对象相对应属性名的值进行断言处理。如果都符合返回 `true`，否则返回 `false`。
  *
  * @function
  * @alias module:Util.conforms

package/types/conformsTo.d.ts

@@ -4,14 +4,14 @@ interface ConformsTo {
     (object: WithNullable<object>, source: Record<PropertyName, (value: any) => boolean>): boolean;
 }
 /**
- * 通过调用断言 `source` 的属性与 `object` 的相应属性值，检查 `object` 是否符合 `source` 。
+ * 通过调用断言 `source` 的属性与 `object` 的相应属性值，检查 `object` 是否符合 `source`。
  *
  * @function
  * @alias module:Util.conformsTo
  * @since 1.0.0
  * @param {Object} object 要检查的对象。
  * @param {Object} source 要断言属性是否符合的对象。
- * @returns {boolean} 如果 `object` 符合，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果 `object` 符合，返回 `true`，否则返回 `false`。
  * @example
  *
  * const object = { a: 1, b: 2 }

package/types/countBy.d.ts

@@ -8,7 +8,7 @@ interface CountBy {
 /**
  * 创建一个组成对象， `key` 是经过 `iteratee` 执行处理 `collection` 中每个元素后返回的结果，每个 `key` 对应的值是 `iteratee` 返回该 `key` 的次数。
  *
- * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection`。
  *
  * @function
  * @alias module:Collection.countBy

package/types/curry.d.ts

@@ -98,7 +98,7 @@ interface CurriedFunction5<T1, T2, T3, T4, T5, R> {
  * @alias module:Function.curry
  * @since 1.8.0
  * @param {Function} func 需要柯里化的函数。
- * @param {number} [arity] 指定参数数量，默认值为 `func.length`。
+ * @param {number} [arity] 指定参数数量。默认值为 `func.length`。
  * @returns {Function} 新的柯里化函数。
  * @example
  *

package/types/debounce.d.ts

@@ -11,8 +11,8 @@ import { FunctionAny } from './internals/types';
  * @alias module:Function.debounce
  * @since 1.0.0
  * @param {Function} func 要防抖动的函数。
- * @param {number} [wait=0] 需要延迟的毫秒数。
- * @param {boolean} [immediate=false] 是否在延迟开始前调用。
+ * @param {number} [wait=0] 需要延迟的毫秒数。默认 `0`。
+ * @param {boolean} [immediate=false] 是否在延迟开始前调用。默认 `false`。
  * @returns {Function} 防抖动函数。
  * @example
  *

package/types/defaultTo.d.ts

@@ -3,14 +3,14 @@ interface DefaultTo {
     <T, D>(value: T | null | undefined, defaultValue: D): T | D;
 }
 /**
- * 检查值以确定是否应在其位置返回默认值。如果值为 `NaN` `null` 或 `undefined` ，返回 `defaultValue` 。
+ * 检查值以确定是否应在其位置返回默认值。如果值为 `NaN` `null` 或 `undefined`，返回 `defaultValue`。
  *
  * @function
  * @alias module:Util.defaultTo
  * @since 1.0.0
  * @param {*} value 要检查的值。
  * @param {*} defaultValue 默认值。
- * @returns {*} 如果值为 `NaN` `null` 或 `undefined` ，返回 `defaultValue` ，否则返回 `value` 。
+ * @returns {*} 如果值为 `NaN` `null` 或 `undefined`，返回 `defaultValue`，否则返回 `value`。
  * @example
  *
  * defaultTo(undefined, 1); // 1

package/types/delay.d.ts

@@ -1,6 +1,6 @@
 import { FunctionAny } from './internals/types';
 /**
- * 延迟 `wait` 毫秒后调用 `func` 。
+ * 延迟 `wait` 毫秒后调用 `func`。
  *
  * @static
  * @alias module:Function.delay
@@ -8,7 +8,7 @@ import { FunctionAny } from './internals/types';
  * @param {Function} func 要延迟的函数。
  * @param {number} wait 要延迟的毫秒数。
  * @param {...*} [args] 调用函数时传入的参数。
- * @returns {number} 计时器 id 。
+ * @returns {number} 定时器 `id`。
  * @example
  *
  * // 延迟 1000 毫秒后执行

package/types/difference.d.ts

@@ -2,7 +2,7 @@ import { IterateeParam } from './internals/types';
 /**
  * 创建一个 `array` 排除 `values` 值的新数组。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
- * `iteratee` 调用时会传入一个参数 `value` 。
+ * `iteratee` 调用时会传入一个参数 `value`。
  *
  * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
  *
@@ -11,8 +11,8 @@ import { IterateeParam } from './internals/types';
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} values 排除的值。
- * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，调用每个元素。
- * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
+ * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，调用每个元素。默认 `identity`。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`。默认 `false`。
  * @returns {Array} 过滤值后的新数组。
  * @example
  *

package/types/eq.d.ts

@@ -9,8 +9,8 @@
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Equality_comparisons_and_sameness JavaScript 中的相等性判断}
  * @param {*} value 要比较的值。
  * @param {*} other 另一个要比较的值。
- * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
- * @returns {boolean} 如果两个值相等，返回 `true` ，否则返回 `false` 。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`。默认 `false`。
+ * @returns {boolean} 如果两个值相等，返回 `true`，否则返回 `false`。
  * @example
  *
  * eq(-0, 0); // true

package/types/escapeRegExp.d.ts

@@ -1,5 +1,5 @@
 /**
- * 转义 `RegExp` 字符串中特殊的字符 `\\` `^` `$` `.` `*` `+` `?` `-` `(` `)` `[` `]` `{` `}` `|` 。
+ * 转义 `RegExp` 字符串中特殊的字符 `\\` `^` `$` `.` `*` `+` `?` `-` `(` `)` `[` `]` `{` `}` `|`。
  *
  * @static
  * @alias module:String.escapeRegExp

package/types/every.d.ts

@@ -6,16 +6,16 @@ interface Every {
     <T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): boolean;
 }
 /**
- * 迭代集合中的元素执行 `predicate` 函数，如果全部元素都通过 `predicate` 返回真值，则返回 `true` ，否则停止迭代并返回 `false` 。
+ * 迭代集合中的元素执行 `predicate` 函数，如果全部元素都通过 `predicate` 返回真值，则返回 `true`，否则停止迭代并返回 `false`。
  *
- * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ * `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` 。
+ * @param {function} [predicate=identity] 每次迭代调用的函数。默认 `identity`。
+ * @returns {boolean} 如果全部元素都通过 `predicate` 测试，则返回 `true`，否则返回 `false`。
  * @example
  *
  * const arr = [1, 2, 3, 4, 5, 6];

package/types/filter.d.ts

@@ -8,13 +8,13 @@ interface Filter {
 /**
  * 过滤集合元素，为每个元素执行 `predicate` 函数，返回真值的元素将保留在结果数组中（不改变原值）。
  *
- * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ * `predicate` 调用时会传入三个参数 `value` `index|key` `collection`。
  *
  * @static
  * @alias module:Collection.filter
  * @since 1.7.0
  * @param {ArrayLike<any> | Object} collection 要迭代的集合。
- * @param {function} [predicate=identity] 每次迭代调用的函数。
+ * @param {function} [predicate=identity] 每次迭代调用的函数。默认 `identity`。
  * @returns {Array} 返回新的过滤数组。
  * @example
  *

package/types/find.d.ts

@@ -6,15 +6,15 @@ interface Find {
     <T extends object>(collection: WithNullable<T>, predicate?: ObjectIterator<T, any>): T[keyof T] | undefined;
 }
 /**
- * 迭代集合中的元素执行 `predicate` 函数，返回第一个通过 `predicate` 返回真值的元素（停止迭代），如果都不通过返回 `undefined` 。
+ * 迭代集合中的元素执行 `predicate` 函数，返回第一个通过 `predicate` 返回真值的元素（停止迭代），如果都不通过返回 `undefined`。
  *
- * `predicate` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ * `predicate` 调用时会传入三个参数 `value` `index|key` `collection`。
  *
  * @function
  * @alias module:Collection.find
  * @since 1.7.0
  * @param {ArrayLike<any> | Object} collection 要迭代的集合。
- * @param {function} [predicate=identity] 每次迭代调用的函数。
+ * @param {function} [predicate=identity] 每次迭代调用的函数。默认 `identity`。
  * @returns {ArrayLike<any> | Object} 返回第一个通过 `predicate` 返回真值的元素，否则返回 `undefined`。
  * @example
  *

package/types/floor.d.ts

@@ -1,5 +1,5 @@
 /**
- * 根据精度向下舍入 `number` 。
+ * 根据精度向下舍入 `number`。
  *
  * 注：精度可以理解为保留几位小数。
  *
@@ -8,7 +8,7 @@
  * @since 1.0.0
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Math/round#小数舍入 小数舍入}
  * @param {number} number 要向下舍入的值。
- * @param {number} [precision=0] 向下舍入的精度。
+ * @param {number} [precision=0] 向下舍入的精度。默认 `0`。
  * @returns {number} 向下舍入的值。
  * @example
  *

package/types/forEach.d.ts

@@ -1,15 +1,15 @@
 /**
- * 迭代集合元素，为每个元素调用 `iteratee` 。
+ * 迭代集合元素，为每个元素调用 `iteratee`。
  *
  * `iteratee` 函数可以通过显式返回 `false` 来提前退出迭代。
  *
- * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection`。
  *
  * @function
  * @alias module:Collection.forEach
  * @since 1.7.0
  * @param {ArrayLike<any> | Object} collection 要迭代的集合。
- * @param {Function} [iteratee=identity] 每次迭代调用的函数。
+ * @param {Function} [iteratee=identity] 每次迭代调用的函数。默认 `identity`。
  * @returns {ArrayLike<any> | Object} 迭代集合本身。
  * @example
  *

package/types/forEachRight.d.ts

@@ -1,15 +1,15 @@
 /**
- * 迭代集合元素（从右往左的顺序），为每个元素调用 `iteratee` 。
+ * 迭代集合元素（从右往左的顺序），为每个元素调用 `iteratee`。
  *
  * `iteratee` 函数可以通过显式返回 `false` 来提前退出迭代。
  *
- * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection`。
  *
  * @function
  * @alias module:Collection.forEachRight
  * @since 1.7.0
  * @param {ArrayLike<any> | Object} collection 要迭代的集合。
- * @param {Function} [iteratee=identity] 每次迭代调用的函数。
+ * @param {Function} [iteratee=identity] 每次迭代调用的函数。默认 `identity`。
  * @returns {ArrayLike<any> | Object} 迭代集合本身。
  * @example
  *

package/types/groupBy.d.ts

@@ -8,13 +8,13 @@ interface GroupBy {
 /**
  * 创建一个组成聚合对象， `key` 是经过 `iteratee` 执行处理 `collection` 中每个元素后返回的结果。分组值的顺序是由他们出现在 `collection` 的顺序确定的。每个键对应的值负责生成 `key` 的元素组成的数组。
  *
- * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection` 。
+ * `iteratee` 调用时会传入三个参数 `value` `index|key` `collection`。
  *
  * @static
  * @alias module:Collection.groupBy
  * @since 1.0.0
  * @param {ArrayLike<any> | Object} collection 一个用来迭代的集合。
- * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，用来转换键。
+ * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，用来转换键。默认 `identity`。
  * @returns {Object} 组成聚合对象。
  * @example
  *

package/types/gt.d.ts

@@ -1,12 +1,12 @@
 /**
- * 检查 `value` 是否大于 `other` 。
+ * 检查 `value` 是否大于 `other`。
  *
  * @function
  * @alias module:Util.gt
  * @since 1.0.0
  * @param {*} value 要比较的值。
  * @param {*} other 另一个要比较的值。
- * @returns {boolean} 如果 `value` 大于 `other` 返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果 `value` 大于 `other` 返回 `true`，否则返回 `false`。
  * @example
  *
  * gt(1, 3); // false

package/types/gte.d.ts

@@ -1,12 +1,12 @@
 /**
- * 检查 `value` 是否大于或等于 `other` 。
+ * 检查 `value` 是否大于或等于 `other`。
  *
  * @function
  * @alias module:Util.gte
  * @since 1.0.0
  * @param {*} value 要比较的值。
  * @param {*} other 另一个要比较的值。
- * @returns {boolean} 如果 `value` 大于或等于 `other` 返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果 `value` 大于或等于 `other` 返回 `true`，否则返回 `false`。
  * @example
  *
  * gte(1, 3); // false

package/types/identity.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Util.identity
  * @since 1.0.0
  * @param {*} value 任意值。
- * @returns 返回 `value` 。
+ * @returns 返回 `value`。
  * @example
  *
  * const obj = { a: 1, b: 2 };

package/types/inRange.d.ts

@@ -1,5 +1,5 @@
 /**
- * 检查数字是否在 `start` 与 `end` 之间，但不包括 `end` 。
+ * 检查数字是否在 `start` 与 `end` 之间，但不包括 `end`。
  *
  * 如果 `start` 大于 `end` 会自动交换范围参数。
  *
@@ -8,8 +8,8 @@
  * @since 1.0.0
  * @param {number} number 要检查的值。
  * @param {number} start 开始范围。
- * @param {number} [end=0] 结束范围。
- * @returns {number} 如果数字在范围内，返回 `true` ，否则返回 `false` 。
+ * @param {number} [end=0] 结束范围。默认 `0`。
+ * @returns {number} 如果数字在范围内，返回 `true`，否则返回 `false`。
  * @example
  *
  * inRange(3, 2, 4); // true

package/types/internals/getTag.d.ts

@@ -1,5 +1,5 @@
 /**
- * 获取值的 `Object.prototype.toString` 。
+ * 获取值的 `Object.prototype.toString`。
  *
  * @private
  * @param value 要查询的值

package/types/internals/isEqualDeep.d.ts

@@ -5,7 +5,7 @@ type Customizer = (objValue: any, othValue: any, key?: number | string | symbol,
  *
  * 支持比较 `boolean` `number` `string` `symbol` `array` `array buffer` `date` `error` `map` `object` `regexp` `set` `typed array` 类型。对象只比较自身的属性，不包括继承和不可枚举的属性。
  *
- * 如果 `strictCheck=true` , 以下值不相等：
+ * 如果 `strictCheck=true`， 以下值不相等：
  *
  * 1. `0` `-0`
  * 2. `typeof` 不同类型，如 `1` `Object(1)`
@@ -15,10 +15,10 @@ type Customizer = (objValue: any, othValue: any, key?: number | string | symbol,
  * @param {*} value 要比较的值。
  * @param {*} other 另一个要比较的值。
  * @param {Function} [customizer] 自定义比较。
- * @param {boolean} [strictCheck=false] 严格比较，默认 `false` 。
+ * @param {boolean} [strictCheck=false] 严格比较。默认 `false`。
  * @param {Array} [valueStack] 值的堆栈。
  * @param {Array} [otherStack] 另一个值的堆栈。
- * @returns {boolean} 如果两个值相等，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果两个值相等，返回 `true`，否则返回 `false`。
  */
 declare function isEqualDeep(value: any, other: any, customizer?: Customizer, strictCheck?: boolean, valueStack?: any[], otherStack?: any[]): boolean;
 export default isEqualDeep;

package/types/internals/native.d.ts

@@ -45,7 +45,7 @@ export declare const MAX_SAFE_INTEGER: number;
  */
 export declare const MIN_SAFE_INTEGER: number;
 /**
- * 最大数组长度 `Math.pow(2,32) - 1` 。
+ * 最大数组长度 `Math.pow(2,32) - 1`。
  *
  * @static
  * @since 1.0.0

package/types/intersection.d.ts

@@ -2,7 +2,7 @@ import { IterateeParam } from './internals/types';
 /**
  * 创建唯一值的数组，该数组包含两个数组参数都包含的元素（交集）。如果传入迭代函数，会调用数组的每个元素以产生唯一性计算的标准。
  *
- * `iteratee` 调用时会传入一个参数 `value` 。
+ * `iteratee` 调用时会传入一个参数 `value`。
  *
  * 默认使用了 [`SameValueZero`](https://tc39.es/ecma262/#sec-samevaluezero) 做等值比较。如果 `strictCheck=true` 将使用 [`SameValue`](https://tc39.es/ecma262/#sec-samevalue) 做等值比较。
  *
@@ -11,8 +11,8 @@ import { IterateeParam } from './internals/types';
  * @since 1.0.0
  * @param {Array} array 要检查的数组。
  * @param {Array} other 另一个要检查的数组。
- * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，调用每个元素。
- * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
+ * @param {Function | string | number | Symbol} [iteratee=identity] 迭代函数，调用每个元素。默认 `identity`。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`。默认 `false`。
  * @returns {Array} 包含所有传入数组交集元素的新数组。
  * @example
  *

package/types/invert.d.ts

@@ -5,8 +5,9 @@ import { ObjectPredicate, PropertyName, WithNullable } from './internals/types';
  * @static
  * @alias module:Object.invert
  * @since 1.8.0
+ * @see {@link https://developer.mozilla.org/zh-CN/docs/Glossary/Truthy Truthy}
  * @param {Object} object 来源对象。
- * @param {Function} [predicate] 调用每一个属性的函数，返回 `truthy` 表示要反转，否则不反转。
+ * @param {Function} [predicate] 调用每一个属性的函数，返回 `Truthy` 表示要反转，否则不反转。
  * @returns {Object} 新对象。
  * @example
  *

package/types/isArguments.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Language.isArguments
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `arguments` 对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `arguments` 对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isArguments(function() { return arguments }()); // true

package/types/isArray.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Language.isArray
  * @since 1.0.0
  * @param {*} value 要检查的值
- * @returns {boolean} 如果值为 `Array` 对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `Array` 对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isArray([1, 2, 3]); // true

package/types/isArrayBuffer.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Language.isArrayBuffer
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `ArrayBuffer` 对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `ArrayBuffer` 对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isArrayBuffer(new ArrayBuffer(8)); // true

package/types/isArrayLike.d.ts

@@ -7,7 +7,7 @@
  * @alias module:Language.isArrayLike
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为类数组，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为类数组，返回 `true`，否则返回 `false`。
  * @example
  *
  * isArrayLike([1, 2, 3]); // true

package/types/isArrayLikeObject.d.ts

@@ -1,3 +1,7 @@
+type ArrayLikeObject = Array<any> | {
+    length: number;
+    [x: string | symbol]: any;
+};
 /**
  * 检查值是否为类数组对象。
  *
@@ -5,7 +9,7 @@
  * @alias module:Language.isArrayLikeObject
  * @since 1.0.0
  * @param {*} value 要检查的值
- * @returns {boolean} 如果值为类数组对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为类数组对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isArrayLikeObject([1, 2, 3]); // true
@@ -17,5 +21,5 @@
  * isArrayLikeObject(()=>{}); // false
  *
  */
-declare function isArrayLikeObject(value: any): value is ArrayLike<any>;
+declare function isArrayLikeObject(value: any): value is ArrayLikeObject;
 export default isArrayLikeObject;

package/types/isBigInt.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Language.isBigInt
  * @since 1.8.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 bigint 类型或对象，返回 `true` 否则返回 `false` 。
+ * @returns {boolean} 如果值为 bigint 类型或对象，返回 `true` 否则返回 `false`。
  * @example
  *
  * isBigInt(0n); // true

package/types/isBlob.d.ts

@@ -1,7 +1,7 @@
 /**
  * 检查值是否为 `Blob` 对象。
  *
- * 浏览器环境的 `Blob` 或 `File` 对象，或其他继承自 `Blob` 的实例，都将返回 `true` 。
+ * 浏览器环境的 `Blob` 或 `File` 对象，或其他继承自 `Blob` 的实例，都将返回 `true`。
  *
  * @static
  * @alias module:Language.isBlob
@@ -9,7 +9,7 @@
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/API/Blob Blob}
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/API/File File}
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `Blob` 对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `Blob` 对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isBlob(new Blob(['a'])); // true

package/types/isBoolean.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Language.isBoolean
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为布尔类型或对象，返回 `true` 否则返回 `false` 。
+ * @returns {boolean} 如果值为布尔类型或对象，返回 `true` 否则返回 `false`。
  * @example
  *
  * isBoolean(false); // true

package/types/isBuffer.d.ts

@@ -1,13 +1,13 @@
 /**
- * 检查值是否为 `buffer` 。
+ * 检查值是否为 `buffer`。
  *
- * 非 Node.js 环境，始终返回 `false` 。
+ * 非 Node.js 环境，始终返回 `false`。
  *
  * @static
  * @alias module:Language.isBuffer
  * @since 1.0.0
  * @param {*} value 要检查的值
- * @returns {boolean} 如果值为 `buffer` ，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `buffer`，返回 `true`，否则返回 `false`。
  * @example
  *
  * isBuffer(Buffer.alloc(2)); // true