ut2 1.2.2 → 1.3.0

package/lib/internals/getTag.js

@@ -3,11 +3,11 @@
 var native = require('./native.js');
 
 function getRawTag(value) {
-    var isOwn = native.hasOwnProperty.call(value, Symbol.toStringTag);
-    var tag = value[Symbol.toStringTag];
+    var isOwn = native.hasOwnProperty.call(value, native.symToStringTag);
+    var tag = value[native.symToStringTag];
     var unmasked = false;
     try {
-        value[Symbol.toStringTag] = undefined;
+        value[native.symToStringTag] = undefined;
         unmasked = true;
     }
     catch (e) {
@@ -15,18 +15,16 @@ function getRawTag(value) {
     var result = native.objectToString.call(value);
     if (unmasked) {
         if (isOwn) {
-            value[Symbol.toStringTag] = tag;
+            value[native.symToStringTag] = tag;
         }
         else {
-            delete value[Symbol.toStringTag];
+            delete value[native.symToStringTag];
         }
     }
     return result;
 }
 function _getTag(value) {
-    return Symbol && Symbol.toStringTag && Symbol.toStringTag in Object(value)
-        ? getRawTag(value)
-        : native.objectToString.call(value);
+    return native.symToStringTag && native.symToStringTag in Object(value) ? getRawTag(value) : native.objectToString.call(value);
 }
 var getTag = _getTag;
 if ((native.dataViewExisted && native.objectToString.call(new DataView(new ArrayBuffer(1))) !== native.dataViewTag) ||

package/lib/internals/helpers.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var isType = require('./isType.js');
+var native = require('./native.js');
 
 exports.argType = 'Arguments';
 exports.supportedArgumentsType = isType((function () { return arguments; })(), exports.argType);
@@ -9,5 +10,5 @@ exports.numberIsFinite = Number.isFinite;
 exports.numberIsInteger = Number.isInteger;
 exports.numberIsSafeInteger = Number.isSafeInteger;
 exports.objectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
-exports.arrayAt = Array.prototype.at;
-exports.VERSION = "1.2.2";
+exports.arrayAt = native.arrayProto.at;
+exports.VERSION = "1.3.0";

package/lib/internals/native.js

@@ -10,6 +10,12 @@ exports.hasOwnProperty = exports.objectProto.hasOwnProperty;
 exports.propertyIsEnumerable = exports.objectProto.propertyIsEnumerable;
 exports.functionToString = Function.prototype.toString;
 exports.objectCtorString = exports.functionToString.call(Object);
+exports.symbolProto = Symbol ? Symbol.prototype : undefined;
+exports.symbolValueOf = exports.symbolProto ? exports.symbolProto.valueOf : undefined;
+exports.symbolProto ? exports.symbolProto.toString : undefined;
+exports.symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+exports.arrayProto = Array.prototype;
+exports.arrSlice = Array.prototype.slice;
 exports.MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
 exports.MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991;
 exports.MAX_ARRAY_LENGTH = 4294967295;
@@ -29,6 +35,16 @@ function toSource(func) {
     }
     return '';
 }
+exports.numberTag = '[object Number]';
+exports.booleanTag = '[object Boolean]';
+exports.stringTag = '[object String]';
+exports.dateTag = '[object Date]';
+exports.regExpTag = '[object RegExp]';
+exports.symbolTag = '[object Symbol]';
+exports.errorTag = '[object Error]';
+exports.arrayBufferTag = '[object ArrayBuffer]';
+exports.argumentsTag = '[object Arguments]';
+exports.arrayTag = '[object Array]';
 exports.objectTag = '[object Object]';
 exports.dataViewTag = '[object DataView]';
 exports.mapTag = '[object Map]';

package/lib/isArguments.js

@@ -9,9 +9,7 @@ function isArguments(value) {
     if (helpers.supportedArgumentsType) {
         return isObjectLike(value) && isType(value, helpers.argType);
     }
-    return (isObjectLike(value) &&
-        native.hasOwnProperty.call(value, 'callee') &&
-        !native.propertyIsEnumerable.call(value, 'callee'));
+    return isObjectLike(value) && native.hasOwnProperty.call(value, 'callee') && !native.propertyIsEnumerable.call(value, 'callee');
 }
 
 module.exports = isArguments;

package/lib/isArrayBuffer.js

@@ -5,9 +5,7 @@ var nodeUtil = require('./internals/nodeUtil.js');
 var isObjectLike = require('./isObjectLike.js');
 
 function isArrayBuffer(value) {
-    return nodeUtil.nodeIsArrayBuffer
-        ? nodeUtil.nodeIsArrayBuffer(value)
-        : isObjectLike(value) && isType(value, 'ArrayBuffer');
+    return nodeUtil.nodeIsArrayBuffer ? nodeUtil.nodeIsArrayBuffer(value) : isObjectLike(value) && isType(value, 'ArrayBuffer');
 }
 
 module.exports = isArrayBuffer;

package/lib/isEqual.js

@@ -0,0 +1,187 @@
+'use strict';
+
+var allKeys = require('./allKeys.js');
+var eq = require('./eq.js');
+var getTag = require('./internals/getTag.js');
+var native = require('./internals/native.js');
+var isBuffer = require('./isBuffer.js');
+var isFunction = require('./isFunction.js');
+var isNil = require('./isNil.js');
+var isObjectLike = require('./isObjectLike.js');
+var isTypedArray = require('./isTypedArray.js');
+var orderBy = require('./orderBy.js');
+
+function mapToArray(map) {
+    var result = [];
+    map.forEach(function (value, key) {
+        result.push([key, value]);
+    });
+    return orderBy(result, function (item) { return item[0]; });
+}
+function setToArray(set) {
+    var result = [];
+    set.forEach(function (value) {
+        result.push(value);
+    });
+    return orderBy(result);
+}
+function argToArray(arg) {
+    return native.arrSlice.call(arg);
+}
+function toBufferView(bufferSource) {
+    return new Uint8Array(bufferSource.buffer || bufferSource, bufferSource.byteOffset || 0, bufferSource.byteLength);
+}
+function isDomNode(obj) {
+    return isObjectLike(obj) && typeof obj.nodeType === 'number' && typeof obj.nodeName === 'string' && typeof obj.isEqualNode === 'function';
+}
+function isEqualDeep(value, other, customizer, strictCheck, valueStack, otherStack) {
+    if (eq(value, other, strictCheck)) {
+        return true;
+    }
+    var valType = typeof value;
+    var othType = typeof other;
+    if (strictCheck && valType !== othType) {
+        return false;
+    }
+    if (isNil(value) || isNil(other) || (valType !== 'object' && othType !== 'object')) {
+        return false;
+    }
+    var tag = getTag(value);
+    if (tag !== getTag(other)) {
+        return false;
+    }
+    var convert;
+    switch (tag) {
+        case native.numberTag:
+            return eq(+value, +other, strictCheck);
+        case native.booleanTag:
+        case native.dateTag:
+            return strictCheck ? +value === +other : eq(+value, +other);
+        case native.stringTag:
+        case native.regExpTag:
+            return '' + value === '' + other;
+        case native.symbolTag:
+            return native.symbolValueOf ? native.symbolValueOf.call(value) === native.symbolValueOf.call(other) : false;
+        case native.errorTag:
+            return value.name == other.name && value.message == other.message;
+        case native.dataViewTag:
+        case native.arrayBufferTag:
+            if (value.byteLength !== other.byteLength || (value.byteOffset && value.byteOffset !== other.byteOffset)) {
+                return false;
+            }
+            convert = toBufferView;
+            break;
+        case native.mapTag:
+            convert = mapToArray;
+            break;
+        case native.setTag:
+            convert = setToArray;
+            break;
+        case native.argumentsTag:
+            convert = argToArray;
+            break;
+    }
+    if (convert) {
+        return isEqualDeep(convert(value), convert(other), customizer, strictCheck, valueStack, otherStack);
+    }
+    if (isDomNode(value) && isDomNode(other)) {
+        return value.isEqualNode(other);
+    }
+    var areArrays = tag === native.arrayTag;
+    if (!areArrays && isTypedArray(value)) {
+        if (value.byteLength !== other.byteLength) {
+            return false;
+        }
+        if (value.buffer === other.buffer && value.byteOffset === other.byteOffset) {
+            return true;
+        }
+        areArrays = true;
+    }
+    if (isBuffer(value)) {
+        if (!isBuffer(other)) {
+            return false;
+        }
+        areArrays = true;
+    }
+    valueStack = valueStack || [];
+    otherStack = otherStack || [];
+    var length = valueStack.length;
+    while (length--) {
+        if (valueStack[length] === value) {
+            return otherStack[length] === other;
+        }
+    }
+    valueStack.push(value);
+    otherStack.push(other);
+    var result = true;
+    var hasCustomizer = typeof customizer === 'function';
+    if (areArrays) {
+        length = value.length;
+        if (length !== other.length) {
+            return false;
+        }
+        while (length--) {
+            if (hasCustomizer) {
+                var compared = customizer(value[length], other[length], length, value, other, valueStack, otherStack);
+                if (compared !== undefined) {
+                    result = !!compared;
+                    break;
+                }
+            }
+            if (!isEqualDeep(value[length], other[length], customizer, strictCheck, valueStack, otherStack)) {
+                result = false;
+                break;
+            }
+        }
+    }
+    else if (tag === native.objectTag) {
+        var keys = allKeys(value);
+        length = keys.length;
+        if (allKeys(other).length !== length) {
+            return false;
+        }
+        var skipCtor = false;
+        while (length--) {
+            var key = keys[length];
+            if (hasCustomizer) {
+                var compared = customizer(value[key], other[key], key, value, other, valueStack, otherStack);
+                if (compared !== undefined) {
+                    result = !!compared;
+                    break;
+                }
+            }
+            if (!(native.hasOwnProperty.call(other, key) && isEqualDeep(value[key], other[key], customizer, strictCheck, valueStack, otherStack))) {
+                result = false;
+                break;
+            }
+            if (!skipCtor && key === 'constructor') {
+                skipCtor = true;
+            }
+        }
+        if (result && !skipCtor) {
+            var valCtor = value.constructor;
+            var othCtor = other.constructor;
+            if (valCtor !== othCtor && !(isFunction(valCtor) && valCtor instanceof valCtor && isFunction(othCtor) && othCtor instanceof othCtor) && 'constructor' in value && 'constructor' in other) {
+                result = false;
+            }
+        }
+    }
+    else {
+        result = false;
+    }
+    valueStack.pop();
+    otherStack.pop();
+    return result;
+}
+function isEqual(value, other, customizer, strictCheck) {
+    if (strictCheck === void 0) { strictCheck = false; }
+    if (typeof customizer === 'function') {
+        var result = customizer(value, other);
+        if (result !== undefined) {
+            return !!result;
+        }
+    }
+    return isEqualDeep(value, other, customizer, strictCheck);
+}
+
+module.exports = isEqual;

package/lib/isSafeInteger.js

@@ -5,9 +5,7 @@ var helpers = require('./internals/helpers.js');
 var isInteger = require('./isInteger.js');
 
 function isSafeInteger(value) {
-    return helpers.numberIsSafeInteger
-        ? helpers.numberIsSafeInteger(value)
-        : isInteger(value) && Math.abs(value) <= native.MAX_SAFE_INTEGER;
+    return helpers.numberIsSafeInteger ? helpers.numberIsSafeInteger(value) : isInteger(value) && Math.abs(value) <= native.MAX_SAFE_INTEGER;
 }
 
 module.exports = isSafeInteger;

package/lib/isTypedArray.js

@@ -9,21 +9,7 @@ function isTypedArray(value) {
     if (nodeUtil.nodeIsTypedArray) {
         return nodeUtil.nodeIsTypedArray(value);
     }
-    return (isObjectLike(value) &&
-        isLength(value.length) &&
-        isType(value, [
-            'Float32Array',
-            'Float64Array',
-            'Int8Array',
-            'Int16Array',
-            'Int32Array',
-            'Uint8Array',
-            'Uint8ClampedArray',
-            'Uint16Array',
-            'Uint32Array',
-            'BigInt64Array',
-            'BigUint64Array'
-        ]));
+    return isObjectLike(value) && isLength(value.length) && isType(value, ['Float32Array', 'Float64Array', 'Int8Array', 'Int16Array', 'Int32Array', 'Uint8Array', 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'BigInt64Array', 'BigUint64Array']);
 }
 
 module.exports = isTypedArray;

package/package.json

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

package/types/difference.d.ts

@@ -11,7 +11,7 @@
  * @param {Array} array 要检查的数组。
  * @param {Array} values 排除的值。
  * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
- * @param {boolean} [strictCheck=false] 严格比较，区分 `+0` `-0`。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {Array} 过滤值后的新数组。
  * @example
  *

package/types/eq.d.ts

@@ -9,7 +9,7 @@
  * @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`。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {boolean} 如果两个值相等，返回 `true` ，否则返回 `false` 。
  * @example
  *

package/types/index.d.ts

@@ -41,6 +41,48 @@ export { default as negate } from './negate';
 export { default as once } from './once';
 export { default as partial } from './partial';
 export { default as throttle } from './throttle';
+/**
+ * 语言
+ *
+ * @module Language
+ * @since 1.0.0
+ */
+export { default as isArguments } from './isArguments';
+export { default as isArray } from './isArray';
+export { default as isArrayBuffer } from './isArrayBuffer';
+export { default as isArrayLike } from './isArrayLike';
+export { default as isArrayLikeObject } from './isArrayLikeObject';
+export { default as isBlob } from './isBlob';
+export { default as isBoolean } from './isBoolean';
+export { default as isBuffer } from './isBuffer';
+export { default as isDataView } from './isDataView';
+export { default as isDate } from './isDate';
+export { default as isElement } from './isElement';
+export { default as isEmpty } from './isEmpty';
+export { default as isEqual } from './isEqual';
+export { default as isError } from './isError';
+export { default as isFinite } from './isFinite';
+export { default as isFunction } from './isFunction';
+export { default as isInteger } from './isInteger';
+export { default as isLength } from './isLength';
+export { default as isMap } from './isMap';
+export { default as isNaN } from './isNaN';
+export { default as isNil } from './isNil';
+export { default as isNull } from './isNull';
+export { default as isNumber } from './isNumber';
+export { default as isObject } from './isObject';
+export { default as isObjectLike } from './isObjectLike';
+export { default as isPlainObject } from './isPlainObject';
+export { default as isPromiseLike } from './isPromiseLike';
+export { default as isRegExp } from './isRegExp';
+export { default as isSafeInteger } from './isSafeInteger';
+export { default as isSet } from './isSet';
+export { default as isString } from './isString';
+export { default as isSymbol } from './isSymbol';
+export { default as isTypedArray } from './isTypedArray';
+export { default as isUndefined } from './isUndefined';
+export { default as isWeakMap } from './isWeakMap';
+export { default as isWeakSet } from './isWeakSet';
 /**
  * 数学
  *
@@ -94,47 +136,6 @@ export { default as unescape } from './unescape';
 export { default as upperCase } from './upperCase';
 export { default as upperFirst } from './upperFirst';
 export { default as words } from './words';
-/**
- * 类型检测
- *
- * @module Type
- * @since 1.0.0
- */
-export { default as isArguments } from './isArguments';
-export { default as isArray } from './isArray';
-export { default as isArrayBuffer } from './isArrayBuffer';
-export { default as isArrayLike } from './isArrayLike';
-export { default as isArrayLikeObject } from './isArrayLikeObject';
-export { default as isBlob } from './isBlob';
-export { default as isBoolean } from './isBoolean';
-export { default as isBuffer } from './isBuffer';
-export { default as isDataView } from './isDataView';
-export { default as isDate } from './isDate';
-export { default as isElement } from './isElement';
-export { default as isEmpty } from './isEmpty';
-export { default as isError } from './isError';
-export { default as isFinite } from './isFinite';
-export { default as isFunction } from './isFunction';
-export { default as isInteger } from './isInteger';
-export { default as isLength } from './isLength';
-export { default as isMap } from './isMap';
-export { default as isNaN } from './isNaN';
-export { default as isNil } from './isNil';
-export { default as isNull } from './isNull';
-export { default as isNumber } from './isNumber';
-export { default as isObject } from './isObject';
-export { default as isObjectLike } from './isObjectLike';
-export { default as isPlainObject } from './isPlainObject';
-export { default as isPromiseLike } from './isPromiseLike';
-export { default as isRegExp } from './isRegExp';
-export { default as isSafeInteger } from './isSafeInteger';
-export { default as isSet } from './isSet';
-export { default as isString } from './isString';
-export { default as isSymbol } from './isSymbol';
-export { default as isTypedArray } from './isTypedArray';
-export { default as isUndefined } from './isUndefined';
-export { default as isWeakMap } from './isWeakMap';
-export { default as isWeakSet } from './isWeakSet';
 /**
  * 工具
  *

package/types/internals/native.d.ts

@@ -5,6 +5,12 @@ export declare const hasOwnProperty: (v: PropertyKey) => boolean;
 export declare const propertyIsEnumerable: (v: PropertyKey) => boolean;
 export declare const functionToString: () => string;
 export declare const objectCtorString: string;
+export declare const symbolProto: Symbol | undefined;
+export declare const symbolValueOf: (() => symbol) | undefined;
+export declare const symbolToString: (() => string) | undefined;
+export declare const symToStringTag: typeof Symbol.toStringTag | undefined;
+export declare const arrayProto: any[];
+export declare const arrSlice: (start?: number | undefined, end?: number | undefined) => any[];
 /**
  * 最大安全整数。
  *
@@ -31,6 +37,16 @@ export declare const MIN_SAFE_INTEGER: number;
 export declare const MAX_ARRAY_LENGTH = 4294967295;
 export declare const blobExisted: boolean;
 export declare function toSource(func: any): string;
+export declare const numberTag = "[object Number]";
+export declare const booleanTag = "[object Boolean]";
+export declare const stringTag = "[object String]";
+export declare const dateTag = "[object Date]";
+export declare const regExpTag = "[object RegExp]";
+export declare const symbolTag = "[object Symbol]";
+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 objectTag = "[object Object]";
 export declare const dataViewTag = "[object DataView]";
 export declare const mapTag = "[object Map]";

package/types/intersection.d.ts

@@ -11,7 +11,7 @@
  * @param {Array} array 要检查的数组。
  * @param {Array} other 另一个要检查的数组。
  * @param {Function | string} [iteratee] 迭代函数，调用每个元素。
- * @param {boolean} [strictCheck=false] 严格比较，区分 `+0` `-0`。
+ * @param {boolean} [strictCheck=false] 严格比较，区分 `0` `-0`，默认 `false` 。
  * @returns {Array} 包含所有传入数组交集元素的新数组。
  * @example
  *

package/types/isArguments.d.ts

@@ -2,7 +2,7 @@
  * 检查值是否为 `arguments` 对象。
  *
  * @static
- * @alias module:Type.isArguments
+ * @alias module:Language.isArguments
  * @since 1.0.0
  * @param {*} value 要检查的值。
  * @returns {boolean} 如果值为 `arguments` 对象，返回 `true` ，否则返回 `false` 。

package/types/isArray.d.ts

@@ -2,7 +2,7 @@
  * 检查值是否为 `Array` 对象。
  *
  * @static
- * @alias module:Type.isArray
+ * @alias module:Language.isArray
  * @since 1.0.0
  * @param {*} value 要检查的值
  * @returns {boolean} 如果值为 `Array` 对象，返回 `true` ，否则返回 `false` 。

package/types/isArrayBuffer.d.ts

@@ -2,7 +2,7 @@
  * 检查值是否为 `ArrayBuffer` 对象。
  *
  * @static
- * @alias module:Type.isArrayBuffer
+ * @alias module:Language.isArrayBuffer
  * @since 1.0.0
  * @param {*} value 要检查的值。
  * @returns {boolean} 如果值为 `ArrayBuffer` 对象，返回 `true` ，否则返回 `false` 。

package/types/isArrayLike.d.ts

@@ -4,7 +4,7 @@
  * 如果一个值不是函数并且其 `value.length` 是大于或等于 `0` 且小于或等于 `Number.MAX_SAFE_INTEGER` 的整数，则该值被视为类数组。
  *
  * @static
- * @alias module:Type.isArrayLike
+ * @alias module:Language.isArrayLike
  * @since 1.0.0
  * @param {*} value 要检查的值。
  * @returns {boolean} 如果值为类数组，返回 `true` ，否则返回 `false` 。

package/types/isArrayLikeObject.d.ts

@@ -2,7 +2,7 @@
  * 检查值是否为类数组对象。
  *
  * @static
- * @alias module:Type.isArrayLikeObject
+ * @alias module:Language.isArrayLikeObject
  * @since 1.0.0
  * @param {*} value 要检查的值
  * @returns {boolean} 如果值为类数组对象，返回 `true` ，否则返回 `false` 。

package/types/isBlob.d.ts

@@ -4,7 +4,7 @@
  * 浏览器环境的 `Blob` 或 `File` 对象，或其他继承自 `Blob` 的实例，都将返回 `true` 。
  *
  * @static
- * @alias module:Type.isBlob
+ * @alias module:Language.isBlob
  * @since 1.0.0
  * @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}

package/types/isBoolean.d.ts

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

package/types/isBuffer.d.ts

@@ -5,7 +5,7 @@
  * 非 Node.js 环境，始终返回 `false` 。
  *
  * @static
- * @alias module:Type.isBuffer
+ * @alias module:Language.isBuffer
  * @since 1.0.0
  * @param {*} value 要检查的值
  * @returns {boolean} 如果值为 `buffer` ，返回 `true` ，否则返回 `false` 。

package/types/isDataView.d.ts

@@ -2,7 +2,7 @@
  * 检查值是否为 `DataView` 对象。
  *
  * @static
- * @alias module:Type.isDataView
+ * @alias module:Language.isDataView
  * @since 1.2.0
  * @param {*} value 要检查的值。
  * @returns {boolean} 如果值为 `DataView` 对象，返回 `true` ，否则返回 `false` 。

package/types/isDate.d.ts

@@ -2,7 +2,7 @@
  * 检查值是否为 `Date` 对象。
  *
  * @static
- * @alias module:Type.isDate
+ * @alias module:Language.isDate
  * @since 1.0.0
  * @param {*} value 要检查的值。
  * @returns {boolean} 如果值为 `Date` 对象，返回 `true` ，否则返回 `false` 。

package/types/isElement.d.ts

@@ -2,7 +2,7 @@
  * 检查值是否可能为 `DOM` 元素。
  *
  * @static
- * @alias module:Type.isElement
+ * @alias module:Language.isElement
  * @since 1.0.0
  * @param {*} value 要检查的值。
  * @returns {boolean} 如果值为 `DOM` 元素，返回 `true` ，否则返回 `false` 。

package/types/isEmpty.d.ts

@@ -6,7 +6,7 @@
  * 非上述类型值，都将被认为是空的。
  *
  * @static
- * @alias module:Type.isEmpty
+ * @alias module:Language.isEmpty
  * @since 1.0.0
  * @param {*} value 要检查的值。
  * @returns {boolean} 如果值为空，返回 `true` ，否则返回 `false` 。

package/types/isEqual.d.ts

@@ -0,0 +1,44 @@
+type Customizer = (objValue: any, othValue: any, key?: number | string | symbol, object?: any, other?: any, valueStack?: any[], otherStack?: any[]) => void | undefined | boolean;
+/**
+ * 深度比较两个值是否相等。
+ *
+ * 支持比较 `boolean` `number` `string` `symbol` `array` `array buffer` `date` `error` `map` `object` `regexp` `set` `typed array` 类型。对象只比较自身的属性，不包括继承和不可枚举的属性。
+ *
+ * 如果 `strictCheck=true` , 以下值不相等：
+ *
+ * 1. `0` `-0`
+ * 2. `typeof` 不同类型，如 `1` `Object(1)`
+ * 3. 无效日期对象，如 `new Date('')` `new Date('abc')`
+ *
+ * @static
+ * @alias module:Language.isEqual
+ * @since 1.3.0
+ * @param {*} value 要比较的值。
+ * @param {*} other 另一个要比较的值。
+ * @param {Function} [customizer] 自定义比较。
+ * @param {boolean} [strictCheck=false] 严格比较，默认 `false` 。
+ * @returns {boolean} 如果两个值相等，返回 `true` ，否则返回 `false` 。
+ * @example
+ *
+ * const value = { a: 1, b: -0 }
+ * const other = { a: 1, b: 0 }
+ *
+ * isEqual(value, other); // true
+ * value === other // false
+ *
+ * // 严格比较
+ * isEqual(value, other, undefined, true); // false
+ *
+ * // 自定义比较
+ * function customizer(value, other){
+ *   if(typeof value === 'string' && typeof other === 'string'){
+ *     return true;
+ *   }
+ * }
+ * isEqual('a', 'b', customizer); // true
+ * isEqual(['a'], ['b'], customizer); // true
+ * isEqual({foo: 'a'}, {foo: 'b'}, customizer); // true
+ *
+ */
+declare function isEqual(value: any, other: any, customizer?: Customizer, strictCheck?: boolean): boolean;
+export default isEqual;