ut2 1.3.2 → 1.4.1

package/dist/ut2.js

@@ -43,6 +43,9 @@
         }
         return '';
     }
+    function wrapTags(tags) {
+        return tags.map(function (item) { return '[object ' + item + ']'; });
+    }
     var numberTag = '[object Number]';
     var booleanTag = '[object Boolean]';
     var stringTag = '[object String]';
@@ -53,6 +56,12 @@
     var arrayBufferTag = '[object ArrayBuffer]';
     var argumentsTag = '[object Arguments]';
     var arrayTag = '[object Array]';
+    var typedArrayTags = wrapTags(['Float32Array', 'Float64Array', 'Int8Array', 'Int16Array', 'Int32Array', 'Uint8Array', 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'BigInt64Array', 'BigUint64Array']);
+    var functionTags = wrapTags(['Function', 'AsyncFunction', 'GeneratorFunction', 'Proxy']);
+    var weakSetTag = '[object WeakSet]';
+    var blobTag = '[object Blob]';
+    var fileTag = '[object Blob]';
+    var domExceptionTag = '[object DOMException]';
     var objectTag = '[object Object]';
     var dataViewTag = '[object DataView]';
     var mapTag = '[object Map]';
@@ -129,20 +138,16 @@
     }
     var getTag$1 = getTag;
 
-    function isType(value, type) {
-        var nativeTypeString = getTag$1(value);
-        if (typeof type === 'string') {
-            return nativeTypeString === '[object ' + type + ']';
-        }
-        return type.some(function (item) { return nativeTypeString === '[object ' + item + ']'; });
+    function checkType(value, tag) {
+        return getTag$1(value) === tag;
     }
-
-    function isObjectLike(value) {
-        return value != null && typeof value === 'object';
+    function checkTypes(value, tags) {
+        var tag = getTag$1(value);
+        return tags.some(function (item) { return tag === item; });
     }
 
     function isSymbol(value) {
-        return typeof value === 'symbol' || (isObjectLike(value) && isType(value, 'Symbol'));
+        return typeof value === 'symbol' || checkType(value, symbolTag);
     }
 
     var reIsBinary = /^0b[01]+$/i;
@@ -273,21 +278,20 @@
         });
     }
 
-    var argType = 'Arguments';
-    var supportedArgumentsType = isType((function () { return arguments; })(), argType);
+    var supportedArgumentsType = checkType((function () { return arguments; })(), argumentsTag);
     var FUNC_ERROR_TEXT = 'Expected a function';
     var numberIsFinite = Number.isFinite;
     var numberIsInteger = Number.isInteger;
     var numberIsSafeInteger = Number.isSafeInteger;
     var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
     var arrayAt = arrayProto.at;
-    var VERSION = "1.3.2";
+    var VERSION = "1.4.1";
 
     function isFunction(value) {
         if (!isObject(value)) {
             return false;
         }
-        return isType(value, ['Function', 'AsyncFunction', 'GeneratorFunction', 'Proxy']);
+        return checkTypes(value, functionTags);
     }
 
     function isLength(value) {
@@ -375,6 +379,10 @@
         return uniq(array.concat(other), iteratee, strickCheck);
     }
 
+    function isObjectLike(value) {
+        return value != null && typeof value === 'object';
+    }
+
     function isArrayLikeObject(value) {
         return isObjectLike(value) && isArrayLike(value);
     }
@@ -736,7 +744,7 @@
 
     function isArguments(value) {
         if (supportedArgumentsType) {
-            return isObjectLike(value) && isType(value, argType);
+            return checkType(value, argumentsTag);
         }
         return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
     }
@@ -764,15 +772,15 @@
     var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
 
     function isArrayBuffer(value) {
-        return nodeIsArrayBuffer ? nodeIsArrayBuffer(value) : isObjectLike(value) && isType(value, 'ArrayBuffer');
+        return nodeIsArrayBuffer ? nodeIsArrayBuffer(value) : checkType(value, arrayBufferTag);
     }
 
     function isBlob(value) {
-        return (blobExisted && value instanceof Blob) || isType(value, ['Blob', 'File']);
+        return (blobExisted && value instanceof Blob) || checkTypes(value, [blobTag, fileTag]);
     }
 
     function isBoolean(value) {
-        return value === true || value === false || isType(value, 'Boolean');
+        return value === true || value === false || checkType(value, booleanTag);
     }
 
     function isBuffer(value) {
@@ -783,15 +791,15 @@
     }
 
     function isDataView(value) {
-        return isType(value, 'DataView');
+        return checkType(value, dataViewTag);
     }
 
     function isDate(value) {
-        return nodeIsDate ? nodeIsDate(value) : isObjectLike(value) && isType(value, 'Date');
+        return nodeIsDate ? nodeIsDate(value) : checkType(value, dateTag);
     }
 
     function isPlainObject(value) {
-        if (!isObjectLike(value) || !isType(value, 'Object')) {
+        if (!isObjectLike(value) || !checkType(value, objectTag)) {
             return false;
         }
         var proto = Object.getPrototypeOf(Object(value));
@@ -829,11 +837,11 @@
     }
 
     function isMap(value) {
-        return nodeIsMap ? nodeIsMap(value) : isObjectLike(value) && isType(value, 'Map');
+        return nodeIsMap ? nodeIsMap(value) : checkType(value, mapTag);
     }
 
     function isSet(value) {
-        return nodeIsSet ? nodeIsSet(value) : isObjectLike(value) && isType(value, 'Set');
+        return nodeIsSet ? nodeIsSet(value) : checkType(value, setTag);
     }
 
     function isEmpty(value) {
@@ -876,7 +884,7 @@
         if (nodeIsTypedArray) {
             return 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) && checkTypes(value, typedArrayTags);
     }
 
     function mapToArray(map) {
@@ -1055,10 +1063,7 @@
     }
 
     function isError(value) {
-        if (!isObjectLike(value)) {
-            return false;
-        }
-        return value instanceof Error || isType(value, ['Error', 'DOMException']);
+        return isObjectLike(value) && (value instanceof Error || checkTypes(value, [errorTag, domExceptionTag]));
     }
 
     function isFinite(value) {
@@ -1069,8 +1074,73 @@
         return numberIsInteger ? numberIsInteger(value) : isFinite(value) && Math.floor(value) === value;
     }
 
+    function isDeepComparable(object, source) {
+        return checkType(object, objectTag) && checkType(source, objectTag);
+    }
+    function baseIsMatch(object, source, customizer, strictCheck, objStack, srcStack) {
+        var hasCustomizer = typeof customizer === 'function';
+        if (isDeepComparable(object, source)) {
+            objStack = objStack || [];
+            srcStack = srcStack || [];
+            var stackLen = objStack.length;
+            while (stackLen--) {
+                if (objStack[stackLen] === object && srcStack[stackLen] === source) {
+                    return true;
+                }
+            }
+            objStack.push(object);
+            srcStack.push(source);
+            var keys = allKeys(source);
+            var length_1 = keys.length;
+            while (length_1--) {
+                var key = keys[length_1];
+                if (!(key in object)) {
+                    return false;
+                }
+                var compared = void 0;
+                if (hasCustomizer) {
+                    compared = customizer(object[key], source[key], key, object, source, objStack, srcStack);
+                }
+                if (compared !== undefined) {
+                    if (!compared) {
+                        return false;
+                    }
+                    continue;
+                }
+                if (!baseIsMatch(object[key], source[key], customizer, strictCheck, objStack, srcStack)) {
+                    return false;
+                }
+            }
+            objStack.pop();
+            srcStack.pop();
+            return true;
+        }
+        var result = isEqual(object, source, function (objValue, srcValue, k, obj, src) {
+            if (hasCustomizer) {
+                var compared = customizer(objValue, srcValue, k, obj, src, objStack, srcStack);
+                if (compared !== undefined) {
+                    return compared;
+                }
+            }
+            if (isDeepComparable(objValue, srcValue)) {
+                return baseIsMatch(objValue, srcValue, customizer, strictCheck, objStack, srcStack);
+            }
+        }, strictCheck);
+        return result;
+    }
+    function isMatch(object, source, customizer, strictCheck) {
+        if (strictCheck === void 0) { strictCheck = false; }
+        if (typeof customizer === 'function' && isDeepComparable(object, source)) {
+            var compared = customizer(object, source);
+            if (compared !== undefined) {
+                return !!compared;
+            }
+        }
+        return baseIsMatch(object, source, customizer, strictCheck);
+    }
+
     function isNumber(value) {
-        return typeof value === 'number' || (isObjectLike(value) && isType(value, 'Number'));
+        return typeof value === 'number' || checkType(value, numberTag);
     }
 
     function isNaN(value) {
@@ -1086,7 +1156,7 @@
     }
 
     function isRegExp(value) {
-        return nodeIsRegExp ? nodeIsRegExp(value) : isObjectLike(value) && isType(value, 'RegExp');
+        return nodeIsRegExp ? nodeIsRegExp(value) : checkType(value, regExpTag);
     }
 
     function isSafeInteger(value) {
@@ -1094,7 +1164,7 @@
     }
 
     function isString(value) {
-        return typeof value === 'string' || (isObjectLike(value) && isType(value, 'String'));
+        return typeof value === 'string' || checkType(value, stringTag);
     }
 
     function isUndefined(value) {
@@ -1102,11 +1172,11 @@
     }
 
     function isWeakMap(value) {
-        return isObjectLike(value) && isType(value, 'WeakMap');
+        return checkType(value, weakMapTag);
     }
 
     function isWeakSet(value) {
-        return isObjectLike(value) && isType(value, 'WeakSet');
+        return checkType(value, weakSetTag);
     }
 
     function decimalAdjust(type, value, precision) {
@@ -1609,6 +1679,7 @@
     exports.isInteger = isInteger;
     exports.isLength = isLength;
     exports.isMap = isMap;
+    exports.isMatch = isMatch;
     exports.isNaN = isNaN;
     exports.isNil = isNil;
     exports.isNull = isNull;