https://rsez.lv/wp-content/plugins/progress-map-markers-filter/ass…/multiple-select/multiple-select.js?ver=1.2

131    } catch (error) {
132      return true;
133    }
134  };
135
136  // Thank's IE8 for his funny defineProperty
137  var descriptors = !fails(function () {
138    return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
139  });
140
141  var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
142  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
143
144  // Nashorn ~ JDK8 bug
145  var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
146
147  // `Object.prototype.propertyIsEnumerable` method implementation
148  // https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable
149  var f = NASHORN_BUG ? function propertyIsEnumerable(V) {
150    var descriptor = getOwnPropertyDescriptor(this, V);
151    return !!descriptor && descriptor.enumerable;
152  } : nativePropertyIsEnumerable;
153
154  var objectPropertyIsEnumerable = {
155  	f: f
156  };
157
158  var createPropertyDescriptor = function (bitmap, value) {
159    return {
160      enumerable: !(bitmap & 1),
161      configurable: !(bitmap & 2),
162      writable: !(bitmap & 4),
163      value: value
164    };
165  };
166
167  var toString = {}.toString;
168
169  var classofRaw = function (it) {
170    return toString.call(it).slice(8, -1);
171  };
172
173  var split = ''.split;
174
175  // fallback for non-array-like ES3 and non-enumerable old V8 strings
176  var indexedObject = fails(function () {
177    // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
178    // eslint-disable-next-line no-prototype-builtins
179    return !Object('z').propertyIsEnumerable(0);
180  }) ? function (it) {
181    return classofRaw(it) == 'String' ? split.call(it, '') : Object(it);
182  } : Object;
183
184  // `RequireObjectCoercible` abstract operation
185  // https://tc39.github.io/ecma262/#sec-requireobjectcoercible
186  var requireObjectCoercible = function (it) {
187    if (it == undefined) throw TypeError("Can't call method on " + it);
188    return it;
189  };
190
191  // toObject with fallback for non-array-like ES3 strings
192
193
194
195  var toIndexedObject = function (it) {
196    return indexedObject(requireObjectCoercible(it));
197  };
198
199  var isObject = function (it) {
200    return typeof it === 'object' ? it !== null : typeof it === 'function';
201  };
202
203  // `ToPrimitive` abstract operation
204  // https://tc39.github.io/ecma262/#sec-toprimitive
205  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
206  // and the second argument - flag - preferred type is a string
207  var toPrimitive = function (input, PREFERRED_STRING) {
208    if (!isObject(input)) return input;
209    var fn, val;
210    if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
211    if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
212    if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
213    throw TypeError("Can't convert object to primitive value");
214  };
215
216  var hasOwnProperty = {}.hasOwnProperty;
217
218  var has = function (it, key) {
219    return hasOwnProperty.call(it, key);
220  };
221
222  var document$1 = global_1.document;
223  // typeof document.createElement is 'object' in old IE
224  var EXISTS = isObject(document$1) && isObject(document$1.createElement);
225
226  var documentCreateElement = function (it) {
227    return EXISTS ? document$1.createElement(it) : {};
228  };
229
230  // Thank's IE8 for his funny defineProperty
231  var ie8DomDefine = !descriptors && !fails(function () {
232    return Object.defineProperty(documentCreateElement('div'), 'a', {
233      get: function () { return 7; }
234    }).a != 7;
235  });
236
237  var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
238
239  // `Object.getOwnPropertyDescriptor` method
240  // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor
241  var f$1 = descriptors ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
242    O = toIndexedObject(O);
243    P = toPrimitive(P, true);
244    if (ie8DomDefine) try {
245      return nativeGetOwnPropertyDescriptor(O, P);
246    } catch (error) { /* empty */ }
247    if (has(O, P)) return createPropertyDescriptor(!objectPropertyIsEnumerable.f.call(O, P), O[P]);
248  };
249
250  var objectGetOwnPropertyDescriptor = {
251  	f: f$1
252  };
253
254  var anObject = function (it) {
255    if (!isObject(it)) {
256      throw TypeError(String(it) + ' is not an object');
257    } return it;
258  };
259
260  var nativeDefineProperty = Object.defineProperty;
261
262  // `Object.defineProperty` method
263  // https://tc39.github.io/ecma262/#sec-object.defineproperty
264  var f$2 = descriptors ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
265    anObject(O);
266    P = toPrimitive(P, true);
267    anObject(Attributes);
268    if (ie8DomDefine) try {
269      return nativeDefineProperty(O, P, Attributes);
270    } catch (error) { /* empty */ }
271    if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
272    if ('value' in Attributes) O[P] = Attributes.value;
273    return O;
274  };
275
276  var objectDefineProperty = {
277  	f: f$2
278  };
279
280  var hide = descriptors ? function (object, key, value) {
281    return objectDefineProperty.f(object, key, createPropertyDescriptor(1, value));
282  } : function (object, key, value) {
283    object[key] = value;
284    return object;
285  };
286
287  var setGlobal = function (key, value) {
288    try {

289      hide(global_1, key, value);
290    } catch (error) {
291      global_1[key] = value;
292    } return value;
293  };
294
295  var shared = createCommonjsModule(function (module) {
296  var SHARED = '__core-js_shared__';
297  var store = global_1[SHARED] || setGlobal(SHARED, {});
298
299  (module.exports = function (key, value) {
300    return store[key] || (store[key] = value !== undefined ? value : {});
301  })('versions', []).push({
302    version: '3.2.1',
303    mode:  'global',
304    copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
305  });
306  });
307
308  var functionToString = shared('native-function-to-string', Function.toString);
309
310  var WeakMap = global_1.WeakMap;
311
312  var nativeWeakMap = typeof WeakMap === 'function' && /native code/.test(functionToString.call(WeakMap));
313
314  var id = 0;
315  var postfix = Math.random();
316
317  var uid = function (key) {
318    return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
319  };
320
321  var keys = shared('keys');
322
323  var sharedKey = function (key) {
324    return keys[key] || (keys[key] = uid(key));
325  };
326
327  var hiddenKeys = {};
328
329  var WeakMap$1 = global_1.WeakMap;
330  var set, get, has$1;
331
332  var enforce = function (it) {
333    return has$1(it) ? get(it) : set(it, {});
334  };
335
336  var getterFor = function (TYPE) {
337    return function (it) {
338      var state;
339      if (!isObject(it) || (state = get(it)).type !== TYPE) {
340        throw TypeError('Incompatible receiver, ' + TYPE + ' required');
341      } return state;
342    };
343  };
344
345  if (nativeWeakMap) {
346    var store = new WeakMap$1();
347    var wmget = store.get;
348    var wmhas = store.has;
349    var wmset = store.set;
350    set = function (it, metadata) {
351      wmset.call(store, it, metadata);
352      return metadata;
353    };
354    get = function (it) {
355      return wmget.call(store, it) || {};
356    };
357    has$1 = function (it) {
358      return wmhas.call(store, it);
359    };
360  } else {
361    var STATE = sharedKey('state');
362    hiddenKeys[STATE] = true;
363    set = function (it, metadata) {
364      hide(it, STATE, metadata);
365      return metadata;
366    };
367    get = function (it) {
368      return has(it, STATE) ? it[STATE] : {};
369    };
370    has$1 = function (it) {
371      return has(it, STATE);
372    };
373  }
374
375  var internalState = {
376    set: set,
377    get: get,
378    has: has$1,
379    enforce: enforce,
380    getterFor: getterFor
381  };
382
383  var redefine = createCommonjsModule(function (module) {
384  var getInternalState = internalState.get;
385  var enforceInternalState = internalState.enforce;
386  var TEMPLATE = String(functionToString).split('toString');
387
388  shared('inspectSource', function (it) {
389    return functionToString.call(it);
390  });
391
392  (module.exports = function (O, key, value, options) {
393    var unsafe = options ? !!options.unsafe : false;
394    var simple = options ? !!options.enumerable : false;
395    var noTargetGet = options ? !!options.noTargetGet : false;
396    if (typeof value == 'function') {
397      if (typeof key == 'string' && !has(value, 'name')) hide(value, 'name', key);
398      enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
399    }
400    if (O === global_1) {
401      if (simple) O[key] = value;
402      else setGlobal(key, value);
403      return;
404    } else if (!unsafe) {
405      delete O[key];
406    } else if (!noTargetGet && O[key]) {
407      simple = true;
408    }
409    if (simple) O[key] = value;
410    else hide(O, key, value);
411  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
412  })(Function.prototype, 'toString', function toString() {
413    return typeof this == 'function' && getInternalState(this).source || functionToString.call(this);
414  });
415  });
416
417  var path = global_1;
418
419  var aFunction = function (variable) {
420    return typeof variable == 'function' ? variable : undefined;
421  };
422
423  var getBuiltIn = function (namespace, method) {
424    return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global_1[namespace])
425      : path[namespace] && path[namespace][method] || global_1[namespace] && global_1[namespace][method];
426  };
427

428  var ceil = Math.ceil;
429  var floor = Math.floor;
430
431  // `ToInteger` abstract operation
432  // https://tc39.github.io/ecma262/#sec-tointeger
433  var toInteger = function (argument) {
434    return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
435  };
436
437  var min = Math.min;
438
439  // `ToLength` abstract operation
440  // https://tc39.github.io/ecma262/#sec-tolength
441  var toLength = function (argument) {
442    return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
443  };
444
445  var max = Math.max;
446  var min$1 = Math.min;
447
448  // Helper for a popular repeating case of the spec:
449  // Let integer be ? ToInteger(index).
450  // If integer < 0, let result be max((length + integer), 0); else let result be min(length, length).
451  var toAbsoluteIndex = function (index, length) {
452    var integer = toInteger(index);
453    return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
454  };
455
456  // `Array.prototype.{ indexOf, includes }` methods implementation
457  var createMethod = function (IS_INCLUDES) {
458    return function ($this, el, fromIndex) {
459      var O = toIndexedObject($this);
460      var length = toLength(O.length);
461      var index = toAbsoluteIndex(fromIndex, length);
462      var value;
463      // Array#includes uses SameValueZero equality algorithm
464      // eslint-disable-next-line no-self-compare
465      if (IS_INCLUDES && el != el) while (length > index) {
466        value = O[index++];
467        // eslint-disable-next-line no-self-compare
468        if (value != value) return true;
469      // Array#indexOf ignores holes, Array#includes - not
470      } else for (;length > index; index++) {
471        if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
472      } return !IS_INCLUDES && -1;
473    };
474  };
475
476  var arrayIncludes = {
477    // `Array.prototype.includes` method
478    // https://tc39.github.io/ecma262/#sec-array.prototype.includes
479    includes: createMethod(true),
480    // `Array.prototype.indexOf` method
481    // https://tc39.github.io/ecma262/#sec-array.prototype.indexof
482    indexOf: createMethod(false)
483  };
484
485  var indexOf = arrayIncludes.indexOf;
486
487
488  var objectKeysInternal = function (object, names) {
489    var O = toIndexedObject(object);
490    var i = 0;
491    var result = [];
492    var key;
493    for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);
494    // Don't enum bug & hidden keys
495    while (names.length > i) if (has(O, key = names[i++])) {
496      ~indexOf(result, key) || result.push(key);
497    }
498    return result;
499  };
500
501  // IE8- don't enum bug keys
502  var enumBugKeys = [
503    'constructor',
504    'hasOwnProperty',
505    'isPrototypeOf',
506    'propertyIsEnumerable',
507    'toLocaleString',
508    'toString',
509    'valueOf'
510  ];
511
512  var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype');
513
514  // `Object.getOwnPropertyNames` method
515  // https://tc39.github.io/ecma262/#sec-object.getownpropertynames
516  var f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
517    return objectKeysInternal(O, hiddenKeys$1);
518  };
519
520  var objectGetOwnPropertyNames = {
521  	f: f$3
522  };
523
524  var f$4 = Object.getOwnPropertySymbols;
525
526  var objectGetOwnPropertySymbols = {
527  	f: f$4
528  };
529
530  // all object keys, includes non-enumerable and symbols
531  var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
532    var keys = objectGetOwnPropertyNames.f(anObject(it));
533    var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
534    return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
535  };
536
537  var copyConstructorProperties = function (target, source) {
538    var keys = ownKeys(source);
539    var defineProperty = objectDefineProperty.f;
540    var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
541    for (var i = 0; i < keys.length; i++) {
542      var key = keys[i];
543      if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
544    }
545  };
546
547  var replacement = /#|\.prototype\./;
548
549  var isForced = function (feature, detection) {
550    var value = data[normalize(feature)];
551    return value == POLYFILL ? true
552      : value == NATIVE ? false
553      : typeof detection == 'function' ? fails(detection)
554      : !!detection;
555  };
556
557  var normalize = isForced.normalize = function (string) {
558    return String(string).replace(replacement, '.').toLowerCase();
559  };
560
561  var data = isForced.data = {};
562  var NATIVE = isForced.NATIVE = 'N';
563  var POLYFILL = isForced.POLYFILL = 'P';
564
565  var isForced_1 = isForced;
566
567  var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
568
569
570
571
572
573
574  /*
575    options.target      - name of the target object
576    options.global      - target is the global object
577    options.stat        - export as static methods of target
578    options.proto       - export as prototype methods of target
579    options.real        - real prototype method for the `pure` version
580    options.forced      - export even if the native feature is available

581    options.bind        - bind methods to the target, required for the `pure` version
582    options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
583    options.unsafe      - use the simple assignment of property instead of delete + defineProperty
584    options.sham        - add a flag to not completely full polyfills
585    options.enumerable  - export as enumerable property
586    options.noTargetGet - prevent calling a getter on target
587  */
588  var _export = function (options, source) {
589    var TARGET = options.target;
590    var GLOBAL = options.global;
591    var STATIC = options.stat;
592    var FORCED, target, key, targetProperty, sourceProperty, descriptor;
593    if (GLOBAL) {
594      target = global_1;
595    } else if (STATIC) {
596      target = global_1[TARGET] || setGlobal(TARGET, {});
597    } else {
598      target = (global_1[TARGET] || {}).prototype;
599    }
600    if (target) for (key in source) {
601      sourceProperty = source[key];
602      if (options.noTargetGet) {
603        descriptor = getOwnPropertyDescriptor$1(target, key);
604        targetProperty = descriptor && descriptor.value;
605      } else targetProperty = target[key];
606      FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
607      // contained in target
608      if (!FORCED && targetProperty !== undefined) {
609        if (typeof sourceProperty === typeof targetProperty) continue;
610        copyConstructorProperties(sourceProperty, targetProperty);
611      }
612      // add a flag to not completely full polyfills
613      if (options.sham || (targetProperty && targetProperty.sham)) {
614        hide(sourceProperty, 'sham', true);
615      }
616      // extend global
617      redefine(target, key, sourceProperty, options);
618    }
619  };
620
621  var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () {
622    // Chrome 38 Symbol has incorrect toString conversion
623    // eslint-disable-next-line no-undef
624    return !String(Symbol());
625  });
626
627  var Symbol$1 = global_1.Symbol;
628  var store$1 = shared('wks');
629
630  var wellKnownSymbol = function (name) {
631    return store$1[name] || (store$1[name] = nativeSymbol && Symbol$1[name]
632      || (nativeSymbol ? Symbol$1 : uid)('Symbol.' + name));
633  };
634
635  // `Object.keys` method
636  // https://tc39.github.io/ecma262/#sec-object.keys
637  var objectKeys = Object.keys || function keys(O) {
638    return objectKeysInternal(O, enumBugKeys);
639  };
640
641  // `Object.defineProperties` method
642  // https://tc39.github.io/ecma262/#sec-object.defineproperties
643  var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) {
644    anObject(O);
645    var keys = objectKeys(Properties);
646    var length = keys.length;
647    var index = 0;
648    var key;
649    while (length > index) objectDefineProperty.f(O, key = keys[index++], Properties[key]);
650    return O;
651  };
652
653  var html = getBuiltIn('document', 'documentElement');
654
655  var IE_PROTO = sharedKey('IE_PROTO');
656
657  var PROTOTYPE = 'prototype';
658  var Empty = function () { /* empty */ };
659
660  // Create object with fake `null` prototype: use iframe Object with cleared prototype
661  var createDict = function () {
662    // Thrash, waste and sodomy: IE GC bug
663    var iframe = documentCreateElement('iframe');
664    var length = enumBugKeys.length;
665    var lt = '<';
666    var script = 'script';
667    var gt = '>';
668    var js = 'java' + script + ':';
669    var iframeDocument;
670    iframe.style.display = 'none';
671    html.appendChild(iframe);
672    iframe.src = String(js);
673    iframeDocument = iframe.contentWindow.document;
674    iframeDocument.open();
675    iframeDocument.write(lt + script + gt + 'document.F=Object' + lt + '/' + script + gt);
676    iframeDocument.close();
677    createDict = iframeDocument.F;
678    while (length--) delete createDict[PROTOTYPE][enumBugKeys[length]];
679    return createDict();
680  };
681
682  // `Object.create` method
683  // https://tc39.github.io/ecma262/#sec-object.create
684  var objectCreate = Object.create || function create(O, Properties) {
685    var result;
686    if (O !== null) {
687      Empty[PROTOTYPE] = anObject(O);
688      result = new Empty();
689      Empty[PROTOTYPE] = null;
690      // add "__proto__" for Object.getPrototypeOf polyfill
691      result[IE_PROTO] = O;
692    } else result = createDict();
693    return Properties === undefined ? result : objectDefineProperties(result, Properties);
694  };
695
696  hiddenKeys[IE_PROTO] = true;
697
698  var UNSCOPABLES = wellKnownSymbol('unscopables');
699  var ArrayPrototype = Array.prototype;
700
701  // Array.prototype[@@unscopables]
702  // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
703  if (ArrayPrototype[UNSCOPABLES] == undefined) {
704    hide(ArrayPrototype, UNSCOPABLES, objectCreate(null));
705  }
706
707  // add a key to Array.prototype[@@unscopables]
708  var addToUnscopables = function (key) {
709    ArrayPrototype[UNSCOPABLES][key] = true;
710  };
711
712  var $includes = arrayIncludes.includes;
713
714
715  // `Array.prototype.includes` method
716  // https://tc39.github.io/ecma262/#sec-array.prototype.includes
717  _export({ target: 'Array', proto: true }, {
718    includes: function includes(el /* , fromIndex = 0 */) {
719      return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
720    }
721  });
722
723  // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
724  addToUnscopables('includes');
725
726  // `ToObject` abstract operation
727  // https://tc39.github.io/ecma262/#sec-toobject
728  var toObject = function (argument) {
729    return Object(requireObjectCoercible(argument));
730  };
731
732  var nativeAssign = Object.assign;
733
734  // `Object.assign` method
735  // https://tc39.github.io/ecma262/#sec-object.assign
736  // should work with symbols and should have deterministic property order (V8 bug)
737  var objectAssign = !nativeAssign || fails(function () {
738    var A = {};
739    var B = {};
740    // eslint-disable-next-line no-undef
741    var symbol = Symbol();
742    var alphabet = 'abcdefghijklmnopqrst';
743    A[symbol] = 7;

744    alphabet.split('').forEach(function (chr) { B[chr] = chr; });
745    return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;
746  }) ? function assign(target, source) { // eslint-disable-line no-unused-vars
747    var T = toObject(target);
748    var argumentsLength = arguments.length;
749    var index = 1;
750    var getOwnPropertySymbols = objectGetOwnPropertySymbols.f;
751    var propertyIsEnumerable = objectPropertyIsEnumerable.f;
752    while (argumentsLength > index) {
753      var S = indexedObject(arguments[index++]);
754      var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);
755      var length = keys.length;
756      var j = 0;
757      var key;
758      while (length > j) {
759        key = keys[j++];
760        if (!descriptors || propertyIsEnumerable.call(S, key)) T[key] = S[key];
761      }
762    } return T;
763  } : nativeAssign;
764
765  // `Object.assign` method
766  // https://tc39.github.io/ecma262/#sec-object.assign
767  _export({ target: 'Object', stat: true, forced: Object.assign !== objectAssign }, {
768    assign: objectAssign
769  });
770
771  var MATCH = wellKnownSymbol('match');
772
773  // `IsRegExp` abstract operation
774  // https://tc39.github.io/ecma262/#sec-isregexp
775  var isRegexp = function (it) {
776    var isRegExp;
777    return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classofRaw(it) == 'RegExp');
778  };
779
780  var notARegexp = function (it) {
781    if (isRegexp(it)) {
782      throw TypeError("The method doesn't accept regular expressions");
783    } return it;
784  };
785
786  var MATCH$1 = wellKnownSymbol('match');
787
788  var correctIsRegexpLogic = function (METHOD_NAME) {
789    var regexp = /./;
790    try {
791      '/./'[METHOD_NAME](regexp);
792    } catch (e) {
793      try {
794        regexp[MATCH$1] = false;
795        return '/./'[METHOD_NAME](regexp);
796      } catch (f) { /* empty */ }
797    } return false;
798  };
799
800  // `String.prototype.includes` method
801  // https://tc39.github.io/ecma262/#sec-string.prototype.includes
802  _export({ target: 'String', proto: true, forced: !correctIsRegexpLogic('includes') }, {
803    includes: function includes(searchString /* , position = 0 */) {
804      return !!~String(requireObjectCoercible(this))
805        .indexOf(notARegexp(searchString), arguments.length > 1 ? arguments[1] : undefined);
806    }
807  });
808
809  // a string of all valid unicode whitespaces
810  // eslint-disable-next-line max-len
811  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';
812
813  var whitespace = '[' + whitespaces + ']';
814  var ltrim = RegExp('^' + whitespace + whitespace + '*');
815  var rtrim = RegExp(whitespace + whitespace + '*$');
816
817  // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
818  var createMethod$1 = function (TYPE) {
819    return function ($this) {
820      var string = String(requireObjectCoercible($this));
821      if (TYPE & 1) string = string.replace(ltrim, '');
822      if (TYPE & 2) string = string.replace(rtrim, '');
823      return string;
824    };
825  };
826
827  var stringTrim = {
828    // `String.prototype.{ trimLeft, trimStart }` methods
829    // https://tc39.github.io/ecma262/#sec-string.prototype.trimstart
830    start: createMethod$1(1),
831    // `String.prototype.{ trimRight, trimEnd }` methods
832    // https://tc39.github.io/ecma262/#sec-string.prototype.trimend
833    end: createMethod$1(2),
834    // `String.prototype.trim` method
835    // https://tc39.github.io/ecma262/#sec-string.prototype.trim
836    trim: createMethod$1(3)
837  };
838
839  var non = '\u200B\u0085\u180E';
840
841  // check that a method works with the correct list
842  // of whitespaces and has a correct name
843  var forcedStringTrimMethod = function (METHOD_NAME) {
844    return fails(function () {
845      return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME;
846    });
847  };
848
849  var $trim = stringTrim.trim;
850
851
852  // `String.prototype.trim` method
853  // https://tc39.github.io/ecma262/#sec-string.prototype.trim
854  _export({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {
855    trim: function trim() {
856      return $trim(this);
857    }
858  });
859
860  var VERSION = '1.5.2';
861  var BLOCK_ROWS = 50;
862  var CLUSTER_BLOCKS = 4;
863  var DEFAULTS = {
864    name: '',
865    placeholder: '',
866    data: undefined,
867    locale: undefined,
868    selectAll: true,
869    single: undefined,
870    singleRadio: false,
871    multiple: false,
872    hideOptgroupCheckboxes: false,
873    multipleWidth: 80,
874    width: undefined,
875    dropWidth: undefined,
876    maxHeight: 250,
877    maxHeightUnit: 'px',
878    position: 'bottom',
879    displayValues: false,
880    displayTitle: false,
881    displayDelimiter: ', ',
882    minimumCountSelected: 3,

1035  // optional / simple context binding
1036  var bindContext = function (fn, that, length) {
1037    aFunction$1(fn);
1038    if (that === undefined) return fn;
1039    switch (length) {
1040      case 0: return function () {
1041        return fn.call(that);
1042      };
1043      case 1: return function (a) {
1044        return fn.call(that, a);
1045      };
1046      case 2: return function (a, b) {
1047        return fn.call(that, a, b);
1048      };
1049      case 3: return function (a, b, c) {
1050        return fn.call(that, a, b, c);
1051      };
1052    }
1053    return function (/* ...args */) {
1054      return fn.apply(that, arguments);
1055    };
1056  };
1057
1058  var SPECIES = wellKnownSymbol('species');
1059
1060  // `ArraySpeciesCreate` abstract operation
1061  // https://tc39.github.io/ecma262/#sec-arrayspeciescreate
1062  var arraySpeciesCreate = function (originalArray, length) {
1063    var C;
1064    if (isArray(originalArray)) {
1065      C = originalArray.constructor;
1066      // cross-realm fallback
1067      if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
1068      else if (isObject(C)) {
1069        C = C[SPECIES];
1070        if (C === null) C = undefined;
1071      }
1072    } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);
1073  };
1074
1075  var push = [].push;
1076
1077  // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation
1078  var createMethod$2 = function (TYPE) {
1079    var IS_MAP = TYPE == 1;
1080    var IS_FILTER = TYPE == 2;
1081    var IS_SOME = TYPE == 3;
1082    var IS_EVERY = TYPE == 4;
1083    var IS_FIND_INDEX = TYPE == 6;
1084    var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
1085    return function ($this, callbackfn, that, specificCreate) {
1086      var O = toObject($this);
1087      var self = indexedObject(O);
1088      var boundFunction = bindContext(callbackfn, that, 3);
1089      var length = toLength(self.length);
1090      var index = 0;
1091      var create = specificCreate || arraySpeciesCreate;
1092      var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
1093      var value, result;
1094      for (;length > index; index++) if (NO_HOLES || index in self) {
1095        value = self[index];
1096        result = boundFunction(value, index, O);
1097        if (TYPE) {
1098          if (IS_MAP) target[index] = result; // map
1099          else if (result) switch (TYPE) {
1100            case 3: return true;              // some
1101            case 5: return value;             // find
1102            case 6: return index;             // findIndex
1103            case 2: push.call(target, value); // filter
1104          } else if (IS_EVERY) return false;  // every
1105        }
1106      }
1107      return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
1108    };
1109  };
1110
1111  var arrayIteration = {
1112    // `Array.prototype.forEach` method
1113    // https://tc39.github.io/ecma262/#sec-array.prototype.foreach
1114    forEach: createMethod$2(0),
1115    // `Array.prototype.map` method
1116    // https://tc39.github.io/ecma262/#sec-array.prototype.map
1117    map: createMethod$2(1),
1118    // `Array.prototype.filter` method
1119    // https://tc39.github.io/ecma262/#sec-array.prototype.filter
1120    filter: createMethod$2(2),
1121    // `Array.prototype.some` method
1122    // https://tc39.github.io/ecma262/#sec-array.prototype.some
1123    some: createMethod$2(3),
1124    // `Array.prototype.every` method
1125    // https://tc39.github.io/ecma262/#sec-array.prototype.every
1126    every: createMethod$2(4),
1127    // `Array.prototype.find` method
1128    // https://tc39.github.io/ecma262/#sec-array.prototype.find
1129    find: createMethod$2(5),
1130    // `Array.prototype.findIndex` method
1131    // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex
1132    findIndex: createMethod$2(6)
1133  };
1134
1135  var $forEach = arrayIteration.forEach;
1136
1137  var HIDDEN = sharedKey('hidden');
1138  var SYMBOL = 'Symbol';
1139  var PROTOTYPE$1 = 'prototype';
1140  var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
1141  var setInternalState = internalState.set;
1142  var getInternalState = internalState.getterFor(SYMBOL);
1143  var ObjectPrototype = Object[PROTOTYPE$1];
1144  var $Symbol = global_1.Symbol;
1145  var JSON = global_1.JSON;
1146  var nativeJSONStringify = JSON && JSON.stringify;
1147  var nativeGetOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
1148  var nativeDefineProperty$1 = objectDefineProperty.f;
1149  var nativeGetOwnPropertyNames$1 = objectGetOwnPropertyNamesExternal.f;
1150  var nativePropertyIsEnumerable$1 = objectPropertyIsEnumerable.f;
1151  var AllSymbols = shared('symbols');

1152  var ObjectPrototypeSymbols = shared('op-symbols');
1153  var StringToSymbolRegistry = shared('string-to-symbol-registry');
1154  var SymbolToStringRegistry = shared('symbol-to-string-registry');
1155  var WellKnownSymbolsStore = shared('wks');
1156  var QObject = global_1.QObject;
1157  // Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
1158  var USE_SETTER = !QObject || !QObject[PROTOTYPE$1] || !QObject[PROTOTYPE$1].findChild;
1159
1160  // fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
1161  var setSymbolDescriptor = descriptors && fails(function () {
1162    return objectCreate(nativeDefineProperty$1({}, 'a', {
1163      get: function () { return nativeDefineProperty$1(this, 'a', { value: 7 }).a; }
1164    })).a != 7;
1165  }) ? function (O, P, Attributes) {
1166    var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor$1(ObjectPrototype, P);
1167    if (ObjectPrototypeDescriptor) delete ObjectPrototype[P];
1168    nativeDefineProperty$1(O, P, Attributes);
1169    if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
1170      nativeDefineProperty$1(ObjectPrototype, P, ObjectPrototypeDescriptor);
1171    }
1172  } : nativeDefineProperty$1;
1173
1174  var wrap = function (tag, description) {
1175    var symbol = AllSymbols[tag] = objectCreate($Symbol[PROTOTYPE$1]);
1176    setInternalState(symbol, {
1177      type: SYMBOL,
1178      tag: tag,
1179      description: description
1180    });
1181    if (!descriptors) symbol.description = description;
1182    return symbol;
1183  };
1184
1185  var isSymbol = nativeSymbol && typeof $Symbol.iterator == 'symbol' ? function (it) {
1186    return typeof it == 'symbol';
1187  } : function (it) {
1188    return Object(it) instanceof $Symbol;
1189  };
1190
1191  var $defineProperty = function defineProperty(O, P, Attributes) {
1192    if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);
1193    anObject(O);
1194    var key = toPrimitive(P, true);
1195    anObject(Attributes);
1196    if (has(AllSymbols, key)) {
1197      if (!Attributes.enumerable) {
1198        if (!has(O, HIDDEN)) nativeDefineProperty$1(O, HIDDEN, createPropertyDescriptor(1, {}));
1199        O[HIDDEN][key] = true;
1200      } else {
1201        if (has(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false;
1202        Attributes = objectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) });
1203      } return setSymbolDescriptor(O, key, Attributes);
1204    } return nativeDefineProperty$1(O, key, Attributes);
1205  };
1206
1207  var $defineProperties = function defineProperties(O, Properties) {
1208    anObject(O);
1209    var properties = toIndexedObject(Properties);
1210    var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));
1211    $forEach(keys, function (key) {
1212      if (!descriptors || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]);
1213    });
1214    return O;
1215  };
1216
1217  var $create = function create(O, Properties) {
1218    return Properties === undefined ? objectCreate(O) : $defineProperties(objectCreate(O), Properties);
1219  };
1220
1221  var $propertyIsEnumerable = function propertyIsEnumerable(V) {
1222    var P = toPrimitive(V, true);
1223    var enumerable = nativePropertyIsEnumerable$1.call(this, P);
1224    if (this === ObjectPrototype && has(AllSymbols, P) && !has(ObjectPrototypeSymbols, P)) return false;
1225    return enumerable || !has(this, P) || !has(AllSymbols, P) || has(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true;
1226  };
1227
1228  var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
1229    var it = toIndexedObject(O);
1230    var key = toPrimitive(P, true);
1231    if (it === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) return;
1232    var descriptor = nativeGetOwnPropertyDescriptor$1(it, key);
1233    if (descriptor && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) {
1234      descriptor.enumerable = true;
1235    }
1236    return descriptor;
1237  };
1238
1239  var $getOwnPropertyNames = function getOwnPropertyNames(O) {
1240    var names = nativeGetOwnPropertyNames$1(toIndexedObject(O));
1241    var result = [];
1242    $forEach(names, function (key) {
1243      if (!has(AllSymbols, key) && !has(hiddenKeys, key)) result.push(key);
1244    });
1245    return result;
1246  };
1247
1248  var $getOwnPropertySymbols = function getOwnPropertySymbols(O) {
1249    var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
1250    var names = nativeGetOwnPropertyNames$1(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));
1251    var result = [];
1252    $forEach(names, function (key) {
1253      if (has(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has(ObjectPrototype, key))) {
1254        result.push(AllSymbols[key]);
1255      }
1256    });
1257    return result;
1258  };
1259
1260  // `Symbol` constructor
1261  // https://tc39.github.io/ecma262/#sec-symbol-constructor
1262  if (!nativeSymbol) {
1263    $Symbol = function Symbol() {
1264      if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor');
1265      var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]);
1266      var tag = uid(description);
1267      var setter = function (value) {
1268        if (this === ObjectPrototype) setter.call(ObjectPrototypeSymbols, value);
1269        if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
1270        setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value));
1271      };
1272      if (descriptors && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });
1273      return wrap(tag, description);
1274    };
1275
1276    redefine($Symbol[PROTOTYPE$1], 'toString', function toString() {
1277      return getInternalState(this).tag;
1278    });
1279
1280    objectPropertyIsEnumerable.f = $propertyIsEnumerable;
1281    objectDefineProperty.f = $defineProperty;
1282    objectGetOwnPropertyDescriptor.f = $getOwnPropertyDescriptor;
1283    objectGetOwnPropertyNames.f = objectGetOwnPropertyNamesExternal.f = $getOwnPropertyNames;
1284    objectGetOwnPropertySymbols.f = $getOwnPropertySymbols;
1285
1286    if (descriptors) {
1287      // https://github.com/tc39/proposal-Symbol-description
1288      nativeDefineProperty$1($Symbol[PROTOTYPE$1], 'description', {
1289        configurable: true,
1290        get: function description() {
1291          return getInternalState(this).description;
1292        }
1293      });
1294      {
1295        redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });
1296      }
1297    }
1298
1299    wrappedWellKnownSymbol.f = function (name) {
1300      return wrap(wellKnownSymbol(name), name);
1301    };
1302  }
1303
1304  _export({ global: true, wrap: true, forced: !nativeSymbol, sham: !nativeSymbol }, {
1305    Symbol: $Symbol
1306  });
1307
1308  $forEach(objectKeys(WellKnownSymbolsStore), function (name) {
1309    defineWellKnownSymbol(name);
1310  });
1311
1312  _export({ target: SYMBOL, stat: true, forced: !nativeSymbol }, {
1313    // `Symbol.for` method
1314    // https://tc39.github.io/ecma262/#sec-symbol.for
1315    'for': function (key) {
1316      var string = String(key);
1317      if (has(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];
1318      var symbol = $Symbol(string);
1319      StringToSymbolRegistry[string] = symbol;
1320      SymbolToStringRegistry[symbol] = string;
1321      return symbol;
1322    },
1323    // `Symbol.keyFor` method
1324    // https://tc39.github.io/ecma262/#sec-symbol.keyfor
1325    keyFor: function keyFor(sym) {
1326      if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol');
1327      if (has(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];
1328    },
1329    useSetter: function () { USE_SETTER = true; },
1330    useSimple: function () { USE_SETTER = false; }
1331  });
1332
1333  _export({ target: 'Object', stat: true, forced: !nativeSymbol, sham: !descriptors }, {
1334    // `Object.create` method
1335    // https://tc39.github.io/ecma262/#sec-object.create
1336    create: $create,
1337    // `Object.defineProperty` method
1338    // https://tc39.github.io/ecma262/#sec-object.defineproperty
1339    defineProperty: $defineProperty,
1340    // `Object.defineProperties` method
1341    // https://tc39.github.io/ecma262/#sec-object.defineproperties
1342    defineProperties: $defineProperties,
1343    // `Object.getOwnPropertyDescriptor` method
1344    // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors
1345    getOwnPropertyDescriptor: $getOwnPropertyDescriptor
1346  });
1347
1348  _export({ target: 'Object', stat: true, forced: !nativeSymbol }, {
1349    // `Object.getOwnPropertyNames` method
1350    // https://tc39.github.io/ecma262/#sec-object.getownpropertynames
1351    getOwnPropertyNames: $getOwnPropertyNames,
1352    // `Object.getOwnPropertySymbols` method
1353    // https://tc39.github.io/ecma262/#sec-object.getownpropertysymbols
1354    getOwnPropertySymbols: $getOwnPropertySymbols
1355  });
1356
1357  // Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
1358  // https://bugs.chromium.org/p/v8/issues/detail?id=3443
1359  _export({ target: 'Object', stat: true, forced: fails(function () { objectGetOwnPropertySymbols.f(1); }) }, {
1360    getOwnPropertySymbols: function getOwnPropertySymbols(it) {
1361      return objectGetOwnPropertySymbols.f(toObject(it));
1362    }
1363  });
1364
1365  // `JSON.stringify` method behavior with symbols
1366  // https://tc39.github.io/ecma262/#sec-json.stringify
1367  JSON && _export({ target: 'JSON', stat: true, forced: !nativeSymbol || fails(function () {
1368    var symbol = $Symbol();
1369    // MS Edge converts symbol values to JSON as {}
1370    return nativeJSONStringify([symbol]) != '[null]'
1371      // WebKit converts symbol values to JSON as null
1372      || nativeJSONStringify({ a: symbol }) != '{}'
1373      // V8 throws on boxed symbols
1374      || nativeJSONStringify(Object(symbol)) != '{}';
1375  }) }, {
1376    stringify: function stringify(it) {
1377      var args = [it];
1378      var index = 1;
1379      var replacer, $replacer;
1380      while (arguments.length > index) args.push(arguments[index++]);
1381      $replacer = replacer = args[1];
1382      if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
1383      if (!isArray(replacer)) replacer = function (key, value) {
1384        if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
1385        if (!isSymbol(value)) return value;
1386      };
1387      args[1] = replacer;
1388      return nativeJSONStringify.apply(JSON, args);
1389    }
1390  });
1391
1392  // `Symbol.prototype[@@toPrimitive]` method
1393  // https://tc39.github.io/ecma262/#sec-symbol.prototype-@@toprimitive
1394  if (!$Symbol[PROTOTYPE$1][TO_PRIMITIVE]) hide($Symbol[PROTOTYPE$1], TO_PRIMITIVE, $Symbol[PROTOTYPE$1].valueOf);
1395  // `Symbol.prototype[@@toStringTag]` property
1396  // https://tc39.github.io/ecma262/#sec-symbol.prototype-@@tostringtag
1397  setToStringTag($Symbol, SYMBOL);
1398
1399  hiddenKeys[HIDDEN] = true;
1400
1401  var defineProperty$2 = objectDefineProperty.f;
1402
1403
1404  var NativeSymbol = global_1.Symbol;
1405
1406  if (descriptors && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||
1407    // Safari 12 bug
1408    NativeSymbol().description !== undefined
1409  )) {
1410    var EmptyStringDescriptionStore = {};
1411    // wrap Symbol constructor for correct work with undefined description
1412    var SymbolWrapper = function Symbol() {
1413      var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);
1414      var result = this instanceof SymbolWrapper
1415        ? new NativeSymbol(description)
1416        // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
1417        : description === undefined ? NativeSymbol() : NativeSymbol(description);
1418      if (description === '') EmptyStringDescriptionStore[result] = true;
1419      return result;
1420    };
1421    copyConstructorProperties(SymbolWrapper, NativeSymbol);
1422    var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;
1423    symbolPrototype.constructor = SymbolWrapper;
1424
1425    var symbolToString = symbolPrototype.toString;
1426    var native = String(NativeSymbol('test')) == 'Symbol(test)';
1427    var regexp = /^Symbol\((.*)\)[^)]+$/;
1428    defineProperty$2(symbolPrototype, 'description', {
1429      configurable: true,
1430      get: function description() {
1431        var symbol = isObject(this) ? this.valueOf() : this;
1432        var string = symbolToString.call(symbol);
1433        if (has(EmptyStringDescriptionStore, symbol)) return '';
1434        var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');
1435        return desc === '' ? undefined : desc;
1436      }
1437    });

1438
1439    _export({ global: true, forced: true }, {
1440      Symbol: SymbolWrapper
1441    });
1442  }
1443
1444  // `Symbol.iterator` well-known symbol
1445  // https://tc39.github.io/ecma262/#sec-symbol.iterator
1446  defineWellKnownSymbol('iterator');
1447
1448  var createProperty = function (object, key, value) {
1449    var propertyKey = toPrimitive(key);
1450    if (propertyKey in object) objectDefineProperty.f(object, propertyKey, createPropertyDescriptor(0, value));
1451    else object[propertyKey] = value;
1452  };
1453
1454  var SPECIES$1 = wellKnownSymbol('species');
1455
1456  var arrayMethodHasSpeciesSupport = function (METHOD_NAME) {
1457    return !fails(function () {
1458      var array = [];
1459      var constructor = array.constructor = {};
1460      constructor[SPECIES$1] = function () {
1461        return { foo: 1 };
1462      };
1463      return array[METHOD_NAME](Boolean).foo !== 1;
1464    });
1465  };
1466
1467  var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');
1468  var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
1469  var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded';
1470
1471  var IS_CONCAT_SPREADABLE_SUPPORT = !fails(function () {
1472    var array = [];
1473    array[IS_CONCAT_SPREADABLE] = false;
1474    return array.concat()[0] !== array;
1475  });
1476
1477  var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat');
1478
1479  var isConcatSpreadable = function (O) {
1480    if (!isObject(O)) return false;
1481    var spreadable = O[IS_CONCAT_SPREADABLE];
1482    return spreadable !== undefined ? !!spreadable : isArray(O);
1483  };
1484
1485  var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT;
1486
1487  // `Array.prototype.concat` method
1488  // https://tc39.github.io/ecma262/#sec-array.prototype.concat
1489  // with adding support of @@isConcatSpreadable and @@species
1490  _export({ target: 'Array', proto: true, forced: FORCED }, {
1491    concat: function concat(arg) { // eslint-disable-line no-unused-vars
1492      var O = toObject(this);
1493      var A = arraySpeciesCreate(O, 0);
1494      var n = 0;
1495      var i, k, length, len, E;
1496      for (i = -1, length = arguments.length; i < length; i++) {
1497        E = i === -1 ? O : arguments[i];
1498        if (isConcatSpreadable(E)) {
1499          len = toLength(E.length);
1500          if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
1501          for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);
1502        } else {
1503          if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
1504          createProperty(A, n++, E);
1505        }
1506      }
1507      A.length = n;
1508      return A;
1509    }
1510  });
1511
1512  var $filter = arrayIteration.filter;
1513
1514
1515  // `Array.prototype.filter` method
1516  // https://tc39.github.io/ecma262/#sec-array.prototype.filter
1517  // with adding support of @@species
1518  _export({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('filter') }, {
1519    filter: function filter(callbackfn /* , thisArg */) {
1520      return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
1521    }
1522  });
1523
1524  var $find = arrayIteration.find;
1525
1526
1527  var FIND = 'find';
1528  var SKIPS_HOLES = true;
1529
1530  // Shouldn't skip holes
1531  if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });
1532
1533  // `Array.prototype.find` method
1534  // https://tc39.github.io/ecma262/#sec-array.prototype.find
1535  _export({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
1536    find: function find(callbackfn /* , that = undefined */) {
1537      return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
1538    }
1539  });
1540
1541  // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
1542  addToUnscopables(FIND);
1543
1544  var correctPrototypeGetter = !fails(function () {
1545    function F() { /* empty */ }
1546    F.prototype.constructor = null;
1547    return Object.getPrototypeOf(new F()) !== F.prototype;
1548  });
1549
1550  var IE_PROTO$1 = sharedKey('IE_PROTO');
1551  var ObjectPrototype$1 = Object.prototype;
1552
1553  // `Object.getPrototypeOf` method
1554  // https://tc39.github.io/ecma262/#sec-object.getprototypeof
1555  var objectGetPrototypeOf = correctPrototypeGetter ? Object.getPrototypeOf : function (O) {
1556    O = toObject(O);
1557    if (has(O, IE_PROTO$1)) return O[IE_PROTO$1];
1558    if (typeof O.constructor == 'function' && O instanceof O.constructor) {
1559      return O.constructor.prototype;
1560    } return O instanceof Object ? ObjectPrototype$1 : null;
1561  };
1562
1563  var ITERATOR = wellKnownSymbol('iterator');
1564  var BUGGY_SAFARI_ITERATORS = false;
1565
1566  var returnThis = function () { return this; };
1567
1568  // `%IteratorPrototype%` object
1569  // https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
1570  var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
1571
1572  if ([].keys) {
1573    arrayIterator = [].keys();
1574    // Safari 8 has buggy iterators w/o `next`
1575    if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
1576    else {
1577      PrototypeOfArrayIteratorPrototype = objectGetPrototypeOf(objectGetPrototypeOf(arrayIterator));
1578      if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
1579    }
1580  }
1581
1582  if (IteratorPrototype == undefined) IteratorPrototype = {};
1583
1584  // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
1585  if ( !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);
1586
1587  var iteratorsCore = {
1588    IteratorPrototype: IteratorPrototype,
1589    BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
1590  };
1591
1592  var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
1593
1594  var createIteratorConstructor = function (IteratorConstructor, NAME, next) {
1595    var TO_STRING_TAG = NAME + ' Iterator';
1596    IteratorConstructor.prototype = objectCreate(IteratorPrototype$1, { next: createPropertyDescriptor(1, next) });
1597    setToStringTag(IteratorConstructor, TO_STRING_TAG, false);
1598    return IteratorConstructor;
1599  };
1600
1601  var aPossiblePrototype = function (it) {
1602    if (!isObject(it) && it !== null) {
1603      throw TypeError("Can't set " + String(it) + ' as a prototype');
1604    } return it;
1605  };
1606
1607  // `Object.setPrototypeOf` method
1608  // https://tc39.github.io/ecma262/#sec-object.setprototypeof
1609  // Works with __proto__ only. Old v8 can't work with null proto objects.
1610  /* eslint-disable no-proto */
1611  var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
1612    var CORRECT_SETTER = false;
1613    var test = {};
1614    var setter;
1615    try {
1616      setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
1617      setter.call(test, []);
1618      CORRECT_SETTER = test instanceof Array;
1619    } catch (error) { /* empty */ }
1620    return function setPrototypeOf(O, proto) {
1621      anObject(O);
1622      aPossiblePrototype(proto);
1623      if (CORRECT_SETTER) setter.call(O, proto);
1624      else O.__proto__ = proto;
1625      return O;
1626    };
1627  }() : undefined);
1628
1629  var IteratorPrototype$2 = iteratorsCore.IteratorPrototype;
1630  var BUGGY_SAFARI_ITERATORS$1 = iteratorsCore.BUGGY_SAFARI_ITERATORS;
1631  var ITERATOR$1 = wellKnownSymbol('iterator');
1632  var KEYS = 'keys';
1633  var VALUES = 'values';
1634  var ENTRIES = 'entries';
1635
1636  var returnThis$1 = function () { return this; };
1637
1638  var defineIterator = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
1639    createIteratorConstructor(IteratorConstructor, NAME, next);
1640
1641    var getIterationMethod = function (KIND) {
1642      if (KIND === DEFAULT && defaultIterator) return defaultIterator;
1643      if (!BUGGY_SAFARI_ITERATORS$1 && KIND in IterablePrototype) return IterablePrototype[KIND];
1644      switch (KIND) {
1645        case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
1646        case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
1647        case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
1648      } return function () { return new IteratorConstructor(this); };
1649    };
1650
1651    var TO_STRING_TAG = NAME + ' Iterator';

1652    var INCORRECT_VALUES_NAME = false;
1653    var IterablePrototype = Iterable.prototype;
1654    var nativeIterator = IterablePrototype[ITERATOR$1]
1655      || IterablePrototype['@@iterator']
1656      || DEFAULT && IterablePrototype[DEFAULT];
1657    var defaultIterator = !BUGGY_SAFARI_ITERATORS$1 && nativeIterator || getIterationMethod(DEFAULT);
1658    var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
1659    var CurrentIteratorPrototype, methods, KEY;
1660
1661    // fix native
1662    if (anyNativeIterator) {
1663      CurrentIteratorPrototype = objectGetPrototypeOf(anyNativeIterator.call(new Iterable()));
1664      if (IteratorPrototype$2 !== Object.prototype && CurrentIteratorPrototype.next) {
1665        if ( objectGetPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype$2) {
1666          if (objectSetPrototypeOf) {
1667            objectSetPrototypeOf(CurrentIteratorPrototype, IteratorPrototype$2);
1668          } else if (typeof CurrentIteratorPrototype[ITERATOR$1] != 'function') {
1669            hide(CurrentIteratorPrototype, ITERATOR$1, returnThis$1);
1670          }
1671        }
1672        // Set @@toStringTag to native iterators
1673        setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true);
1674      }
1675    }
1676
1677    // fix Array#{values, @@iterator}.name in V8 / FF
1678    if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
1679      INCORRECT_VALUES_NAME = true;
1680      defaultIterator = function values() { return nativeIterator.call(this); };
1681    }
1682
1683    // define iterator
1684    if ( IterablePrototype[ITERATOR$1] !== defaultIterator) {
1685      hide(IterablePrototype, ITERATOR$1, defaultIterator);
1686    }
1687
1688    // export additional methods
1689    if (DEFAULT) {
1690      methods = {
1691        values: getIterationMethod(VALUES),
1692        keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
1693        entries: getIterationMethod(ENTRIES)
1694      };
1695      if (FORCED) for (KEY in methods) {
1696        if (BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
1697          redefine(IterablePrototype, KEY, methods[KEY]);
1698        }
1699      } else _export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME }, methods);
1700    }
1701
1702    return methods;
1703  };
1704
1705  var ARRAY_ITERATOR = 'Array Iterator';
1706  var setInternalState$1 = internalState.set;
1707  var getInternalState$1 = internalState.getterFor(ARRAY_ITERATOR);
1708
1709  // `Array.prototype.entries` method
1710  // https://tc39.github.io/ecma262/#sec-array.prototype.entries
1711  // `Array.prototype.keys` method
1712  // https://tc39.github.io/ecma262/#sec-array.prototype.keys
1713  // `Array.prototype.values` method
1714  // https://tc39.github.io/ecma262/#sec-array.prototype.values
1715  // `Array.prototype[@@iterator]` method
1716  // https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator
1717  // `CreateArrayIterator` internal method
1718  // https://tc39.github.io/ecma262/#sec-createarrayiterator
1719  var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
1720    setInternalState$1(this, {
1721      type: ARRAY_ITERATOR,
1722      target: toIndexedObject(iterated), // target
1723      index: 0,                          // next index
1724      kind: kind                         // kind
1725    });
1726  // `%ArrayIteratorPrototype%.next` method
1727  // https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next
1728  }, function () {
1729    var state = getInternalState$1(this);
1730    var target = state.target;
1731    var kind = state.kind;
1732    var index = state.index++;
1733    if (!target || index >= target.length) {
1734      state.target = undefined;
1735      return { value: undefined, done: true };
1736    }
1737    if (kind == 'keys') return { value: index, done: false };
1738    if (kind == 'values') return { value: target[index], done: false };
1739    return { value: [index, target[index]], done: false };
1740  }, 'values');
1741
1742  // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
1743  addToUnscopables('keys');
1744  addToUnscopables('values');
1745  addToUnscopables('entries');
1746
1747  var sloppyArrayMethod = function (METHOD_NAME, argument) {
1748    var method = [][METHOD_NAME];
1749    return !method || !fails(function () {
1750      // eslint-disable-next-line no-useless-call,no-throw-literal
1751      method.call(null, argument || function () { throw 1; }, 1);
1752    });

1753  };
1754
1755  var nativeJoin = [].join;
1756
1757  var ES3_STRINGS = indexedObject != Object;
1758  var SLOPPY_METHOD = sloppyArrayMethod('join', ',');
1759
1760  // `Array.prototype.join` method
1761  // https://tc39.github.io/ecma262/#sec-array.prototype.join
1762  _export({ target: 'Array', proto: true, forced: ES3_STRINGS || SLOPPY_METHOD }, {
1763    join: function join(separator) {
1764      return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator);
1765    }
1766  });
1767
1768  var $map = arrayIteration.map;
1769
1770
1771  // `Array.prototype.map` method
1772  // https://tc39.github.io/ecma262/#sec-array.prototype.map
1773  // with adding support of @@species
1774  _export({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('map') }, {
1775    map: function map(callbackfn /* , thisArg */) {
1776      return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
1777    }
1778  });
1779
1780  var SPECIES$2 = wellKnownSymbol('species');
1781  var nativeSlice = [].slice;
1782  var max$1 = Math.max;
1783
1784  // `Array.prototype.slice` method
1785  // https://tc39.github.io/ecma262/#sec-array.prototype.slice
1786  // fallback for not array-like ES3 strings and DOM objects
1787  _export({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('slice') }, {
1788    slice: function slice(start, end) {
1789      var O = toIndexedObject(this);
1790      var length = toLength(O.length);
1791      var k = toAbsoluteIndex(start, length);
1792      var fin = toAbsoluteIndex(end === undefined ? length : end, length);
1793      // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
1794      var Constructor, result, n;
1795      if (isArray(O)) {
1796        Constructor = O.constructor;
1797        // cross-realm fallback
1798        if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) {
1799          Constructor = undefined;
1800        } else if (isObject(Constructor)) {
1801          Constructor = Constructor[SPECIES$2];
1802          if (Constructor === null) Constructor = undefined;
1803        }
1804        if (Constructor === Array || Constructor === undefined) {
1805          return nativeSlice.call(O, k, fin);
1806        }
1807      }
1808      result = new (Constructor === undefined ? Array : Constructor)(max$1(fin - k, 0));
1809      for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
1810      result.length = n;
1811      return result;
1812    }
1813  });
1814
1815  var defineProperty$3 = objectDefineProperty.f;
1816
1817  var FunctionPrototype = Function.prototype;
1818  var FunctionPrototypeToString = FunctionPrototype.toString;
1819  var nameRE = /^\s*function ([^ (]*)/;
1820  var NAME = 'name';
1821
1822  // Function instances `.name` property
1823  // https://tc39.github.io/ecma262/#sec-function-instances-name
1824  if (descriptors && !(NAME in FunctionPrototype)) {
1825    defineProperty$3(FunctionPrototype, NAME, {
1826      configurable: true,
1827      get: function () {
1828        try {
1829          return FunctionPrototypeToString.call(this).match(nameRE)[1];
1830        } catch (error) {
1831          return '';
1832        }
1833      }
1834    });
1835  }
1836
1837  var propertyIsEnumerable = objectPropertyIsEnumerable.f;
1838
1839  // `Object.{ entries, values }` methods implementation
1840  var createMethod$3 = function (TO_ENTRIES) {
1841    return function (it) {
1842      var O = toIndexedObject(it);
1843      var keys = objectKeys(O);
1844      var length = keys.length;
1845      var i = 0;
1846      var result = [];
1847      var key;
1848      while (length > i) {
1849        key = keys[i++];
1850        if (!descriptors || propertyIsEnumerable.call(O, key)) {
1851          result.push(TO_ENTRIES ? [key, O[key]] : O[key]);
1852        }
1853      }
1854      return result;
1855    };
1856  };
1857
1858  var objectToArray = {
1859    // `Object.entries` method
1860    // https://tc39.github.io/ecma262/#sec-object.entries
1861    entries: createMethod$3(true),
1862    // `Object.values` method
1863    // https://tc39.github.io/ecma262/#sec-object.values
1864    values: createMethod$3(false)
1865  };
1866
1867  var $entries = objectToArray.entries;
1868
1869  // `Object.entries` method
1870  // https://tc39.github.io/ecma262/#sec-object.entries
1871  _export({ target: 'Object', stat: true }, {
1872    entries: function entries(O) {
1873      return $entries(O);
1874    }
1875  });
1876
1877  var FAILS_ON_PRIMITIVES = fails(function () { objectKeys(1); });
1878
1879  // `Object.keys` method
1880  // https://tc39.github.io/ecma262/#sec-object.keys
1881  _export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
1882    keys: function keys(it) {
1883      return objectKeys(toObject(it));
1884    }
1885  });
1886
1887  var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag');
1888  // ES3 wrong here
1889  var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
1890
1891  // fallback for IE11 Script Access Denied error
1892  var tryGet = function (it, key) {
1893    try {
1894      return it[key];
1895    } catch (error) { /* empty */ }
1896  };
1897
1898  // getting tag from ES6+ `Object.prototype.toString`
1899  var classof = function (it) {
1900    var O, tag, result;

1901    return it === undefined ? 'Undefined' : it === null ? 'Null'
1902      // @@toStringTag case
1903      : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG$1)) == 'string' ? tag
1904      // builtinTag case
1905      : CORRECT_ARGUMENTS ? classofRaw(O)
1906      // ES3 arguments fallback
1907      : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
1908  };
1909
1910  var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag');
1911  var test = {};
1912
1913  test[TO_STRING_TAG$2] = 'z';
1914
1915  // `Object.prototype.toString` method implementation
1916  // https://tc39.github.io/ecma262/#sec-object.prototype.tostring
1917  var objectToString = String(test) !== '[object z]' ? function toString() {
1918    return '[object ' + classof(this) + ']';
1919  } : test.toString;
1920
1921  var ObjectPrototype$2 = Object.prototype;
1922
1923  // `Object.prototype.toString` method
1924  // https://tc39.github.io/ecma262/#sec-object.prototype.tostring
1925  if (objectToString !== ObjectPrototype$2.toString) {
1926    redefine(ObjectPrototype$2, 'toString', objectToString, { unsafe: true });
1927  }
1928
1929  // `String.prototype.{ codePointAt, at }` methods implementation
1930  var createMethod$4 = function (CONVERT_TO_STRING) {
1931    return function ($this, pos) {
1932      var S = String(requireObjectCoercible($this));
1933      var position = toInteger(pos);
1934      var size = S.length;
1935      var first, second;
1936      if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
1937      first = S.charCodeAt(position);
1938      return first < 0xD800 || first > 0xDBFF || position + 1 === size
1939        || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
1940          ? CONVERT_TO_STRING ? S.charAt(position) : first
1941          : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
1942    };
1943  };
1944
1945  var stringMultibyte = {
1946    // `String.prototype.codePointAt` method
1947    // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat
1948    codeAt: createMethod$4(false),
1949    // `String.prototype.at` method
1950    // https://github.com/mathiasbynens/String.prototype.at
1951    charAt: createMethod$4(true)
1952  };
1953
1954  var charAt = stringMultibyte.charAt;
1955
1956
1957
1958  var STRING_ITERATOR = 'String Iterator';
1959  var setInternalState$2 = internalState.set;
1960  var getInternalState$2 = internalState.getterFor(STRING_ITERATOR);
1961
1962  // `String.prototype[@@iterator]` method
1963  // https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator
1964  defineIterator(String, 'String', function (iterated) {
1965    setInternalState$2(this, {
1966      type: STRING_ITERATOR,
1967      string: String(iterated),
1968      index: 0
1969    });
1970  // `%StringIteratorPrototype%.next` method
1971  // https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next
1972  }, function next() {
1973    var state = getInternalState$2(this);
1974    var string = state.string;
1975    var index = state.index;
1976    var point;
1977    if (index >= string.length) return { value: undefined, done: true };
1978    point = charAt(string, index);
1979    state.index += point.length;
1980    return { value: point, done: false };
1981  });
1982
1983  // `RegExp.prototype.flags` getter implementation
1984  // https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags
1985  var regexpFlags = function () {
1986    var that = anObject(this);
1987    var result = '';
1988    if (that.global) result += 'g';
1989    if (that.ignoreCase) result += 'i';
1990    if (that.multiline) result += 'm';
1991    if (that.dotAll) result += 's';
1992    if (that.unicode) result += 'u';
1993    if (that.sticky) result += 'y';
1994    return result;
1995  };
1996
1997  var nativeExec = RegExp.prototype.exec;
1998  // This always refers to the native implementation, because the
1999  // String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,
2000  // which loads this file before patching the method.
2001  var nativeReplace = String.prototype.replace;
2002
2003  var patchedExec = nativeExec;
2004
2005  var UPDATES_LAST_INDEX_WRONG = (function () {
2006    var re1 = /a/;
2007    var re2 = /b*/g;
2008    nativeExec.call(re1, 'a');
2009    nativeExec.call(re2, 'a');
2010    return re1.lastIndex !== 0 || re2.lastIndex !== 0;
2011  })();

2012
2013  // nonparticipating capturing group, copied from es5-shim's String#split patch.
2014  var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
2015
2016  var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED;
2017
2018  if (PATCH) {
2019    patchedExec = function exec(str) {
2020      var re = this;
2021      var lastIndex, reCopy, match, i;
2022
2023      if (NPCG_INCLUDED) {
2024        reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re));
2025      }
2026      if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
2027
2028      match = nativeExec.call(re, str);
2029
2030      if (UPDATES_LAST_INDEX_WRONG && match) {
2031        re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
2032      }
2033      if (NPCG_INCLUDED && match && match.length > 1) {
2034        // Fix browsers whose `exec` methods don't consistently return `undefined`
2035        // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
2036        nativeReplace.call(match[0], reCopy, function () {
2037          for (i = 1; i < arguments.length - 2; i++) {
2038            if (arguments[i] === undefined) match[i] = undefined;
2039          }
2040        });
2041      }
2042
2043      return match;
2044    };
2045  }
2046
2047  var regexpExec = patchedExec;
2048
2049  var SPECIES$3 = wellKnownSymbol('species');
2050
2051  var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
2052    // #replace needs built-in support for named groups.
2053    // #match works fine because it just return the exec results, even if it has
2054    // a "grops" property.
2055    var re = /./;
2056    re.exec = function () {
2057      var result = [];
2058      result.groups = { a: '7' };
2059      return result;
2060    };
2061    return ''.replace(re, '$<a>') !== '7';
2062  });
2063
2064  // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
2065  // Weex JS has frozen built-in prototypes, so use try / catch wrapper
2066  var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
2067    var re = /(?:)/;
2068    var originalExec = re.exec;
2069    re.exec = function () { return originalExec.apply(this, arguments); };
2070    var result = 'ab'.split(re);
2071    return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
2072  });
2073
2074  var fixRegexpWellKnownSymbolLogic = function (KEY, length, exec, sham) {
2075    var SYMBOL = wellKnownSymbol(KEY);
2076
2077    var DELEGATES_TO_SYMBOL = !fails(function () {
2078      // String methods call symbol-named RegEp methods
2079      var O = {};
2080      O[SYMBOL] = function () { return 7; };
2081      return ''[KEY](O) != 7;
2082    });
2083
2084    var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {
2085      // Symbol-named RegExp methods call .exec
2086      var execCalled = false;
2087      var re = /a/;
2088      re.exec = function () { execCalled = true; return null; };
2089
2090      if (KEY === 'split') {
2091        // RegExp[@@split] doesn't call the regex's exec method, but first creates
2092        // a new one. We need to return the patched regex when creating the new one.
2093        re.constructor = {};
2094        re.constructor[SPECIES$3] = function () { return re; };
2095      }
2096
2097      re[SYMBOL]('');
2098      return !execCalled;
2099    });
2100
2101    if (
2102      !DELEGATES_TO_SYMBOL ||
2103      !DELEGATES_TO_EXEC ||
2104      (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) ||
2105      (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
2106    ) {
2107      var nativeRegExpMethod = /./[SYMBOL];
2108      var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
2109        if (regexp.exec === regexpExec) {
2110          if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
2111            // The native String method already delegates to @@method (this
2112            // polyfilled function), leasing to infinite recursion.
2113            // We avoid it by directly calling the native @@method method.
2114            return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };
2115          }
2116          return { done: true, value: nativeMethod.call(str, regexp, arg2) };
2117        }
2118        return { done: false };
2119      });
2120      var stringMethod = methods[0];
2121      var regexMethod = methods[1];
2122
2123      redefine(String.prototype, KEY, stringMethod);
2124      redefine(RegExp.prototype, SYMBOL, length == 2
2125        // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)

2126        // 21.2.5.11 RegExp.prototype[@@split](string, limit)
2127        ? function (string, arg) { return regexMethod.call(string, this, arg); }
2128        // 21.2.5.6 RegExp.prototype[@@match](string)
2129        // 21.2.5.9 RegExp.prototype[@@search](string)
2130        : function (string) { return regexMethod.call(string, this); }
2131      );
2132      if (sham) hide(RegExp.prototype[SYMBOL], 'sham', true);
2133    }
2134  };
2135
2136  var SPECIES$4 = wellKnownSymbol('species');
2137
2138  // `SpeciesConstructor` abstract operation
2139  // https://tc39.github.io/ecma262/#sec-speciesconstructor
2140  var speciesConstructor = function (O, defaultConstructor) {
2141    var C = anObject(O).constructor;
2142    var S;
2143    return C === undefined || (S = anObject(C)[SPECIES$4]) == undefined ? defaultConstructor : aFunction$1(S);
2144  };
2145
2146  var charAt$1 = stringMultibyte.charAt;
2147
2148  // `AdvanceStringIndex` abstract operation
2149  // https://tc39.github.io/ecma262/#sec-advancestringindex
2150  var advanceStringIndex = function (S, index, unicode) {
2151    return index + (unicode ? charAt$1(S, index).length : 1);
2152  };
2153
2154  // `RegExpExec` abstract operation
2155  // https://tc39.github.io/ecma262/#sec-regexpexec
2156  var regexpExecAbstract = function (R, S) {
2157    var exec = R.exec;
2158    if (typeof exec === 'function') {
2159      var result = exec.call(R, S);
2160      if (typeof result !== 'object') {
2161        throw TypeError('RegExp exec method returned something other than an Object or null');
2162      }
2163      return result;
2164    }
2165
2166    if (classofRaw(R) !== 'RegExp') {
2167      throw TypeError('RegExp#exec called on incompatible receiver');
2168    }
2169
2170    return regexpExec.call(R, S);
2171  };
2172
2173  var arrayPush = [].push;
2174  var min$2 = Math.min;
2175  var MAX_UINT32 = 0xFFFFFFFF;
2176
2177  // babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError
2178  var SUPPORTS_Y = !fails(function () { return !RegExp(MAX_UINT32, 'y'); });
2179
2180  // @@split logic
2181  fixRegexpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCallNative) {
2182    var internalSplit;
2183    if (
2184      'abbc'.split(/(b)*/)[1] == 'c' ||
2185      'test'.split(/(?:)/, -1).length != 4 ||
2186      'ab'.split(/(?:ab)*/).length != 2 ||
2187      '.'.split(/(.?)(.?)/).length != 4 ||
2188      '.'.split(/()()/).length > 1 ||
2189      ''.split(/.?/).length
2190    ) {
2191      // based on es5-shim implementation, need to rework it
2192      internalSplit = function (separator, limit) {
2193        var string = String(requireObjectCoercible(this));
2194        var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
2195        if (lim === 0) return [];
2196        if (separator === undefined) return [string];
2197        // If `separator` is not a regex, use native split
2198        if (!isRegexp(separator)) {
2199          return nativeSplit.call(string, separator, lim);
2200        }
2201        var output = [];
2202        var flags = (separator.ignoreCase ? 'i' : '') +
2203                    (separator.multiline ? 'm' : '') +
2204                    (separator.unicode ? 'u' : '') +
2205                    (separator.sticky ? 'y' : '');
2206        var lastLastIndex = 0;
2207        // Make `global` and avoid `lastIndex` issues by working with a copy
2208        var separatorCopy = new RegExp(separator.source, flags + 'g');
2209        var match, lastIndex, lastLength;
2210        while (match = regexpExec.call(separatorCopy, string)) {
2211          lastIndex = separatorCopy.lastIndex;
2212          if (lastIndex > lastLastIndex) {
2213            output.push(string.slice(lastLastIndex, match.index));
2214            if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1));
2215            lastLength = match[0].length;
2216            lastLastIndex = lastIndex;
2217            if (output.length >= lim) break;
2218          }
2219          if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
2220        }
2221        if (lastLastIndex === string.length) {
2222          if (lastLength || !separatorCopy.test('')) output.push('');
2223        } else output.push(string.slice(lastLastIndex));
2224        return output.length > lim ? output.slice(0, lim) : output;
2225      };
2226    // Chakra, V8
2227    } else if ('0'.split(undefined, 0).length) {
2228      internalSplit = function (separator, limit) {
2229        return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit);
2230      };
2231    } else internalSplit = nativeSplit;
2232
2233    return [
2234      // `String.prototype.split` method
2235      // https://tc39.github.io/ecma262/#sec-string.prototype.split
2236      function split(separator, limit) {
2237        var O = requireObjectCoercible(this);
2238        var splitter = separator == undefined ? undefined : separator[SPLIT];
2239        return splitter !== undefined
2240          ? splitter.call(separator, O, limit)
2241          : internalSplit.call(String(O), separator, limit);
2242      },

2572ngth(rx.lastIndex), fullUnicode);
2573        }
2574
2575        var accumulatedResult = '';
2576        var nextSourcePosition = 0;
2577        for (var i = 0; i < results.length; i++) {
2578          result = results[i];
2579
2580          var matched = String(result[0]);
2581          var position = max$2(min$3(toInteger(result.index), S.length), 0);
2582          var captures = [];
2583          // NOTE: This is equivalent to
2584          //   captures = result.slice(1).map(maybeToString)
2585          // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
2586          // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
2587          // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
2588          for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j]));
2589          var namedCaptures = result.groups;
2590          if (functionalReplace) {
2591            var replacerArgs = [matched].concat(captures, position, S);
2592            if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);
2593            var replacement = String(replaceValue.apply(undefined, replacerArgs));
2594          } else {
2595            replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
2596          }
2597          if (position >= nextSourcePosition) {
2598            accumulatedResult += S.slice(nextSourcePosition, position) + replacement;
2599            nextSourcePosition = position + matched.length;
2600          }
2601        }
2602        return accumulatedResult + S.slice(nextSourcePosition);
2603      }
2604    ];
2605
2606    // https://tc39.github.io/ecma262/#sec-getsubstitution
2607    function getSubstitution(matched, str, position, captures, namedCaptures, replacement) {
2608      var tailPos = position + matched.length;
2609      var m = captures.length;
2610      var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
2611      if (namedCaptures !== undefined) {
2612        namedCaptures = toObject(namedCaptures);
2613        symbols = SUBSTITUTION_SYMBOLS;
2614      }
2615      return nativeReplace.call(replacement, symbols, function (match, ch) {
2616        var capture;
2617        switch (ch.charAt(0)) {
2618          case '$': return '$';
2619          case '&': return matched;
2620          case '`': return str.slice(0, position);
2621          case "'": return str.slice(tailPos);
2622          case '<':
2623            capture = namedCaptures[ch.slice(1, -1)];
2624            break;
2625          default: // \d\d?
2626            var n = +ch;
2627            if (n === 0) return match;
2628            if (n > m) {
2629              var f = floor$1(n / 10);
2630              if (f === 0) return match;
2631              if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);
2632              return match;
2633            }
2634            capture = captures[n - 1];
2635        }
2636        return capture === undefined ? '' : capture;
2637      });
2638    }
2639  });
2640
2641  var compareObjects = function compareObjects(objectA, objectB, compareLength) {
2642    var aKeys = Object.keys(objectA);
2643    var bKeys = Object.keys(objectB);
2644
2645    if (compareLength && aKeys.length !== bKeys.length) {
2646      return false;
2647    }
2648
2649    for (var _i = 0, _aKeys = aKeys; _i < _aKeys.length; _i++) {
2650      var key = _aKeys[_i];
2651
2652      if (bKeys.includes(key) && objectA[key] !== objectB[key]) {
2653        return false;
2654      }
2655    }
2656
2657    return true;
2658  };
2659
2660  var removeDiacritics = function removeDiacritics(str) {
2661    if (str.normalize) {
2662      return str.normalize('NFD').replace(/[\u0300-\u036F]/g, '');
2663    }
2664
2665    var defaultDiacriticsRemovalMap = [{
2666      'base': 'A',
2667      'letters': /[\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F]/g
2668    }, {
2669      'base': 'AA',
2670      'letters': /[\uA732]/g
2671    }, {
2672      'base': 'AE',
2673      'letters': /[\u00C6\u01FC\u01E2]/g
2674    }, {
2675      'base': 'AO',
2676      'letters': /[\uA734]/g
2677    }, {
2678      'base': 'AU',
2679      'letters': /[\uA736]/g
2680    }, {
2681      'base': 'AV',
2682      'letters': /[\uA738\uA73A]/g
2683    }, {
2684      'base': 'AY',
2685      'letters': /[\uA73C]/g
2686    }, {
2687      'base': 'B',
2688      'letters': /[\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181]/g
2689    }, {
2690      'base': 'C',
2691      'letters': /[\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E]/g
2692    }, {
2693      'base': 'D',
2694      'letters': /[\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779]/g
2695    }, {
2696      'base': 'DZ',
2697      'letters': /[\u01F1\u01C4]/g
2698    }, {
2699      'base': 'Dz',
2700      'letters': /[\u01F2\u01C5]/g
2701    }, {
2702      'base': 'E',
2703      'letters': /[\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E]/g
2704    }, {
2705      'base': 'F',
2706      'letters': /[\u0046\u24BB\uFF26\u1E1E\u0191\uA77B]/g
2707    }, {
2708      'base': 'G',
2709      'letters': /[\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E]/g
2710    }, {
2711      'base': 'H',
2712      'letters': /[\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D]/g
2713    }, {
2714      'base': 'I',
2715      'letters': /[\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197]/g
2716    }, {
2717      'base': 'J',
2718      'letters': /[\u004A\u24BF\uFF2A\u0134\u0248]/g
2719    }, {
2720      'base': 'K',
2721      'letters': /[\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2]/g
2722    }, {
2723      'base': 'L',
2724      'letters': /[\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u014