ut2 1.9.2 → 1.9.4

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

@@ -15,7 +15,7 @@ export declare const functionProto: Function;
 export declare const functionProtoToString: () => string;
 export declare const symbolProto: Symbol | undefined;
 export declare const arrayProto: any[];
-export declare const arrayProtoSlice: (start?: number | undefined, end?: number | undefined) => any[];
+export declare const arrayProtoSlice: (start?: number, end?: number) => any[];
 export declare const mathMin: (...values: number[]) => number;
 export declare const mathMax: (...values: number[]) => number;
 export declare const mathRandom: () => number;
@@ -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
@@ -63,7 +63,6 @@ export declare const errorTag = "[object Error]";
 export declare const arrayBufferTag = "[object ArrayBuffer]";
 export declare const argumentsTag = "[object Arguments]";
 export declare const arrayTag = "[object Array]";
-export declare const typedArrayTags: string[];
 export declare const functionTags: string[];
 export declare const weakSetTag = "[object WeakSet]";
 export declare const blobTag = "[object Blob]";

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): boolean;
+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,14 +1,13 @@
-/// <reference types="node" />
 /**
- * 检查值是否为 `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

package/types/isDataView.d.ts

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

package/types/isDate.d.ts

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

package/types/isElement.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Language.isElement
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `DOM` 元素，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `DOM` 元素，返回 `true`，否则返回 `false`。
  * @example
  *
  * isElement(document.body); // true
@@ -13,5 +13,5 @@
  * isElement('<body>'); // false
  *
  */
-declare function isElement(value: any): boolean;
+declare function isElement(value: any): value is Element;
 export default isElement;

package/types/isEmpty.d.ts

@@ -9,7 +9,7 @@
  * @alias module:Language.isEmpty
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为空，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为空，返回 `true`，否则返回 `false`。
  * @example
  *
  * isEmpty(null); // true

package/types/isEqual.d.ts

@@ -4,7 +4,7 @@ import isEqualDeep from './internals/isEqualDeep';
  *
  * 支持比较 `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)`
@@ -16,8 +16,8 @@ import isEqualDeep from './internals/isEqualDeep';
  * @param {*} value 要比较的值。
  * @param {*} other 另一个要比较的值。
  * @param {Function} [customizer] 自定义比较。
- * @param {boolean} [strictCheck=false] 严格比较，默认 `false` 。
- * @returns {boolean} 如果两个值相等，返回 `true` ，否则返回 `false` 。
+ * @param {boolean} [strictCheck=false] 严格比较。默认 `false`。
+ * @returns {boolean} 如果两个值相等，返回 `true`，否则返回 `false`。
  * @example
  *
  * const value = { a: 1, b: -0 }

package/types/isError.d.ts

@@ -1,13 +1,13 @@
 /**
- * 检查值是否为 `Error` 或 `DOMException` 。
+ * 检查值是否为 `Error` 或 `DOMException`。
  *
- * 继承自 `Error` 的对象，如 `EvalError` `RangeError` `ReferenceError` `SyntaxError` `TypeError` `URIError` `AggregateError`，都将返回 `true` 。
+ * 继承自 `Error` 的对象，如 `EvalError` `RangeError` `ReferenceError` `SyntaxError` `TypeError` `URIError` `AggregateError`，都将返回 `true`。
  *
  * @static
  * @alias module:Language.isError
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `Error` 或 `DOMException` 对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `Error` 或 `DOMException` 对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isError(new Error); // true

package/types/isFinite.d.ts

@@ -1,13 +1,13 @@
 /**
  * 检查值是否为有限数字。
  *
- * 同 `Number.isFinite` 。
+ * 同 `Number.isFinite`。
  *
  * @static
  * @alias module:Language.isFinite
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为有限数字，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为有限数字，返回 `true`，否则返回 `false`。
  * @example
  *
  * isFinite(1); // true

package/types/isFunction.d.ts

@@ -1,14 +1,14 @@
 import { FunctionAny } from './internals/types';
 /**
- * 检查值是否为 `Function` 对象 。
+ * 检查值是否为 `Function` 对象。
  *
- * `Function` `AsyncFunction` `GeneratorFunction` `Proxy` 都将返回 `true` 。
+ * `Function` `AsyncFunction` `GeneratorFunction` `Proxy` 都将返回 `true`。
  *
  * @static
  * @alias module:Language.isFunction
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `Function` 对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `Function` 对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isFunction(()=>{})); // true

package/types/isInteger.d.ts

@@ -1,13 +1,13 @@
 /**
  * 检查值是否为整数。
  *
- * 同 `Number.isInteger` 。
+ * 同 `Number.isInteger`。
  *
  * @static
  * @alias module:Language.isInteger
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为整数，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为整数，返回 `true`，否则返回 `false`。
  * @example
  *
  * isInteger(1); // true

package/types/isLength.d.ts

@@ -6,7 +6,7 @@
  * @since 1.0.0
  * @see {@link https://tc39.es/ecma262/#sec-tolength ToLength}
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为有效的类数组长度，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为有效的类数组长度，返回 `true`，否则返回 `false`。
  * @example
  *
  * isLength(3); // true

package/types/isMap.d.ts

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

package/types/isMatch.d.ts

@@ -4,7 +4,7 @@ type Customizer = (objValue: any, srcValue: any, key?: number | string | symbol,
  *
  * 注意：只有普通对象才会执行部分匹配，函数、数组不会执行部分匹配。
  *
- * 如果 `strictCheck=true` , 以下值不相等：
+ * 如果 `strictCheck=true`， 以下值不相等：
  *
  * 1. `0` `-0`
  * 2. `typeof` 不同类型，如 `1` `Object(1)`
@@ -17,8 +17,8 @@ type Customizer = (objValue: any, srcValue: any, key?: number | string | symbol,
  * @param {Object} object 要检查的对象。
  * @param {Object} source 属性值相匹配的对象。
  * @param {Function} [customizer] 自定义比较。
- * @param {boolean} [strictCheck=false] 严格比较。
- * @returns {boolean} 如果 `object` 匹配，返回 `true` ，否则返回 `false` 。
+ * @param {boolean} [strictCheck=false] 严格比较。默认 `false`。
+ * @returns {boolean} 如果 `object` 匹配，返回 `true`，否则返回 `false`。
  * @example
  *
  * const object = { a: 1, b: -0 }

package/types/isNaN.d.ts

@@ -1,5 +1,5 @@
 /**
- * 检查值是否为 `NaN` 。
+ * 检查值是否为 `NaN`。
  *
  * 和 `Number.isNaN` 区别是 `new Number(NaN)` 也被认为是 `NaN`。
  *
@@ -7,7 +7,7 @@
  * @alias module:Language.isNaN
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `NaN` ，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `NaN`，返回 `true`，否则返回 `false`。
  * @example
  *
  * isNaN(NaN); // true

package/types/isNil.d.ts

@@ -1,11 +1,11 @@
 /**
- * 检查值是否为 `undefined` 或 `null` 。
+ * 检查值是否为 `undefined` 或 `null`。
  *
  * @static
  * @alias module:Language.isNil
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `undefined` 或 `null` ，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `undefined` 或 `null`，返回 `true`，否则返回 `false`。
  * @example
  *
  * isNil(undefined); // true

package/types/isNull.d.ts

@@ -1,11 +1,11 @@
 /**
- * 检查值是否为 `null` 。
+ * 检查值是否为 `null`。
  *
  * @static
  * @alias module:Language.isNull
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `null` ，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `null`，返回 `true`，否则返回 `false`。
  * @example
  *
  * isNull(null); // true

package/types/isNumber.d.ts

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

package/types/isObject.d.ts

@@ -1,3 +1,4 @@
+import { FunctionAny } from './internals/types';
 /**
  * 检查值是否为对象。(例如，数组、函数、对象、正则表达式、new Number(0) 和 new String(''))。
  *
@@ -6,7 +7,7 @@
  * @since 1.0.0
  * @see {@link https://tc39.es/ecma262/#sec-ecmascript-language-types language type}
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isObject({}); // true
@@ -18,5 +19,5 @@
  * isObject(null); // false
  *
  */
-declare function isObject(value: any): boolean;
+declare function isObject(value: any): value is object | FunctionAny;
 export default isObject;

package/types/isObjectLike.d.ts

@@ -7,7 +7,7 @@
  * @alias module:Language.isObjectLike
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为类对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为类对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isObjectLike({}); // true
@@ -19,5 +19,5 @@
  * isObjectLike(null); // false
  *
  */
-declare function isObjectLike(value: any): boolean;
+declare function isObjectLike(value: any): value is object;
 export default isObjectLike;

package/types/isPlainObject.d.ts

@@ -5,7 +5,7 @@
  * @alias module:Language.isPlainObject
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为普通对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为普通对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * function Foo(){
@@ -21,5 +21,5 @@
  * isPlainObject(Object.create(null)); // true
  *
  */
-declare function isPlainObject(value: any): boolean;
+declare function isPlainObject(value: any): value is object;
 export default isPlainObject;

package/types/isPromiseLike.d.ts

@@ -1,3 +1,8 @@
+import { FunctionAny } from './internals/types';
+type PromiseLikeObject = {
+    then: FunctionAny;
+    [x: string]: any;
+};
 /**
  * 检测值是否类似 `Promise` 对象。
  *
@@ -7,7 +12,7 @@
  * @alias module:Language.isPromiseLike
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值类似 `Promise` 对象，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值类似 `Promise` 对象，返回 `true`，否则返回 `false`。
  * @example
  *
  * isPromiseLike(Promise.resolve()); // true
@@ -17,5 +22,5 @@
  * isPromiseLike([]); // false
  *
  */
-declare function isPromiseLike(value: any): boolean;
+declare function isPromiseLike(value: any): value is Promise<any> | PromiseLikeObject;
 export default isPromiseLike;

package/types/isRegExp.d.ts

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

package/types/isSafeInteger.d.ts

@@ -1,7 +1,7 @@
 /**
  * 检查值是否为安全整数。
  *
- * 同 `Number.isSafeInteger` 。
+ * 同 `Number.isSafeInteger`。
  *
  * 如果一个整数是一个 `IEEE-754` 双精度数字，它不是四舍五入的不安全整数的结果，那么它就是安全的。安全整数范围为 `-(2^53 - 1)` 到 `2^53 - 1` 之间的整数，包含 `-(2^53 - 1)` 和 `2^53 - 1`。
  *
@@ -9,7 +9,7 @@
  * @alias module:Language.isSafeInteger
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为安全整数，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为安全整数，返回 `true`，否则返回 `false`。
  * @example
  *
  * isSafeInteger(1); // true

package/types/isSet.d.ts

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

package/types/isString.d.ts

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

package/types/isSymbol.d.ts

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

package/types/isTypedArray.d.ts

@@ -6,7 +6,7 @@
  * @since 1.0.0
  * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Typed_arrays Typed_arrays}
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为类型化数组，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为类型化数组，返回 `true`，否则返回 `false`。
  * @example
  *
  * isTypedArray(new Uint8Array); // true

package/types/isUndefined.d.ts

@@ -1,11 +1,11 @@
 /**
- * 检查值是否为 `undefined` 。
+ * 检查值是否为 `undefined`。
  *
  * @static
  * @alias module:Language.isUndefined
  * @since 1.0.0
  * @param {*} value 要检查的值。
- * @returns {boolean} 如果值为 `undefined` ，返回 `true` ，否则返回 `false` 。
+ * @returns {boolean} 如果值为 `undefined`，返回 `true`，否则返回 `false`。
  * @example
  *
  * isUndefined(undefined); // true

package/types/isWeakMap.d.ts

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

package/types/isWeakSet.d.ts

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