PageSourceSearch
Opt out API access

https://spa-cart.websupport.sk/assets/vendor-utils-j6SE9MGc.js

js websupport.sk collected 2026-10-02 02:25:51 UTC 88,772 bytes, 2,723 lines download raw bytes

vendor: 4,306 bytes, lines 1-128
1var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
2var freeSelf = typeof self == "object" && self && self.Object === Object && self;
3var root = freeGlobal || freeSelf || Function("return this")();
4var Symbol$1 = root.Symbol;
5var objectProto$g = Object.prototype;
6var hasOwnProperty$d = objectProto$g.hasOwnProperty;
7var nativeObjectToString$1 = objectProto$g.toString;
8var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
9function getRawTag(value) {
10  var isOwn = hasOwnProperty$d.call(value, symToStringTag$1), tag = value[symToStringTag$1];
11  try {
12    value[symToStringTag$1] = void 0;
13    var unmasked = true;
14  } catch (e) {
15  }
16  var result = nativeObjectToString$1.call(value);
17  if (unmasked) {
18    if (isOwn) {
19      value[symToStringTag$1] = tag;
20    } else {
21      delete value[symToStringTag$1];
22    }
23  }
24  return result;
25}
26var objectProto$f = Object.prototype;
27var nativeObjectToString = objectProto$f.toString;
28function objectToString(value) {
29  return nativeObjectToString.call(value);
30}
31var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
32var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
33function baseGetTag(value) {
34  if (value == null) {
35    return value === void 0 ? undefinedTag : nullTag;
36  }
37  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
38}
39function isObjectLike(value) {
40  return value != null && typeof value == "object";
41}
42var symbolTag$3 = "[object Symbol]";
43function isSymbol(value) {
44  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$3;
45}
46function arrayMap(array, iteratee) {
47  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
48  while (++index < length) {
49    result[index] = iteratee(array[index], index, array);
50  }
51  return result;
52}
53var isArray = Array.isArray;
54var symbolProto$2 = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto$2 ? symbolProto$2.toString : void 0;
55function baseToString(value) {
56  if (typeof value == "string") {
57    return value;
58  }
59  if (isArray(value)) {
60    return arrayMap(value, baseToString) + "";
61  }
62  if (isSymbol(value)) {
63    return symbolToString ? symbolToString.call(value) : "";
64  }
65  var result = value + "";
66  return result == "0" && 1 / value == -Infinity ? "-0" : result;
67}
68var reWhitespace = /\s/;
69function trimmedEndIndex(string) {
70  var index = string.length;
71  while (index-- && reWhitespace.test(string.charAt(index))) {
72  }
73  return index;
74}
75var reTrimStart = /^\s+/;
76function baseTrim(string) {
77  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
78}
79function isObject(value) {
80  var type = typeof value;
81  return value != null && (type == "object" || type == "function");
82}
83var NAN = 0 / 0;
84var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
85var reIsBinary = /^0b[01]+$/i;
86var reIsOctal = /^0o[0-7]+$/i;
87var freeParseInt = parseInt;
88function toNumber(value) {
89  if (typeof value == "number") {
90    return value;
91  }
92  if (isSymbol(value)) {
93    return NAN;
94  }
95  if (isObject(value)) {
96    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
97    value = isObject(other) ? other + "" : other;
98  }
99  if (typeof value != "string") {
100    return value === 0 ? value : +value;
101  }
102  value = baseTrim(value);
103  var isBinary = reIsBinary.test(value);
104  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
105}
106var INFINITY$1 = 1 / 0, MAX_INTEGER = 17976931348623157e292;
107function toFinite(value) {
108  if (!value) {
109    return value === 0 ? value : 0;
110  }
111  value = toNumber(value);
112  if (value === INFINITY$1 || value === -INFINITY$1) {
113    var sign = value < 0 ? -1 : 1;
114    return sign * MAX_INTEGER;
115  }
116  return value === value ? value : 0;
117}
118function toInteger(value) {
119  var result = toFinite(value), remainder = result % 1;
120  return result === result ? remainder ? result - remainder : result : 0;
121}
122function identity(value) {
123  return value;
124}
125var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
126function isFunction(value) {
127  if (!isObject(value)) {
128    return false;

129  }
130  var tag = baseGetTag(value);
131  return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
132}
133var coreJsData = root["__core-js_shared__"];
134var maskSrcKey = (function() {
135  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
136  return uid ? "Symbol(src)_1." + uid : "";
137})();
138function isMasked(func) {
139  return !!maskSrcKey && maskSrcKey in func;
140}
141var funcProto$2 = Function.prototype;
142var funcToString$2 = funcProto$2.toString;
143function toSource(func) {
144  if (func != null) {
145    try {
146      return funcToString$2.call(func);
147    } catch (e) {
148    }
149    try {
150      return func + "";
151    } catch (e) {
152    }
153  }
154  return "";
155}
156var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
157var reIsHostCtor = /^\[object .+?Constructor\]$/;
158var funcProto$1 = Function.prototype, objectProto$e = Object.prototype;
159var funcToString$1 = funcProto$1.toString;
160var hasOwnProperty$c = objectProto$e.hasOwnProperty;
161var reIsNative = RegExp(
162  "^" + funcToString$1.call(hasOwnProperty$c).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
163);
164function baseIsNative(value) {
165  if (!isObject(value) || isMasked(value)) {
166    return false;
167  }
168  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
169  return pattern.test(toSource(value));
170}
171function getValue(object, key) {
172  return object == null ? void 0 : object[key];
173}
174function getNative(object, key) {
175  var value = getValue(object, key);
176  return baseIsNative(value) ? value : void 0;
177}
178var WeakMap = getNative(root, "WeakMap");
179var objectCreate = Object.create;
180var baseCreate = /* @__PURE__ */ (function() {
181  function object() {
182  }
183  return function(proto) {
184    if (!isObject(proto)) {
185      return {};
186    }
187    if (objectCreate) {
188      return objectCreate(proto);
189    }
190    object.prototype = proto;
191    var result = new object();
192    object.prototype = void 0;
193    return result;
194  };
195})();
196function apply(func, thisArg, args) {
197  switch (args.length) {
198    case 0:
199      return func.call(thisArg);
200    case 1:
201      return func.call(thisArg, args[0]);
202    case 2:
203      return func.call(thisArg, args[0], args[1]);
204    case 3:
205      return func.call(thisArg, args[0], args[1], args[2]);
206  }
207  return func.apply(thisArg, args);
208}
209function noop() {
210}
211function copyArray(source, array) {
212  var index = -1, length = source.length;
213  array || (array = Array(length));
214  while (++index < length) {
215    array[index] = source[index];
216  }
217  return array;
218}
219var HOT_COUNT = 800, HOT_SPAN = 16;
220var nativeNow = Date.now;
221function shortOut(func) {
222  var count = 0, lastCalled = 0;
223  return function() {
224    var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
225    lastCalled = stamp;
226    if (remaining > 0) {
227      if (++count >= HOT_COUNT) {
228        return arguments[0];
229      }
230    } else {
231      count = 0;
232    }
233    return func.apply(void 0, arguments);
234  };
235}
236function constant(value) {
237  return function() {
238    return value;
239  };
240}
241var defineProperty = (function() {
242  try {
243    var func = getNative(Object, "defineProperty");
244    func({}, "", {});
245    return func;
246  } catch (e) {
247  }
248})();
249var baseSetToString = !defineProperty ? identity : function(func, string) {
250  return defineProperty(func, "toString", {
251    "configurable": true,
252    "enumerable": false,
253    "value": constant(string),
254    "writable": true
255  });
256};
257var setToString = shortOut(baseSetToString);
258function arrayEach(array, iteratee) {
259  var index = -1, length = array == null ? 0 : array.length;
260  while (++index < length) {
261    if (iteratee(array[index], index, array) === false) {
262      break;
263    }
264  }
265  return array;
266}
267function baseFindIndex(array, predicate, fromIndex, fromRight) {
268  var length = array.length, index = fromIndex + -1;
269  while (++index < length) {
270    if (predicate(array[index], index, array)) {
271      return index;
272    }
273  }
274  return -1;
275}
276function baseIsNaN(value) {
277  return value !== value;
278}
279function strictIndexOf(array, value, fromIndex) {
280  var index = fromIndex - 1, length = array.length;
281  while (++index < length) {
282    if (array[index] === value) {
283      return index;
284    }
285  }
286  return -1;
287}
288function baseIndexOf(array, value, fromIndex) {

289  return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
290}
291function arrayIncludes(array, value) {
292  var length = array == null ? 0 : array.length;
293  return !!length && baseIndexOf(array, value, 0) > -1;
294}
295var MAX_SAFE_INTEGER$1 = 9007199254740991;
296var reIsUint = /^(?:0|[1-9]\d*)$/;
297function isIndex(value, length) {
298  var type = typeof value;
299  length = length == null ? MAX_SAFE_INTEGER$1 : length;
300  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
301}
302function baseAssignValue(object, key, value) {
303  if (key == "__proto__" && defineProperty) {
304    defineProperty(object, key, {
305      "configurable": true,
306      "enumerable": true,
307      "value": value,
308      "writable": true
309    });
310  } else {
311    object[key] = value;
312  }
313}
314function eq(value, other) {
315  return value === other || value !== value && other !== other;
316}
317var objectProto$d = Object.prototype;
318var hasOwnProperty$b = objectProto$d.hasOwnProperty;
319function assignValue(object, key, value) {
320  var objValue = object[key];
321  if (!(hasOwnProperty$b.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
322    baseAssignValue(object, key, value);
323  }
324}
325function copyObject(source, props, object, customizer) {
326  var isNew = !object;
327  object || (object = {});
328  var index = -1, length = props.length;
329  while (++index < length) {
330    var key = props[index];
331    var newValue = void 0;
332    if (newValue === void 0) {
333      newValue = source[key];
334    }
335    if (isNew) {
336      baseAssignValue(object, key, newValue);
337    } else {
338      assignValue(object, key, newValue);
339    }
340  }
341  return object;
342}
343var nativeMax$3 = Math.max;
344function overRest(func, start, transform) {
345  start = nativeMax$3(start === void 0 ? func.length - 1 : start, 0);
346  return function() {
347    var args = arguments, index = -1, length = nativeMax$3(args.length - start, 0), array = Array(length);
348    while (++index < length) {
349      array[index] = args[start + index];
350    }
351    index = -1;
352    var otherArgs = Array(start + 1);
353    while (++index < start) {
354      otherArgs[index] = args[index];
355    }
356    otherArgs[start] = transform(array);
357    return apply(func, this, otherArgs);
358  };
359}
360function baseRest(func, start) {
361  return setToString(overRest(func, start, identity), func + "");
362}
363var MAX_SAFE_INTEGER = 9007199254740991;
364function isLength(value) {
365  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
366}
367function isArrayLike(value) {
368  return value != null && isLength(value.length) && !isFunction(value);
369}
370function isIterateeCall(value, index, object) {
371  if (!isObject(object)) {
372    return false;
373  }
374  var type = typeof index;
375  if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
376    return eq(object[index], value);
377  }
378  return false;
379}
380function createAssigner(assigner) {
381  return baseRest(function(object, sources) {
382    var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
383    customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
384    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
385      customizer = length < 3 ? void 0 : customizer;
386      length = 1;
387    }
388    object = Object(object);
389    while (++index < length) {
390      var source = sources[index];
391      if (source) {
392        assigner(object, source, index, customizer);
393      }
394    }
395    return object;
396  });
397}
398var objectProto$c = Object.prototype;
399function isPrototype(value) {
400  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$c;
401  return value === proto;
402}
403function baseTimes(n, iteratee) {
404  var index = -1, result = Array(n);
405  while (++index < n) {
406    result[index] = iteratee(index);
407  }
408  return result;
409}
410var argsTag$3 = "[object Arguments]";
411function baseIsArguments(value) {
412  return isObjectLike(value) && baseGetTag(value) == argsTag$3;
413}
414var objectProto$b = Object.prototype;
415var hasOwnProperty$a = objectProto$b.hasOwnProperty;
416var propertyIsEnumerable$1 = objectProto$b.propertyIsEnumerable;
417var isArguments = baseIsArguments(/* @__PURE__ */ (function() {
418  return arguments;
419})()) ? baseIsArguments : function(value) {
420  return isObjectLike(value) && hasOwnProperty$a.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
421};
422function stubFalse() {
423  return false;
vendor: 10,083 bytes, lines 424-687
424}
425var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports;
426var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module;
427var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2;
428var Buffer$1 = moduleExports$2 ? root.Buffer : void 0;
429var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0;
430var isBuffer = nativeIsBuffer || stubFalse;
431var argsTag$2 = "[object Arguments]", arrayTag$2 = "[object Array]", boolTag$3 = "[object Boolean]", dateTag$3 = "[object Date]", errorTag$2 = "[object Error]", funcTag$1 = "[object Function]", mapTag$5 = "[object Map]", numberTag$4 = "[object Number]", objectTag$4 = "[object Object]", regexpTag$3 = "[object RegExp]", setTag$5 = "[object Set]", stringTag$3 = "[object String]", weakMapTag$2 = "[object WeakMap]";
432var arrayBufferTag$3 = "[object ArrayBuffer]", dataViewTag$4 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]";
433var typedArrayTags = {};
434typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
435typedArrayTags[argsTag$2] = typedArrayTags[arrayTag$2] = typedArrayTags[arrayBufferTag$3] = typedArrayTags[boolTag$3] = typedArrayTags[dataViewTag$4] = typedArrayTags[dateTag$3] = typedArrayTags[errorTag$2] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$5] = typedArrayTags[numberTag$4] = typedArrayTags[objectTag$4] = typedArrayTags[regexpTag$3] = typedArrayTags[setTag$5] = typedArrayTags[stringTag$3] = typedArrayTags[weakMapTag$2] = false;
436function baseIsTypedArray(value) {
437  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
438}
439function baseUnary(func) {
440  return function(value) {
441    return func(value);
442  };
443}
444var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
445var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
446var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
447var freeProcess = moduleExports$1 && freeGlobal.process;
448var nodeUtil = (function() {
449  try {
450    var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
451    if (types) {
452      return types;
453    }
454    return freeProcess && freeProcess.binding && freeProcess.binding("util");
455  } catch (e) {
456  }
457})();
458var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
459var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
460var objectProto$a = Object.prototype;
461var hasOwnProperty$9 = objectProto$a.hasOwnProperty;
462function arrayLikeKeys(value, inherited) {
463  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;
464  for (var key in value) {
465    if ((inherited || hasOwnProperty$9.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
466    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
467    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
468    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
469    isIndex(key, length)))) {
470      result.push(key);
471    }
472  }
473  return result;
474}
475function overArg(func, transform) {
476  return function(arg) {
477    return func(transform(arg));
478  };
479}
480var nativeKeys = overArg(Object.keys, Object);
481var objectProto$9 = Object.prototype;
482var hasOwnProperty$8 = objectProto$9.hasOwnProperty;
483function baseKeys(object) {
484  if (!isPrototype(object)) {
485    return nativeKeys(object);
486  }
487  var result = [];
488  for (var key in Object(object)) {
489    if (hasOwnProperty$8.call(object, key) && key != "constructor") {
490      result.push(key);
491    }
492  }
493  return result;
494}
495function keys(object) {
496  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
497}
498function nativeKeysIn(object) {
499  var result = [];
500  if (object != null) {
501    for (var key in Object(object)) {
502      result.push(key);
503    }
504  }
505  return result;
506}
507var objectProto$8 = Object.prototype;
508var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
509function baseKeysIn(object) {
510  if (!isObject(object)) {
511    return nativeKeysIn(object);
512  }
513  var isProto = isPrototype(object), result = [];
514  for (var key in object) {
515    if (!(key == "constructor" && (isProto || !hasOwnProperty$7.call(object, key)))) {
516      result.push(key);
517    }
518  }
519  return result;
520}
521function keysIn(object) {
522  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
523}
524var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
525function isKey(value, object) {
526  if (isArray(value)) {
527    return false;
528  }
529  var type = typeof value;
530  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
531    return true;
532  }
533  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
534}
535var nativeCreate = getNative(Object, "create");
536function hashClear() {
537  this.__data__ = nativeCreate ? nativeCreate(null) : {};
538  this.size = 0;
539}
540function hashDelete(key) {
541  var result = this.has(key) && delete this.__data__[key];
542  this.size -= result ? 1 : 0;
543  return result;
544}
545var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
546var objectProto$7 = Object.prototype;
547var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
548function hashGet(key) {
549  var data = this.__data__;
550  if (nativeCreate) {
551    var result = data[key];
552    return result === HASH_UNDEFINED$2 ? void 0 : result;
553  }
554  return hasOwnProperty$6.call(data, key) ? data[key] : void 0;
555}
556var objectProto$6 = Object.prototype;
557var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
558function hashHas(key) {
559  var data = this.__data__;
560  return nativeCreate ? data[key] !== void 0 : hasOwnProperty$5.call(data, key);
561}
562var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
563function hashSet(key, value) {
564  var data = this.__data__;
565  this.size += this.has(key) ? 0 : 1;
566  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
567  return this;
568}
569function Hash(entries) {
570  var index = -1, length = entries == null ? 0 : entries.length;
571  this.clear();
572  while (++index < length) {
573    var entry = entries[index];
574    this.set(entry[0], entry[1]);
575  }
576}
577Hash.prototype.clear = hashClear;
578Hash.prototype["delete"] = hashDelete;
579Hash.prototype.get = hashGet;
580Hash.prototype.has = hashHas;
581Hash.prototype.set = hashSet;
582function listCacheClear() {
583  this.__data__ = [];
584  this.size = 0;
585}
586function assocIndexOf(array, key) {
587  var length = array.length;
588  while (length--) {
589    if (eq(array[length][0], key)) {
590      return length;
591    }
592  }
593  return -1;
594}
595var arrayProto$1 = Array.prototype;
596var splice$1 = arrayProto$1.splice;
597function listCacheDelete(key) {
598  var data = this.__data__, index = assocIndexOf(data, key);
599  if (index < 0) {
600    return false;
601  }
602  var lastIndex = data.length - 1;
603  if (index == lastIndex) {
604    data.pop();
605  } else {
606    splice$1.call(data, index, 1);
607  }
608  --this.size;
609  return true;
610}
611function listCacheGet(key) {
612  var data = this.__data__, index = assocIndexOf(data, key);
613  return index < 0 ? void 0 : data[index][1];
614}
615function listCacheHas(key) {
616  return assocIndexOf(this.__data__, key) > -1;
617}
618function listCacheSet(key, value) {
619  var data = this.__data__, index = assocIndexOf(data, key);
620  if (index < 0) {
621    ++this.size;
622    data.push([key, value]);
623  } else {
624    data[index][1] = value;
625  }
626  return this;
627}
628function ListCache(entries) {
629  var index = -1, length = entries == null ? 0 : entries.length;
630  this.clear();
631  while (++index < length) {
632    var entry = entries[index];
633    this.set(entry[0], entry[1]);
634  }
635}
636ListCache.prototype.clear = listCacheClear;
637ListCache.prototype["delete"] = listCacheDelete;
638ListCache.prototype.get = listCacheGet;
639ListCache.prototype.has = listCacheHas;
640ListCache.prototype.set = listCacheSet;
641var Map = getNative(root, "Map");
642function mapCacheClear() {
643  this.size = 0;
644  this.__data__ = {
645    "hash": new Hash(),
646    "map": new (Map || ListCache)(),
647    "string": new Hash()
648  };
649}
650function isKeyable(value) {
651  var type = typeof value;
652  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
653}
654function getMapData(map, key) {
655  var data = map.__data__;
656  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
657}
658function mapCacheDelete(key) {
659  var result = getMapData(this, key)["delete"](key);
660  this.size -= result ? 1 : 0;
661  return result;
662}
663function mapCacheGet(key) {
664  return getMapData(this, key).get(key);
665}
666function mapCacheHas(key) {
667  return getMapData(this, key).has(key);
668}
669function mapCacheSet(key, value) {
670  var data = getMapData(this, key), size = data.size;
671  data.set(key, value);
672  this.size += data.size == size ? 0 : 1;
673  return this;
674}
675function MapCache(entries) {
676  var index = -1, length = entries == null ? 0 : entries.length;
677  this.clear();
678  while (++index < length) {
679    var entry = entries[index];
680    this.set(entry[0], entry[1]);
681  }
682}
683MapCache.prototype.clear = mapCacheClear;
684MapCache.prototype["delete"] = mapCacheDelete;
685MapCache.prototype.get = mapCacheGet;
686MapCache.prototype.has = mapCacheHas;
687MapCache.prototype.set = mapCacheSet;

688var FUNC_ERROR_TEXT$2 = "Expected a function";
689function memoize(func, resolver) {
690  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
691    throw new TypeError(FUNC_ERROR_TEXT$2);
692  }
693  var memoized = function() {
694    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
695    if (cache.has(key)) {
696      return cache.get(key);
697    }
698    var result = func.apply(this, args);
699    memoized.cache = cache.set(key, result) || cache;
700    return result;
701  };
702  memoized.cache = new (memoize.Cache || MapCache)();
703  return memoized;
704}
705memoize.Cache = MapCache;
706var MAX_MEMOIZE_SIZE = 500;
707function memoizeCapped(func) {
708  var result = memoize(func, function(key) {
709    if (cache.size === MAX_MEMOIZE_SIZE) {
710      cache.clear();
711    }
712    return key;
713  });
714  var cache = result.cache;
715  return result;
716}
717var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
718var reEscapeChar = /\\(\\)?/g;
719var stringToPath = memoizeCapped(function(string) {
720  var result = [];
721  if (string.charCodeAt(0) === 46) {
722    result.push("");
723  }
724  string.replace(rePropName, function(match, number, quote, subString) {
725    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
726  });
727  return result;
728});
729function toString(value) {
730  return value == null ? "" : baseToString(value);
731}
732function castPath(value, object) {
733  if (isArray(value)) {
734    return value;
735  }
736  return isKey(value, object) ? [value] : stringToPath(toString(value));
737}
738function toKey(value) {
739  if (typeof value == "string" || isSymbol(value)) {
740    return value;
741  }
742  var result = value + "";
743  return result == "0" && 1 / value == -Infinity ? "-0" : result;
744}
745function baseGet(object, path) {
746  path = castPath(path, object);
747  var index = 0, length = path.length;
748  while (object != null && index < length) {
749    object = object[toKey(path[index++])];
750  }
751  return index && index == length ? object : void 0;
752}
753function get(object, path, defaultValue) {
754  var result = object == null ? void 0 : baseGet(object, path);
755  return result === void 0 ? defaultValue : result;
756}
757function arrayPush(array, values) {
758  var index = -1, length = values.length, offset = array.length;
759  while (++index < length) {
760    array[offset + index] = values[index];
761  }
762  return array;
763}
764var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
765function isFlattenable(value) {
766  return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
767}
768function baseFlatten(array, depth, predicate, isStrict, result) {
769  var index = -1, length = array.length;
770  predicate || (predicate = isFlattenable);
771  result || (result = []);
772  while (++index < length) {
773    var value = array[index];
774    if (predicate(value)) {
775      {
776        arrayPush(result, value);
777      }
778    } else {
779      result[result.length] = value;
780    }
781  }
782  return result;
783}
784function flatten(array) {
785  var length = array == null ? 0 : array.length;
786  return length ? baseFlatten(array) : [];
787}
788function flatRest(func) {
789  return setToString(overRest(func, void 0, flatten), func + "");
790}
791var getPrototype = overArg(Object.getPrototypeOf, Object);
792var objectTag$3 = "[object Object]";
793var funcProto = Function.prototype, objectProto$5 = Object.prototype;
794var funcToString = funcProto.toString;
795var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
796var objectCtorString = funcToString.call(Object);
797function isPlainObject(value) {
798  if (!isObjectLike(value) || baseGetTag(value) != objectTag$3) {
799    return false;
800  }
801  var proto = getPrototype(value);
802  if (proto === null) {
803    return true;
804  }
805  var Ctor = hasOwnProperty$4.call(proto, "constructor") && proto.constructor;
806  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
807}
808function baseSlice(array, start, end) {
809  var index = -1, length = array.length;
810  if (start < 0) {
811    start = -start > length ? 0 : length + start;
812  }
813  end = end > length ? length : end;
814  if (end < 0) {
815    end += length;
816  }
817  length = start > end ? 0 : end - start >>> 0;
818  start >>>= 0;
819  var result = Array(length);
820  while (++index < length) {
821    result[index] = array[index + start];
822  }
823  return result;
824}
825function castSlice(array, start, end) {
826  var length = array.length;
827  end = end === void 0 ? length : end;
828  return !start && end >= length ? array : baseSlice(array, start, end);
829}
830var rsAstralRange$2 = "\\ud800-\\udfff", rsComboMarksRange$3 = "\\u0300-\\u036f", reComboHalfMarksRange$3 = "\\ufe20-\\ufe2f", rsComboSymbol
vendor: 13,159 bytes, lines 830-1247
830sRange$3 = "\\u20d0-\\u20ff", rsComboRange$3 = rsComboMarksRange$3 + reComboHalfMarksRange$3 + rsComboSymbolsRange$3, rsVarRange$2 = "\\ufe0e\\ufe0f";
831var rsZWJ$2 = "\\u200d";
832var reHasUnicode = RegExp("[" + rsZWJ$2 + rsAstralRange$2 + rsComboRange$3 + rsVarRange$2 + "]");
833function hasUnicode(string) {
834  return reHasUnicode.test(string);
835}
836function asciiToArray(string) {
837  return string.split("");
838}
839var rsAstralRange$1 = "\\ud800-\\udfff", rsComboMarksRange$2 = "\\u0300-\\u036f", reComboHalfMarksRange$2 = "\\ufe20-\\ufe2f", rsComboSymbolsRange$2 = "\\u20d0-\\u20ff", rsComboRange$2 = rsComboMarksRange$2 + reComboHalfMarksRange$2 + rsComboSymbolsRange$2, rsVarRange$1 = "\\ufe0e\\ufe0f";
840var rsAstral = "[" + rsAstralRange$1 + "]", rsCombo$2 = "[" + rsComboRange$2 + "]", rsFitz$1 = "\\ud83c[\\udffb-\\udfff]", rsModifier$1 = "(?:" + rsCombo$2 + "|" + rsFitz$1 + ")", rsNonAstral$1 = "[^" + rsAstralRange$1 + "]", rsRegional$1 = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair$1 = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsZWJ$1 = "\\u200d";
841var reOptMod$1 = rsModifier$1 + "?", rsOptVar$1 = "[" + rsVarRange$1 + "]?", rsOptJoin$1 = "(?:" + rsZWJ$1 + "(?:" + [rsNonAstral$1, rsRegional$1, rsSurrPair$1].join("|") + ")" + rsOptVar$1 + reOptMod$1 + ")*", rsSeq$1 = rsOptVar$1 + reOptMod$1 + rsOptJoin$1, rsSymbol = "(?:" + [rsNonAstral$1 + rsCombo$2 + "?", rsCombo$2, rsRegional$1, rsSurrPair$1, rsAstral].join("|") + ")";
842var reUnicode = RegExp(rsFitz$1 + "(?=" + rsFitz$1 + ")|" + rsSymbol + rsSeq$1, "g");
843function unicodeToArray(string) {
844  return string.match(reUnicode) || [];
845}
846function stringToArray(string) {
847  return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
848}
849function createCaseFirst(methodName) {
850  return function(string) {
851    string = toString(string);
852    var strSymbols = hasUnicode(string) ? stringToArray(string) : void 0;
853    var chr = strSymbols ? strSymbols[0] : string.charAt(0);
854    var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
855    return chr[methodName]() + trailing;
856  };
857}
858var upperFirst = createCaseFirst("toUpperCase");
859function capitalize(string) {
860  return upperFirst(toString(string).toLowerCase());
861}
862function arrayReduce(array, iteratee, accumulator, initAccum) {
863  var index = -1, length = array == null ? 0 : array.length;
864  while (++index < length) {
865    accumulator = iteratee(accumulator, array[index], index, array);
866  }
867  return accumulator;
868}
869function basePropertyOf(object) {
870  return function(key) {
871    return object == null ? void 0 : object[key];
872  };
873}
874var deburredLetters = {
875  // Latin-1 Supplement block.
876  "À": "A",
877  "Á": "A",
878  "Â": "A",
879  "Ã": "A",
880  "Ä": "A",
881  "Å": "A",
882  "à": "a",
883  "á": "a",
884  "â": "a",
885  "ã": "a",
886  "ä": "a",
887  "Ã¥": "a",
888  "Ç": "C",
889  "ç": "c",
890  "Ð": "D",
891  "ð": "d",
892  "È": "E",
893  "É": "E",
894  "Ê": "E",
895  "Ë": "E",
896  "è": "e",
897  "é": "e",
898  "ê": "e",
899  "ë": "e",
900  "Ì": "I",
901  "Í": "I",
902  "Î": "I",
903  "Ï": "I",
904  "ì": "i",
905  "í": "i",
906  "î": "i",
907  "ï": "i",
908  "Ñ": "N",
909  "ñ": "n",
910  "Ò": "O",
911  "Ó": "O",
912  "Ô": "O",
913  "Õ": "O",
914  "Ö": "O",
915  "Ø": "O",
916  "ò": "o",
917  "ó": "o",
918  "ô": "o",
919  "õ": "o",
920  "ö": "o",
921  "ø": "o",
922  "Ù": "U",
923  "Ú": "U",
924  "Û": "U",
925  "Ü": "U",
926  "ù": "u",
927  "ú": "u",
928  "û": "u",
929  "ü": "u",
930  "Ý": "Y",
931  "ý": "y",
932  "ÿ": "y",
933  "Æ": "Ae",
934  "æ": "ae",
935  "Þ": "Th",
936  "þ": "th",
937  "ß": "ss",
938  // Latin Extended-A block.
939  "Ā": "A",
940  "Ă": "A",
941  "Ą": "A",
942  "ā": "a",
943  "ă": "a",
944  "ą": "a",
945  "Ć": "C",
946  "Ĉ": "C",
947  "Ċ": "C",
948  "Č": "C",
949  "ć": "c",
950  "ĉ": "c",
951  "ċ": "c",
952  "č": "c",
953  "Ď": "D",
954  "Đ": "D",
955  "ď": "d",
956  "đ": "d",
957  "Ē": "E",
958  "Ĕ": "E",
959  "Ė": "E",
960  "Ę": "E",
961  "Ě": "E",
962  "ē": "e",
963  "ĕ": "e",
964  "ė": "e",
965  "ę": "e",
966  "ě": "e",
967  "Ĝ": "G",
968  "Ğ": "G",
969  "Ä ": "G",
970  "Ä¢": "G",
971  "ĝ": "g",
972  "ğ": "g",
973  "Ä¡": "g",
974  "Ä£": "g",
975  "Ĥ": "H",
976  "Ħ": "H",
977  "Ä¥": "h",
978  "ħ": "h",
979  "Ĩ": "I",
980  "Ī": "I",
981  "Ĭ": "I",
982  "Ä®": "I",
983  "Ä°": "I",
984  "Ä©": "i",
985  "Ä«": "i",
986  "Ä­": "i",
987  "į": "i",
988  "ı": "i",
989  "Ä´": "J",
990  "ĵ": "j",
991  "Ķ": "K",
992  "Ä·": "k",
993  "ĸ": "k",
994  "Ĺ": "L",
995  "Ä»": "L",
996  "Ľ": "L",
997  "Ä¿": "L",
998  "Ł": "L",
999  "ĺ": "l",
1000  "ļ": "l",
1001  "ľ": "l",
1002  "ŀ": "l",
1003  "ł": "l",
1004  "Ń": "N",
1005  "Ņ": "N",
1006  "Ň": "N",
1007  "Ŋ": "N",
1008  "ń": "n",
1009  "ņ": "n",
1010  "ň": "n",
1011  "ŋ": "n",
1012  "Ō": "O",
1013  "Ŏ": "O",
1014  "Ő": "O",
1015  "ō": "o",
1016  "ŏ": "o",
1017  "ő": "o",
1018  "Ŕ": "R",
1019  "Ŗ": "R",
1020  "Ř": "R",
1021  "ŕ": "r",
1022  "ŗ": "r",
1023  "ř": "r",
1024  "Ś": "S",
1025  "Ŝ": "S",
1026  "Ş": "S",
1027  "Å ": "S",
1028  "ś": "s",
1029  "ŝ": "s",
1030  "ş": "s",
1031  "Å¡": "s",
1032  "Å¢": "T",
1033  "Ť": "T",
1034  "Ŧ": "T",
1035  "Å£": "t",
1036  "Å¥": "t",
1037  "ŧ": "t",
1038  "Ũ": "U",
1039  "Ū": "U",
1040  "Ŭ": "U",
1041  "Å®": "U",
1042  "Å°": "U",
1043  "Ų": "U",
1044  "Å©": "u",
1045  "Å«": "u",
1046  "Å­": "u",
1047  "ů": "u",
1048  "ű": "u",
1049  "ų": "u",
1050  "Å´": "W",
1051  "ŵ": "w",
1052  "Ŷ": "Y",
1053  "Å·": "y",
1054  "Ÿ": "Y",
1055  "Ź": "Z",
1056  "Å»": "Z",
1057  "Ž": "Z",
1058  "ź": "z",
1059  "ż": "z",
1060  "ž": "z",
1061  "IJ": "IJ",
1062  "ij": "ij",
1063  "Œ": "Oe",
1064  "œ": "oe",
1065  "ʼn": "'n",
1066  "Å¿": "s"
1067};
1068var deburrLetter = basePropertyOf(deburredLetters);
1069var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
1070var rsComboMarksRange$1 = "\\u0300-\\u036f", reComboHalfMarksRange$1 = "\\ufe20-\\ufe2f", rsComboSymbolsRange$1 = "\\u20d0-\\u20ff", rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1;
1071var rsCombo$1 = "[" + rsComboRange$1 + "]";
1072var reComboMark = RegExp(rsCombo$1, "g");
1073function deburr(string) {
1074  string = toString(string);
1075  return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
1076}
1077var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
1078function asciiWords(string) {
1079  return string.match(reAsciiWord) || [];
1080}
1081var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
1082function hasUnicodeWord(string) {
1083  return reHasUnicodeWord.test(string);
1084}
1085var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
1086var rsApos$1 = "['’]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
1087var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos$1 + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos$1 + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq;
1088var reUnicodeWord = RegExp([
1089  rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
1090  rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
1091  rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
1092  rsUpper + "+" + rsOptContrUpper,
1093  rsOrdUpper,
1094  rsOrdLower,
1095  rsDigits,
1096  rsEmoji
1097].join("|"), "g");
1098function unicodeWords(string) {
1099  return string.match(reUnicodeWord) || [];
1100}
1101function words(string, pattern, guard) {
1102  string = toString(string);
1103  pattern = pattern;
1104  if (pattern === void 0) {
1105    return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
1106  }
1107  return string.match(pattern) || [];
1108}
1109var rsApos = "['’]";
1110var reApos = RegExp(rsApos, "g");
1111function createCompounder(callback) {
1112  return function(string) {
1113    return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
1114  };
1115}
1116var camelCase = createCompounder(function(result, word, index) {
1117  word = word.toLowerCase();
1118  return result + (index ? capitalize(word) : word);
1119});
1120function castArray() {
1121  if (!arguments.length) {
1122    return [];
1123  }
1124  var value = arguments[0];
1125  return isArray(value) ? value : [value];
1126}
1127var nativeIsFinite = root.isFinite, nativeMin$1 = Math.min;
1128function createRound(methodName) {
1129  var func = Math[methodName];
1130  return function(number, precision) {
1131    number = toNumber(number);
1132    precision = precision == null ? 0 : nativeMin$1(toInteger(precision), 292);
1133    if (precision && nativeIsFinite(number)) {
1134      var pair = (toString(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
1135      pair = (toString(value) + "e").split("e");
1136      return +(pair[0] + "e" + (+pair[1] - precision));
1137    }
1138    return func(number);
1139  };
1140}
1141var nativeCeil = Math.ceil, nativeMax$2 = Math.max;
1142function chunk(array, size, guard) {
1143  if (size === void 0) {
1144    size = 1;
1145  } else {
1146    size = nativeMax$2(toInteger(size), 0);
1147  }
1148  var length = array == null ? 0 : array.length;
1149  if (!length || size < 1) {
1150    return [];
1151  }
1152  var index = 0, resIndex = 0, result = Array(nativeCeil(length / size));
1153  while (index < length) {
1154    result[resIndex++] = baseSlice(array, index, index += size);
1155  }
1156  return result;
1157}
1158function stackClear() {
1159  this.__data__ = new ListCache();
1160  this.size = 0;
1161}
1162function stackDelete(key) {
1163  var data = this.__data__, result = data["delete"](key);
1164  this.size = data.size;
1165  return result;
1166}
1167function stackGet(key) {
1168  return this.__data__.get(key);
1169}
1170function stackHas(key) {
1171  return this.__data__.has(key);
1172}
1173var LARGE_ARRAY_SIZE$1 = 200;
1174function stackSet(key, value) {
1175  var data = this.__data__;
1176  if (data instanceof ListCache) {
1177    var pairs = data.__data__;
1178    if (!Map || pairs.length < LARGE_ARRAY_SIZE$1 - 1) {
1179      pairs.push([key, value]);
1180      this.size = ++data.size;
1181      return this;
1182    }
1183    data = this.__data__ = new MapCache(pairs);
1184  }
1185  data.set(key, value);
1186  this.size = data.size;
1187  return this;
1188}
1189function Stack(entries) {
1190  var data = this.__data__ = new ListCache(entries);
1191  this.size = data.size;
1192}
1193Stack.prototype.clear = stackClear;
1194Stack.prototype["delete"] = stackDelete;
1195Stack.prototype.get = stackGet;
1196Stack.prototype.has = stackHas;
1197Stack.prototype.set = stackSet;
1198function baseAssign(object, source) {
1199  return object && copyObject(source, keys(source), object);
1200}
1201function baseAssignIn(object, source) {
1202  return object && copyObject(source, keysIn(source), object);
1203}
1204var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
1205var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
1206var moduleExports = freeModule && freeModule.exports === freeExports;
1207var Buffer = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
1208function cloneBuffer(buffer, isDeep) {
1209  if (isDeep) {
1210    return buffer.slice();
1211  }
1212  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
1213  buffer.copy(result);
1214  return result;
1215}
1216function arrayFilter(array, predicate) {
1217  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
1218  while (++index < length) {
1219    var value = array[index];
1220    if (predicate(value, index, array)) {
1221      result[resIndex++] = value;
1222    }
1223  }
1224  return result;
1225}
1226function stubArray() {
1227  return [];
1228}
1229var objectProto$4 = Object.prototype;
1230var propertyIsEnumerable = objectProto$4.propertyIsEnumerable;
1231var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
1232var getSymbols = !nativeGetSymbols$1 ? stubArray : function(object) {
1233  if (object == null) {
1234    return [];
1235  }
1236  object = Object(object);
1237  return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
1238    return propertyIsEnumerable.call(object, symbol);
1239  });
1240};
1241function copySymbols(source, object) {
1242  return copyObject(source, getSymbols(source), object);
1243}
1244var nativeGetSymbols = Object.getOwnPropertySymbols;
1245var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
1246  var result = [];
1247  while (object) {
vendor: 5,513 bytes, lines 1248-1377
1248    arrayPush(result, getSymbols(object));
1249    object = getPrototype(object);
1250  }
1251  return result;
1252};
1253function copySymbolsIn(source, object) {
1254  return copyObject(source, getSymbolsIn(source), object);
1255}
1256function baseGetAllKeys(object, keysFunc, symbolsFunc) {
1257  var result = keysFunc(object);
1258  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
1259}
1260function getAllKeys(object) {
1261  return baseGetAllKeys(object, keys, getSymbols);
1262}
1263function getAllKeysIn(object) {
1264  return baseGetAllKeys(object, keysIn, getSymbolsIn);
1265}
1266var DataView = getNative(root, "DataView");
1267var Promise$1 = getNative(root, "Promise");
1268var Set = getNative(root, "Set");
1269var mapTag$4 = "[object Map]", objectTag$2 = "[object Object]", promiseTag = "[object Promise]", setTag$4 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
1270var dataViewTag$3 = "[object DataView]";
1271var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set), weakMapCtorString = toSource(WeakMap);
1272var getTag = baseGetTag;
1273if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$3 || Map && getTag(new Map()) != mapTag$4 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set && getTag(new Set()) != setTag$4 || WeakMap && getTag(new WeakMap()) != weakMapTag$1) {
1274  getTag = function(value) {
1275    var result = baseGetTag(value), Ctor = result == objectTag$2 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
1276    if (ctorString) {
1277      switch (ctorString) {
1278        case dataViewCtorString:
1279          return dataViewTag$3;
1280        case mapCtorString:
1281          return mapTag$4;
1282        case promiseCtorString:
1283          return promiseTag;
1284        case setCtorString:
1285          return setTag$4;
1286        case weakMapCtorString:
1287          return weakMapTag$1;
1288      }
1289    }
1290    return result;
1291  };
1292}
1293var objectProto$3 = Object.prototype;
1294var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
1295function initCloneArray(array) {
1296  var length = array.length, result = new array.constructor(length);
1297  if (length && typeof array[0] == "string" && hasOwnProperty$3.call(array, "index")) {
1298    result.index = array.index;
1299    result.input = array.input;
1300  }
1301  return result;
1302}
1303var Uint8Array = root.Uint8Array;
1304function cloneArrayBuffer(arrayBuffer) {
1305  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
1306  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
1307  return result;
1308}
1309function cloneDataView(dataView, isDeep) {
1310  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
1311  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
1312}
1313var reFlags = /\w*$/;
1314function cloneRegExp(regexp) {
1315  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
1316  result.lastIndex = regexp.lastIndex;
1317  return result;
1318}
1319var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf$1 = symbolProto$1 ? symbolProto$1.valueOf : void 0;
1320function cloneSymbol(symbol) {
1321  return symbolValueOf$1 ? Object(symbolValueOf$1.call(symbol)) : {};
1322}
1323function cloneTypedArray(typedArray, isDeep) {
1324  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
1325  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
1326}
1327var boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", mapTag$3 = "[object Map]", numberTag$3 = "[object Number]", regexpTag$2 = "[object RegExp]", setTag$3 = "[object Set]", stringTag$2 = "[object String]", symbolTag$2 = "[object Symbol]";
1328var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
1329function initCloneByTag(object, tag, isDeep) {
1330  var Ctor = object.constructor;
1331  switch (tag) {
1332    case arrayBufferTag$2:
1333      return cloneArrayBuffer(object);
1334    case boolTag$2:
1335    case dateTag$2:
1336      return new Ctor(+object);
1337    case dataViewTag$2:
1338      return cloneDataView(object, isDeep);
1339    case float32Tag$1:
1340    case float64Tag$1:
1341    case int8Tag$1:
1342    case int16Tag$1:
1343    case int32Tag$1:
1344    case uint8Tag$1:
1345    case uint8ClampedTag$1:
1346    case uint16Tag$1:
1347    case uint32Tag$1:
1348      return cloneTypedArray(object, isDeep);
1349    case mapTag$3:
1350      return new Ctor();
1351    case numberTag$3:
1352    case stringTag$2:
1353      return new Ctor(object);
1354    case regexpTag$2:
1355      return cloneRegExp(object);
1356    case setTag$3:
1357      return new Ctor();
1358    case symbolTag$2:
1359      return cloneSymbol(object);
1360  }
1361}
1362function initCloneObject(object) {
1363  return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
1364}
1365var mapTag$2 = "[object Map]";
1366function baseIsMap(value) {
1367  return isObjectLike(value) && getTag(value) == mapTag$2;
1368}
1369var nodeIsMap = nodeUtil && nodeUtil.isMap;
1370var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
1371var setTag$2 = "[object Set]";
1372function baseIsSet(value) {
1373  return isObjectLike(value) && getTag(value) == setTag$2;
1374}
1375var nodeIsSet = nodeUtil && nodeUtil.isSet;
1376var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
1377var CLONE_DEEP_FLAG$2 = 1, CLONE_FLAT_FLAG$1 = 2, CLONE_SYMBOLS_FLAG$2 = 4;
vendor: 4,168 bytes, lines 1378-1461
1378var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag$1 = "[object Map]", numberTag$2 = "[object Number]", objectTag$1 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$1 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]", weakMapTag = "[object WeakMap]";
1379var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
1380var cloneableTags = {};
1381cloneableTags[argsTag$1] = cloneableTags[arrayTag$1] = cloneableTags[arrayBufferTag$1] = cloneableTags[dataViewTag$1] = cloneableTags[boolTag$1] = cloneableTags[dateTag$1] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$1] = cloneableTags[numberTag$2] = cloneableTags[objectTag$1] = cloneableTags[regexpTag$1] = cloneableTags[setTag$1] = cloneableTags[stringTag$1] = cloneableTags[symbolTag$1] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
1382cloneableTags[errorTag$1] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
1383function baseClone(value, bitmask, customizer, key, object, stack) {
1384  var result, isDeep = bitmask & CLONE_DEEP_FLAG$2, isFlat = bitmask & CLONE_FLAT_FLAG$1, isFull = bitmask & CLONE_SYMBOLS_FLAG$2;
1385  if (customizer) {
1386    result = object ? customizer(value, key, object, stack) : customizer(value);
1387  }
1388  if (result !== void 0) {
1389    return result;
1390  }
1391  if (!isObject(value)) {
1392    return value;
1393  }
1394  var isArr = isArray(value);
1395  if (isArr) {
1396    result = initCloneArray(value);
1397    if (!isDeep) {
1398      return copyArray(value, result);
1399    }
1400  } else {
1401    var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
1402    if (isBuffer(value)) {
1403      return cloneBuffer(value, isDeep);
1404    }
1405    if (tag == objectTag$1 || tag == argsTag$1 || isFunc && !object) {
1406      result = isFlat || isFunc ? {} : initCloneObject(value);
1407      if (!isDeep) {
1408        return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
1409      }
1410    } else {
1411      if (!cloneableTags[tag]) {
1412        return object ? value : {};
1413      }
1414      result = initCloneByTag(value, tag, isDeep);
1415    }
1416  }
1417  stack || (stack = new Stack());
1418  var stacked = stack.get(value);
1419  if (stacked) {
1420    return stacked;
1421  }
1422  stack.set(value, result);
1423  if (isSet(value)) {
1424    value.forEach(function(subValue) {
1425      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
1426    });
1427  } else if (isMap(value)) {
1428    value.forEach(function(subValue, key2) {
1429      result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
1430    });
1431  }
1432  var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
1433  var props = isArr ? void 0 : keysFunc(value);
1434  arrayEach(props || value, function(subValue, key2) {
1435    if (props) {
1436      key2 = subValue;
1437      subValue = value[key2];
1438    }
1439    assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
1440  });
1441  return result;
1442}
1443var CLONE_DEEP_FLAG$1 = 1, CLONE_SYMBOLS_FLAG$1 = 4;
1444function cloneDeep(value) {
1445  return baseClone(value, CLONE_DEEP_FLAG$1 | CLONE_SYMBOLS_FLAG$1);
1446}
1447var HASH_UNDEFINED = "__lodash_hash_undefined__";
1448function setCacheAdd(value) {
1449  this.__data__.set(value, HASH_UNDEFINED);
1450  return this;
1451}
1452function setCacheHas(value) {
1453  return this.__data__.has(value);
1454}
1455function SetCache(values) {
1456  var index = -1, length = values == null ? 0 : values.length;
1457  this.__data__ = new MapCache();
1458  while (++index < length) {
1459    this.add(values[index]);
1460  }
1461}
vendor: 1,419 bytes, lines 1462-1499
1462SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
1463SetCache.prototype.has = setCacheHas;
1464function arraySome(array, predicate) {
1465  var index = -1, length = array == null ? 0 : array.length;
1466  while (++index < length) {
1467    if (predicate(array[index], index, array)) {
1468      return true;
1469    }
1470  }
1471  return false;
1472}
1473function cacheHas(cache, key) {
1474  return cache.has(key);
1475}
1476var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
1477function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
1478  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
1479  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
1480    return false;
1481  }
1482  var arrStacked = stack.get(array);
1483  var othStacked = stack.get(other);
1484  if (arrStacked && othStacked) {
1485    return arrStacked == other && othStacked == array;
1486  }
1487  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
1488  stack.set(array, other);
1489  stack.set(other, array);
1490  while (++index < arrLength) {
1491    var arrValue = array[index], othValue = other[index];
1492    if (customizer) {
1493      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
1494    }
1495    if (compared !== void 0) {
1496      if (compared) {
1497        continue;
1498      }
1499      result = false;
vendor: 4,223 bytes, lines 1500-1615
1500      break;
1501    }
1502    if (seen) {
1503      if (!arraySome(other, function(othValue2, othIndex) {
1504        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
1505          return seen.push(othIndex);
1506        }
1507      })) {
1508        result = false;
1509        break;
1510      }
1511    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
1512      result = false;
1513      break;
1514    }
1515  }
1516  stack["delete"](array);
1517  stack["delete"](other);
1518  return result;
1519}
1520function mapToArray(map) {
1521  var index = -1, result = Array(map.size);
1522  map.forEach(function(value, key) {
1523    result[++index] = [key, value];
1524  });
1525  return result;
1526}
1527function setToArray(set2) {
1528  var index = -1, result = Array(set2.size);
1529  set2.forEach(function(value) {
1530    result[++index] = value;
1531  });
1532  return result;
1533}
1534var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2;
1535var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag$1 = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
1536var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
1537var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
1538function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
1539  switch (tag) {
1540    case dataViewTag:
1541      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
1542        return false;
1543      }
1544      object = object.buffer;
1545      other = other.buffer;
1546    case arrayBufferTag:
1547      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
1548        return false;
1549      }
1550      return true;
1551    case boolTag:
1552    case dateTag:
1553    case numberTag$1:
1554      return eq(+object, +other);
1555    case errorTag:
1556      return object.name == other.name && object.message == other.message;
1557    case regexpTag:
1558    case stringTag:
1559      return object == other + "";
1560    case mapTag:
1561      var convert = mapToArray;
1562    case setTag:
1563      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
1564      convert || (convert = setToArray);
1565      if (object.size != other.size && !isPartial) {
1566        return false;
1567      }
1568      var stacked = stack.get(object);
1569      if (stacked) {
1570        return stacked == other;
1571      }
1572      bitmask |= COMPARE_UNORDERED_FLAG$2;
1573      stack.set(object, other);
1574      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
1575      stack["delete"](object);
1576      return result;
1577    case symbolTag:
1578      if (symbolValueOf) {
1579        return symbolValueOf.call(object) == symbolValueOf.call(other);
1580      }
1581  }
1582  return false;
1583}
1584var COMPARE_PARTIAL_FLAG$3 = 1;
1585var objectProto$2 = Object.prototype;
1586var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
1587function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
1588  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
1589  if (objLength != othLength && !isPartial) {
1590    return false;
1591  }
1592  var index = objLength;
1593  while (index--) {
1594    var key = objProps[index];
1595    if (!(isPartial ? key in other : hasOwnProperty$2.call(other, key))) {
1596      return false;
1597    }
1598  }
1599  var objStacked = stack.get(object);
1600  var othStacked = stack.get(other);
1601  if (objStacked && othStacked) {
1602    return objStacked == other && othStacked == object;
1603  }
1604  var result = true;
1605  stack.set(object, other);
1606  stack.set(other, object);
1607  var skipCtor = isPartial;
1608  while (++index < objLength) {
1609    key = objProps[index];
1610    var objValue = object[key], othValue = other[key];
1611    if (customizer) {
1612      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
1613    }
1614    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
1615      result = false;
vendor: 4,479 bytes, lines 1616-1736
1616      break;
1617    }
1618    skipCtor || (skipCtor = key == "constructor");
1619  }
1620  if (result && !skipCtor) {
1621    var objCtor = object.constructor, othCtor = other.constructor;
1622    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
1623      result = false;
1624    }
1625  }
1626  stack["delete"](object);
1627  stack["delete"](other);
1628  return result;
1629}
1630var COMPARE_PARTIAL_FLAG$2 = 1;
1631var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
1632var objectProto$1 = Object.prototype;
1633var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
1634function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
1635  var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
1636  objTag = objTag == argsTag ? objectTag : objTag;
1637  othTag = othTag == argsTag ? objectTag : othTag;
1638  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
1639  if (isSameTag && isBuffer(object)) {
1640    if (!isBuffer(other)) {
1641      return false;
1642    }
1643    objIsArr = true;
1644    objIsObj = false;
1645  }
1646  if (isSameTag && !objIsObj) {
1647    stack || (stack = new Stack());
1648    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
1649  }
1650  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
1651    var objIsWrapped = objIsObj && hasOwnProperty$1.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$1.call(other, "__wrapped__");
1652    if (objIsWrapped || othIsWrapped) {
1653      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
1654      stack || (stack = new Stack());
1655      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
1656    }
1657  }
1658  if (!isSameTag) {
1659    return false;
1660  }
1661  stack || (stack = new Stack());
1662  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
1663}
1664function baseIsEqual(value, other, bitmask, customizer, stack) {
1665  if (value === other) {
1666    return true;
1667  }
1668  if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
1669    return value !== value && other !== other;
1670  }
1671  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
1672}
1673var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
1674function baseIsMatch(object, source, matchData, customizer) {
1675  var index = matchData.length, length = index;
1676  if (object == null) {
1677    return !length;
1678  }
1679  object = Object(object);
1680  while (index--) {
1681    var data = matchData[index];
1682    if (data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
1683      return false;
1684    }
1685  }
1686  while (++index < length) {
1687    data = matchData[index];
1688    var key = data[0], objValue = object[key], srcValue = data[1];
1689    if (data[2]) {
1690      if (objValue === void 0 && !(key in object)) {
1691        return false;
1692      }
1693    } else {
1694      var stack = new Stack();
1695      var result;
1696      if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
1697        return false;
1698      }
1699    }
1700  }
1701  return true;
1702}
1703function isStrictComparable(value) {
1704  return value === value && !isObject(value);
1705}
1706function getMatchData(object) {
1707  var result = keys(object), length = result.length;
1708  while (length--) {
1709    var key = result[length], value = object[key];
1710    result[length] = [key, value, isStrictComparable(value)];
1711  }
1712  return result;
1713}
1714function matchesStrictComparable(key, srcValue) {
1715  return function(object) {
1716    if (object == null) {
1717      return false;
1718    }
1719    return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
1720  };
1721}
1722function baseMatches(source) {
1723  var matchData = getMatchData(source);
1724  if (matchData.length == 1 && matchData[0][2]) {
1725    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
1726  }
1727  return function(object) {
1728    return object === source || baseIsMatch(object, source, matchData);
1729  };
1730}
1731function baseHasIn(object, key) {
1732  return object != null && key in Object(object);
1733}
1734function hasPath(object, path, hasFunc) {
1735  path = castPath(path, object);
1736  var index = -1, length = path.length, result = false;

1737  while (++index < length) {
1738    var key = toKey(path[index]);
1739    if (!(result = object != null && hasFunc(object, key))) {
1740      break;
1741    }
1742    object = object[key];
1743  }
1744  if (result || ++index != length) {
1745    return result;
1746  }
1747  length = object == null ? 0 : object.length;
1748  return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
1749}
1750function hasIn(object, path) {
1751  return object != null && hasPath(object, path, baseHasIn);
1752}
1753var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
1754function baseMatchesProperty(path, srcValue) {
1755  if (isKey(path) && isStrictComparable(srcValue)) {
1756    return matchesStrictComparable(toKey(path), srcValue);
1757  }
1758  return function(object) {
1759    var objValue = get(object, path);
1760    return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
1761  };
1762}
1763function baseProperty(key) {
1764  return function(object) {
1765    return object == null ? void 0 : object[key];
1766  };
1767}
1768function basePropertyDeep(path) {
1769  return function(object) {
1770    return baseGet(object, path);
1771  };
1772}
1773function property(path) {
1774  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
1775}
1776function baseIteratee(value) {
1777  if (typeof value == "function") {
1778    return value;
1779  }
1780  if (value == null) {
1781    return identity;
1782  }
1783  if (typeof value == "object") {
1784    return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
1785  }
1786  return property(value);
1787}
1788function createBaseFor(fromRight) {
1789  return function(object, iteratee, keysFunc) {
1790    var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
1791    while (length--) {
1792      var key = props[++index];
1793      if (iteratee(iterable[key], key, iterable) === false) {
1794        break;
1795      }
1796    }
1797    return object;
1798  };
1799}
1800var baseFor = createBaseFor();
1801var now = function() {
1802  return root.Date.now();
1803};
1804var FUNC_ERROR_TEXT$1 = "Expected a function";
1805var nativeMax$1 = Math.max, nativeMin = Math.min;
1806function debounce(func, wait, options) {
1807  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
1808  if (typeof func != "function") {
1809    throw new TypeError(FUNC_ERROR_TEXT$1);
1810  }
1811  wait = toNumber(wait) || 0;
1812  if (isObject(options)) {
1813    leading = !!options.leading;
1814    maxing = "maxWait" in options;
1815    maxWait = maxing ? nativeMax$1(toNumber(options.maxWait) || 0, wait) : maxWait;
1816    trailing = "trailing" in options ? !!options.trailing : trailing;
1817  }
1818  function invokeFunc(time) {
1819    var args = lastArgs, thisArg = lastThis;
1820    lastArgs = lastThis = void 0;
1821    lastInvokeTime = time;
1822    result = func.apply(thisArg, args);
1823    return result;
1824  }
1825  function leadingEdge(time) {
1826    lastInvokeTime = time;
1827    timerId = setTimeout(timerExpired, wait);
1828    return leading ? invokeFunc(time) : result;
1829  }
1830  function remainingWait(time) {
1831    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
1832    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
1833  }
1834  function shouldInvoke(time) {
1835    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
1836    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
1837  }
1838  function timerExpired() {
1839    var time = now();
1840    if (shouldInvoke(time)) {
1841      return trailingEdge(time);
1842    }
1843    timerId = setTimeout(timerExpired, remainingWait(time));
1844  }
1845  function trailingEdge(time) {
1846    timerId = void 0;
1847    if (trailing && lastArgs) {
1848      return invokeFunc(time);
1849    }
1850    lastArgs = lastThis = void 0;
1851    return result;
1852  }
1853  function cancel() {
1854    if (timerId !== void 0) {
1855      clearTimeout(timerId);
1856    }
1857    lastInvokeTime = 0;
1858    lastArgs = lastCallTime = lastThis = timerId = void 0;
1859  }
1860  function flush() {
1861    return timerId === void 0 ? result : trailingEdge(now());
1862  }
1863  function debounced() {
1864    var time = now(), isInvoking = shouldInvoke(time);
1865    lastArgs = arguments;
1866    lastThis = this;
1867    lastCallTime = time;
1868    if (isInvoking) {
1869      if (timerId === void 0) {
1870        return leadingEdge(lastCallTime);
1871      }
1872      if (maxing) {
1873        clearTimeout(timerId);
1874        timerId = setTimeout(timerExpired, wait);
1875        return invokeFunc(lastCallTime);
1876      }
1877    }
1878    if (timerId === void 0) {
1879      timerId = setTimeout(timerExpired, wait);
1880    }
1881    return result;
1882  }
1883  debounced.cancel = cancel;
1884  debounced.flush = flush;
1885  return debounced;
1886}
1887function assignMergeValue(object, key, value) {
1888  if (value !== void 0 && !eq(object[key], value) || value === void 0 && !(key in object)) {
1889    baseAssignValue(object, key, value);
1890  }
1891}
1892function isArrayLikeObject(value) {
1893  return isObjectLike(value) && isArrayLike(value);
1894}
1895function safeGet(object, key) {
1896  if (key === "constructor" && typeof object[key] === "function") {
1897    return;
1898  }
1899  if (key == "__proto__") {
1900    return;
1901  }
1902  return object[key];
1903}
1904function toPlainObject(value) {
1905  return copyObject(value, keysIn(value));
1906}
1907function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
1908  var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
1909  if (stacked) {
1910    assignMergeValue(object, key, stacked);
1911    return;
1912  }
1913  var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
1914  var isCommon = newValue === void 0;
1915  if (isCommon) {
1916    var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
1917    newValue = srcValue;
1918    if (isArr || isBuff || isTyped) {
1919      if (isArray(objValue)) {
1920        newValue = objValue;
1921      } else if (isArrayLikeObject(objValue)) {
1922        newValue = copyArray(objValue);
1923      } else if (isBuff) {
1924        isCommon = false;
vendor: 6,373 bytes, lines 1925-2133
1925        newValue = cloneBuffer(srcValue, true);
1926      } else if (isTyped) {
1927        isCommon = false;
1928        newValue = cloneTypedArray(srcValue, true);
1929      } else {
1930        newValue = [];
1931      }
1932    } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
1933      newValue = objValue;
1934      if (isArguments(objValue)) {
1935        newValue = toPlainObject(objValue);
1936      } else if (!isObject(objValue) || isFunction(objValue)) {
1937        newValue = initCloneObject(srcValue);
1938      }
1939    } else {
1940      isCommon = false;
1941    }
1942  }
1943  if (isCommon) {
1944    stack.set(srcValue, newValue);
1945    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
1946    stack["delete"](srcValue);
1947  }
1948  assignMergeValue(object, key, newValue);
1949}
1950function baseMerge(object, source, srcIndex, customizer, stack) {
1951  if (object === source) {
1952    return;
1953  }
1954  baseFor(source, function(srcValue, key) {
1955    stack || (stack = new Stack());
1956    if (isObject(srcValue)) {
1957      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
1958    } else {
1959      var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
1960      if (newValue === void 0) {
1961        newValue = srcValue;
1962      }
1963      assignMergeValue(object, key, newValue);
1964    }
1965  }, keysIn);
1966}
1967var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
1968  baseMerge(object, source, srcIndex, customizer);
1969});
1970function last(array) {
1971  var length = array == null ? 0 : array.length;
1972  return length ? array[length - 1] : void 0;
1973}
1974function createFind(findIndexFunc) {
1975  return function(collection, predicate, fromIndex) {
1976    var iterable = Object(collection);
1977    if (!isArrayLike(collection)) {
1978      var iteratee = baseIteratee(predicate);
1979      collection = keys(collection);
1980      predicate = function(key) {
1981        return iteratee(iterable[key], key, iterable);
1982      };
1983    }
1984    var index = findIndexFunc(collection, predicate, fromIndex);
1985    return index > -1 ? iterable[iteratee ? collection[index] : index] : void 0;
1986  };
1987}
1988var nativeMax = Math.max;
1989function findIndex(array, predicate, fromIndex) {
1990  var length = array == null ? 0 : array.length;
1991  if (!length) {
1992    return -1;
1993  }
1994  var index = fromIndex == null ? 0 : toInteger(fromIndex);
1995  if (index < 0) {
1996    index = nativeMax(length + index, 0);
1997  }
1998  return baseFindIndex(array, baseIteratee(predicate), index);
1999}
2000var find = createFind(findIndex);
2001function parent(object, path) {
2002  return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
2003}
2004function isEqual(value, other) {
2005  return baseIsEqual(value, other);
2006}
2007var numberTag = "[object Number]";
2008function isNumber(value) {
2009  return typeof value == "number" || isObjectLike(value) && baseGetTag(value) == numberTag;
2010}
2011var merge = createAssigner(function(object, source, srcIndex) {
2012  baseMerge(object, source, srcIndex);
2013});
2014var objectProto = Object.prototype;
2015var hasOwnProperty = objectProto.hasOwnProperty;
2016function baseUnset(object, path) {
2017  path = castPath(path, object);
2018  var index = -1, length = path.length;
2019  if (!length) {
2020    return true;
2021  }
2022  while (++index < length) {
2023    var key = toKey(path[index]);
2024    if (key === "__proto__" && !hasOwnProperty.call(object, "__proto__")) {
2025      return false;
2026    }
2027    if ((key === "constructor" || key === "prototype") && index < length - 1) {
2028      return false;
2029    }
2030  }
2031  var obj = parent(object, path);
2032  return obj == null || delete obj[toKey(last(path))];
2033}
2034function customOmitClone(value) {
2035  return isPlainObject(value) ? void 0 : value;
2036}
2037var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4;
2038var omit = flatRest(function(object, paths) {
2039  var result = {};
2040  if (object == null) {
2041    return result;
2042  }
2043  var isDeep = false;
2044  paths = arrayMap(paths, function(path) {
2045    path = castPath(path, object);
2046    isDeep || (isDeep = path.length > 1);
2047    return path;
2048  });
2049  copyObject(object, getAllKeysIn(object), result);
2050  if (isDeep) {
2051    result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
2052  }
2053  var length = paths.length;
2054  while (length--) {
2055    baseUnset(result, paths[length]);
2056  }
2057  return result;
2058});
2059function baseSet(object, path, value, customizer) {
2060  if (!isObject(object)) {
2061    return object;
2062  }
2063  path = castPath(path, object);
2064  var index = -1, length = path.length, lastIndex = length - 1, nested = object;
2065  while (nested != null && ++index < length) {
2066    var key = toKey(path[index]), newValue = value;
2067    if (key === "__proto__" || key === "constructor" || key === "prototype") {
2068      return object;
2069    }
2070    if (index != lastIndex) {
2071      var objValue = nested[key];
2072      newValue = void 0;
2073      if (newValue === void 0) {
2074        newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
2075      }
2076    }
2077    assignValue(nested, key, newValue);
2078    nested = nested[key];
2079  }
2080  return object;
2081}
2082function basePickBy(object, paths, predicate) {
2083  var index = -1, length = paths.length, result = {};
2084  while (++index < length) {
2085    var path = paths[index], value = baseGet(object, path);
2086    if (predicate(value, path)) {
2087      baseSet(result, castPath(path, object), value);
2088    }
2089  }
2090  return result;
2091}
2092function basePick(object, paths) {
2093  return basePickBy(object, paths, function(value, path) {
2094    return hasIn(object, path);
2095  });
2096}
2097var pick = flatRest(function(object, paths) {
2098  return object == null ? {} : basePick(object, paths);
2099});
2100var arrayProto = Array.prototype;
2101var splice = arrayProto.splice;
2102function basePullAt(array, indexes) {
2103  var length = array ? indexes.length : 0, lastIndex = length - 1;
2104  while (length--) {
2105    var index = indexes[length];
2106    if (length == lastIndex || index !== previous) {
2107      var previous = index;
2108      if (isIndex(index)) {
2109        splice.call(array, index, 1);
2110      } else {
2111        baseUnset(array, index);
2112      }
2113    }
2114  }
2115  return array;
2116}
2117function remove(array, predicate) {
2118  var result = [];
2119  if (!(array && array.length)) {
2120    return result;
2121  }
2122  var index = -1, indexes = [], length = array.length;
2123  predicate = baseIteratee(predicate);
2124  while (++index < length) {
2125    var value = array[index];
2126    if (predicate(value, index, array)) {
2127      result.push(value);
2128      indexes.push(index);
2129    }
2130  }
2131  basePullAt(array, indexes);
2132  return result;
2133}
vendor: 7,446 bytes, lines 2134-2406
2134var round = createRound("round");
2135function set(object, path, value) {
2136  return object == null ? object : baseSet(object, path, value);
2137}
2138var snakeCase = createCompounder(function(result, word, index) {
2139  return result + (index ? "_" : "") + word.toLowerCase();
2140});
2141var FUNC_ERROR_TEXT = "Expected a function";
2142function throttle(func, wait, options) {
2143  var leading = true, trailing = true;
2144  if (typeof func != "function") {
2145    throw new TypeError(FUNC_ERROR_TEXT);
2146  }
2147  if (isObject(options)) {
2148    leading = "leading" in options ? !!options.leading : leading;
2149    trailing = "trailing" in options ? !!options.trailing : trailing;
2150  }
2151  return debounce(func, wait, {
2152    "leading": leading,
2153    "maxWait": wait,
2154    "trailing": trailing
2155  });
2156}
2157var INFINITY = 1 / 0;
2158var createSet = !(Set && 1 / setToArray(new Set([, -0]))[1] == INFINITY) ? noop : function(values) {
2159  return new Set(values);
2160};
2161var LARGE_ARRAY_SIZE = 200;
2162function baseUniq(array, iteratee, comparator) {
2163  var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
2164  if (length >= LARGE_ARRAY_SIZE) {
2165    var set2 = iteratee ? null : createSet(array);
2166    if (set2) {
2167      return setToArray(set2);
2168    }
2169    isCommon = false;
2170    includes = cacheHas;
2171    seen = new SetCache();
2172  } else {
2173    seen = iteratee ? [] : result;
2174  }
2175  outer:
2176    while (++index < length) {
2177      var value = array[index], computed = iteratee ? iteratee(value) : value;
2178      value = value !== 0 ? value : 0;
2179      if (isCommon && computed === computed) {
2180        var seenIndex = seen.length;
2181        while (seenIndex--) {
2182          if (seen[seenIndex] === computed) {
2183            continue outer;
2184          }
2185        }
2186        if (iteratee) {
2187          seen.push(computed);
2188        }
2189        result.push(value);
2190      } else if (!includes(seen, computed, comparator)) {
2191        if (seen !== result) {
2192          seen.push(computed);
2193        }
2194        result.push(value);
2195      }
2196    }
2197  return result;
2198}
2199function uniqBy(array, iteratee) {
2200  return array && array.length ? baseUniq(array, baseIteratee(iteratee)) : [];
2201}
2202const BROWSER_ALIASES_MAP = {
2203  AmazonBot: "amazonbot",
2204  "Amazon Silk": "amazon_silk",
2205  "Android Browser": "android",
2206  BaiduSpider: "baiduspider",
2207  Bada: "bada",
2208  BingCrawler: "bingcrawler",
2209  Brave: "brave",
2210  BlackBerry: "blackberry",
2211  "ChatGPT-User": "chatgpt_user",
2212  Chrome: "chrome",
2213  ClaudeBot: "claudebot",
2214  Chromium: "chromium",
2215  Diffbot: "diffbot",
2216  DuckDuckBot: "duckduckbot",
2217  DuckDuckGo: "duckduckgo",
2218  Electron: "electron",
2219  Epiphany: "epiphany",
2220  FacebookExternalHit: "facebookexternalhit",
2221  Firefox: "firefox",
2222  Focus: "focus",
2223  Generic: "generic",
2224  "Google Search": "google_search",
2225  Googlebot: "googlebot",
2226  GPTBot: "gptbot",
2227  "Internet Explorer": "ie",
2228  InternetArchiveCrawler: "internetarchivecrawler",
2229  "K-Meleon": "k_meleon",
2230  LibreWolf: "librewolf",
2231  Linespider: "linespider",
2232  Maxthon: "maxthon",
2233  "Meta-ExternalAds": "meta_externalads",
2234  "Meta-ExternalAgent": "meta_externalagent",
2235  "Meta-ExternalFetcher": "meta_externalfetcher",
2236  "Meta-WebIndexer": "meta_webindexer",
2237  "Microsoft Edge": "edge",
2238  "MZ Browser": "mz",
2239  "NAVER Whale Browser": "naver",
2240  "OAI-SearchBot": "oai_searchbot",
2241  Omgilibot: "omgilibot",
2242  Opera: "opera",
2243  "Opera Coast": "opera_coast",
2244  "Pale Moon": "pale_moon",
2245  PerplexityBot: "perplexitybot",
2246  "Perplexity-User": "perplexity_user",
2247  PhantomJS: "phantomjs",
2248  PingdomBot: "pingdombot",
2249  Puffin: "puffin",
2250  QQ: "qq",
2251  QQLite: "qqlite",
2252  QupZilla: "qupzilla",
2253  Roku: "roku",
2254  Safari: "safari",
2255  Sailfish: "sailfish",
2256  "Samsung Internet for Android": "samsung_internet",
2257  SlackBot: "slackbot",
2258  SeaMonkey: "seamonkey",
2259  Sleipnir: "sleipnir",
2260  "Sogou Browser": "sogou",
2261  Swing: "swing",
2262  Tizen: "tizen",
2263  "UC Browser": "uc",
2264  Vivaldi: "vivaldi",
2265  "WebOS Browser": "webos",
2266  WeChat: "wechat",
2267  YahooSlurp: "yahooslurp",
2268  "Yandex Browser": "yandex",
2269  YandexBot: "yandexbot",
2270  YouBot: "youbot"
2271};
2272const BROWSER_MAP = {
2273  amazonbot: "AmazonBot",
2274  amazon_silk: "Amazon Silk",
2275  android: "Android Browser",
2276  baiduspider: "BaiduSpider",
2277  bada: "Bada",
2278  bingcrawler: "BingCrawler",
2279  blackberry: "BlackBerry",
2280  brave: "Brave",
2281  chatgpt_user: "ChatGPT-User",
2282  chrome: "Chrome",
2283  claudebot: "ClaudeBot",
2284  chromium: "Chromium",
2285  diffbot: "Diffbot",
2286  duckduckbot: "DuckDuckBot",
2287  duckduckgo: "DuckDuckGo",
2288  edge: "Microsoft Edge",
2289  electron: "Electron",
2290  epiphany: "Epiphany",
2291  facebookexternalhit: "FacebookExternalHit",
2292  firefox: "Firefox",
2293  focus: "Focus",
2294  generic: "Generic",
2295  google_search: "Google Search",
2296  googlebot: "Googlebot",
2297  gptbot: "GPTBot",
2298  ie: "Internet Explorer",
2299  internetarchivecrawler: "InternetArchiveCrawler",
2300  k_meleon: "K-Meleon",
2301  librewolf: "LibreWolf",
2302  linespider: "Linespider",
2303  maxthon: "Maxthon",
2304  meta_externalads: "Meta-ExternalAds",
2305  meta_externalagent: "Meta-ExternalAgent",
2306  meta_externalfetcher: "Meta-ExternalFetcher",
2307  meta_webindexer: "Meta-WebIndexer",
2308  mz: "MZ Browser",
2309  naver: "NAVER Whale Browser",
2310  oai_searchbot: "OAI-SearchBot",
2311  omgilibot: "Omgilibot",
2312  opera: "Opera",
2313  opera_coast: "Opera Coast",
2314  pale_moon: "Pale Moon",
2315  perplexitybot: "PerplexityBot",
2316  perplexity_user: "Perplexity-User",
2317  phantomjs: "PhantomJS",
2318  pingdombot: "PingdomBot",
2319  puffin: "Puffin",
2320  qq: "QQ Browser",
2321  qqlite: "QQ Browser Lite",
2322  qupzilla: "QupZilla",
2323  roku: "Roku",
2324  safari: "Safari",
2325  sailfish: "Sailfish",
2326  samsung_internet: "Samsung Internet for Android",
2327  seamonkey: "SeaMonkey",
2328  slackbot: "SlackBot",
2329  sleipnir: "Sleipnir",
2330  sogou: "Sogou Browser",
2331  swing: "Swing",
2332  tizen: "Tizen",
2333  uc: "UC Browser",
2334  vivaldi: "Vivaldi",
2335  webos: "WebOS Browser",
2336  wechat: "WeChat",
2337  yahooslurp: "YahooSlurp",
2338  yandex: "Yandex Browser",
2339  yandexbot: "YandexBot",
2340  youbot: "YouBot"
2341};
2342const PLATFORMS_MAP = {
2343  bot: "bot",
2344  desktop: "desktop",
2345  mobile: "mobile",
2346  tablet: "tablet",
2347  tv: "tv"
2348};
2349const OS_MAP = {
2350  Android: "Android",
2351  Bada: "Bada",
2352  BlackBerry: "BlackBerry",
2353  ChromeOS: "Chrome OS",
2354  HarmonyOS: "HarmonyOS",
2355  iOS: "iOS",
2356  Linux: "Linux",
2357  MacOS: "macOS",
2358  PlayStation4: "PlayStation 4",
2359  Roku: "Roku",
2360  Tizen: "Tizen",
2361  WebOS: "WebOS",
2362  Windows: "Windows",
2363  WindowsPhone: "Windows Phone"
2364};
2365const ENGINE_MAP = {
2366  Blink: "Blink",
2367  EdgeHTML: "EdgeHTML",
2368  Gecko: "Gecko",
2369  Presto: "Presto",
2370  Trident: "Trident",
2371  WebKit: "WebKit"
2372};
2373class Utils {
2374  /**
2375   * Get first matched item for a string
2376   * @param {RegExp} regexp
2377   * @param {String} ua
2378   * @return {Array|{index: number, input: string}|*|boolean|string}
2379   */
2380  static getFirstMatch(regexp, ua) {
2381    const match = ua.match(regexp);
2382    return match && match.length > 0 && match[1] || "";
2383  }
2384  /**
2385   * Get second matched item for a string
2386   * @param regexp
2387   * @param {String} ua
2388   * @return {Array|{index: number, input: string}|*|boolean|string}
2389   */
2390  static getSecondMatch(regexp, ua) {
2391    const match = ua.match(regexp);
2392    return match && match.length > 1 && match[2] || "";
2393  }
2394  /**
2395   * Match a regexp and return a constant or undefined
2396   * @param {RegExp} regexp
2397   * @param {String} ua
2398   * @param {*} _const Any const that will be returned if regexp matches the string
2399   * @return {*}
2400   */
2401  static matchAndReturnConst(regexp, ua, _const) {
2402    if (regexp.test(ua)) {
2403      return _const;
2404    }
2405    return void 0;
2406  }

2407  static getWindowsVersionName(version) {
2408    switch (version) {
2409      case "NT":
2410        return "NT";
2411      case "XP":
2412        return "XP";
2413      case "NT 5.0":
2414        return "2000";
2415      case "NT 5.1":
2416        return "XP";
2417      case "NT 5.2":
2418        return "2003";
2419      case "NT 6.0":
2420        return "Vista";
2421      case "NT 6.1":
2422        return "7";
2423      case "NT 6.2":
2424        return "8";
2425      case "NT 6.3":
2426        return "8.1";
2427      case "NT 10.0":
2428        return "10";
2429      default:
2430        return void 0;
2431    }
2432  }
2433  /**
2434   * Get macOS version name
2435   *    10.5 - Leopard
2436   *    10.6 - Snow Leopard
2437   *    10.7 - Lion
2438   *    10.8 - Mountain Lion
2439   *    10.9 - Mavericks
2440   *    10.10 - Yosemite
2441   *    10.11 - El Capitan
2442   *    10.12 - Sierra
2443   *    10.13 - High Sierra
2444   *    10.14 - Mojave
2445   *    10.15 - Catalina
2446   *    11 - Big Sur
2447   *    12 - Monterey
2448   *    13 - Ventura
2449   *    14 - Sonoma
2450   *    15 - Sequoia
2451   *
2452   * @example
2453   *   getMacOSVersionName("10.14") // 'Mojave'
2454   *
2455   * @param  {string} version
2456   * @return {string} versionName
2457   */
2458  static getMacOSVersionName(version) {
2459    const v = version.split(".").splice(0, 2).map((s) => parseInt(s, 10) || 0);
2460    v.push(0);
2461    const major = v[0];
2462    const minor = v[1];
2463    if (major === 10) {
2464      switch (minor) {
2465        case 5:
2466          return "Leopard";
2467        case 6:
2468          return "Snow Leopard";
2469        case 7:
2470          return "Lion";
2471        case 8:
2472          return "Mountain Lion";
2473        case 9:
2474          return "Mavericks";
2475        case 10:
2476          return "Yosemite";
2477        case 11:
2478          return "El Capitan";
2479        case 12:
2480          return "Sierra";
2481        case 13:
2482          return "High Sierra";
2483        case 14:
2484          return "Mojave";
2485        case 15:
2486          return "Catalina";
2487        default:
2488          return void 0;
2489      }
2490    }
2491    switch (major) {
2492      case 11:
2493        return "Big Sur";
2494      case 12:
2495        return "Monterey";
2496      case 13:
2497        return "Ventura";
2498      case 14:
2499        return "Sonoma";
2500      case 15:
2501        return "Sequoia";
2502      default:
2503        return void 0;
2504    }
2505  }
2506  /**
2507   * Get Android version name
2508   *    1.5 - Cupcake
2509   *    1.6 - Donut
2510   *    2.0 - Eclair
2511   *    2.1 - Eclair
2512   *    2.2 - Froyo
2513   *    2.x - Gingerbread
2514   *    3.x - Honeycomb
2515   *    4.0 - Ice Cream Sandwich
2516   *    4.1 - Jelly Bean
2517   *    4.4 - KitKat
2518   *    5.x - Lollipop
2519   *    6.x - Marshmallow
2520   *    7.x - Nougat
2521   *    8.x - Oreo
2522   *    9.x - Pie
2523   *
2524   * @example
2525   *   getAndroidVersionName("7.0") // 'Nougat'
2526   *
2527   * @param  {string} version
2528   * @return {string} versionName
2529   */
2530  static getAndroidVersionName(version) {
2531    const v = version.split(".").splice(0, 2).map((s) => parseInt(s, 10) || 0);
2532    v.push(0);
2533    if (v[0] === 1 && v[1] < 5) return void 0;
2534    if (v[0] === 1 && v[1] < 6) return "Cupcake";
2535    if (v[0] === 1 && v[1] >= 6) return "Donut";
2536    if (v[0] === 2 && v[1] < 2) return "Eclair";
2537    if (v[0] === 2 && v[1] === 2) return "Froyo";
2538    if (v[0] === 2 && v[1] > 2) return "Gingerbread";
2539    if (v[0] === 3) return "Honeycomb";
2540    if (v[0] === 4 && v[1] < 1) return "Ice Cream Sandwich";
2541    if (v[0] === 4 && v[1] < 4) return "Jelly Bean";
2542    if (v[0] === 4 && v[1] >= 4) return "KitKat";
2543    if (v[0] === 5) return "Lollipop";
2544    if (v[0] === 6) return "Marshmallow";
2545    if (v[0] === 7) return "Nougat";
2546    if (v[0] === 8) return "Oreo";
2547    if (v[0] === 9) return "Pie";
2548    return void 0;
2549  }
2550  /**
2551   * Get version precisions count
2552   *
2553   * @example
2554   *   getVersionPrecision("1.10.3") // 3
2555   *
2556   * @param  {string} version
2557   * @return {number}
2558   */
2559  static getVersionPrecision(version) {
2560    return version.split(".").length;
2561  }
2562  /**
2563   * Calculate browser version weight
2564   *
2565   * @example
2566   *   compareVersions('1.10.2.1',  '1.8.2.1.90')    // 1
2567   *   compareVersions('1.010.2.1', '1.09.2.1.90');  // 1
2568   *   compareVersions('1.10.2.1',  '1.10.2.1');     // 0
2569   *   compareVersions('1.10.2.1',  '1.0800.2');     // -1
2570   *   compareVersions('1.10.2.1',  '1.10',  true);  // 0
2571   *
2572   * @param {String} versionA versions versions to compare
2573   * @param {String} versionB versions versions to compare
2574   * @param {boolean} [isLoose] enable loose comparison
2575   * @return {Number}

2575 comparison result: -1 when versionA is lower,
2576   * 1 when versionA is bigger, 0 when both equal
2577   */
2578  /* eslint consistent-return: 1 */
2579  static compareVersions(versionA, versionB, isLoose = false) {
2580    const versionAPrecision = Utils.getVersionPrecision(versionA);
2581    const versionBPrecision = Utils.getVersionPrecision(versionB);
2582    let precision = Math.max(versionAPrecision, versionBPrecision);
2583    let lastPrecision = 0;
2584    const chunks = Utils.map([versionA, versionB], (version) => {
2585      const delta = precision - Utils.getVersionPrecision(version);
2586      const _version = version + new Array(delta + 1).join(".0");
2587      return Utils.map(_version.split("."), (chunk2) => new Array(20 - chunk2.length).join("0") + chunk2).reverse();
2588    });
2589    if (isLoose) {
2590      lastPrecision = precision - Math.min(versionAPrecision, versionBPrecision);
2591    }
2592    precision -= 1;
2593    while (precision >= lastPrecision) {
2594      if (chunks[0][precision] > chunks[1][precision]) {
2595        return 1;
2596      }
2597      if (chunks[0][precision] === chunks[1][precision]) {
2598        if (precision === lastPrecision) {
2599          return 0;
2600        }
2601        precision -= 1;
2602      } else if (chunks[0][precision] < chunks[1][precision]) {
2603        return -1;
2604      }
2605    }
2606    return void 0;
2607  }
2608  /**
2609   * Array::map polyfill
2610   *
2611   * @param  {Array} arr
2612   * @param  {Function} iterator
2613   * @return {Array}
2614   */
2615  static map(arr, iterator) {
2616    const result = [];
2617    let i;
2618    if (Array.prototype.map) {
2619      return Array.prototype.map.call(arr, iterator);
2620    }
2621    for (i = 0; i < arr.length; i += 1) {
2622      result.push(iterator(arr[i]));
2623    }
2624    return result;
2625  }
2626  /**
2627   * Array::find polyfill
2628   *
2629   * @param  {Array} arr
2630   * @param  {Function} predicate
2631   * @return {Array}
2632   */
2633  static find(arr, predicate) {
2634    let i;
2635    let l;
2636    if (Array.prototype.find) {
2637      return Array.prototype.find.call(arr, predicate);
2638    }
2639    for (i = 0, l = arr.length; i < l; i += 1) {
2640      const value = arr[i];
2641      if (predicate(value, i)) {
2642        return value;
2643      }
2644    }
2645    return void 0;
2646  }
2647  /**
2648   * Object::assign polyfill
2649   *
2650   * @param  {Object} obj
2651   * @param  {Object} ...objs
2652   * @return {Object}
2653   */
2654  static assign(obj, ...assigners) {
2655    const result = obj;
2656    let i;
2657    let l;
2658    if (Object.assign) {
2659      return Object.assign(obj, ...assigners);
2660    }
2661    for (i = 0, l = assigners.length; i < l; i += 1) {
2662      const assigner = assigners[i];
2663      if (typeof assigner === "object" && assigner !== null) {
2664        const keys2 = Object.keys(assigner);
2665        keys2.forEach((key) => {
2666          result[key] = assigner[key];
2667        });
2668      }
2669    }
2670    return obj;
2671  }
2672  /**
2673   * Get short version/alias for a browser name
2674   *
2675   * @example
2676   *   getBrowserAlias('Microsoft Edge') // edge
2677   *
2678   * @param  {string} browserName
2679   * @return {string}
2680   */
2681  static getBrowserAlias(browserName) {
2682    return BROWSER_ALIASES_MAP[browserName];
2683  }
2684  /**
2685   * Get browser name for a short version/alias
2686   *
2687   * @example
2688   *   getBrowserTypeByAlias('edge') // Microsoft Edge
2689   *
2690   * @param  {string} browserAlias
2691   * @return {string}
2692   */
2693  static getBrowserTypeByAlias(browserAlias) {
2694    return BROWSER_MAP[browserAlias] || "";
2695  }
2696}
2697export {
2698  BROWSER_MAP as B,
2699  ENGINE_MAP as E,
2700  OS_MAP as O,
2701  PLATFORMS_MAP as P,
2702  Utils as U,
2703  snakeCase as a,
2704  cloneDeep as b,
2705  chunk as c,
2706  debounce as d,
2707  mergeWith as e,
2708  isEqual as f,
2709  get as g,
2710  round as h,
2711  isNumber as i,
2712  castArray as j,
2713  camelCase as k,
2714  find as l,
2715  merge as m,
2716  omit as o,
2717  pick as p,
2718  remove as r,
2719  set as s,
2720  throttle as t,
2721  uniqBy as u
2722};
2723//# sourceMappingURL=vendor-utils-j6SE9MGc.js.map

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.