https://amarsheba.com.bd/template/assets/libs/simplebar/dist/simplebar.js

1/**
2 * SimpleBar.js - v5.3.6
3 * Scrollbars, simpler.
4 * https://grsmto.github.io/simplebar/
5 *
6 * Made by Adrien Denat from a fork by Jonathan Nicol
7 * Under MIT License
8 */
9
10(function (global, factory) {
11	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
12	typeof define === 'function' && define.amd ? define(factory) :
13	(global = global || self, global.SimpleBar = factory());
14}(this, function () { 'use strict';
15
16	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
17
18	function createCommonjsModule(fn, module) {
19		return module = { exports: {} }, fn(module, module.exports), module.exports;
20	}
21
22	var O = 'object';
23	var check = function (it) {
24	  return it && it.Math == Math && it;
25	};
26
27	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
28	var global_1 =
29	  // eslint-disable-next-line no-undef
30	  check(typeof globalThis == O && globalThis) ||
31	  check(typeof window == O && window) ||
32	  check(typeof self == O && self) ||
33	  check(typeof commonjsGlobal == O && commonjsGlobal) ||
34	  // eslint-disable-next-line no-new-func
35	  Function('return this')();
36
37	var fails = function (exec) {
38	  try {
39	    return !!exec();
40	  } catch (error) {
41	    return true;
42	  }
43	};
44
45	// Thank's IE8 for his funny defineProperty
46	var descriptors = !fails(function () {
47	  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
48	});
49
50	var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
51	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
52
53	// Nashorn ~ JDK8 bug
54	var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
55
56	// `Object.prototype.propertyIsEnumerable` method implementation
57	// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable
58	var f = NASHORN_BUG ? function propertyIsEnumerable(V) {
59	  var descriptor = getOwnPropertyDescriptor(this, V);
60	  return !!descriptor && descriptor.enumerable;
61	} : nativePropertyIsEnumerable;
62
63	var objectPropertyIsEnumerable = {
64		f: f
65	};
66
67	var createPropertyDescriptor = function (bitmap, value) {
68	  return {
69	    enumerable: !(bitmap & 1),
70	    configurable: !(bitmap & 2),
71	    writable: !(bitmap & 4),
72	    value: value
73	  };
74	};
75
76	var toString = {}.toString;
77
78	var classofRaw = function (it) {
79	  return toString.call(it).slice(8, -1);
80	};
81
82	var split = ''.split;
83
84	// fallback for non-array-like ES3 and non-enumerable old V8 strings
85	var indexedObject = fails(function () {
86	  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
87	  // eslint-disable-next-line no-prototype-builtins
88	  return !Object('z').propertyIsEnumerable(0);
89	}) ? function (it) {
90	  return classofRaw(it) == 'String' ? split.call(it, '') : Object(it);
91	} : Object;
92
93	// `RequireObjectCoercible` abstract operation
94	// https://tc39.github.io/ecma262/#sec-requireobjectcoercible
95	var requireObjectCoercible = function (it) {
96	  if (it == undefined) throw TypeError("Can't call method on " + it);
97	  return it;
98	};
99
100	// toObject with fallback for non-array-like ES3 strings
101
102
103
104	var toIndexedObject = function (it) {
105	  return indexedObject(requireObjectCoercible(it));
106	};
107
108	var isObject = function (it) {
109	  return typeof it === 'object' ? it !== null : typeof it === 'function';
110	};
111
112	// `ToPrimitive` abstract operation
113	// https://tc39.github.io/ecma262/#sec-toprimitive
114	// instead of the ES6 spec version, we didn't implement @@toPrimitive case
115	// and the second argument - flag - preferred type is a string
116	var toPrimitive = function (input, PREFERRED_STRING) {
117	  if (!isObject(input)) return input;
118	  var fn, val;
119	  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
120	  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
121	  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
122	  throw TypeError("Can't convert object to primitive value");
123	};
124
125	var hasOwnProperty = {}.hasOwnProperty;
126
127	var has = function (it, key) {
128	  return hasOwnProperty.call(it, key);
129	};
130
131	var document$1 = global_1.document;
132	// typeof document.createElement is 'object' in old IE
133	var EXISTS = isObject(document$1) && isObject(document$1.createElement);
134
135	var documentCreateElement = function (it) {
136	  return EXISTS ? document$1.createElement(it) : {};
137	};
138
139	// Thank's IE8 for his funny defineProperty
140	var ie8DomDefine = !descriptors && !fails(function () {
141	  return Object.defineProperty(documentCreateElement('div'), 'a', {
142	    get: function () { return 7; }
143	  }).a != 7;
144	});
145
146	var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
147
148	// `Object.getOwnPropertyDescriptor` method
149	// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor
150	var f$1 = descriptors ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
151	  O = toIndexedObject(O);
152	  P = toPrimitive(P, true);
153	  if (ie8DomDefine) try {
154	    return nativeGetOwnPropertyDescriptor(O, P);
155	  } catch (error) { /* empty */ }
156	  if (has(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]);
157	};
158
159	var objectGetOwnPropertyDescriptor = {
160		f: f$1
161	};
162
163	var anObject = function (it) {
164	  if (!isObject(it)) {
165	    throw TypeError(String(it) + ' is not an object');
166	  } return it;
167	};
168
169	var nativeDefineProperty = Object.defineProperty;
170
171	// `Object.defineProperty` method
172	// https://tc39.github.io/ecma262/#sec-object.defineproperty
173	var f$2 = descriptors ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
174	  anObject(O);
175	  P = toPrimitive(P, true);
176	  anObject(Attributes);
177	  if (ie8DomDefine) try {
178	    return nativeDefineProperty(O, P, Attributes);
179	  } catch (error) { /* empty */ }
180	  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
181	  if ('value' in Attributes) O[P] = Attributes.value;
182	  return O;
183	};
184
185	var objectDefineProperty = {
186		f: f$2
187	};
188
189	var hide = descriptors ? function (object, key, value) {
190	  return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));
191	} : function (object, key, value) {
192	  object[key] = value;
193	  return object;
194	};
195
196	var setGlobal = function (key, value) {
197	  try {

198	    hide(global_1, key, value);
199	  } catch (error) {
200	    global_1[key] = value;
201	  } return value;
202	};
203
204	var shared = createCommonjsModule(function (module) {
205	var SHARED = '__core-js_shared__';
206	var store = global_1[SHARED] || setGlobal(SHARED, {});
207
208	(module.exports = function (key, value) {
209	  return store[key] || (store[key] = value !== undefined ? value : {});
210	})('versions', []).push({
211	  version: '3.2.1',
212	  mode:  'global',
213	  copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
214	});
215	});
216
217	var functionToString = shared('native-function-to-string', Function.toString);
218
219	var WeakMap$1 = global_1.WeakMap;
220
221	var nativeWeakMap = typeof WeakMap$1 === 'function' && /native code/.test(functionToString.call(WeakMap$1));
222
223	var id = 0;
224	var postfix = Math.random();
225
226	var uid = function (key) {
227	  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
228	};
229
230	var keys = shared('keys');
231
232	var sharedKey = function (key) {
233	  return keys[key] || (keys[key] = uid(key));
234	};
235
236	var hiddenKeys = {};
237
238	var WeakMap$2 = global_1.WeakMap;
239	var set, get, has$1;
240
241	var enforce = function (it) {
242	  return has$1(it) ? get(it) : set(it, {});
243	};
244
245	var getterFor = function (TYPE) {
246	  return function (it) {
247	    var state;
248	    if (!isObject(it) || (state = get(it)).type !== TYPE) {
249	      throw TypeError('Incompatible receiver, ' + TYPE + ' required');
250	    } return state;
251	  };
252	};
253
254	if (nativeWeakMap) {
255	  var store = new WeakMap$2();
256	  var wmget = store.get;
257	  var wmhas = store.has;
258	  var wmset = store.set;
259	  set = function (it, metadata) {
260	    wmset.call(store, it, metadata);
261	    return metadata;
262	  };
263	  get = function (it) {
264	    return wmget.call(store, it) || {};
265	  };
266	  has$1 = function (it) {
267	    return wmhas.call(store, it);
268	  };
269	} else {
270	  var STATE = sharedKey('state');
271	  hiddenKeys[STATE] = true;
272	  set = function (it, metadata) {
273	    hide(it, STATE, metadata);
274	    return metadata;
275	  };
276	  get = function (it) {
277	    return has(it, STATE) ? it[STATE] : {};
278	  };
279	  has$1 = function (it) {
280	    return has(it, STATE);
281	  };
282	}
283
284	var internalState = {
285	  set: set,
286	  get: get,
287	  has: has$1,
288	  enforce: enforce,
289	  getterFor: getterFor
290	};
291
292	var redefine = createCommonjsModule(function (module) {
293	var getInternalState = internalState.get;
294	var enforceInternalState = internalState.enforce;
295	var TEMPLATE = String(functionToString).split('toString');
296
297	shared('inspectSource', function (it) {
298	  return functionToString.call(it);
299	});
300
301	(module.exports = function (O, key, value, options) {
302	  var unsafe = options ? !!options.unsafe : false;
303	  var simple = options ? !!options.enumerable : false;
304	  var noTargetGet = options ? !!options.noTargetGet : false;

305	  if (typeof value == 'function') {
306	    if (typeof key == 'string' && !has(value, 'name')) hide(value, 'name', key);
307	    enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
308	  }
309	  if (O === global_1) {
310	    if (simple) O[key] = value;
311	    else setGlobal(key, value);
312	    return;
313	  } else if (!unsafe) {
314	    delete O[key];
315	  } else if (!noTargetGet && O[key]) {
316	    simple = true;
317	  }
318	  if (simple) O[key] = value;
319	  else hide(O, key, value);
320	// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
321	})(Function.prototype, 'toString', function toString() {
322	  return typeof this == 'function' && getInternalState(this).source || functionToString.call(this);
323	});
324	});
325
326	var path = global_1;
327
328	var aFunction = function (variable) {
329	  return typeof variable == 'function' ? variable : undefined;
330	};
331
332	var getBuiltIn = function (namespace, method) {
333	  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global_1[namespace])
334	    : path[namespace] && path[namespace][method] || global_1[namespace] && global_1[namespace][method];
335	};
336
337	var ceil = Math.ceil;
338	var floor = Math.floor;
339
340	// `ToInteger` abstract operation
341	// https://tc39.github.io/ecma262/#sec-tointeger
342	var toInteger = function (argument) {
343	  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
344	};
345
346	var min = Math.min;
347
348	// `ToLength` abstract operation
349	// https://tc39.github.io/ecma262/#sec-tolength
350	var toLength = function (argument) {
351	  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
352	};
353
354	var max = Math.max;
355	var min$1 = Math.min;
356
357	// Helper for a popular repeating case of the spec:
358	// Let integer be ? ToInteger(index).
359	// If integer < 0, let result be max((length + integer), 0); else let result be min(length, length).
360	var toAbsoluteIndex = function (index, length) {
361	  var integer = toInteger(index);
362	  return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
363	};
364
365	// `Array.prototype.{ indexOf, includes }` methods implementation
366	var createMethod = function (IS_INCLUDES) {
367	  return function ($this, el, fromIndex) {
368	    var O = toIndexedObject($this);
369	    var length = toLength(O.length);
370	    var index = toAbsoluteIndex(fromIndex, length);
371	    var value;
372	    // Array#includes uses SameValueZero equality algorithm
373	    // eslint-disable-next-line no-self-compare
374	    if (IS_INCLUDES && el != el) while (length > index) {
375	      value = O[index++];
376	      // eslint-disable-next-line no-self-compare
377	      if (value != value) return true;
378	    // Array#indexOf ignores holes, Array#includes - not
379	    } else for (;length > index; index++) {
380	      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
381	    } return !IS_INCLUDES && -1;
382	  };
383	};
384
385	var arrayIncludes = {
386	  // `Array.prototype.includes` method
387	  // https://tc39.github.io/ecma262/#sec-array.prototype.includes
388	  includes: createMethod(true),
389	  // `Array.prototype.indexOf` method
390	  // https://tc39.github.io/ecma262/#sec-array.prototype.indexof
391	  indexOf: createMethod(false)
392	};
393
394	var indexOf = arrayIncludes.indexOf;
395
396
397	var objectKeysInternal = function (object, names) {
398	  var O = toIndexedObject(object);
399	  var i = 0;
400	  var result = [];
401	  var key;
402	  for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);
403	  // Don't enum bug & hidden keys
404	  while (names.length > i) if (has(O, key = names[i++])) {
405	    ~indexOf(result, key) || result.push(key);
406	  }
407	  return result;
408	};
409
410	// IE8- don't enum bug keys
411	var enumBugKeys = [
412	  'constructor',
413	  'hasOwnProperty',
414	  'isPrototypeOf',
415	  'propertyIsEnumerable',
416	  'toLocaleString',
417	  'toString',
418	  'valueOf'
419	];
420
421	var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype');
422
423	// `Object.getOwnPropertyNames` method
424	// https://tc39.github.io/ecma262/#sec-object.getownpropertynames
425	var f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
426	  return objectKeysInternal(O, hiddenKeys$1);
427	};
428
429	var objectGetOwnPropertyNames = {
430		f: f$3
431	};
432
433	var f$4 = Object.getOwnPropertySymbols;
434
435	var objectGetOwnPropertySymbols = {
436		f: f$4
437	};
438
439	// all object keys, includes non-enumerable and symbols
440	var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
441	  var keys = objectGetOwnPropertyNames.f(anObject(it));
442	  var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
443	  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
444	};
445
446	var copyConstructorProperties = function (target, source) {
447	  var keys = ownKeys(source);
448	  var defineProperty = objectDefineProperty.f;
449	  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
450	  for (var i = 0; i < keys.length; i++) {
451	    var key = keys[i];
452	    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
453	  }
454	};
455
456	var replacement = /#|\.prototype\./;
457
458	var isForced = function (feature, detection) {
459	  var value = data[normalize(feature)];
460	  return value == POLYFILL ? true
461	    : value == NATIVE ? false
462	    : typeof detection == 'function' ? fails(detection)
463	    : !!detection;
464	};
465
466	var normalize = isForced.normalize = function (string) {
467	  return String(string).replace(replacement, '.').toLowerCase();
468	};
469
470	var data = isForced.data = {};
471	var NATIVE = isForced.NATIVE = 'N';
472	var POLYFILL = isForced.POLYFILL = 'P';
473
474	var isForced_1 = isForced;
475
476	var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
477
478
479
480
481
482
483	/*
484	  options.target      - name of the target object
485	  options.global      - target is the global object
486	  options.stat        - export as static methods of target
487	  options.proto       - export as prototype methods of target
488	  options.real        - real prototype method for the `pure` version
489	  options.forced      - export even if the native feature is available

490	  options.bind        - bind methods to the target, required for the `pure` version
491	  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
492	  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
493	  options.sham        - add a flag to not completely full polyfills
494	  options.enumerable  - export as enumerable property
495	  options.noTargetGet - prevent calling a getter on target
496	*/
497	var _export = function (options, source) {
498	  var TARGET = options.target;
499	  var GLOBAL = options.global;
500	  var STATIC = options.stat;
501	  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
502	  if (GLOBAL) {
503	    target = global_1;
504	  } else if (STATIC) {
505	    target = global_1[TARGET] || setGlobal(TARGET, {});
506	  } else {
507	    target = (global_1[TARGET] || {}).prototype;
508	  }
509	  if (target) for (key in source) {
510	    sourceProperty = source[key];
511	    if (options.noTargetGet) {
512	      descriptor = getOwnPropertyDescriptor$1(target, key);
513	      targetProperty = descriptor && descriptor.value;
514	    } else targetProperty = target[key];
515	    FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
516	    // contained in target
517	    if (!FORCED && targetProperty !== undefined) {
518	      if (typeof sourceProperty === typeof targetProperty) continue;
519	      copyConstructorProperties(sourceProperty, targetProperty);
520	    }
521	    // add a flag to not completely full polyfills
522	    if (options.sham || (targetProperty && targetProperty.sham)) {
523	      hide(sourceProperty, 'sham', true);
524	    }
525	    // extend global
526	    redefine(target, key, sourceProperty, options);
527	  }
528	};
529
530	var aFunction$1 = function (it) {
531	  if (typeof it != 'function') {
532	    throw TypeError(String(it) + ' is not a function');
533	  } return it;
534	};
535
536	// optional / simple context binding
537	var bindContext = function (fn, that, length) {
538	  aFunction$1(fn);
539	  if (that === undefined) return fn;
540	  switch (length) {
541	    case 0: return function () {
542	      return fn.call(that);
543	    };
544	    case 1: return function (a) {
545	      return fn.call(that, a);
546	    };
547	    case 2: return function (a, b) {
548	      return fn.call(that, a, b);
549	    };
550	    case 3: return function (a, b, c) {
551	      return fn.call(that, a, b, c);
552	    };
553	  }
554	  return function (/* ...args */) {
555	    return fn.apply(that, arguments);
556	  };
557	};
558
559	// `ToObject` abstract operation
560	// https://tc39.github.io/ecma262/#sec-toobject
561	var toObject = function (argument) {
562	  return Object(requireObjectCoercible(argument));
563	};
564
565	// `IsArray` abstract operation
566	// https://tc39.github.io/ecma262/#sec-isarray
567	var isArray = Array.isArray || function isArray(arg) {
568	  return classofRaw(arg) == 'Array';
569	};
570
571	var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () {
572	  // Chrome 38 Symbol has incorrect toString conversion
573	  // eslint-disable-next-line no-undef
574	  return !String(Symbol());
575	});
576
577	var Symbol$1 = global_1.Symbol;
578	var store$1 = shared('wks');
579
580	var wellKnownSymbol = function (name) {
581	  return store$1[name] || (store$1[name] = nativeSymbol && Symbol$1[name]
582	    || (nativeSymbol ? Symbol$1 : uid)('Symbol.' + name));
583	};
584
585	var SPECIES = wellKnownSymbol('species');
586
587	// `ArraySpeciesCreate` abstract operation
588	// https://tc39.github.io/ecma262/#sec-arrayspeciescreate
589	var arraySpeciesCreate = function (originalArray, length) {
590	  var C;
591	  if (isArray(originalArray)) {
592	    C = originalArray.constructor;
593	    // cross-realm fallback
594	    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
595	    else if (isObject(C)) {
596	      C = C[SPECIES];
597	      if (C === null) C = undefined;
598	    }
599	  } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);
600	};
601
602	var push = [].push;
603
604	// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation
605	var createMethod$1 = function (TYPE) {
606	  var IS_MAP = TYPE == 1;
607	  var IS_FILTER = TYPE == 2;
608	  var IS_SOME = TYPE == 3;
609	  var IS_EVERY = TYPE == 4;
610	  var IS_FIND_INDEX = TYPE == 6;
611	  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
612	  return function ($this, callbackfn, that, specificCreate) {
613	    var O = toObject($this);
614	    var self = indexedObject(O);
615	    var boundFunction = bindContext(callbackfn, that, 3);
616	    var length = toLength(self.length);
617	    var index = 0;
618	    var create = specificCreate || arraySpeciesCreate;
619	    var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
620	    var value, result;
621	    for (;length > index; index++) if (NO_HOLES || index in self) {
622	      value = self[index];
623	      result = boundFunction(value, index, O);
624	      if (TYPE) {
625	        if (IS_MAP) target[index] = result; // map
626	        else if (result) switch (TYPE) {
627	          case 3: return true;              // some
628	          case 5: return value;             // find
629	          case 6: return index;             // findIndex
630	          case 2: push.call(target, value); // filter
631	        } else if (IS_EVERY) return false;  // every
632	      }
633	    }
634	    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
635	  };
636	};
637
638	var arrayIteration = {
639	  // `Array.prototype.forEach` method
640	  // https://tc39.github.io/ecma262/#sec-array.prototype.foreach

792	  // Thrash, waste and sodomy: IE GC bug
793	  var iframe = documentCreateElement('iframe');
794	  var length = enumBugKeys.length;
795	  var lt = '<';
796	  var script = 'script';
797	  var gt = '>';
798	  var js = 'java' + script + ':';
799	  var iframeDocument;
800	  iframe.style.display = 'none';
801	  html.appendChild(iframe);
802	  iframe.src = String(js);
803	  iframeDocument = iframe.contentWindow.document;
804	  iframeDocument.open();
805	  iframeDocument.write(lt + script + gt + 'document.F=Object' + lt + '/' + script + gt);
806	  iframeDocument.close();
807	  createDict = iframeDocument.F;
808	  while (length--) delete createDict[PROTOTYPE][enumBugKeys[length]];
809	  return createDict();
810	};
811
812	// `Object.create` method
813	// https://tc39.github.io/ecma262/#sec-object.create
814	var objectCreate = Object.create || function create(O, Properties) {
815	  var result;
816	  if (O !== null) {
817	    Empty[PROTOTYPE] = anObject(O);
818	    result = new Empty();
819	    Empty[PROTOTYPE] = null;
820	    // add "__proto__" for Object.getPrototypeOf polyfill
821	    result[IE_PROTO] = O;
822	  } else result = createDict();
823	  return Properties === undefined ? result : objectDefineProperties(result, Properties);
824	};
825
826	hiddenKeys[IE_PROTO] = true;
827
828	var UNSCOPABLES = wellKnownSymbol('unscopables');
829	var ArrayPrototype = Array.prototype;
830
831	// Array.prototype[@@unscopables]
832	// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
833	if (ArrayPrototype[UNSCOPABLES] == undefined) {
834	  hide(ArrayPrototype, UNSCOPABLES, objectCreate(null));
835	}
836
837	// add a key to Array.prototype[@@unscopables]
838	var addToUnscopables = function (key) {
839	  ArrayPrototype[UNSCOPABLES][key] = true;
840	};
841
842	var iterators = {};
843
844	var correctPrototypeGetter = !fails(function () {
845	  function F() { /* empty */ }
846	  F.prototype.constructor = null;
847	  return Object.getPrototypeOf(new F()) !== F.prototype;
848	});
849
850	var IE_PROTO$1 = sharedKey('IE_PROTO');
851	var ObjectPrototype = Object.prototype;
852
853	// `Object.getPrototypeOf` method
854	// https://tc39.github.io/ecma262/#sec-object.getprototypeof
855	var objectGetPrototypeOf = correctPrototypeGetter ? Object.getPrototypeOf : function (O) {
856	  O = toObject(O);
857	  if (has(O, IE_PROTO$1)) return O[IE_PROTO$1];
858	  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
859	    return O.constructor.prototype;
860	  } return O instanceof Object ? ObjectPrototype : null;
861	};
862
863	var ITERATOR = wellKnownSymbol('iterator');
864	var BUGGY_SAFARI_ITERATORS = false;
865
866	var returnThis = function () { return this; };
867
868	// `%IteratorPrototype%` object
869	// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
870	var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
871
872	if ([].keys) {
873	  arrayIterator = [].keys();
874	  // Safari 8 has buggy iterators w/o `next`
875	  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
876	  else {
877	    PrototypeOfArrayIteratorPrototype = objectGetPrototypeOf(objectGetPrototypeOf(arrayIterator));
878	    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
879	  }
880	}
881
882	if (IteratorPrototype == undefined) IteratorPrototype = {};
883
884	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
885	if ( !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);
886
887	var iteratorsCore = {
888	  IteratorPrototype: IteratorPrototype,
889	  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
890	};
891
892	var defineProperty = objectDefineProperty.f;
893
894
895
896	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
897
898	var setToStringTag = function (it, TAG, STATIC) {
899	  if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
900	    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });
901	  }
902	};
903
904	var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
905
906
907
908
909
910	var returnThis$1 = function () { return this; };
911
912	var createIteratorConstructor = function (IteratorConstructor, NAME, next) {
913	  var TO_STRING_TAG = NAME + ' Iterator';
914	  IteratorConstructor.prototype = objectCreate(IteratorPrototype$1, { next: createPropertyDescriptor(1, next) });
915	  setToStringTag(IteratorConstructor, TO_STRING_TAG, false);
916	  iterators[TO_STRING_TAG] = returnThis$1;
917	  return IteratorConstructor;
918	};
919
920	var aPossiblePrototype = function (it) {
921	  if (!isObject(it) && it !== null) {
922	    throw TypeError("Can't set " + String(it) + ' as a prototype');
923	  } return it;
924	};
925
926	// `Object.setPrototypeOf` method
927	// https://tc39.github.io/ecma262/#sec-object.setprototypeof
928	// Works with __proto__ only. Old v8 can't work with null proto objects.
929	/* eslint-disable no-proto */
930	var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
931	  var CORRECT_SETTER = false;
932	  var test = {};
933	  var setter;
934	  try {
935	    setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
936	    setter.call(test, []);
937	    CORRECT_SETTER = test instanceof Array;
938	  } catch (error) { /* empty */ }
939	  return function setPrototypeOf(O, proto) {
940	    anObject(O);
941	    aPossiblePrototype(proto);
942	    if (CORRECT_SETTER) setter.call(O, proto);
943	    else O.__proto__ = proto;
944	    return O;
945	  };
946	}() : undefined);
947
948	var IteratorPrototype$2 = iteratorsCore.IteratorPrototype;
949	var BUGGY_SAFARI_ITERATORS$1 = iteratorsCore.BUGGY_SAFARI_ITERATORS;
950	var ITERATOR$1 = wellKnownSymbol('iterator');
951	var KEYS = 'keys';
952	var VALUES = 'values';
953	var ENTRIES = 'entries';
954
955	var returnThis$2 = function () { return this; };
956
957	var defineIterator = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
958	  createIteratorConstructor(IteratorConstructor, NAME, next);
959
960	  var getIterationMethod = function (KIND) {
961	    if (KIND === DEFAULT && defaultIterator) return defaultIterator;
962	    if (!BUGGY_SAFARI_ITERATORS$1 && KIND in IterablePrototype) return IterablePrototype[KIND];
963	    switch (KIND) {
964	      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
965	      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
966	      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
967	    } return function () { return new IteratorConstructor(this); };
968	  };
969
970	  var TO_STRING_TAG = NAME + ' Iterator';
971	  var INCORRECT_VALUES_NAME = false;
972	  var IterablePrototype = Iterable.prototype;
973	  var nativeIterator = IterablePrototype[ITERATOR$1]
974	    || IterablePrototype['@@iterator']
975	    || DEFAULT && IterablePrototype[DEFAULT];
976	  var defaultIterator = !BUGGY_SAFARI_ITERATORS$1 && nativeIterator || getIterationMethod(DEFAULT);
977	  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
978	  var CurrentIteratorPrototype, methods, KEY;
979
980	  // fix native
981	  if (anyNativeIterator) {
982	    CurrentIteratorPrototype = objectGetPrototypeOf(anyNativeIterator.call(new Iterable()));
983	    if (IteratorPrototype$2 !== Object.prototype && CurrentIteratorPrototype.next) {
984	      if ( objectGetPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype$2) {
985	        if (objectSetPrototypeOf) {
986	          objectSetPrototypeOf(CurrentIteratorPrototype, IteratorPrototype$2);
987	        } else if (typeof CurrentIteratorPrototype[ITERATOR$1] != 'function') {
988	          hide(CurrentIteratorPrototype, ITERATOR$1, returnThis$2);
989	        }
990	      }
991	      // Set @@toStringTag to native iterators
992	      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true);
993	    }
994	  }
995
996	  // fix Array#{values, @@iterator}.name in V8 / FF
997	  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
998	    INCORRECT_VALUES_NAME = true;
999	    defaultIterator = function values() { return nativeIterator.call(this); };
1000	  }
1001
1002	  // define iterator
1003	  if ( IterablePrototype[ITERATOR$1] !== defaultIterator) {
1004	    hide(IterablePrototype, ITERATOR$1, defaultIterator);
1005	  }
1006	  iterators[NAME] = defaultIterator;
1007
1008	  // export additional methods
1009	  if (DEFAULT) {
1010	    methods = {
1011	      values: getIterationMethod(VALUES),
1012	      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
1013	      entries: getIterationMethod(ENTRIES)
1014	    };
1015	    if (FORCED) for (KEY in methods) {
1016	      if (BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
1017	        redefine(IterablePrototype, KEY, methods[KEY]);
1018	      }
1019	    } else _export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME }, methods);
1020	  }
1021
1022	  return methods;
1023	};
1024
1025	var ARRAY_ITERATOR = 'Array Iterator';
1026	var setInternalState = internalState.set;
1027	var getInternalState = internalState.getterFor(ARRAY_ITERATOR);
1028
1029	// `Array.prototype.entries` method
1030	// https://tc39.github.io/ecma262/#sec-array.prototype.entries
1031	// `Array.prototype.keys` method
1032	// https://tc39.github.io/ecma262/#sec-array.prototype.keys
1033	// `Array.prototype.values` method
1034	// https://tc39.github.io/ecma262/#sec-array.prototype.values
1035	// `Array.prototype[@@iterator]` method
1036	// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator
1037	// `CreateArrayIterator` internal method
1038	// https://tc39.github.io/ecma262/#sec-createarrayiterator
1039	var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
1040	  setInternalState(this, {
1041	    type: ARRAY_ITERATOR,
1042	    target: toIndexedObject(iterated), // target
1043	    index: 0,                          // next index
1044	    kind: kind                         // kind
1045	  });
1046	// `%ArrayIteratorPrototype%.next` method
1047	// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next
1048	}, function () {
1049	  var state = getInternalState(this);
1050	  var target = state.target;
1051	  var kind = state.kind;
1052	  var index = state.index++;
1053	  if (!target || index >= target.length) {
1054	    state.target = undefined;
1055	    return { value: undefined, done: true };
1056	  }
1057	  if (kind == 'keys') return { value: index, done: false };
1058	  if (kind == 'values') return { value: target[index], done: false };
1059	  return { value: [index, target[index]], done: false };
1060	}, 'values');
1061
1062	// argumentsList[@@iterator] is %ArrayProto_values%
1063	// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject
1064	// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject
1065	iterators.Arguments = iterators.Array;
1066
1067	// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
1068	addToUnscopables('keys');
1069	addToUnscopables('values');
1070	addToUnscopables('entries');
1071
1072	var nativeAssign = Object.assign;
1073
1074	// `Object.assign` method
1075	// https://tc39.github.io/ecma262/#sec-object.assign
1076	// should work with symbols and should have deterministic property order (V8 bug)
1077	var objectAssign = !nativeAssign || fails(function () {
1078	  var A = {};
1079	  var B = {};
1080	  // eslint-disable-next-line no-undef
1081	  var symbol = Symbol();
1082	  var alphabet = 'abcdefghijklmnopqrst';
1083	  A[symbol] = 7;
1084	  alphabet.split('').forEach(function (chr) { B[chr] = chr; });
1085	  return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;
1086	}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
1087	  var T = toObject(target);
1088	  var argumentsLength = arguments.length;
1089	  var index = 1;
1090	  var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
1091	  var propertyIsEnumerable = objectPropertyIsEnumerable.f;
1092	  while (argumentsLength > index) {
1093	    var S = indexedObject(arguments[index++]);
1094	    var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);
1095	    var length = keys.length;
1096	    var j = 0;
1097	    var key;
1098	    while (length > j) {
1099	      key = keys[j++];
1100	      if (!descriptors || propertyIsEnumerable.call(S, key)) T[ke

1100y] = S[key];
1101	    }
1102	  } return T;
1103	} : nativeAssign;
1104
1105	// `Object.assign` method
1106	// https://tc39.github.io/ecma262/#sec-object.assign
1107	_export({ target: 'Object', stat: true, forced: Object.assign !== objectAssign }, {
1108	  assign: objectAssign
1109	});
1110
1111	var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag');
1112	// ES3 wrong here
1113	var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
1114
1115	// fallback for IE11 Script Access Denied error
1116	var tryGet = function (it, key) {
1117	  try {
1118	    return it[key];
1119	  } catch (error) { /* empty */ }
1120	};
1121
1122	// getting tag from ES6+ `Object.prototype.toString`
1123	var classof = function (it) {
1124	  var O, tag, result;
1125	  return it === undefined ? 'Undefined' : it === null ? 'Null'
1126	    // @@toStringTag case
1127	    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG$1)) == 'string' ? tag
1128	    // builtinTag case
1129	    : CORRECT_ARGUMENTS ? classofRaw(O)
1130	    // ES3 arguments fallback
1131	    : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
1132	};
1133
1134	var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag');
1135	var test = {};
1136
1137	test[TO_STRING_TAG$2] = 'z';
1138
1139	// `Object.prototype.toString` method implementation
1140	// https://tc39.github.io/ecma262/#sec-object.prototype.tostring
1141	var objectToString = String(test) !== '[object z]' ? function toString() {
1142	  return '[object ' + classof(this) + ']';
1143	} : test.toString;
1144
1145	var ObjectPrototype$1 = Object.prototype;
1146
1147	// `Object.prototype.toString` method
1148	// https://tc39.github.io/ecma262/#sec-object.prototype.tostring
1149	if (objectToString !== ObjectPrototype$1.toString) {
1150	  redefine(ObjectPrototype$1, 'toString', objectToString, { unsafe: true });
1151	}
1152
1153	// a string of all valid unicode whitespaces
1154	// eslint-disable-next-line max-len
1155	var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
1156
1157	var whitespace = '[' + whitespaces + ']';
1158	var ltrim = RegExp('^' + whitespace + whitespace + '*');
1159	var rtrim = RegExp(whitespace + whitespace + '*$');
1160
1161	// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
1162	var createMethod$2 = function (TYPE) {
1163	  return function ($this) {
1164	    var string = String(requireObjectCoercible($this));
1165	    if (TYPE & 1) string = string.replace(ltrim, '');
1166	    if (TYPE & 2) string = string.replace(rtrim, '');
1167	    return string;
1168	  };
1169	};
1170
1171	var stringTrim = {
1172	  // `String.prototype.{ trimLeft, trimStart }` methods
1173	  // https://tc39.github.io/ecma262/#sec-string.prototype.trimstart
1174	  start: createMethod$2(1),
1175	  // `String.prototype.{ trimRight, trimEnd }` methods
1176	  // https://tc39.github.io/ecma262/#sec-string.prototype.trimend
1177	  end: createMethod$2(2),
1178	  // `String.prototype.trim` method
1179	  // https://tc39.github.io/ecma262/#sec-string.prototype.trim
1180	  trim: createMethod$2(3)
1181	};
1182
1183	var trim = stringTrim.trim;
1184
1185
1186	var nativeParseInt = global_1.parseInt;
1187	var hex = /^[+-]?0[Xx]/;

1188	var FORCED = nativeParseInt(whitespaces + '08') !== 8 || nativeParseInt(whitespaces + '0x16') !== 22;
1189
1190	// `parseInt` method
1191	// https://tc39.github.io/ecma262/#sec-parseint-string-radix
1192	var _parseInt = FORCED ? function parseInt(string, radix) {
1193	  var S = trim(String(string));
1194	  return nativeParseInt(S, (radix >>> 0) || (hex.test(S) ? 16 : 10));
1195	} : nativeParseInt;
1196
1197	// `parseInt` method
1198	// https://tc39.github.io/ecma262/#sec-parseint-string-radix
1199	_export({ global: true, forced: parseInt != _parseInt }, {
1200	  parseInt: _parseInt
1201	});
1202
1203	// `String.prototype.{ codePointAt, at }` methods implementation
1204	var createMethod$3 = function (CONVERT_TO_STRING) {
1205	  return function ($this, pos) {
1206	    var S = String(requireObjectCoercible($this));
1207	    var position = toInteger(pos);
1208	    var size = S.length;
1209	    var first, second;
1210	    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
1211	    first = S.charCodeAt(position);
1212	    return first < 0xD800 || first > 0xDBFF || position + 1 === size
1213	      || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
1214	        ? CONVERT_TO_STRING ? S.charAt(position) : first
1215	        : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
1216	  };
1217	};
1218
1219	var stringMultibyte = {
1220	  // `String.prototype.codePointAt` method
1221	  // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat
1222	  codeAt: createMethod$3(false),
1223	  // `String.prototype.at` method
1224	  // https://github.com/mathiasbynens/String.prototype.at
1225	  charAt: createMethod$3(true)
1226	};
1227
1228	var charAt = stringMultibyte.charAt;
1229
1230
1231
1232	var STRING_ITERATOR = 'String Iterator';
1233	var setInternalState$1 = internalState.set;
1234	var getInternalState$1 = internalState.getterFor(STRING_ITERATOR);
1235
1236	// `String.prototype[@@iterator]` method
1237	// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator
1238	defineIterator(String, 'String', function (iterated) {
1239	  setInternalState$1(this, {
1240	    type: STRING_ITERATOR,
1241	    string: String(iterated),
1242	    index: 0
1243	  });
1244	// `%StringIteratorPrototype%.next` method
1245	// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next
1246	}, function next() {
1247	  var state = getInternalState$1(this);
1248	  var string = state.string;
1249	  var index = state.index;
1250	  var point;
1251	  if (index >= string.length) return { value: undefined, done: true };
1252	  point = charAt(string, index);
1253	  state.index += point.length;
1254	  return { value: point, done: false };
1255	});
1256
1257	var redefineAll = function (target, src, options) {
1258	  for (var key in src) redefine(target, key, src[key], options);
1259	  return target;
1260	};
1261
1262	var freezing = !fails(function () {
1263	  return Object.isExtensible(Object.preventExtensions({}));
1264	});
1265
1266	var internalMetadata = createCommonjsModule(function (module) {
1267	var defineProperty = objectDefineProperty.f;
1268
1269
1270
1271	var METADATA = uid('meta');
1272	var id = 0;
1273
1274	var isExtensible = Object.isExtensible || function () {
1275	  return true;
1276	};
1277
1278	var setMetadata = function (it) {
1279	  defineProperty(it, METADATA, { value: {
1280	    objectID: 'O' + ++id, // object ID
1281	    weakData: {}          // weak collections IDs
1282	  } });
1283	};
1284
1285	var fastKey = function (it, create) {
1286	  // return a primitive with prefix
1287	  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
1288	  if (!has(it, METADATA)) {
1289	    // can't set metadata to uncaught frozen object
1290	    if (!isExtensible(it)) return 'F';
1291	    // not necessary to add metadata
1292	    if (!create) return 'E';
1293	    // add missing metadata
1294	    setMetadata(it);
1295	  // return object ID
1296	  } return it[METADATA].objectID;
1297	};
1298
1299	var getWeakData = function (it, create) {
1300	  if (!has(it, METADATA)) {
1301	    // can't set metadata to uncaught frozen object
1302	    if (!isExtensible(it)) return true;
1303	    // not necessary to add metadata
1304	    if (!create) return false;
1305	    // add missing metadata
1306	    setMetadata(it);
1307	  // return the store of weak collections IDs
1308	  } return it[METADATA].weakData;
1309	};
1310
1311	// add metadata on freeze-family methods calling
1312	var onFreeze = function (it) {
1313	  if (freezing && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it);
1314	  return it;
1315	};
1316
1317	var meta = module.exports = {
1318	  REQUIRED: false,
1319	  fastKey: fastKey,
1320	  getWeakData: getWeakData,
1321	  onFreeze: onFreeze
1322	};
1323
1324	hiddenKeys[METADATA] = true;
1325	});
1326	var internalMetadata_1 = internalMetadata.REQUIRED;
1327	var internalMetadata_2 = internalMetadata.fastKey;
1328	var internalMetadata_3 = internalMetadata.getWeakData;
1329	var internalMetadata_4 = internalMetadata.onFreeze;
1330
1331	var ITERATOR$2 = wellKnownSymbol('iterator');
1332	var ArrayPrototype$1 = Array.prototype;
1333
1334	// check on default Array iterator
1335	var isArrayIteratorMethod = function (it) {
1336	  return it !== undefined && (iterators.Array === it || ArrayPrototype$1[ITERATOR$2] === it);
1337	};
1338
1339	var ITERATOR$3 = wellKnownSymbol('iterator');
1340
1341	var getIteratorMethod = function (it) {
1342	  if (it != undefined) return it[ITERATOR$3]
1343	    || it['@@iterator']
1344	    || iterators[classof(it)];
1345	};
1346
1347	// call something on iterator step with safe closing on error
1348	var callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) {
1349	  try {
1350	    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
1351	  // 7.4.6 IteratorClose(iterator, completion)
1352	  } catch (error) {
1353	    var returnMethod = iterator['return'];
1354	    if (returnMethod !== undefined) anObject(returnMethod.call(iterator));
1355	    throw error;
1356	  }
1357	};
1358
1359	var iterate_1 = createCommonjsModule(function (module) {
1360	var Result = function (stopped, result) {
1361	  this.stopped = stopped;
1362	  this.result = result;
1363	};
1364
1365	var iterate = module.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) {
1366	  var boundFunction = bindContext(fn, that, AS_ENTRIES ? 2 : 1);
1367	  var iterator, iterFn, index, length, result, step;
1368
1369	  if (IS_ITERATOR) {
1370	    iterator = iterable;
1371	  } else {
1372	    iterFn = getIteratorMethod(iterable);
1373	    if (typeof iterFn != 'function') throw TypeError('Target is not iterable');
1374	    // optimisation for array iterators
1375	    if (isArrayIteratorMethod(iterFn)) {
1376	      for (index = 0, length = toLength(iterable.length); length > index; index++) {
1377	        result = AS_ENTRIES
1378	          ? boundFunction(anObject(step = iterable[index])[0], step[1])
1379	          : boundFunction(iterable[index]);
1380	        if (result && result instanceof Result) return result;
1381	      } return new Result(false);
1382	    }
1383	    iterator = iterFn.call(iterable);
1384	  }
1385
1386	  while (!(step = iterator.next()).done) {
1387	    result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES);
1388	    if (result && result instanceof Result) return result;
1389	  } return new Result(false);
1390	};
1391
1392	iterate.stop = function (result) {
1393	  return new Result(true, result);
1394	};
1395	});
1396
1397	var anInstance = function (it, Constructor, name) {
1398	  if (!(it instanceof Constructor)) {
1399	    throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
1400	  } return it;
1401	};
1402
1403	var ITERATOR$4 = wellKnownSymbol('iterator');
1404	var SAFE_CLOSING = false;

1405
1406	try {
1407	  var called = 0;
1408	  var iteratorWithReturn = {
1409	    next: function () {
1410	      return { done: !!called++ };
1411	    },
1412	    'return': function () {
1413	      SAFE_CLOSING = true;
1414	    }
1415	  };
1416	  iteratorWithReturn[ITERATOR$4] = function () {
1417	    return this;
1418	  };
1419	  // eslint-disable-next-line no-throw-literal
1420	  Array.from(iteratorWithReturn, function () { throw 2; });
1421	} catch (error) { /* empty */ }
1422
1423	var checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) {
1424	  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
1425	  var ITERATION_SUPPORT = false;
1426	  try {
1427	    var object = {};
1428	    object[ITERATOR$4] = function () {
1429	      return {
1430	        next: function () {
1431	          return { done: ITERATION_SUPPORT = true };
1432	        }
1433	      };
1434	    };
1435	    exec(object);
1436	  } catch (error) { /* empty */ }
1437	  return ITERATION_SUPPORT;
1438	};
1439
1440	// makes subclassing work correct for wrapped built-ins
1441	var inheritIfRequired = function ($this, dummy, Wrapper) {
1442	  var NewTarget, NewTargetPrototype;
1443	  if (
1444	    // it can work only with native `setPrototypeOf`
1445	    objectSetPrototypeOf &&
1446	    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
1447	    typeof (NewTarget = dummy.constructor) == 'function' &&
1448	    NewTarget !== Wrapper &&
1449	    isObject(NewTargetPrototype = NewTarget.prototype) &&
1450	    NewTargetPrototype !== Wrapper.prototype
1451	  ) objectSetPrototypeOf($this, NewTargetPrototype);
1452	  return $this;
1453	};
1454
1455	var collection = function (CONSTRUCTOR_NAME, wrapper, common, IS_MAP, IS_WEAK) {
1456	  var NativeConstructor = global_1[CONSTRUCTOR_NAME];
1457	  var NativePrototype = NativeConstructor && NativeConstructor.prototype;
1458	  var Constructor = NativeConstructor;
1459	  var ADDER = IS_MAP ? 'set' : 'add';
1460	  var exported = {};
1461
1462	  var fixMethod = function (KEY) {
1463	    var nativeMethod = NativePrototype[KEY];
1464	    redefine(NativePrototype, KEY,
1465	      KEY == 'add' ? function add(value) {
1466	        nativeMethod.call(this, value === 0 ? 0 : value);
1467	        return this;
1468	      } : KEY == 'delete' ? function (key) {
1469	        return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);
1470	      } : KEY == 'get' ? function get(key) {
1471	        return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key);
1472	      } : KEY == 'has' ? function has(key) {
1473	        return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);
1474	      } : function set(key, value) {
1475	        nativeMethod.call(this, key === 0 ? 0 : key, value);
1476	        return this;
1477	      }
1478	    );
1479	  };
1480
1481	  // eslint-disable-next-line max-len
1482	  if (isForced_1(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {
1483	    new NativeConstructor().entries().next();
1484	  })))) {
1485	    // create collection constructor
1486	    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);
1487	    internalMetadata.REQUIRED = true;
1488	  } else if (isForced_1(CONSTRUCTOR_NAME, true)) {
1489	    var instance = new Constructor();
1490	    // early implementations not supports chaining
1491	    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
1492	    // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false
1493	    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });
1494	    // most early implementations doesn't supports iterables, most modern - not close it correctly
1495	    // eslint-disable-next-line no-new
1496	    var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });
1497	    // for early implementations -0 and +0 not the same
1498	    var BUGGY_ZERO = !IS_WEAK && fails(function () {
1499	      // V8 ~ Chromium 42- fails only with 5+ elements
1500	      var $instance = new NativeConstructor();
1501	      var index = 5;
1502	      while (index--) $instance[ADDER](index, index);
1503	      return !$instance.has(-0);
1504	    });
1505
1506	    if (!ACCEPT_ITERABLES) {
1507	      Constructor = wrapper(function (dummy, iterable) {
1508	        anInstance(dummy, Constructor, CONSTRUCTOR_NAME);
1509	        var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);
1510	        if (iterable != undefined) iterate_1(iterable, that[ADDER], that, IS_MAP);
1511	        return that;
1512	      });
1513	      Constructor.prototype = NativePrototype;
1514	      NativePrototype.constructor = Constructor;
1515	    }
1516
1517	    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
1518	      fixMethod('delete');
1519	      fixMethod('has');
1520	      IS_MAP && fixMethod('get');
1521	    }
1522
1523	    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
1524
1525	    // weak collections should not contains .clear method
1526	    if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;
1527	  }
1528
1529	  exported[CONSTRUCTOR_NAME] = Constructor;
1530	  _export({ global: true, forced: Constructor != NativeConstructor }, exported);
1531
1532	  setToStringTag(Constructor, CONSTRUCTOR_NAME);
1533
1534	  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);
1535
1536	  return Constructor;
1537	};
1538
1539	var getWeakData = internalMetadata.getWeakData;
1540
1541
1542
1543
1544
1545
1546
1547
1548	var setInternalState$2 = internalState.set;
1549	var internalStateGetterFor = internalState.getterFor;
1550	var find = arrayIteration.find;
1551	var findIndex = arrayIteration.findIndex;
1552	var id$1 = 0;
1553

1754	/**
1755	 * lodash (Custom Build) <https://lodash.com/>
1756	 * Build: `lodash modularize exports="npm" -o ./`
1757	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
1758	 * Released under MIT license <https://lodash.com/license>
1759	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
1760	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
1761	 */
1762
1763	/** Used as the `TypeError` message for "Functions" methods. */
1764	var FUNC_ERROR_TEXT = 'Expected a function';
1765
1766	/** Used as references for various `Number` constants. */
1767	var NAN = 0 / 0;
1768
1769	/** `Object#toString` result references. */
1770	var symbolTag = '[object Symbol]';
1771
1772	/** Used to match leading and trailing whitespace. */
1773	var reTrim = /^\s+|\s+$/g;
1774
1775	/** Used to detect bad signed hexadecimal string values. */
1776	var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
1777
1778	/** Used to detect binary string values. */
1779	var reIsBinary = /^0b[01]+$/i;
1780
1781	/** Used to detect octal string values. */
1782	var reIsOctal = /^0o[0-7]+$/i;
1783
1784	/** Built-in method references without a dependency on `root`. */
1785	var freeParseInt = parseInt;
1786
1787	/** Detect free variable `global` from Node.js. */
1788	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
1789
1790	/** Detect free variable `self`. */
1791	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
1792
1793	/** Used as a reference to the global object. */
1794	var root = freeGlobal || freeSelf || Function('return this')();
1795
1796	/** Used for built-in method references. */
1797	var objectProto = Object.prototype;
1798
1799	/**
1800	 * Used to resolve the
1801	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
1802	 * of values.
1803	 */
1804	var objectToString$1 = objectProto.toString;
1805
1806	/* Built-in method references for those with the same name as other `lodash` methods. */
1807	var nativeMax = Math.max,
1808	    nativeMin = Math.min;
1809
1810	/**
1811	 * Gets the timestamp of the number of milliseconds that have elapsed since
1812	 * the Unix epoch (1 January 1970 00:00:00 UTC).
1813	 *
1814	 * @static
1815	 * @memberOf _
1816	 * @since 2.4.0
1817	 * @category Date
1818	 * @returns {number} Returns the timestamp.
1819	 * @example
1820	 *
1821	 * _.defer(function(stamp) {
1822	 *   console.log(_.now() - stamp);
1823	 * }, _.now());
1824	 * // => Logs the number of milliseconds it took for the deferred invocation.
1825	 */
1826	var now = function() {
1827	  return root.Date.now();
1828	};
1829
1830	/**
1831	 * Creates a debounced function that delays invoking `func` until after `wait`
1832	 * milliseconds have elapsed since the last time the debounced function was
1833	 * invoked. The debounced function comes with a `cancel` method to cancel
1834	 * delayed `func` invocations and a `flush` method to immediately invoke them.
1835	 * Provide `options` to indicate whether `func` should be invoked on the
1836	 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
1837	 * with the last arguments provided to the debounced function. Subsequent
1838	 * calls to the debounced function return the result of the last `func`
1839	 * invocation.
1840	 *
1841	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
1842	 * invoked on the trailing edge of the timeout only if the debounced function
1843	 * is invoked more than once during the `wait` timeout.
1844	 *
1845	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
1846	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
1847	 *
1848	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
1849	 * for details over the differences between `_.debounce` and `_.throttle`.
1850	 *
1851	 * @static
1852	 * @memberOf _
1853	 * @since 0.1.0
1854	 * @category Function
1855	 * @param {Function} func The function to debounce.
1856	 * @param {number} [wait=0] The number of milliseconds to delay.
1857	 * @param {Object} [options={}] The options object.
1858	 * @param {boolean} [options.leading=false]
1859	 *  Specify invoking on the leading edge of the timeout.
1860	 * @param {number} [options.maxWait]
1861	 *  The maximum time `func` is allowed to be delayed before it's invoked.
1862	 * @param {boolean} [options.trailing=true]
1863	 *  Specify invoking on the trailing edge of the timeout.
1864	 * @returns {Function} Returns the new debounced function.
1865	 * @example
1866	 *
1867	 * // Avoid costly calculations while the window size is in flux.
1868	 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
1869	 *
1870	 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
1871	 * jQuery(element).on('click', _.debounce(sendMail, 300, {
1872	 *   'leading': true,
1873	 *   'trailing': false
1874	 * }));
1875	 *
1876	 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
1877	 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
1878	 * var source = new EventSource('/stream');
1879	 * jQuery(source).on('message', debounced);
1880	 *
1881	 * // Cancel the trailing debounced invocation.
1882	 * jQuery(window).on('popstate', debounced.cancel);
1883	 */
1884	function debounce(func, wait, options) {
1885	  var lastArgs,
1886	      lastThis,
1887	      maxWait,
1888	      result,
1889	      timerId,
1890	      lastCallTime,
1891	      lastInvokeTime = 0,
1892	      leading = false,
1893	      maxing = false,
1894	      trailing = true;
1895
1896	  if (typeof func != 'function') {
1897	    throw new TypeError(FUNC_ERROR_TEXT);
1898	  }
1899	  wait = toNumber(wait) || 0;
1900	  if (isObject$1(options)) {
1901	    leading = !!options.leading;
1902	    maxing = 'maxWait' in options;
1903	    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
1904	    trailing = 'trailing' in options ? !!options.trailing : trailing;
1905	  }
1906
1907	  function invokeFunc(time) {
1908	    var args = lastArgs,
1909	        thisArg = lastThis;
1910
1911	    lastArgs = lastThis = undefined;
1912	    lastInvokeTime = time;
1913	    result = func.apply(thisArg, args);
1914	    return result;
1915	  }
1916
1917	  function leadingEdge(time) {
1918	    // Reset any `maxWait` timer.
1919	    lastInvokeTime = time;
1920	    // Start the timer for the trailing edge.
1921	    timerId = setTimeout(timerExpired, wait);
1922	    // Invoke the leading edge.
1923	    return leading ? invokeFunc(time) : result;
1924	  }
1925
1926	  function remainingWait(time) {
1927	    var timeSinceLastCall = time - lastCallTime,
1928	        timeSinceLastInvoke = time - lastInvokeTime,
1929	        result = wait - timeSinceLastCall;
1930
1931	    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
1932	  }
1933
1934	  function shouldInvoke(time) {
1935	    var timeSinceLastCall = time - lastCallTime,
1936	        timeSinceLastInvoke = time - lastInvokeTime;
1937
1938	    // Either this is the first call, activity has stopped and we're at the
1939	    // trailing edge, the system time has gone backwards and we're treating
1940	    // it as the trailing edge, or we've hit the `maxWait` limit.
1941	    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
1942	      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
1943	  }
1944
1945	  function timerExpired() {
1946	    var time = now();
1947	    if (shouldInvoke(time)) {
1948	      return trailingEdge(time);
1949	    }
1950	    // Restart the timer.
1951	    timerId = setTimeout(timerExpired, remainingWait(time));
1952	  }
1953
1954	  function trailingEdge(time) {
1955	    timerId = undefined;
1956
1957	    // Only invoke if we have `lastArgs` which means `func` has been
1958	    // debounced at least once.
1959	    if (trailing && lastArgs) {
1960	      return invokeFunc(time);
1961	    }
1962	    lastArgs = lastThis = undefined;
1963	    return result;
1964	  }
1965
1966	  function cancel() {
1967	    if (timerId !== undefined) {
1968	      clearTimeout(timerId);
1969	    }
1970	    lastInvokeTime = 0;
1971	    lastArgs = lastCallTime = lastThis = timerId = undefined;
1972	  }
1973
1974	  function flush() {
1975	    return timerId === undefined ? result : trailingEdge(now());
1976	  }
1977
1978	  function debounced() {
1979	    var time = now(),
1980	        isInvoking = shouldInvoke(time);
1981
1982	    lastArgs = arguments;
1983	    lastThis = this;
1984	    lastCallTime = time;
1985
1986	    if (isInvoking) {
1987	      if (timerId === undefined) {
1988	        return leadingEdge(lastCallTime);
1989	      }
1990	      if (maxing) {
1991	        // Handle invocations in a tight loop.
1992	        timerId = setTimeout(timerExpired, wait);
1993	        return invokeFunc(lastCallTime);
1994	      }
1995	    }
1996	    if (timerId === undefined) {
1997	      timerId = setTimeout(timerExpired, wait);
1998	    }
1999	    return result;
2000	  }
2001	  debounced.cancel = cancel;
2002	  debounced.flush = flush;
2003	  return debounced;
2004	}
2005
2006	/**
2007	 * Creates a throttled function that only invokes `func` at most once per
2008	 * every `wait` milliseconds. The throttled function comes with a `cancel`
2009	 * method to cancel delayed `func` invocations and a `flush` method to
2010	 * immediately invoke them. Provide `options` to indicate whether `func`
2011	 * should be invoked on the leading and/or trailing edge of the `wait`
2012	 * timeout. The `func` is invoked with the last arguments provided to the
2013	 * throttled function. Subsequent calls to the throttled function return the
2014	 * result of the last `func` invocation.
2015	 *
2016	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
2017	 * invoked on the trailing edge of the timeout only if the throttled function
2018	 * is invoked more than once during the `wait` timeout.
2019	 *
2020	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
2021	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
2022	 *

2204	var FUNC_ERROR_TEXT$1 = 'Expected a function';
2205
2206	/** Used as references for various `Number` constants. */
2207	var NAN$1 = 0 / 0;
2208
2209	/** `Object#toString` result references. */
2210	var symbolTag$1 = '[object Symbol]';
2211
2212	/** Used to match leading and trailing whitespace. */
2213	var reTrim$1 = /^\s+|\s+$/g;
2214
2215	/** Used to detect bad signed hexadecimal string values. */
2216	var reIsBadHex$1 = /^[-+]0x[0-9a-f]+$/i;
2217
2218	/** Used to detect binary string values. */
2219	var reIsBinary$1 = /^0b[01]+$/i;
2220
2221	/** Used to detect octal string values. */
2222	var reIsOctal$1 = /^0o[0-7]+$/i;
2223
2224	/** Built-in method references without a dependency on `root`. */
2225	var freeParseInt$1 = parseInt;
2226
2227	/** Detect free variable `global` from Node.js. */
2228	var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
2229
2230	/** Detect free variable `self`. */
2231	var freeSelf$1 = typeof self == 'object' && self && self.Object === Object && self;
2232
2233	/** Used as a reference to the global object. */
2234	var root$1 = freeGlobal$1 || freeSelf$1 || Function('return this')();
2235
2236	/** Used for built-in method references. */
2237	var objectProto$1 = Object.prototype;
2238
2239	/**
2240	 * Used to resolve the
2241	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
2242	 * of values.
2243	 */
2244	var objectToString$2 = objectProto$1.toString;
2245
2246	/* Built-in method references for those with the same name as other `lodash` methods. */
2247	var nativeMax$1 = Math.max,
2248	    nativeMin$1 = Math.min;
2249
2250	/**
2251	 * Gets the timestamp of the number of milliseconds that have elapsed since
2252	 * the Unix epoch (1 January 1970 00:00:00 UTC).
2253	 *
2254	 * @static
2255	 * @memberOf _
2256	 * @since 2.4.0
2257	 * @category Date
2258	 * @returns {number} Returns the timestamp.
2259	 * @example
2260	 *
2261	 * _.defer(function(stamp) {
2262	 *   console.log(_.now() - stamp);
2263	 * }, _.now());
2264	 * // => Logs the number of milliseconds it took for the deferred invocation.
2265	 */
2266	var now$1 = function() {
2267	  return root$1.Date.now();
2268	};
2269
2270	/**
2271	 * Creates a debounced function that delays invoking `func` until after `wait`
2272	 * milliseconds have elapsed since the last time the debounced function was
2273	 * invoked. The debounced function comes with a `cancel` method to cancel
2274	 * delayed `func` invocations and a `flush` method to immediately invoke them.
2275	 * Provide `options` to indicate whether `func` should be invoked on the
2276	 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
2277	 * with the last arguments provided to the debounced function. Subsequent
2278	 * calls to the debounced function return the result of the last `func`
2279	 * invocation.
2280	 *
2281	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
2282	 * invoked on the trailing edge of the timeout only if the debounced function
2283	 * is invoked more than once during the `wait` timeout.
2284	 *
2285	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
2286	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
2287	 *
2288	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
2289	 * for details over the differences between `_.debounce` and `_.throttle`.
2290	 *
2291	 * @static
2292	 * @memberOf _
2293	 * @since 0.1.0
2294	 * @category Function
2295	 * @param {Function} func The function to debounce.
2296	 * @param {number} [wait=0] The number of milliseconds to delay.
2297	 * @param {Object} [options={}] The options object.
2298	 * @param {boolean} [options.leading=false]
2299	 *  Specify invoking on the leading edge of the timeout.
2300	 * @param {number} [options.maxWait]
2301	 *  The maximum time `func` is allowed to be delayed before it's invoked.
2302	 * @param {boolean} [options.trailing=true]
2303	 *  Specify invoking on the trailing edge of the timeout.
2304	 * @returns {Function} Returns the new debounced function.
2305	 * @example
2306	 *
2307	 * // Avoid costly calculations while the window size is in flux.
2308	 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
2309	 *
2310	 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
2311	 * jQuery(element).on('click', _.debounce(sendMail, 300, {
2312	 *   'leading': true,
2313	 *   'trailing': false
2314	 * }));
2315	 *
2316	 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
2317	 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
2318	 * var source = new EventSource('/stream');
2319	 * jQuery(source).on('message', debounced);
2320	 *
2321	 * // Cancel the trailing debounced invocation.
2322	 * jQuery(window).on('popstate', debounced.cancel);
2323	 */
2324	function debounce$1(func, wait, options) {
2325	  var lastArgs,
2326	      lastThis,
2327	      maxWait,
2328	      result,
2329	      timerId,
2330	      lastCallTime,
2331	      lastInvokeTime = 0,
2332	      leading = false,
2333	      maxing = false,
2334	      trailing = true;
2335
2336	  if (typeof func != 'function') {
2337	    throw new TypeError(FUNC_ERROR_TEXT$1);
2338	  }
2339	  wait = toNumber$1(wait) || 0;
2340	  if (isObject$2(options)) {
2341	    leading = !!options.leading;
2342	    maxing = 'maxWait' in options;
2343	    maxWait = maxing ? nativeMax$1(toNumber$1(options.maxWait) || 0, wait) : maxWait;
2344	    trailing = 'trailing' in options ? !!options.trailing : trailing;
2345	  }
2346
2347	  function invokeFunc(time) {
2348	    var args = lastArgs,
2349	        thisArg = lastThis;
2350
2351	    lastArgs = lastThis = undefined;
2352	    lastInvokeTime = time;
2353	    result = func.apply(thisArg, args);
2354	    return result;
2355	  }
2356
2357	  function leadingEdge(time) {
2358	    // Reset any `maxWait` timer.
2359	    lastInvokeTime = time;
2360	    // Start the timer for the trailing edge.
2361	    timerId = setTimeout(timerExpired, wait);
2362	    // Invoke the leading edge.
2363	    return leading ? invokeFunc(time) : result;
2364	  }
2365
2366	  function remainingWait(time) {
2367	    var timeSinceLastCall = time - lastCallTime,
2368	        timeSinceLastInvoke = time - lastInvokeTime,
2369	        result = wait - timeSinceLastCall;
2370
2371	    return maxing ? nativeMin$1(result, maxWait - timeSinceLastInvoke) : result;
2372	  }
2373
2374	  function shouldInvoke(time) {
2375	    var timeSinceLastCall = time - lastCallTime,
2376	        timeSinceLastInvoke = time - lastInvokeTime;
2377
2378	    // Either this is the first call, activity has stopped and we're at the
2379	    // trailing edge, the system time has gone backwards and we're treating
2380	    // it as the trailing edge, or we've hit the `maxWait` limit.
2381	    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
2382	      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
2383	  }
2384
2385	  function timerExpired() {
2386	    var time = now$1();
2387	    if (shouldInvoke(time)) {
2388	      return trailingEdge(time);
2389	    }
2390	    // Restart the timer.
2391	    timerId = setTimeout(timerExpired, remainingWait(time));
2392	  }
2393
2394	  function trailingEdge(time) {
2395	    timerId = undefined;
2396
2397	    // Only invoke if we have `lastArgs` which means `func` has been
2398	    // debounced at least once.
2399	    if (trailing && lastArgs) {
2400	      return invokeFunc(time);
2401	    }
2402	    lastArgs = lastThis = undefined;
2403	    return result;
2404	  }
2405
2406	  function cancel() {
2407	    if (timerId !== undefined) {
2408	      clearTimeout(timerId);
2409	    }
2410	    lastInvokeTime = 0;
2411	    lastArgs = lastCallTime = lastThis = timerId = undefined;
2412	  }
2413
2414	  function flush() {
2415	    return timerId === undefined ? result : trailingEdge(now$1());
2416	  }
2417
2418	  function debounced() {
2419	    var time = now$1(),
2420	        isInvoking = shouldInvoke(time);
2421
2422	    lastArgs = arguments;
2423	    lastThis = this;
2424	    lastCallTime = time;
2425
2426	    if (isInvoking) {
2427	      if (timerId === undefined) {
2428	        return leadingEdge(lastCallTime);
2429	      }
2430	      if (maxing) {
2431	        // Handle invocations in a tight loop.
2432	        timerId = setTimeout(timerExpired, wait);
2433	        return invokeFunc(lastCallTime);
2434	      }
2435	    }
2436	    if (timerId === undefined) {
2437	      timerId = setTimeout(timerExpired, wait);
2438	    }
2439	    return result;
2440	  }
2441	  debounced.cancel = cancel;
2442	  debounced.flush = flush;
2443	  return debounced;
2444	}
2445
2446	/**
2447	 * Checks if `value` is the
2448	 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
2449	 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
2450	 *
2451	 * @static
2452	 * @memberOf _
2453	 * @since 0.1.0
2454	 * @category Lang
2455	 * @param {*} value The value to check.
2456	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
2457	 * @example
2458	 *
2459	 * _.isObject({});
2460	 * // => true
2461	 *
2462	 * _.isObject([1, 2, 3]);
2463	 * // => true
2464	 *
2465	 * _.isObject(_.noop);
2466	 * // => true
2467	 *
2468	 * _.isObject(null);
2469	 * // => false
2470	 */
2471	function isObject$2(value) {
2472	  var type = typeof value;
2473	  return !!value && (type == 'object' || type == 'function');
2474	}
2475
2476	/**
2477	 * Checks if `value` is object-like. A value is object-like if it's not `null`
2478	 * and has a `typeof` result of "object".
2479	 *
2480	 * @static
2481	 * @memberOf _
2482	 * @since 4.0.0
2483	 * @category Lang
2484	 * @param {*} value The value to check.
2485	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
2486	 * @example
2487	 *
2488	 * _.isObjectLike({});
2489	 * // => true
2490	 *
2491	 * _.isObjectLike([1, 2, 3]);
2492	 * // => true
2493	 *
2494	 * _.isObjectLike(_.noop);
2495	 * // => false
2496	 *
2497	 * _.isObjectLike(null);
2498	 * // => false
2499	 */
2500	function isObjectLike$1(value) {
2501	  return !!value && typeof value == 'object';
2502	}
2503
2504	/**
2505	 * Checks if `value` is classified as a `Symbol` primitive or object.
2506	 *
2507	 * @static
2508	 * @memberOf _
2509	 * @since 4.0.0
2510	 * @category Lang
2511	 * @param {*} value The value to check.
2512	 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
2513	 * @example
2514	 *
2515	 * _.isSymbol(Symbol.iterator);
2516	 * // => true
2517	 *
2518	 * _.isSymbol('abc');
2519	 * // => false
2520	 */
2521	function isSymbol$1(value) {
2522	  return typeof value == 'symbol' ||
2523	    (isObjectLike$1(value) && objectToString$2.call(value) == symbolTag$1);
2524	}
2525
2526	/**
2527	 * Converts `value` to a number.
2528	 *
2529	 * @static
2530	 * @memberOf _
2531	 * @since 4.0.0
2532	 * @category Lang
2533	 * @param {*} value The value to process.
2534	 * @returns {number} Returns the number.
2535	 * @example
2536	 *
2537	 * _.toNumber(3.2);
2538	 * // => 3.2
2539	 *
2540	 * _.toNumber(Number.MIN_VALUE);
2541	 * // => 5e-324
2542	 *
2543	 * _.toNumber(Infinity);
2544	 * // => Infinity
2545	 *
2546	 * _.toNumber('3.2');
2547	 * // => 3.2
2548	 */
2549	function toNumber$1(value) {
2550	  if (typeof value == 'number') {
2551	    return value;
2552	  }
2553	  if (isSymbol$1(value)) {
2554	    return NAN$1;
2555	  }
2556	  if (isObject$2(value)) {
2557	    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
2558	    value = isObject$2(other) ? (other + '') : other;
2559	  }
2560	  if (typeof value != 'string') {
2561	    return value === 0 ? value : +value;
2562	  }
2563	  value = value.replace(reTrim$1, '');
2564	  var isBinary = reIsBinary$1.test(value);
2565	  return (isBinary || reIsOctal$1.test(value))
2566	    ? freeParseInt$1(value.slice(2), isBinary ? 2 : 8)
2567	    : (reIsBadHex$1.test(value) ? NAN$1 : +value);
2568	}
2569
2570	var lodash_debounce = debounce$1;
2571
2572	/**
2573	 * lodash (Custom Build) <https://lodash.com/>
2574	 * Build: `lodash modularize exports="npm" -o ./`
2575	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
2576	 * Released under MIT license <https://lodash.com/license>
2577	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
2578	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
2579	 */
2580
2581	/** Used as the `TypeError` message for "Functions" methods. */

2632	  if (value != null && typeof value.toString != 'function') {
2633	    try {
2634	      result = !!(value + '');
2635	    } catch (e) {}
2636	  }
2637	  return result;
2638	}
2639
2640	/** Used for built-in method references. */
2641	var arrayProto = Array.prototype,
2642	    funcProto = Function.prototype,
2643	    objectProto$2 = Object.prototype;
2644
2645	/** Used to detect overreaching core-js shims. */
2646	var coreJsData = root$2['__core-js_shared__'];
2647
2648	/** Used to detect methods masquerading as native. */
2649	var maskSrcKey = (function() {
2650	  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
2651	  return uid ? ('Symbol(src)_1.' + uid) : '';
2652	}());
2653
2654	/** Used to resolve the decompiled source of functions. */
2655	var funcToString = funcProto.toString;
2656
2657	/** Used to check objects for own properties. */
2658	var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
2659
2660	/**
2661	 * Used to resolve the
2662	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
2663	 * of values.
2664	 */
2665	var objectToString$3 = objectProto$2.toString;
2666
2667	/** Used to detect if a method is native. */
2668	var reIsNative = RegExp('^' +
2669	  funcToString.call(hasOwnProperty$1).replace(reRegExpChar, '\\$&')
2670	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
2671	);
2672
2673	/** Built-in value references. */
2674	var splice = arrayProto.splice;
2675
2676	/* Built-in method references that are verified to be native. */
2677	var Map = getNative(root$2, 'Map'),
2678	    nativeCreate = getNative(Object, 'create');
2679
2680	/**
2681	 * Creates a hash object.
2682	 *
2683	 * @private
2684	 * @constructor
2685	 * @param {Array} [entries] The key-value pairs to cache.
2686	 */
2687	function Hash(entries) {
2688	  var index = -1,
2689	      length = entries ? entries.length : 0;
2690
2691	  this.clear();
2692	  while (++index < length) {
2693	    var entry = entries[index];
2694	    this.set(entry[0], entry[1]);
2695	  }
2696	}
2697
2698	/**
2699	 * Removes all key-value entries from the hash.
2700	 *
2701	 * @private
2702	 * @name clear
2703	 * @memberOf Hash
2704	 */
2705	function hashClear() {
2706	  this.__data__ = nativeCreate ? nativeCreate(null) : {};
2707	}
2708
2709	/**
2710	 * Removes `key` and its value from the hash.
2711	 *
2712	 * @private
2713	 * @name delete
2714	 * @memberOf Hash
2715	 * @param {Object} hash The hash to modify.
2716	 * @param {string} key The key of the value to remove.
2717	 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2718	 */
2719	function hashDelete(key) {
2720	  return this.has(key) && delete this.__data__[key];
2721	}
2722
2723	/**
2724	 * Gets the hash value for `key`.
2725	 *
2726	 * @private
2727	 * @name get
2728	 * @memberOf Hash
2729	 * @param {string} key The key of the value to get.
2730	 * @returns {*} Returns the entry value.
2731	 */
2732	function hashGet(key) {
2733	  var data = this.__data__;
2734	  if (nativeCreate) {
2735	    var result = data[key];
2736	    return result === HASH_UNDEFINED ? undefined : result;
2737	  }
2738	  return hasOwnProperty$1.call(data, key) ? data[key] : undefined;
2739	}
2740
2741	/**
2742	 * Checks if a hash value for `key` exists.
2743	 *
2744	 * @private
2745	 * @name has
2746	 * @memberOf Hash
2747	 * @param {string} key The key of the entry to check.
2748	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2749	 */
2750	function hashHas(key) {
2751	  var data = this.__data__;
2752	  return nativeCreate ? data[key] !== undefined : hasOwnProperty$1.call(data, key);
2753	}
2754
2755	/**
2756	 * Sets the hash `key` to `value`.
2757	 *
2758	 * @private
2759	 * @name set
2760	 * @memberOf Hash
2761	 * @param {string} key The key of the value to set.
2762	 * @param {*} value The value to set.
2763	 * @returns {Object} Returns the hash instance.
2764	 */
2765	function hashSet(key, value) {
2766	  var data = this.__data__;
2767	  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
2768	  return this;
2769	}
2770
2771	// Add methods to `Hash`.
2772	Hash.prototype.clear = hashClear;
2773	Hash.prototype['delete'] = hashDelete;
2774	Hash.prototype.get = hashGet;
2775	Hash.prototype.has = hashHas;
2776	Hash.prototype.set = hashSet;
2777
2778	/**
2779	 * Creates an list cache object.
2780	 *
2781	 * @private
2782	 * @constructor
2783	 * @param {Array} [entries] The key-value pairs to cache.
2784	 */
2785	function ListCache(entries) {
2786	  var index = -1,
2787	      length = entries ? entries.length : 0;
2788
2789	  this.clear();
2790	  while (++index < length) {
2791	    var entry = entries[index];
2792	    this.set(entry[0], entry[1]);
2793	  }
2794	}
2795