https://web.girona.cat/o/frontend-js-web/liferay/global.bundle.js

1"use strict";
2(() => {
3  var __create = Object.create;
4  var __defProp = Object.defineProperty;
5  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
6  var __getOwnPropNames = Object.getOwnPropertyNames;
7  var __getProtoOf = Object.getPrototypeOf;
8  var __hasOwnProp = Object.prototype.hasOwnProperty;
9  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
10  var __commonJS = (cb, mod) => function __require() {
11    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
12  };
13  var __copyProps = (to, from, except, desc) => {
14    if (from && typeof from === "object" || typeof from === "function") {
15      for (let key of __getOwnPropNames(from))
16        if (!__hasOwnProp.call(to, key) && key !== except)
17          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
18    }
19    return to;
20  };
21  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
22    // If the importer is in node compatibility mode or this is not an ESM
23    // file that has been converted to a CommonJS file using a Babel-
24    // compatible transform (i.e. "__esModule" has not been set), then set
25    // "default" to the CommonJS "module.exports" for node compatibility.
26    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
27    mod
28  ));
29  var __publicField = (obj, key, value) => {
30    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
31    return value;
32  };
33
34  

34// ../../../node_modules/lodash.groupby/index.js
35  var require_lodash = __commonJS({
36    "../../../node_modules/lodash.groupby/index.js"(exports, module) {
37      var LARGE_ARRAY_SIZE = 200;
38      var FUNC_ERROR_TEXT = "Expected a function";
39      var HASH_UNDEFINED = "__lodash_hash_undefined__";
40      var UNORDERED_COMPARE_FLAG = 1;
41      var PARTIAL_COMPARE_FLAG = 2;
42      var INFINITY = 1 / 0;
43      var MAX_SAFE_INTEGER = 9007199254740991;
44      var argsTag = "[object Arguments]";
45      var arrayTag = "[object Array]";
46      var boolTag = "[object Boolean]";
47      var dateTag = "[object Date]";
48      var errorTag = "[object Error]";
49      var funcTag = "[object Function]";
50      var genTag = "[object GeneratorFunction]";
51      var mapTag = "[object Map]";
52      var numberTag = "[object Number]";
53      var objectTag = "[object Object]";
54      var promiseTag = "[object Promise]";
55      var regexpTag = "[object RegExp]";
56      var setTag = "[object Set]";
57      var stringTag = "[object String]";
58      var symbolTag = "[object Symbol]";
59      var weakMapTag = "[object WeakMap]";
60      var arrayBufferTag = "[object ArrayBuffer]";
61      var dataViewTag = "[object DataView]";
62      var float32Tag = "[object Float32Array]";
63      var float64Tag = "[object Float64Array]";
64      var int8Tag = "[object Int8Array]";
65      var int16Tag = "[object Int16Array]";
66      var int32Tag = "[object Int32Array]";
67      var uint8Tag = "[object Uint8Array]";
68      var uint8ClampedTag = "[object Uint8ClampedArray]";
69      var uint16Tag = "[object Uint16Array]";
70      var uint32Tag = "[object Uint32Array]";
71      var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
72      var reIsPlainProp = /^\w*$/;
73      var reLeadingDot = /^\./;
74      var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
75      var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
76      var reEscapeChar = /\\(\\)?/g;
77      var reIsHostCtor = /^\[object .+?Constructor\]$/;
78      var reIsUint = /^(?:0|[1-9]\d*)$/;
79      var typedArrayTags = {};
80      typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
81      typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
82      var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
83      var freeSelf = typeof self == "object" && self && self.Object === Object && self;
84      var root = freeGlobal || freeSelf || Function("return this")();
85      var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
86      var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
87      var moduleExports = freeModule && freeModule.exports === freeExports;
88      var freeProcess = moduleExports && freeGlobal.process;
89      var nodeUtil = function() {
90        try {
91          return freeProcess && freeProcess.binding("util");
92        } catch (e) {
93        }
94      }();
95      var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
96      function arrayAggregator(array, setter, iteratee, accumulator) {
97        var index = -1, length = array ? array.length : 0;
98        while (++index < length) {
99          var value = array[index];
100          setter(accumulator, value, iteratee(value), array);
101        }
102        return accumulator;
103      }
104      function arraySome(array, predicate) {
105        var index = -1, length = array ? array.length : 0;
106        while (++index < length) {
107          if (predicate(array[index], index, array)) {
108            return true;
109          }
110        }
111        return false;
112      }
113      function baseProperty(key) {
114        return function(object) {
115          return object == null ? void 0 : object[key];
116        };
117      }
118      function baseTimes(n, iteratee) {
119        var index = -1, result = Array(n);
120        while (++index < n) {
121          result[index] = iteratee(index);
122        }
123        return result;
124      }
125      function baseUnary(func) {
126        return function(value) {
127          return func(value);
128        };
129      }
130      function getValue(object, key) {
131        return object == null ? void 0 : object[key];
132      }
133      function isHostObject(value) {
134        var result = false;
135        if (value != null && typeof value.toString != "function") {
136          try {
137            result = !!(value + "");
138          } catch (e) {
139          }
140        }
141        return result;
142      }
143      function mapToArray(map) {
144        var index = -1, result = Array(map.size);
145        map.forEach(function(value, key) {
146          result[++index] = [key, value];
147        });
148        return result;
149      }
150      function overArg(func, transform) {
151        return function(arg) {
152          return func(transform(arg));
153        };
154      }
155      function setToArray(set) {
156        var index = -1, result = Array(set.size);
157        set.forEach(function(value) {
158          result[++index] = value;
159        });
160        return result;
161      }
162      var arrayProto = Array.prototype;
163      var funcProto = Function.prototype;
164      var objectProto = Object.prototype;
165      var coreJsData = root["__core-js_shared__"];
166      var maskSrcKey = function() {
167        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
168        return uid ? "Symbol(src)_1." + uid : "";
169      }();
170      var funcToString = funcProto.toString;
171      var hasOwnProperty = objectProto.hasOwnProperty;
172      var objectToString = objectProto.toString;
173      var reIsNative = RegExp(
174        "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
175      );
176      var Symbol2 = root.Symbol;
177      var Uint8Array2 = root.Uint8Array;
178      var propertyIsEnumerable = objectProto.propertyIsEnumerable;
179      var splice = arrayProto.splice;
180      var nativeKeys = overArg(Object.keys, Object);
181      var DataView = getNative(root, "DataView");
182      var Map2 = getNative(root, "Map");
183      var Promise2 = getNative(root, "Promise");
184      var Set2 = getNative(root, "Set");
185      var WeakMap2 = getNative(root, "WeakMap");
186      var nativeCreate = getNative(Object, "create");
187      var dataViewCtorString = toSource(DataView);
188      var mapCtorString = toSource(Map2);
189      var promiseCtorString = toSource(Promise2);
190      var setCtorString = toSource(Set2);
191      var weakMapCtorString = toSource(WeakMap2);
192      var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
193      var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
194      var symbolToString = symbolProto ? symbolProto.toString : void 0;
195      function Hash(entries) {
196        var index = -1, length = entries ? entries.length : 0;
197        this.clear();
198        while (++index < length) {
199          var entry = entries[index];
200          this.set(entry[0], entry[1]);
201        }
202      }
203      function hashClear() {
204        this.__data__ = nativeCreate ? nativeCreate(null) : {};
205      }
206      function hashDelete(key) {
207        return this.has(key) && delete this.__data__[key];
208      }
209      function hashGet(key) {
210        var data = this.__data__;
211        if (nativeCreate) {
212          var result = data[key];
213          return result === HASH_UNDEFINED ? void 0 : result;
214        }
215        return hasOwnProperty.call(data, key) ? data[key] : void 0;
216      }
217      function hashHas(key) {
218        var data = this.__data__;
219        return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
220      }
221      function hashSet(key, value) {
222        var data = this.__data__;
223        data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
224        return this;
225      }
226      Hash.prototype.clear = hashClear;
227      Hash.prototype["delete"] = hashDelete;
228      Hash.prototype.get = hashGet;
229      Hash.prototype.has = hashHas;
230      Hash.prototype.set = hashSet;
231      function ListCache(entries) {
232        var index = -1, length = entries ? entries.length : 0;
233        this.clear();
234        while (++index < length) {
235          var entry = entries[index];
236          this.set(entry[0], entry[1]);
237        }
238      }
239      function listCacheClear() {
240        this.__data__ = [];
241      }
242      function listCacheDelete(key) {
243        var data = this.__data__, index = assocIndexOf(data, key);
244        if (index < 0) {
245          return false;
246        }
247        var lastIndex = data.length - 1;
248        if (index == lastIndex) {
249          data.pop();
250        } else {
251          splice.call(data, index, 1);
252        }
253        return true;
254      }
255      function listCacheGet(key) {
256        var data = this.__data__, index = assocIndexOf(data, key);
257        return index < 0 ? void 0 : data[index][1];
258      }
259      function listCacheHas(key) {
260        return assocIndexOf(this.__data__, key) > -1;
261      }
262      function listCacheSet(key, value) {
263        var data = this.__data__, index = assocIndexOf(data, key);
264        if (index < 0) {
265          data.push([key, value]);
266        } else {
267          data[index][1] = value;
268        }
269        return this;
270      }
271      ListCache.prototype.clear = listCacheClear;
272      ListCache.prototype["delete"] = listCacheDelete;
273      ListCache.prototype.get = listCacheGet;
274      ListCache.prototype.has = listCacheHas;
275      ListCache.prototype.set = listCacheSet;
276      function MapCache(entries) {
277        var index = -1, length = entries ? entries.length : 0;
278        this.clear();
279        while (++index < length) {
280          var entry = entries[index];
281          this.set(entry[0], entry[1]);
282        }
283      }
284      function mapCacheClear() {
285        this.__data__ = {
286          "hash": new Hash(),
287          "map": new (Map2 || ListCache)(),
288          "string": new Hash()
289        };
290      }
291      function mapCacheDelete(key) {
292        return getMapData(this, key)["delete"](key);
293      }
294      function mapCacheGet(key) {
295        return getMapData(this, key).get(key);
296      }
297      function mapCacheHas(key) {
298        return getMapData(this, key).has(key);
299      }
300      function mapCacheSet(key, value) {
301        getMapData(this, key).set(key, value);
302        return this;
303      }
304      MapCache.prototype.clear = mapCacheClear;
305      MapCache.prototype["delete"] = mapCacheDelete;
306      MapCache.prototype.get = mapCacheGet;
307      MapCache.prototype.has = mapCacheHas;
308      MapCache.prototype.set = mapCacheSet;
309      function SetCache(values) {
310        var index = -1, length = values ? values.length : 0;
311        this.__data__ = new MapCache();
312        while (++index < length) {
313          this.add(values[index]);
314        }
315      }
316      function setCacheAdd(value) {
317        this.__data__.set(value, HASH_UNDEFINED);
318        return this;
319      }
320      function setCacheHas(value) {
321        return this.__data__.has(value);
322      }
323      SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
324      SetCache.prototype.has = setCacheHas;
325      function Stack(entries) {
326        this.__data__ = new ListCache(entries);
327      }
328      function stackClear() {
329        this.__data__ = new ListCache();
330      }
331      function stackDelete(key) {
332        return this.__data__["delete"](key);
333      }
334      function stackGet(key) {
335        return this.__data__.get(key);
336      }
337      function stackHas(key) {
338        return this.__data__.has(key);
339      }
340      function stackSet(key, value) {
341        var cache = this.__data__;
342        if (cache instanceof ListCache) {
343          var pairs = cache.__data__;
344          if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
345            pairs.push([key, value]);
346            return this;
347          }
348          cache = this.__data__ = new MapCache(pairs);
349        }
350        cache.set(key, value);
351        return this;
352      }
353      Stack.prototype.clear = stackClear;
354      Stack.prototype["delete"] = stackDelete;
355      Stack.prototype.get = stackGet;
356      Stack.prototype.has = stackHas;
357      Stack.prototype.set = stackSet;
358      function arrayLikeKeys(value, inherited) {
359        var result = isArray(value) || isArguments(value) ? baseTimes(value.length, String) : [];
360        var length = result.length, skipIndexes = !!length;
361        for (var key in value) {
362          if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == "length" || isIndex(key, length)))) {
363            result.push(key);
364          }
365        }
366        return result;
367      }
368      function assocIndexOf(array, key) {
369        var length = array.length;
370        while (length--) {
371          if (eq(array[length][0], key)) {
372            return length;
373          }
374        }
375        return -1;
376      }
377      function baseAggregator(collection, setter, iteratee, accumulator) {
378        baseEach(collection, function(value, key, collection2) {
379          setter(accumulator, value, iteratee(value), collection2);
380        });
381        return accumulator;
382      }
383      var baseEach = createBaseEach(baseForOwn);
384      var baseFor = createBaseFor();
385      function baseForOwn(object, iteratee) {
386        return object && baseFor(object, iteratee, keys);
387      }
388      function baseGet(object, path) {
389        path = isKey(path, object) ? [path] : castPath(path);
390        var index = 0, length = path.length;
391        while (object != null && index < length) {
392          object = object[toKey(path[index++])];
393        }
394        return index && index == length ? object : void 0;
395      }
396      function baseGetTag(value) {
397        return objectToString.call(value);
398      }
399      function baseHasIn(object, key) {
400        return object != null && key in Object(object);
401      }
402      function baseIsEqual(value, other, customizer, bitmask, stack) {
403        if (value === other) {
404          return true;
405        }
406        if (value == null || other == null || !isObject2(value) && !isObjectLike(other)) {
407          return value !== value && other !== other;
408        }
409        return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
410      }
411      function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
412        var objIsArr = isArray(object), othIsArr = isArray(other), objTag = arrayTag, othTag = arrayTag;
413        if (!objIsArr) {
414          objTag = getTag(object);
415          objTag = objTag == argsTag ? objectTag : objTag;
416        }
417        if (!othIsArr) {
418          othTag = getTag(other);
419          othTag = othTag == argsTag ? objectTag : othTag;
420        }
421        var objIsObj = objTag == objectTag && !isHostObject(object), othIsObj = othTag == objectTag && !isHostObject(other), isSameTag = objTag == othTag;
422        if (isSameTag && !objIsObj) {
423          stack || (stack = new Stack());
424          return objIsArr || isTypedArray(object) ? equalArrays(object, other, equalFunc, customizer, bitmask, stack) : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
425        }
426        if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
427          var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
428          if (objIsWrapped || othIsWrapped) {
429            var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
430            stack || (stack = new Stack());
431            return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
432          }
433        }
434        if (!isSameTag) {
435          return false;
436        }
437        stack || (stack = new Stack());
438        return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
439      }
440      function baseIsMatch(object, source, matchData, customizer) {
441        var index = matchData.length, length = index, noCustomizer = !customizer;
442        if (object == null) {
443          return !length;
444        }
445        object = Object(object);
446        while (index--) {
447          var data = matchData[index];
448          if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
449            return false;
450          }
451        }
452        while (++index < length) {
453          data = matchData[index];
454          var key = data[0], objValue = object[key], srcValue = data[1];
455          if (noCustomizer && data[2]) {
456            if (objValue === void 0 && !(key in object)) {
457              return false;
458            }
459          } else {
460            var stack = new Stack();
461            if (customizer) {
462              var result = customizer(objValue, srcValue, key, object, source, stack);
463            }
464            if (!(result === void 0 ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) : result)) {
465              return false;
466            }
467          }
468        }
469        return true;
470      }
471      function baseIsNative(value) {
472        if (!isObject2(value) || isMasked(value)) {
473          return false;
474        }
475        var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
476        return pattern.test(toSource(value));
477      }
478      function baseIsTypedArray(value) {
479        return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objectToString.call(value)];
480      }
481      function baseIteratee(value) {
482        if (typeof value == "function") {
483          return value;
484        }
485        if (value == null) {
486          return identity;
487        }
488        if (typeof value == "object") {
489          return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
490        }
491        return property(value);
492      }
493      function baseKeys(object) {
494        if (!isPrototype(object)) {
495          return nativeKeys(object);
496        }
497        var result = [];
498        for (var key in Object(object)) {
499          if (hasOwnProperty.call(object, key) && key != "constructor") {
500            result.push(key);
501          }
502        }
503        return result;
504      }
505      function baseMatches(source) {
506        var matchData = getMatchData(source);
507        if (matchData.length == 1 && matchData[0][2]) {
508          return matchesStrictComparable(matchData[0][0], matchData[0][1]);
509        }
510        return function(object) {
511          return object === source || baseIsMatch(object, source, matchData);
512        };
513      }
514      function baseMatchesProperty(path, srcValue) {
515        if (isKey(path) && isStrictComparable(srcValue)) {
516          return matchesStrictComparable(toKey(path), srcValue);
517        }
518        return function(object) {
519          var objValue = get(object, path);
520          return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
521        };
522      }
523      function basePropertyDeep(path) {
524        return function(object) {
525          return baseGet(object, path);
526        };
527      }
528      function baseToString(value) {
529        if (typeof value == "string") {
530          return value;
531        }
532        if (isSymbol(value)) {
533          return symbolToString ? symbolToString.call(value) : "";
534        }
535        var result = value + "";
536        return result == "0" && 1 / value == -INFINITY ? "-0" : result;
537      }
538      function castPath(value) {
539        return isArray(value) ? value : stringToPath(value);
540      }
541      function createAggregator(setter, initializer) {
542        return function(collection, iteratee) {
543          var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
544          return func(collection, setter, baseIteratee(iteratee, 2), accumulator);
545        };
546      }
547      function createBaseEach(eachFunc, fromRight) {
548        return function(collection, iteratee) {
549          if (collection == null) {
550            return collection;
551          }
552          if (!isArrayLike2(collection)) {
553            return eachFunc(collection, iteratee);
554          }
555          var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
556          while (fromRight ? index-- : ++index < length) {
557            if (iteratee(iterable[index], index, iterable) === false) {
558              break;
559            }
560          }
561          return collection;
562        };
563      }
564      function createBaseFor(fromRight) {
565        return function(object, iteratee, keysFunc) {
566          var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
567          while (length--) {
568            var key = props[fromRight ? length : ++index];
569            if (iteratee(iterable[key], key, iterable) === false) {
570              break;
571            }
572          }
573          return object;
574        };
575      }
576      function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
577        var isPartial = bitmask & PARTIAL_COMPARE_FLAG, arrLength = array.length, othLength = other.length;
578        if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
579          return false;
580        }
581        var stacked = stack.get(array);
582        if (stacked && stack.get(other)) {
583          return stacked == other;
584        }
585        var index = -1, result = true, seen = bitmask & UNORDERED_COMPARE_FLAG ? new SetCache() : void 0;
586        stack.set(array, other);
587        stack.set(other, array);
588        while (++index < arrLength) {
589          var arrValue = array[index], othValue = other[index];
590          if (customizer) {
591            var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
592          }
593          if (compared !== void 0) {
594            if (compared) {
595              continue;
596            }
597            result = false;
598            break;
599          }
600          if (seen) {
601            if (!arraySome(other, function(othValue2, othIndex) {
602              if (!seen.has(othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, customizer, bitmask, stack))) {
603                return seen.add(othIndex);
604              }
605            })) {
606              result = false;
607              break;
608            }
609          } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
610            result = false;
611            break;
612          }
613        }
614        stack["delete"](array);
615        stack["delete"](other);
616        return result;
617      }
618      function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
619        switch (tag) {
620          case dataViewTag:
621            if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
622              return false;
623            }
624            object = object.buffer;
625            other = other.buffer;
626          case arrayBufferTag:
627            if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
628              return false;
629            }
630            return true;
631          case boolTag:
632          case dateTag:
633          case numberTag:
634            return eq(+object, +other);
635          case errorTag:
636            return object.name == other.name && object.message == other.message;
637          case regexpTag:
638          case stringTag:
639            return object == other + "";
640          case mapTag:
641            var convert = mapToArray;
642          case setTag:
643            var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
644            convert || (convert = setToArray);
645            if (object.size != other.size && !isPartial) {
646              return false;
647            }
648            var stacked = stack.get(object);
649            if (stacked) {
650              return stacked == other;
651            }
652            bitmask |= UNORDERED_COMPARE_FLAG;
653            stack.set(object, other);
654            var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
655            stack["delete"](object);
656            return result;
657          case symbolTag:
658            if (symbolValueOf) {
659              return symbolValueOf.call(object) == symbolValueOf.call(other);
660            }
661        }
662        return false;
663      }
664      function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
665        var isPartial = bitmask & PARTIAL_COMPARE_FLAG, objProps = keys(object), objLength = objProps.length, othProps = keys(other), othLength = othProps.length;
666        if (objLength != othLength && !isPartial) {
667          return false;
668        }
669        var index = objLength;
670        while (index--) {
671          var key = objProps[index];
672          if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
673            return false;
674          }
675        }
676        var stacked = stack.get(object);
677        if (stacked && stack.get(other)) {
678          return stacked == other;
679        }
680        var result = true;
681        stack.set(object, other);
682        stack.set(other, object);
683        var skipCtor = isPartial;
684        while (++index < objLength) {
685          key = objProps[index];
686          var objValue = object[key], othValue = other[key];
687          if (customizer) {
688            var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
689          }
690          if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack) : compared)) {
691            result = false;
692            break;
693          }
694          skipCtor || (skipCtor = key == "constructor");
695        }
696        if (result && !skipCtor) {
697          var objCtor = object.constructor, othCtor = other.constructor;
698          if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
699            result = false;
700          }
701        }
702        stack["delete"](object);
703        stack["delete"](other);
704        return result;
705      }
706      function getMapData(map, key) {
707        var data = map.__data__;
708        return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
709      }
710      function getMatchData(object) {
711        var result = keys(object), length = result.length;
712        while (length--) {
713          var key = result[length], value = object[key];
714          result[length] = [key, value, isStrictComparable(value)];
715        }
716        return result;
717      }
718      function getNative(object, key) {
719        var value = getValue(object, key);
720        return baseIsNative(value) ? value : void 0;
721      }
722      var getTag = baseGetTag;
723      if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
724        getTag = function(value) {
725          var result = objectToString.call(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : void 0;
726          if (ctorString) {
727            switch (ctorString) {
728              case dataViewCtorString:
729                return dataViewTag;
730              case mapCtorString:
731                return mapTag;
732              case promiseCtorString:
733                return promiseTag;
734              case setCtorString:
735                return setTag;
736              case weakMapCtorString:
737                return weakMapTag;
738            }
739          }
740          return result;
741        };
742      }
743      function hasPath(object, path, hasFunc) {
744        path = isKey(path, object) ? [path] : castPath(path);
745        var result, index = -1, length = path.length;
746        while (++index < length) {
747          var key = toKey(path[index]);
748          if (!(result = object != null && hasFunc(object, key))) {
749            break;
750          }
751          object = object[key];
752        }
753        if (result) {
754          return result;
755        }
756        var length = object ? object.length : 0;
757        return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
758      }
759      function isIndex(value, length) {
760        length = length == null ? MAX_SAFE_INTEGER : length;
761        return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
762      }
763      function isKey(value, object) {
764        if (isArray(value)) {
765          return false;
766        }
767        var type = typeof value;
768        if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
769          return true;
770        }
771        return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
772      }
773      function isKeyable(value) {
774        var type = typeof value;
775        return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
776      }
777      function isMasked(func) {
778        return !!maskSrcKey && maskSrcKey in func;
779      }
780      function isPrototype(value) {
781        var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
782        return value === proto;
783      }
784      function isStrictComparable(value) {
785        return value === value && !isObject2(value);
786      }
787      function matchesStrictComparable(key, srcValue) {
788        return function(object) {
789          if (object == null) {
790            return false;
791          }
792          return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
793        };
794      }
795      var stringToPath = memoize2(function(string) {
796        string = toString(string);
797        var result = [];
798        if (reLeadingDot.test(string)) {
799          result.push("");
800        }
801        string.replace(rePropName, function(match, number, quote, string2) {
802          result.push(quote ? string2.replace(reEscapeChar, "$1") : number || match);
803        });
804        return result;
805      });
806      function toKey(value) {
807        if (typeof value == "string" || isSymbol(value)) {
808          return value;
809        }
810        var result = value + "";
811        return result == "0" && 1 / value == -INFINITY ? "-0" : result;
812      }
813      function toSource(func) {
814        if (func != null) {
815          try {
816            return funcToString.call(func);
817          } catch (e) {
818          }
819          try {
820            return func + "";
821          } catch (e) {
822          }
823        }
824        return "";
825      }
826      var groupBy2 = createAggregator(function(result, value, key) {
827        if (hasOwnProperty.call(result, key)) {
828          result[key].push(value);
829        } else {
830          result[key] = [value];
831        }
832      });
833      function memoize2(func, resolver) {
834        if (typeof func != "function" || resolver && typeof resolver != "function") {
835          throw new TypeError(FUNC_ERROR_TEXT);
836        }
837        var memoized = function() {
838          var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
839          if (cache.has(key)) {
840            return cache.get(key);
841          }
842          var result = func.apply(this, args);
843          memoized.cache = cache.set(key, result);
844          return result;
845        };
846        memoized.cache = new (memoize2.Cache || MapCache)();
847        return memoized;
848      }
849      memoize2.Cache = MapCache;
850      function eq(value, other) {
851        return value === other || value !== value && other !== other;
852      }
853      function isArguments(value) {
854        return isArrayLikeObject(value) && hasOwnProperty.call(value, "callee") && (!propertyIsEnumerable.call(value, "callee") || objectToString.call(value) == argsTag);
855      }
856      var isArray = Array.isArray;
857      function isArrayLike2(value) {
858        return value != null && isLength(value.length) && !isFunction(value);
859      }
860      function isArrayLikeObject(value) {
861        return isObjectLike(value) && isArrayLike2(value);
862      }
863      function isFunction(value) {
864        var tag = isObject2(value) ? objectToString.call(value) : "";
865        return tag == funcTag || tag == genTag;
866      }
867      function isLength(value) {
868        return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
869      }
870      function isObject2(value) {
871        var type = typeof value;
872        return !!value && (type == "object" || type == "function");
873      }
874      function isObjectLike(value) {
875        return !!value && typeof value == "object";
876      }
877      function isSymbol(value) {
878        return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
879      }
880      var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
881      function toString(value) {
882        return value == null ? "" : baseToString(value);
883      }
884      function get(object, path, defaultValue) {
885        var result = object == null ? void 0 : baseGet(object, path);
886        return result === void 0 ? defaultValue : result;
887      }
888      function hasIn(object, path) {
889        return object != null && hasPath(object, path, baseHasIn);
890      }
891      function keys(object) {
892        return isArrayLike2(object) ? arrayLikeKeys(object) : baseKeys(object);
893      }
894      function identity(value) {
895        return value;
896      }
897      function property(path) {
898        return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
899      }
900      module.exports = groupBy2;
901    }
902  });
903
904  

904// ../../../node_modules/lodash.isequal/index.js
905  var require_lodash2 = __commonJS({
906    "../../../node_modules/lodash.isequal/index.js"(exports, module) {
907      var LARGE_ARRAY_SIZE = 200;
908      var HASH_UNDEFINED = "__lodash_hash_undefined__";
909      var COMPARE_PARTIAL_FLAG = 1;
910      var COMPARE_UNORDERED_FLAG = 2;
911      var MAX_SAFE_INTEGER = 9007199254740991;
912      var argsTag = "[object Arguments]";
913      var arrayTag = "[object Array]";
914      var asyncTag = "[object AsyncFunction]";
915      var boolTag = "[object Boolean]";
916      var dateTag = "[object Date]";
917      var errorTag = "[object Error]";
918      var funcTag = "[object Function]";
919      var genTag = "[object GeneratorFunction]";
920      var mapTag = "[object Map]";
921      var numberTag = "[object Number]";
922      var nullTag = "[object Null]";
923      var objectTag = "[object Object]";
924      var promiseTag = "[object Promise]";
925      var proxyTag = "[object Proxy]";
926      var regexpTag = "[object RegExp]";
927      var setTag = "[object Set]";
928      var stringTag = "[object String]";
929      var symbolTag = "[object Symbol]";
930      var undefinedTag = "[object Undefined]";
931      var weakMapTag = "[object WeakMap]";
932      var arrayBufferTag = "[object ArrayBuffer]";
933      var dataViewTag = "[object DataView]";
934      var float32Tag = "[object Float32Array]";
935      var float64Tag = "[object Float64Array]";
936      var int8Tag = "[object Int8Array]";
937      var int16Tag = "[object Int16Array]";
938      var int32Tag = "[object Int32Array]";
939      var uint8Tag = "[object Uint8Array]";
940      var uint8ClampedTag = "[object Uint8ClampedArray]";
941      var uint16Tag = "[object Uint16Array]";
942      var uint32Tag = "[object Uint32Array]";
943      var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
944      var reIsHostCtor = /^\[object .+?Constructor\]$/;
945      var reIsUint = /^(?:0|[1-9]\d*)$/;
946      var typedArrayTags = {};
947      typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
948      typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
949      var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
950      var freeSelf = typeof self == "object" && self && self.Object === Object && self;
951      var root = freeGlobal || freeSelf || Function("return this")();
952      var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
953      var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
954      var moduleExports = freeModule && freeModule.exports === freeExports;
955      var freeProcess = moduleExports && freeGlobal.process;
956      var nodeUtil = function() {
957        try {
958          return freeProcess && freeProcess.binding && freeProcess.binding("util");
959        } catch (e) {
960        }
961      }();
962      var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
963      function arrayFilter(array, predicate) {
964        var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
965        while (++index < length) {
966          var value = array[index];
967          if (predicate(value, index, array)) {
968            result[resIndex++] = value;
969          }
970        }
971        return result;
972      }
973      function arrayPush(array, values) {
974        var index = -1, length = values.length, offset = array.length;
975        while (++index < length) {
976          array[offset + index] = values[index];
977        }
978        return array;
979      }
980      function arraySome(array, predicate) {
981        var index = -1, length = array == null ? 0 : array.length;
982        while (++index < length) {
983          if (predicate(array[index], index, array)) {
984            return true;
985          }
986        }
987        return false;
988      }
989      function baseTimes(n, iteratee) {
990        var index = -1, result = Array(n);
991        while (++index < n) {
992          result[index] = iteratee(index);
993        }
994        return result;
995      }
996      function baseUnary(func) {
997        return function(value) {
998          return func(value);
999        };
1000      }
1001      function cacheHas(cache, key) {
1002        return cache.has(key);
1003      }
1004      function getValue(object, key) {
1005        return object == null ? void 0 : object[key];
1006      }
1007      function mapToArray(map) {
1008        var index = -1, result = Array(map.size);
1009        map.forEach(function(value, key) {
1010          result[++index] = [key, value];
1011        });
1012        return result;
1013      }
1014      function overArg(func, transform) {
1015        return function(arg) {
1016          return func(transform(arg));
1017        };
1018      }
1019      function setToArray(set) {
1020        var index = -1, result = Array(set.size);
1021        set.forEach(function(value) {
1022          result[++index] = value;
1023        });
1024        return result;
1025      }
1026      var arrayProto = Array.prototype;
1027      var funcProto = Function.prototype;
1028      var objectProto = Object.prototype;
1029      var coreJsData = root["__core-js_shared__"];
1030      var funcToString = funcProto.toString;
1031      var hasOwnProperty = objectProto.hasOwnProperty;
1032      var maskSrcKey = function() {
1033        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
1034        return uid ? "Symbol(src)_1." + uid : "";
1035      }();
1036      var nativeObjectToString = objectProto.toString;
1037      var reIsNative = RegExp(
1038        "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
1039      );
1040      var Buffer2 = moduleExports ? root.Buffer : void 0;
1041      var Symbol2 = root.Symbol;
1042      var Uint8Array2 = root.Uint8Array;
1043      var propertyIsEnumerable = objectProto.propertyIsEnumerable;
1044      var splice = arrayProto.splice;
1045      var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
1046      var nativeGetSymbols = Object.getOwnPropertySymbols;
1047      var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
1048      var nativeKeys = overArg(Object.keys, Object);
1049      var DataView = getNative(root, "DataView");
1050      var Map2 = getNative(root, "Map");
1051      var Promise2 = getNative(root, "Promise");
1052      var Set2 = getNative(root, "Set");
1053      var WeakMap2 = getNative(root, "WeakMap");
1054      var nativeCreate = getNative(Object, "create");
1055      var dataViewCtorString = toSource(DataView);
1056      var mapCtorString = toSource(Map2);
1057      var promiseCtorString = toSource(Promise2);
1058      var setCtorString = toSource(Set2);
1059      var weakMapCtorString = toSource(WeakMap2);
1060      var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
1061      var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
1062      function Hash(entries) {
1063        var index = -1, length = entries == null ? 0 : entries.length;
1064        this.clear();
1065        while (++index < length) {
1066          var entry = entries[index];
1067          this.set(entry[0], entry[1]);
1068        }
1069      }
1070      function hashClear() {
1071        this.__data__ = nativeCreate ? nativeCreate(null) : {};
1072        this.size = 0;
1073      }
1074      function hashDelete(key) {
1075        var result = this.has(key) && delete this.__data__[key];
1076        this.size -= result ? 1 : 0;
1077        return result;
1078      }
1079      function hashGet(key) {
1080        var data = this.__data__;
1081        if (nativeCreate) {
1082          var result = data[key];
1083          return result === HASH_UNDEFINED ? void 0 : result;
1084        }
1085        return hasOwnProperty.call(data, key) ? data[key] : void 0;
1086      }
1087      function hashHas(key) {
1088        var data = this.__data__;
1089        return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
1090      }
1091      function hashSet(key, value) {
1092        var data = this.__data__;
1093        this.size += this.has(key) ? 0 : 1;
1094        data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
1095        return this;
1096      }
1097      Hash.prototype.clear = hashClear;
1098      Hash.prototype["delete"] = hashDelete;
1099      Hash.prototype.get = hashGet;
1100      Hash.prototype.has = hashHas;
1101      Hash.prototype.set = hashSet;
1102      function ListCache(entries) {
1103        var index = -1, length = entries == null ? 0 : entries.length;
1104        this.clear();
1105        while (++index < length) {
1106          var entry = entries[index];
1107          this.set(entry[0], entry[1]);
1108        }
1109      }
1110      function listCacheClear() {
1111        this.__data__ = [];
1112        this.size = 0;
1113      }
1114      function listCacheDelete(key) {
1115        var data = this.__data__, index = assocIndexOf(data, key);
1116        if (index < 0) {
1117          return false;
1118        }
1119        var lastIndex = data.length - 1;
1120        if (index == lastIndex) {
1121          data.pop();
1122        } else {
1123          splice.call(data, index, 1);
1124        }
1125        --this.size;
1126        return true;
1127      }
1128      function listCacheGet(key) {
1129        var data = this.__data__, index = assocIndexOf(data, key);
1130        return index < 0 ? void 0 : data[index][1];
1131      }
1132      function listCacheHas(key) {
1133        return assocIndexOf(this.__data__, key) > -1;
1134      }
1135      function listCacheSet(key, value) {
1136        var data = this.__data__, index = assocIndexOf(data, key);
1137        if (index < 0) {
1138          ++this.size;
1139          data.push([key, value]);
1140        } else {
1141          data[index][1] = value;
1142        }
1143        return this;
1144      }
1145      ListCache.prototype.clear = listCacheClear;
1146      ListCache.prototype["delete"] = listCacheDelete;
1147      ListCache.prototype.get = listCacheGet;
1148      ListCache.prototype.has = listCacheHas;
1149      ListCache.prototype.set = listCacheSet;
1150      function MapCache(entries) {
1151        var index = -1, length = entries == null ? 0 : entries.length;
1152        this.clear();
1153        while (++index < length) {
1154          var entry = entries[index];
1155          this.set(entry[0], entry[1]);
1156        }
1157      }
1158      function mapCacheClear() {
1159        this.size = 0;
1160        this.__data__ = {
1161          "hash": new Hash(),
1162          "map": new (Map2 || ListCache)(),
1163          "string": new Hash()
1164        };
1165      }
1166      function mapCacheDelete(key) {
1167        var result = getMapData(this, key)["delete"](key);
1168        this.size -= result ? 1 : 0;
1169        return result;
1170      }
1171      function mapCacheGet(key) {
1172        return getMapData(this, key).get(key);
1173      }
1174      function mapCacheHas(key) {
1175        return getMapData(this, key).has(key);
1176      }
1177      function mapCacheSet(key, value) {
1178        var data = getMapData(this, key), size = data.size;
1179        data.set(key, value);
1180        this.size += data.size == size ? 0 : 1;
1181        return this;
1182      }
1183      MapCache.prototype.clear = mapCacheClear;
1184      MapCache.prototype["delete"] = mapCacheDelete;
1185      MapCache.prototype.get = mapCacheGet;
1186      MapCache.prototype.has = mapCacheHas;
1187      MapCache.prototype.set = mapCacheSet;
1188      function SetCache(values) {
1189        var index = -1, length = values == null ? 0 : values.length;
1190        this.__data__ = new MapCache();
1191        while (++index < length) {
1192          this.add(values[index]);
1193        }
1194      }
1195      function setCacheAdd(value) {
1196        this.__data__.set(value, HASH_UNDEFINED);
1197        return this;
1198      }
1199      function setCacheHas(value) {
1200        return this.__data__.has(value);
1201      }
1202      SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
1203      SetCache.prototype.has = setCacheHas;
1204      function Stack(entries) {
1205        var data = this.__data__ = new ListCache(entries);
1206        this.size = data.size;
1207      }
1208      function stackClear() {
1209        this.__data__ = new ListCache();
1210        this.size = 0;
1211      }
1212      function stackDelete(key) {
1213        var data = this.__data__, result = data["delete"](key);
1214        this.size = data.size;
1215        return result;
1216      }
1217      function stackGet(key) {
1218        return this.__data__.get(key);
1219      }
1220      function stackHas(key) {
1221        return this.__data__.has(key);
1222      }
1223      function stackSet(key, value) {
1224        var data = this.__data__;
1225        if (data instanceof ListCache) {
1226          var pairs = data.__data__;
1227          if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
1228            pairs.push([key, value]);
1229            this.size = ++data.size;
1230            return this;
1231          }
1232          data = this.__data__ = new MapCache(pairs);
1233        }
1234        data.set(key, value);
1235        this.size = data.size;
1236        return this;
1237      }
1238      Stack.prototype.clear = stackClear;
1239      Stack.prototype["delete"] = stackDelete;
1240      Stack.prototype.get = stackGet;
1241      Stack.prototype.has = stackHas;
1242      Stack.prototype.set = stackSet;
1243      function arrayLikeKeys(value, inherited) {
1244        var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
1245        for (var key in value) {
1246          if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
1247          (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
1248          isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
1249          isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
1250          isIndex(key, length)))) {
1251            result.push(key);
1252          }
1253        }
1254        return result;
1255      }
1256      function assocIndexOf(array, key) {
1257        var length = array.length;
1258        while (length--) {
1259          if (eq(array[length][0], key)) {
1260            return length;
1261          }
1262        }
1263        return -1;
1264      }
1265      function baseGetAllKeys(object, keysFunc, symbolsFunc) {
1266        var result = keysFunc(object);
1267        return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
1268      }
1269      function baseGetTag(value) {
1270        if (value == null) {
1271          return value === void 0 ? undefinedTag : nullTag;
1272        }
1273        return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
1274      }
1275      function baseIsArguments(value) {
1276        return isObjectLike(value) && baseGetTag(value) == argsTag;
1277      }
1278      function baseIsEqual(value, other, bitmask, customizer, stack) {
1279        if (value === other) {
1280          return true;
1281        }
1282        if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
1283          return value !== value && other !== other;
1284        }
1285        return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
1286      }
1287      function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
1288        var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
1289        objTag = objTag == argsTag ? objectTag : objTag;
1290        othTag = othTag == argsTag ? objectTag : othTag;
1291        var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
1292        if (isSameTag && isBuffer(object)) {
1293          if (!isBuffer(other)) {
1294            return false;
1295          }
1296          objIsArr = true;
1297          objIsObj = false;
1298        }
1299        if (isSameTag && !objIsObj) {
1300          stack || (stack = new Stack());
1301          return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
1302        }
1303        if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
1304          var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
1305          if (objIsWrapped || othIsWrapped) {
1306            var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
1307            stack || (stack = new Stack());
1308            return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
1309          }
1310        }
1311        if (!isSameTag) {
1312          return false;
1313        }
1314        stack || (stack = new Stack());
1315        return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
1316      }
1317      function baseIsNative(value) {
1318        if (!isObject2(value) || isMasked(value)) {
1319          return false;
1320        }
1321        var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
1322        return pattern.test(toSource(value));
1323      }
1324      function baseIsTypedArray(value) {
1325        return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
1326      }
1327      function baseKeys(object) {
1328        if (!isPrototype(object)) {
1329          return nativeKeys(object);
1330        }
1331        var result = [];
1332        for (var key in Object(object)) {
1333          if (hasOwnProperty.call(object, key) && key != "constructor") {
1334            result.push(key);
1335          }
1336        }
1337        return result;
1338      }
1339      function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
1340        var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
1341        if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
1342          return false;
1343        }
1344        var stacked = stack.get(array);
1345        if (stacked && stack.get(other)) {
1346          return stacked == other;
1347        }
1348        var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
1349        stack.set(array, other);
1350        stack.set(other, array);
1351        while (++index < arrLength) {
1352          var arrValue = array[index], othValue = other[index];
1353          if (customizer) {
1354            var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
1355          }
1356          if (compared !== void 0) {
1357            if (compared) {
1358              continue;
1359            }
1360            result = false;
1361            break;
1362          }
1363          if (seen) {
1364            if (!arraySome(other, function(othValue2, othIndex) {
1365              if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
1366                return seen.push(othIndex);
1367              }
1368            })) {
1369              result = false;
1370              break;
1371            }
1372          } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
1373            result = false;
1374            break;
1375          }
1376        }
1377        stack["delete"](array);
1378        stack["delete"](other);
1379        return result;
1380      }
1381      function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
1382        switch (tag) {
1383          case dataViewTag:
1384            if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
1385              return false;
1386            }
1387            object = object.buffer;
1388            other = other.buffer;
1389          case arrayBufferTag:
1390            if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
1391              return false;
1392            }
1393            return true;
1394          case boolTag:
1395          case dateTag:
1396          case numberTag:
1397            return eq(+object, +other);
1398          case errorTag:
1399            return object.name == other.name && object.message == other.message;
1400          case regexpTag:
1401          case stringTag:
1402            return object == other + "";
1403          case mapTag:
1404            var convert = mapToArray;
1405          case setTag:
1406            var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
1407            convert || (convert = setToArray);
1408            if (object.size != other.size && !isPartial) {
1409              return false;
1410            }
1411            var stacked = stack.get(object);
1412            if (stacked) {
1413              return stacked == other;
1414            }
1415            bitmask |= COMPARE_UNORDERED_FLAG;
1416            stack.set(object, other);
1417            var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
1418            stack["delete"](object);
1419            return result;
1420          case symbolTag:
1421            if (symbolValueOf) {
1422              return symbolValueOf.call(object) == symbolValueOf.call(other);
1423            }
1424        }
1425        return false;
1426      }
1427      function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
1428        var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
1429        if (objLength != othLength && !isPartial) {
1430          return false;
1431        }
1432        var index = objLength;
1433        while (index--) {
1434          var key = objProps[index];
1435          if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
1436            return false;
1437          }
1438        }
1439        var stacked = stack.get(object);
1440        if (stacked && stack.get(other)) {
1441          return stacked == other;
1442        }
1443        var result = true;
1444        stack.set(object, other);
1445        stack.set(other, object);
1446        var skipCtor = isPartial;
1447        while (++index < objLength) {
1448          key = objProps[index];
1449          var objValue = object[key], othValue = other[key];
1450          if (customizer) {
1451            var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
1452          }
1453          if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
1454            result = false;
1455            break;
1456          }
1457          skipCtor || (skipCtor = key == "constructor");
1458        }
1459        if (result && !skipCtor) {
1460          var objCtor = object.constructor, othCtor = other.constructor;
1461          if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
1462            result = false;
1463          }
1464        }
1465        stack["delete"](object);
1466        stack["delete"](other);
1467        return result;
1468      }
1469      function getAllKeys(object) {
1470        return baseGetAllKeys(object, keys, getSymbols);
1471      }
1472      function getMapData(map, key) {
1473        var data = map.__data__;
1474        return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
1475      }
1476      function getNative(object, key) {
1477        var value = getValue(object, key);
1478        return baseIsNative(value) ? value : void 0;
1479      }
1480      function getRawTag(value) {
1481        var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
1482        try {
1483          value[symToStringTag] = void 0;
1484          var unmasked = true;
1485        } catch (e) {
1486        }
1487        var result = nativeObjectToString.call(value);
1488        if (unmasked) {
1489          if (isOwn) {
1490            value[symToStringTag] = tag;
1491          } else {
1492            delete value[symToStringTag];
1493          }
1494        }
1495        return result;
1496      }
1497      var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
1498        if (object == null) {
1499          return [];
1500        }
1501        object = Object(object);
1502        return arrayFilter(nativeGetSymbols(object), function(symbol) {
1503          return propertyIsEnumerable.call(object, symbol);
1504        });
1505      };
1506      var getTag = baseGetTag;
1507      if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
1508        getTag = function(value) {
1509          var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
1510          if (ctorString) {
1511            switch (ctorString) {
1512              case dataViewCtorString:
1513                return dataViewTag;
1514              case mapCtorString:
1515                return mapTag;
1516              case promiseCtorString:
1517                return promiseTag;
1518              case setCtorString:
1519                return setTag;
1520              case weakMapCtorString:
1521                return weakMapTag;
1522            }
1523          }
1524          return result;
1525        };
1526      }
1527      function isIndex(value, length) {
1528        length = length == null ? MAX_SAFE_INTEGER : length;
1529        return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
1530      }
1531      function isKeyable(value) {
1532        var type = typeof value;
1533        return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
1534      }
1535      function isMasked(func) {
1536        return !!maskSrcKey && maskSrcKey in func;
1537      }
1538      function isPrototype(value) {
1539        var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
1540        return value === proto;
1541      }
1542      function objectToString(value) {
1543        return nativeObjectToString.call(value);
1544      }
1545      function toSource(func) {
1546        if (func != null) {
1547          try {
1548            return funcToString.call(func);
1549          } catch (e) {
1550          }
1551          try {
1552            return func + "";
1553          } catch (e) {
1554          }
1555        }
1556        return "";
1557      }
1558      function eq(value, other) {
1559        return value === other || value !== value && other !== other;
1560      }
1561      var isArguments = baseIsArguments(/* @__PURE__ */ function() {
1562        return arguments;
1563      }()) ? baseIsArguments : function(value) {
1564        return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
1565      };
1566      var isArray = Array.isArray;
1567      function isArrayLike2(value) {
1568        return value != null && isLength(value.length) && !isFunction(value);
1569      }
1570      var isBuffer = nativeIsBuffer || stubFalse;
1571      function isEqual2(value, other) {
1572        return baseIsEqual(value, other);
1573      }
1574      function isFunction(value) {
1575        if (!isObject2(value)) {
1576          return false;
1577        }
1578        var tag = baseGetTag(value);
1579        return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
1580      }
1581      function isLength(value) {
1582        return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
1583      }
1584      function isObject2(value) {
1585        var type = typeof value;
1586        return value != null && (type == "object" || type == "function");
1587      }
1588      function isObjectLike(value) {
1589        return value != null && typeof value == "object";
1590      }
1591      var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
1592      function keys(object) {
1593        return isArrayLike2(object) ? arrayLikeKeys(object) : baseKeys(object);
1594      }
1595      function stubArray() {
1596        return [];
1597      }
1598      function stubFalse() {
1599        return false;
1600      }
1601      module.exports = isEqual2;
1602    }
1603  });
1604
1605