1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
var Symbol = require('./_Symbol'),    Uint8Array = require('./_Uint8Array'),    eq = require('./eq'),    equalArrays = require('./_equalArrays'),    mapToArray = require('./_mapToArray'),    setToArray = require('./_setToArray');
/** Used to compose bitmasks for value comparisons. */var COMPARE_PARTIAL_FLAG = 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(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;      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(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;}
module.exports = equalByTag;