tdesign-react 0.42.0 → 0.42.1-alpha.1

package/cjs/_chunks/dep-e5e2fa48.js

@@ -0,0 +1,187 @@
+/**
+ * tdesign v0.40.6
+ * (c) 2022 tdesign
+ * @license MIT
+ */
+
+'use strict';
+
+var _baseGet = require('./dep-e5383587.js');
+var _baseSet = require('./dep-7ae06919.js');
+var isArguments$1 = require('./dep-ca88577c.js');
+var isArray$1 = require('./dep-ae2d5109.js');
+var _isIndex = require('./dep-25552f53.js');
+var isLength$1 = require('./dep-70a0a076.js');
+var _flatRest = require('./dep-58f091ba.js');
+
+var baseGet = _baseGet._baseGet,
+    baseSet = _baseSet._baseSet,
+    castPath$1 = _baseGet._castPath;
+/**
+ * The base implementation of  `_.pickBy` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The source object.
+ * @param {string[]} paths The property paths to pick.
+ * @param {Function} predicate The function invoked per property.
+ * @returns {Object} Returns the new object.
+ */
+
+function basePickBy$1(object, paths, predicate) {
+  var index = -1,
+      length = paths.length,
+      result = {};
+
+  while (++index < length) {
+    var path = paths[index],
+        value = baseGet(object, path);
+
+    if (predicate(value, path)) {
+      baseSet(result, castPath$1(path, object), value);
+    }
+  }
+
+  return result;
+}
+
+var _basePickBy = basePickBy$1;
+
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+
+function baseHasIn$1(object, key) {
+  return object != null && key in Object(object);
+}
+
+var _baseHasIn = baseHasIn$1;
+
+var castPath = _baseGet._castPath,
+    isArguments = isArguments$1.isArguments_1,
+    isArray = isArray$1.isArray_1,
+    isIndex = _isIndex._isIndex,
+    isLength = isLength$1.isLength_1,
+    toKey = _baseGet._toKey;
+/**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+
+function hasPath$1(object, path, hasFunc) {
+  path = castPath(path, object);
+  var index = -1,
+      length = path.length,
+      result = false;
+
+  while (++index < length) {
+    var key = toKey(path[index]);
+
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+
+    object = object[key];
+  }
+
+  if (result || ++index != length) {
+    return result;
+  }
+
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+}
+
+var _hasPath = hasPath$1;
+
+var baseHasIn = _baseHasIn,
+    hasPath = _hasPath;
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+
+function hasIn$1(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+
+var hasIn_1 = hasIn$1;
+
+var basePickBy = _basePickBy,
+    hasIn = hasIn_1;
+/**
+ * The base implementation of `_.pick` without support for individual
+ * property identifiers.
+ *
+ * @private
+ * @param {Object} object The source object.
+ * @param {string[]} paths The property paths to pick.
+ * @returns {Object} Returns the new object.
+ */
+
+function basePick$1(object, paths) {
+  return basePickBy(object, paths, function (value, path) {
+    return hasIn(object, path);
+  });
+}
+
+var _basePick = basePick$1;
+
+var basePick = _basePick,
+    flatRest = _flatRest._flatRest;
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [paths] The property paths to pick.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pick(object, ['a', 'c']);
+ * // => { 'a': 1, 'c': 3 }
+ */
+
+var pick = flatRest(function (object, paths) {
+  return object == null ? {} : basePick(object, paths);
+});
+var pick_1 = pick;
+
+exports.pick_1 = pick_1;
+//# sourceMappingURL=dep-e5e2fa48.js.map

package/cjs/_chunks/dep-e5e2fa48.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dep-e5e2fa48.js","sources":["../../node_modules/lodash/_basePickBy.js","../../node_modules/lodash/_baseHasIn.js","../../node_modules/lodash/_hasPath.js","../../node_modules/lodash/hasIn.js","../../node_modules/lodash/_basePick.js","../../node_modules/lodash/pick.js"],"sourcesContent":["var baseGet = require('./_baseGet'),\n    baseSet = require('./_baseSet'),\n    castPath = require('./_castPath');\n\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, paths, predicate) {\n  var index = -1,\n      length = paths.length,\n      result = {};\n\n  while (++index < length) {\n    var path = paths[index],\n        value = baseGet(object, path);\n\n    if (predicate(value, path)) {\n      baseSet(result, castPath(path, object), value);\n    }\n  }\n  return result;\n}\n\nmodule.exports = basePickBy;\n","/**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHasIn(object, key) {\n  return object != null && key in Object(object);\n}\n\nmodule.exports = baseHasIn;\n","var castPath = require('./_castPath'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isIndex = require('./_isIndex'),\n    isLength = require('./isLength'),\n    toKey = require('./_toKey');\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      result = false;\n\n  while (++index < length) {\n    var key = toKey(path[index]);\n    if (!(result = object != null && hasFunc(object, key))) {\n      break;\n    }\n    object = object[key];\n  }\n  if (result || ++index != length) {\n    return result;\n  }\n  length = object == null ? 0 : object.length;\n  return !!length && isLength(length) && isIndex(key, length) &&\n    (isArray(object) || isArguments(object));\n}\n\nmodule.exports = hasPath;\n","var baseHasIn = require('./_baseHasIn'),\n    hasPath = require('./_hasPath');\n\n/**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\nfunction hasIn(object, path) {\n  return object != null && hasPath(object, path, baseHasIn);\n}\n\nmodule.exports = hasIn;\n","var basePickBy = require('./_basePickBy'),\n    hasIn = require('./hasIn');\n\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @returns {Object} Returns the new object.\n */\nfunction basePick(object, paths) {\n  return basePickBy(object, paths, function(value, path) {\n    return hasIn(object, path);\n  });\n}\n\nmodule.exports = basePick;\n","var basePick = require('./_basePick'),\n    flatRest = require('./_flatRest');\n\n/**\n * Creates an object composed of the picked `object` properties.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pick(object, ['a', 'c']);\n * // => { 'a': 1, 'c': 3 }\n */\nvar pick = flatRest(function(object, paths) {\n  return object == null ? {} : basePick(object, paths);\n});\n\nmodule.exports = pick;\n"],"names":["baseGet","require$$0","baseSet","require$$1","castPath","require$$2","basePickBy","object","paths","predicate","index","length","result","path","value","_basePickBy","baseHasIn","key","Object","_baseHasIn","isArguments","isArray","isIndex","require$$3","isLength","require$$4","toKey","require$$5","hasPath","hasFunc","_hasPath","hasIn","hasIn_1","basePick","_basePick","flatRest","pick","pick_1"],"mappings":"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"}

package/cjs/_chunks/dep-e866b0ce.js

@@ -0,0 +1,491 @@
+/**
+ * tdesign v0.40.6
+ * (c) 2022 tdesign
+ * @license MIT
+ */
+
+'use strict';
+
+var keysIn = require('./dep-f905d5cd.js');
+var _cacheHas = require('./dep-eb56f065.js');
+var _baseGetTag = require('./dep-84798ad6.js');
+var eq$1 = require('./dep-ed995e81.js');
+var _getAllKeys = require('./dep-5991a88b.js');
+var _getTag = require('./dep-19d9987c.js');
+var isArray$1 = require('./dep-ae2d5109.js');
+var isTypedArray$1 = require('./dep-48bd4fe7.js');
+var isObjectLike$1 = require('./dep-2858d5e3.js');
+
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+
+function arraySome$1(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+var _arraySome = arraySome$1;
+
+var SetCache = _cacheHas._SetCache,
+    arraySome = _arraySome,
+    cacheHas = _cacheHas._cacheHas;
+/** Used to compose bitmasks for value comparisons. */
+
+var COMPARE_PARTIAL_FLAG$3 = 1,
+    COMPARE_UNORDERED_FLAG$1 = 2;
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+
+function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3,
+      arrLength = array.length,
+      othLength = other.length;
+
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  } // Check that cyclic values are equal.
+
+
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+
+  var index = -1,
+      result = true,
+      seen = bitmask & COMPARE_UNORDERED_FLAG$1 ? new SetCache() : undefined;
+  stack.set(array, other);
+  stack.set(other, array); // Ignore non-index properties.
+
+  while (++index < arrLength) {
+    var arrValue = array[index],
+        othValue = other[index];
+
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+
+    if (compared !== undefined) {
+      if (compared) {
+        continue;
+      }
+
+      result = false;
+      break;
+    } // Recursively compare arrays (susceptible to call stack limits).
+
+
+    if (seen) {
+      if (!arraySome(other, function (othValue, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+
+  stack['delete'](array);
+  stack['delete'](other);
+  return result;
+}
+
+var _equalArrays = equalArrays$2;
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+
+function mapToArray$1(map) {
+  var index = -1,
+      result = Array(map.size);
+  map.forEach(function (value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+
+var _mapToArray = mapToArray$1;
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+
+function setToArray$1(set) {
+  var index = -1,
+      result = Array(set.size);
+  set.forEach(function (value) {
+    result[++index] = value;
+  });
+  return result;
+}
+
+var _setToArray = setToArray$1;
+
+var _Symbol = _baseGetTag._Symbol,
+    Uint8Array = keysIn._Uint8Array,
+    eq = eq$1.eq_1,
+    equalArrays$1 = _equalArrays,
+    mapToArray = _mapToArray,
+    setToArray = _setToArray;
+/** Used to compose bitmasks for value comparisons. */
+
+var COMPARE_PARTIAL_FLAG$2 = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+/** `Object#toString` result references. */
+
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]';
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]';
+/** Used to convert symbols to primitives and strings. */
+
+var symbolProto = _Symbol ? _Symbol.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+
+function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+
+      object = object.buffer;
+      other = other.buffer;
+
+    case arrayBufferTag:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+        return false;
+      }
+
+      return true;
+
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      // Coerce booleans to `1` or `0` and dates to milliseconds.
+      // Invalid dates are coerced to `NaN`.
+      return eq(+object, +other);
+
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+
+    case regexpTag:
+    case stringTag:
+      // Coerce regexes to strings and treat strings, primitives and objects,
+      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+      // for more details.
+      return object == other + '';
+
+    case mapTag:
+      var convert = mapToArray;
+
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2;
+      convert || (convert = setToArray);
+
+      if (object.size != other.size && !isPartial) {
+        return false;
+      } // Assume cyclic values are equal.
+
+
+      var stacked = stack.get(object);
+
+      if (stacked) {
+        return stacked == other;
+      }
+
+      bitmask |= COMPARE_UNORDERED_FLAG; // Recursively compare objects (susceptible to call stack limits).
+
+      stack.set(object, other);
+      var result = equalArrays$1(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack['delete'](object);
+      return result;
+
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+
+  }
+
+  return false;
+}
+
+var _equalByTag = equalByTag$1;
+
+var getAllKeys = _getAllKeys._getAllKeys;
+/** Used to compose bitmasks for value comparisons. */
+
+var COMPARE_PARTIAL_FLAG$1 = 1;
+/** Used for built-in method references. */
+
+var objectProto$1 = Object.prototype;
+/** Used to check objects for own properties. */
+
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+
+function equalObjects$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1,
+      objProps = getAllKeys(object),
+      objLength = objProps.length,
+      othProps = getAllKeys(other),
+      othLength = othProps.length;
+
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+
+  var index = objLength;
+
+  while (index--) {
+    var key = objProps[index];
+
+    if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+      return false;
+    }
+  } // Check that cyclic values are equal.
+
+
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key],
+        othValue = other[key];
+
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    } // Recursively compare objects (susceptible to call stack limits).
+
+
+    if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+
+    skipCtor || (skipCtor = key == 'constructor');
+  }
+
+  if (result && !skipCtor) {
+    var objCtor = object.constructor,
+        othCtor = other.constructor; // Non `Object` object instances with different constructors are not equal.
+
+    if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+
+  stack['delete'](object);
+  stack['delete'](other);
+  return result;
+}
+
+var _equalObjects = equalObjects$1;
+
+var Stack = keysIn._Stack,
+    equalArrays = _equalArrays,
+    equalByTag = _equalByTag,
+    equalObjects = _equalObjects,
+    getTag = _getTag._getTag,
+    isArray = isArray$1.isArray_1,
+    isBuffer = isTypedArray$1.isBuffer.exports,
+    isTypedArray = isTypedArray$1.isTypedArray_1;
+/** Used to compose bitmasks for value comparisons. */
+
+var COMPARE_PARTIAL_FLAG = 1;
+/** `Object#toString` result references. */
+
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    objectTag = '[object Object]';
+/** Used for built-in method references. */
+
+var objectProto = Object.prototype;
+/** Used to check objects for own properties. */
+
+var hasOwnProperty = objectProto.hasOwnProperty;
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+
+function baseIsEqualDeep$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object),
+      othIsArr = isArray(other),
+      objTag = objIsArr ? arrayTag : getTag(object),
+      othTag = othIsArr ? arrayTag : getTag(other);
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+  var objIsObj = objTag == objectTag,
+      othIsObj = othTag == objectTag,
+      isSameTag = objTag == othTag;
+
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+
+    objIsArr = true;
+    objIsObj = false;
+  }
+
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+
+  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object,
+          othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+
+  if (!isSameTag) {
+    return false;
+  }
+
+  stack || (stack = new Stack());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+
+var _baseIsEqualDeep = baseIsEqualDeep$1;
+
+var baseIsEqualDeep = _baseIsEqualDeep,
+    isObjectLike = isObjectLike$1.isObjectLike_1;
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Unordered comparison
+ *  2 - Partial comparison
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+
+  if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+    return value !== value && other !== other;
+  }
+
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+
+var _baseIsEqual = baseIsEqual;
+
+exports._baseIsEqual = _baseIsEqual;
+//# sourceMappingURL=dep-e866b0ce.js.map