UNPKG

61.7 kBJavaScriptView Raw
1(function (global, factory) {
2 typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('jquery')) :
3 typeof define === 'function' && define.amd ? define(['jquery'], factory) :
4 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jQuery));
5})(this, (function ($$3) { 'use strict';
6
7 function _classCallCheck(instance, Constructor) {
8 if (!(instance instanceof Constructor)) {
9 throw new TypeError("Cannot call a class as a function");
10 }
11 }
12 function _defineProperties(target, props) {
13 for (var i = 0; i < props.length; i++) {
14 var descriptor = props[i];
15 descriptor.enumerable = descriptor.enumerable || false;
16 descriptor.configurable = true;
17 if ("value" in descriptor) descriptor.writable = true;
18 Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
19 }
20 }
21 function _createClass(Constructor, protoProps, staticProps) {
22 if (protoProps) _defineProperties(Constructor.prototype, protoProps);
23 if (staticProps) _defineProperties(Constructor, staticProps);
24 Object.defineProperty(Constructor, "prototype", {
25 writable: false
26 });
27 return Constructor;
28 }
29 function _inherits(subClass, superClass) {
30 if (typeof superClass !== "function" && superClass !== null) {
31 throw new TypeError("Super expression must either be null or a function");
32 }
33 subClass.prototype = Object.create(superClass && superClass.prototype, {
34 constructor: {
35 value: subClass,
36 writable: true,
37 configurable: true
38 }
39 });
40 Object.defineProperty(subClass, "prototype", {
41 writable: false
42 });
43 if (superClass) _setPrototypeOf(subClass, superClass);
44 }
45 function _getPrototypeOf(o) {
46 _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
47 return o.__proto__ || Object.getPrototypeOf(o);
48 };
49 return _getPrototypeOf(o);
50 }
51 function _setPrototypeOf(o, p) {
52 _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
53 o.__proto__ = p;
54 return o;
55 };
56 return _setPrototypeOf(o, p);
57 }
58 function _isNativeReflectConstruct() {
59 if (typeof Reflect === "undefined" || !Reflect.construct) return false;
60 if (Reflect.construct.sham) return false;
61 if (typeof Proxy === "function") return true;
62 try {
63 Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
64 return true;
65 } catch (e) {
66 return false;
67 }
68 }
69 function _assertThisInitialized(self) {
70 if (self === void 0) {
71 throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
72 }
73 return self;
74 }
75 function _possibleConstructorReturn(self, call) {
76 if (call && (typeof call === "object" || typeof call === "function")) {
77 return call;
78 } else if (call !== void 0) {
79 throw new TypeError("Derived constructors may only return object or undefined");
80 }
81 return _assertThisInitialized(self);
82 }
83 function _createSuper(Derived) {
84 var hasNativeReflectConstruct = _isNativeReflectConstruct();
85 return function _createSuperInternal() {
86 var Super = _getPrototypeOf(Derived),
87 result;
88 if (hasNativeReflectConstruct) {
89 var NewTarget = _getPrototypeOf(this).constructor;
90 result = Reflect.construct(Super, arguments, NewTarget);
91 } else {
92 result = Super.apply(this, arguments);
93 }
94 return _possibleConstructorReturn(this, result);
95 };
96 }
97 function _superPropBase(object, property) {
98 while (!Object.prototype.hasOwnProperty.call(object, property)) {
99 object = _getPrototypeOf(object);
100 if (object === null) break;
101 }
102 return object;
103 }
104 function _get() {
105 if (typeof Reflect !== "undefined" && Reflect.get) {
106 _get = Reflect.get.bind();
107 } else {
108 _get = function _get(target, property, receiver) {
109 var base = _superPropBase(target, property);
110 if (!base) return;
111 var desc = Object.getOwnPropertyDescriptor(base, property);
112 if (desc.get) {
113 return desc.get.call(arguments.length < 3 ? target : receiver);
114 }
115 return desc.value;
116 };
117 }
118 return _get.apply(this, arguments);
119 }
120 function _toPrimitive(input, hint) {
121 if (typeof input !== "object" || input === null) return input;
122 var prim = input[Symbol.toPrimitive];
123 if (prim !== undefined) {
124 var res = prim.call(input, hint || "default");
125 if (typeof res !== "object") return res;
126 throw new TypeError("@@toPrimitive must return a primitive value.");
127 }
128 return (hint === "string" ? String : Number)(input);
129 }
130 function _toPropertyKey(arg) {
131 var key = _toPrimitive(arg, "string");
132 return typeof key === "symbol" ? key : String(key);
133 }
134
135 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
136
137 var check = function (it) {
138 return it && it.Math == Math && it;
139 };
140
141 // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
142 var global$a =
143 // eslint-disable-next-line es/no-global-this -- safe
144 check(typeof globalThis == 'object' && globalThis) ||
145 check(typeof window == 'object' && window) ||
146 // eslint-disable-next-line no-restricted-globals -- safe
147 check(typeof self == 'object' && self) ||
148 check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
149 // eslint-disable-next-line no-new-func -- fallback
150 (function () { return this; })() || Function('return this')();
151
152 var objectGetOwnPropertyDescriptor = {};
153
154 var fails$a = function (exec) {
155 try {
156 return !!exec();
157 } catch (error) {
158 return true;
159 }
160 };
161
162 var fails$9 = fails$a;
163
164 // Detect IE8's incomplete defineProperty implementation
165 var descriptors = !fails$9(function () {
166 // eslint-disable-next-line es/no-object-defineproperty -- required for testing
167 return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
168 });
169
170 var fails$8 = fails$a;
171
172 var functionBindNative = !fails$8(function () {
173 // eslint-disable-next-line es/no-function-prototype-bind -- safe
174 var test = (function () { /* empty */ }).bind();
175 // eslint-disable-next-line no-prototype-builtins -- safe
176 return typeof test != 'function' || test.hasOwnProperty('prototype');
177 });
178
179 var NATIVE_BIND$2 = functionBindNative;
180
181 var call$4 = Function.prototype.call;
182
183 var functionCall = NATIVE_BIND$2 ? call$4.bind(call$4) : function () {
184 return call$4.apply(call$4, arguments);
185 };
186
187 var objectPropertyIsEnumerable = {};
188
189 var $propertyIsEnumerable = {}.propertyIsEnumerable;
190 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
191 var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
192
193 // Nashorn ~ JDK8 bug
194 var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
195
196 // `Object.prototype.propertyIsEnumerable` method implementation
197 // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
198 objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
199 var descriptor = getOwnPropertyDescriptor$1(this, V);
200 return !!descriptor && descriptor.enumerable;
201 } : $propertyIsEnumerable;
202
203 var createPropertyDescriptor$2 = function (bitmap, value) {
204 return {
205 enumerable: !(bitmap & 1),
206 configurable: !(bitmap & 2),
207 writable: !(bitmap & 4),
208 value: value
209 };
210 };
211
212 var NATIVE_BIND$1 = functionBindNative;
213
214 var FunctionPrototype$1 = Function.prototype;
215 var call$3 = FunctionPrototype$1.call;
216 var uncurryThisWithBind = NATIVE_BIND$1 && FunctionPrototype$1.bind.bind(call$3, call$3);
217
218 var functionUncurryThis = NATIVE_BIND$1 ? uncurryThisWithBind : function (fn) {
219 return function () {
220 return call$3.apply(fn, arguments);
221 };
222 };
223
224 var uncurryThis$d = functionUncurryThis;
225
226 var toString$4 = uncurryThis$d({}.toString);
227 var stringSlice$1 = uncurryThis$d(''.slice);
228
229 var classofRaw$2 = function (it) {
230 return stringSlice$1(toString$4(it), 8, -1);
231 };
232
233 var uncurryThis$c = functionUncurryThis;
234 var fails$7 = fails$a;
235 var classof$6 = classofRaw$2;
236
237 var $Object$3 = Object;
238 var split = uncurryThis$c(''.split);
239
240 // fallback for non-array-like ES3 and non-enumerable old V8 strings
241 var indexedObject = fails$7(function () {
242 // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
243 // eslint-disable-next-line no-prototype-builtins -- safe
244 return !$Object$3('z').propertyIsEnumerable(0);
245 }) ? function (it) {
246 return classof$6(it) == 'String' ? split(it, '') : $Object$3(it);
247 } : $Object$3;
248
249 // we can't use just `it == null` since of `document.all` special case
250 // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
251 var isNullOrUndefined$2 = function (it) {
252 return it === null || it === undefined;
253 };
254
255 var isNullOrUndefined$1 = isNullOrUndefined$2;
256
257 var $TypeError$6 = TypeError;
258
259 // `RequireObjectCoercible` abstract operation
260 // https://tc39.es/ecma262/#sec-requireobjectcoercible
261 var requireObjectCoercible$3 = function (it) {
262 if (isNullOrUndefined$1(it)) throw $TypeError$6("Can't call method on " + it);
263 return it;
264 };
265
266 // toObject with fallback for non-array-like ES3 strings
267 var IndexedObject$1 = indexedObject;
268 var requireObjectCoercible$2 = requireObjectCoercible$3;
269
270 var toIndexedObject$4 = function (it) {
271 return IndexedObject$1(requireObjectCoercible$2(it));
272 };
273
274 var documentAll$2 = typeof document == 'object' && document.all;
275
276 // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
277 // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
278 var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined;
279
280 var documentAll_1 = {
281 all: documentAll$2,
282 IS_HTMLDDA: IS_HTMLDDA
283 };
284
285 var $documentAll$1 = documentAll_1;
286
287 var documentAll$1 = $documentAll$1.all;
288
289 // `IsCallable` abstract operation
290 // https://tc39.es/ecma262/#sec-iscallable
291 var isCallable$c = $documentAll$1.IS_HTMLDDA ? function (argument) {
292 return typeof argument == 'function' || argument === documentAll$1;
293 } : function (argument) {
294 return typeof argument == 'function';
295 };
296
297 var isCallable$b = isCallable$c;
298 var $documentAll = documentAll_1;
299
300 var documentAll = $documentAll.all;
301
302 var isObject$7 = $documentAll.IS_HTMLDDA ? function (it) {
303 return typeof it == 'object' ? it !== null : isCallable$b(it) || it === documentAll;
304 } : function (it) {
305 return typeof it == 'object' ? it !== null : isCallable$b(it);
306 };
307
308 var global$9 = global$a;
309 var isCallable$a = isCallable$c;
310
311 var aFunction = function (argument) {
312 return isCallable$a(argument) ? argument : undefined;
313 };
314
315 var getBuiltIn$4 = function (namespace, method) {
316 return arguments.length < 2 ? aFunction(global$9[namespace]) : global$9[namespace] && global$9[namespace][method];
317 };
318
319 var uncurryThis$b = functionUncurryThis;
320
321 var objectIsPrototypeOf = uncurryThis$b({}.isPrototypeOf);
322
323 var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
324
325 var global$8 = global$a;
326 var userAgent = engineUserAgent;
327
328 var process = global$8.process;
329 var Deno = global$8.Deno;
330 var versions = process && process.versions || Deno && Deno.version;
331 var v8 = versions && versions.v8;
332 var match, version;
333
334 if (v8) {
335 match = v8.split('.');
336 // in old Chrome, versions of V8 isn't V8 = Chrome / 10
337 // but their correct versions are not interesting for us
338 version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
339 }
340
341 // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
342 // so check `userAgent` even if `.v8` exists, but 0
343 if (!version && userAgent) {
344 match = userAgent.match(/Edge\/(\d+)/);
345 if (!match || match[1] >= 74) {
346 match = userAgent.match(/Chrome\/(\d+)/);
347 if (match) version = +match[1];
348 }
349 }
350
351 var engineV8Version = version;
352
353 /* eslint-disable es/no-symbol -- required for testing */
354
355 var V8_VERSION = engineV8Version;
356 var fails$6 = fails$a;
357
358 // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
359 var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$6(function () {
360 var symbol = Symbol();
361 // Chrome 38 Symbol has incorrect toString conversion
362 // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
363 return !String(symbol) || !(Object(symbol) instanceof Symbol) ||
364 // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
365 !Symbol.sham && V8_VERSION && V8_VERSION < 41;
366 });
367
368 /* eslint-disable es/no-symbol -- required for testing */
369
370 var NATIVE_SYMBOL$1 = symbolConstructorDetection;
371
372 var useSymbolAsUid = NATIVE_SYMBOL$1
373 && !Symbol.sham
374 && typeof Symbol.iterator == 'symbol';
375
376 var getBuiltIn$3 = getBuiltIn$4;
377 var isCallable$9 = isCallable$c;
378 var isPrototypeOf = objectIsPrototypeOf;
379 var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
380
381 var $Object$2 = Object;
382
383 var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
384 return typeof it == 'symbol';
385 } : function (it) {
386 var $Symbol = getBuiltIn$3('Symbol');
387 return isCallable$9($Symbol) && isPrototypeOf($Symbol.prototype, $Object$2(it));
388 };
389
390 var $String$3 = String;
391
392 var tryToString$1 = function (argument) {
393 try {
394 return $String$3(argument);
395 } catch (error) {
396 return 'Object';
397 }
398 };
399
400 var isCallable$8 = isCallable$c;
401 var tryToString = tryToString$1;
402
403 var $TypeError$5 = TypeError;
404
405 // `Assert: IsCallable(argument) is true`
406 var aCallable$2 = function (argument) {
407 if (isCallable$8(argument)) return argument;
408 throw $TypeError$5(tryToString(argument) + ' is not a function');
409 };
410
411 var aCallable$1 = aCallable$2;
412 var isNullOrUndefined = isNullOrUndefined$2;
413
414 // `GetMethod` abstract operation
415 // https://tc39.es/ecma262/#sec-getmethod
416 var getMethod$1 = function (V, P) {
417 var func = V[P];
418 return isNullOrUndefined(func) ? undefined : aCallable$1(func);
419 };
420
421 var call$2 = functionCall;
422 var isCallable$7 = isCallable$c;
423 var isObject$6 = isObject$7;
424
425 var $TypeError$4 = TypeError;
426
427 // `OrdinaryToPrimitive` abstract operation
428 // https://tc39.es/ecma262/#sec-ordinarytoprimitive
429 var ordinaryToPrimitive$1 = function (input, pref) {
430 var fn, val;
431 if (pref === 'string' && isCallable$7(fn = input.toString) && !isObject$6(val = call$2(fn, input))) return val;
432 if (isCallable$7(fn = input.valueOf) && !isObject$6(val = call$2(fn, input))) return val;
433 if (pref !== 'string' && isCallable$7(fn = input.toString) && !isObject$6(val = call$2(fn, input))) return val;
434 throw $TypeError$4("Can't convert object to primitive value");
435 };
436
437 var sharedExports = {};
438 var shared$3 = {
439 get exports(){ return sharedExports; },
440 set exports(v){ sharedExports = v; },
441 };
442
443 var global$7 = global$a;
444
445 // eslint-disable-next-line es/no-object-defineproperty -- safe
446 var defineProperty$2 = Object.defineProperty;
447
448 var defineGlobalProperty$3 = function (key, value) {
449 try {
450 defineProperty$2(global$7, key, { value: value, configurable: true, writable: true });
451 } catch (error) {
452 global$7[key] = value;
453 } return value;
454 };
455
456 var global$6 = global$a;
457 var defineGlobalProperty$2 = defineGlobalProperty$3;
458
459 var SHARED = '__core-js_shared__';
460 var store$3 = global$6[SHARED] || defineGlobalProperty$2(SHARED, {});
461
462 var sharedStore = store$3;
463
464 var store$2 = sharedStore;
465
466 (shared$3.exports = function (key, value) {
467 return store$2[key] || (store$2[key] = value !== undefined ? value : {});
468 })('versions', []).push({
469 version: '3.29.0',
470 mode: 'global',
471 copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',
472 license: 'https://github.com/zloirock/core-js/blob/v3.29.0/LICENSE',
473 source: 'https://github.com/zloirock/core-js'
474 });
475
476 var requireObjectCoercible$1 = requireObjectCoercible$3;
477
478 var $Object$1 = Object;
479
480 // `ToObject` abstract operation
481 // https://tc39.es/ecma262/#sec-toobject
482 var toObject$2 = function (argument) {
483 return $Object$1(requireObjectCoercible$1(argument));
484 };
485
486 var uncurryThis$a = functionUncurryThis;
487 var toObject$1 = toObject$2;
488
489 var hasOwnProperty = uncurryThis$a({}.hasOwnProperty);
490
491 // `HasOwnProperty` abstract operation
492 // https://tc39.es/ecma262/#sec-hasownproperty
493 // eslint-disable-next-line es/no-object-hasown -- safe
494 var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
495 return hasOwnProperty(toObject$1(it), key);
496 };
497
498 var uncurryThis$9 = functionUncurryThis;
499
500 var id = 0;
501 var postfix = Math.random();
502 var toString$3 = uncurryThis$9(1.0.toString);
503
504 var uid$2 = function (key) {
505 return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$3(++id + postfix, 36);
506 };
507
508 var global$5 = global$a;
509 var shared$2 = sharedExports;
510 var hasOwn$6 = hasOwnProperty_1;
511 var uid$1 = uid$2;
512 var NATIVE_SYMBOL = symbolConstructorDetection;
513 var USE_SYMBOL_AS_UID = useSymbolAsUid;
514
515 var Symbol$1 = global$5.Symbol;
516 var WellKnownSymbolsStore = shared$2('wks');
517 var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
518
519 var wellKnownSymbol$7 = function (name) {
520 if (!hasOwn$6(WellKnownSymbolsStore, name)) {
521 WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$6(Symbol$1, name)
522 ? Symbol$1[name]
523 : createWellKnownSymbol('Symbol.' + name);
524 } return WellKnownSymbolsStore[name];
525 };
526
527 var call$1 = functionCall;
528 var isObject$5 = isObject$7;
529 var isSymbol$1 = isSymbol$2;
530 var getMethod = getMethod$1;
531 var ordinaryToPrimitive = ordinaryToPrimitive$1;
532 var wellKnownSymbol$6 = wellKnownSymbol$7;
533
534 var $TypeError$3 = TypeError;
535 var TO_PRIMITIVE = wellKnownSymbol$6('toPrimitive');
536
537 // `ToPrimitive` abstract operation
538 // https://tc39.es/ecma262/#sec-toprimitive
539 var toPrimitive$1 = function (input, pref) {
540 if (!isObject$5(input) || isSymbol$1(input)) return input;
541 var exoticToPrim = getMethod(input, TO_PRIMITIVE);
542 var result;
543 if (exoticToPrim) {
544 if (pref === undefined) pref = 'default';
545 result = call$1(exoticToPrim, input, pref);
546 if (!isObject$5(result) || isSymbol$1(result)) return result;
547 throw $TypeError$3("Can't convert object to primitive value");
548 }
549 if (pref === undefined) pref = 'number';
550 return ordinaryToPrimitive(input, pref);
551 };
552
553 var toPrimitive = toPrimitive$1;
554 var isSymbol = isSymbol$2;
555
556 // `ToPropertyKey` abstract operation
557 // https://tc39.es/ecma262/#sec-topropertykey
558 var toPropertyKey$2 = function (argument) {
559 var key = toPrimitive(argument, 'string');
560 return isSymbol(key) ? key : key + '';
561 };
562
563 var global$4 = global$a;
564 var isObject$4 = isObject$7;
565
566 var document$1 = global$4.document;
567 // typeof document.createElement is 'object' in old IE
568 var EXISTS$1 = isObject$4(document$1) && isObject$4(document$1.createElement);
569
570 var documentCreateElement$1 = function (it) {
571 return EXISTS$1 ? document$1.createElement(it) : {};
572 };
573
574 var DESCRIPTORS$7 = descriptors;
575 var fails$5 = fails$a;
576 var createElement = documentCreateElement$1;
577
578 // Thanks to IE8 for its funny defineProperty
579 var ie8DomDefine = !DESCRIPTORS$7 && !fails$5(function () {
580 // eslint-disable-next-line es/no-object-defineproperty -- required for testing
581 return Object.defineProperty(createElement('div'), 'a', {
582 get: function () { return 7; }
583 }).a != 7;
584 });
585
586 var DESCRIPTORS$6 = descriptors;
587 var call = functionCall;
588 var propertyIsEnumerableModule = objectPropertyIsEnumerable;
589 var createPropertyDescriptor$1 = createPropertyDescriptor$2;
590 var toIndexedObject$3 = toIndexedObject$4;
591 var toPropertyKey$1 = toPropertyKey$2;
592 var hasOwn$5 = hasOwnProperty_1;
593 var IE8_DOM_DEFINE$1 = ie8DomDefine;
594
595 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
596 var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
597
598 // `Object.getOwnPropertyDescriptor` method
599 // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
600 objectGetOwnPropertyDescriptor.f = DESCRIPTORS$6 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
601 O = toIndexedObject$3(O);
602 P = toPropertyKey$1(P);
603 if (IE8_DOM_DEFINE$1) try {
604 return $getOwnPropertyDescriptor$1(O, P);
605 } catch (error) { /* empty */ }
606 if (hasOwn$5(O, P)) return createPropertyDescriptor$1(!call(propertyIsEnumerableModule.f, O, P), O[P]);
607 };
608
609 var objectDefineProperty = {};
610
611 var DESCRIPTORS$5 = descriptors;
612 var fails$4 = fails$a;
613
614 // V8 ~ Chrome 36-
615 // https://bugs.chromium.org/p/v8/issues/detail?id=3334
616 var v8PrototypeDefineBug = DESCRIPTORS$5 && fails$4(function () {
617 // eslint-disable-next-line es/no-object-defineproperty -- required for testing
618 return Object.defineProperty(function () { /* empty */ }, 'prototype', {
619 value: 42,
620 writable: false
621 }).prototype != 42;
622 });
623
624 var isObject$3 = isObject$7;
625
626 var $String$2 = String;
627 var $TypeError$2 = TypeError;
628
629 // `Assert: Type(argument) is Object`
630 var anObject$4 = function (argument) {
631 if (isObject$3(argument)) return argument;
632 throw $TypeError$2($String$2(argument) + ' is not an object');
633 };
634
635 var DESCRIPTORS$4 = descriptors;
636 var IE8_DOM_DEFINE = ie8DomDefine;
637 var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
638 var anObject$3 = anObject$4;
639 var toPropertyKey = toPropertyKey$2;
640
641 var $TypeError$1 = TypeError;
642 // eslint-disable-next-line es/no-object-defineproperty -- safe
643 var $defineProperty = Object.defineProperty;
644 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
645 var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
646 var ENUMERABLE = 'enumerable';
647 var CONFIGURABLE$1 = 'configurable';
648 var WRITABLE = 'writable';
649
650 // `Object.defineProperty` method
651 // https://tc39.es/ecma262/#sec-object.defineproperty
652 objectDefineProperty.f = DESCRIPTORS$4 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
653 anObject$3(O);
654 P = toPropertyKey(P);
655 anObject$3(Attributes);
656 if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
657 var current = $getOwnPropertyDescriptor(O, P);
658 if (current && current[WRITABLE]) {
659 O[P] = Attributes.value;
660 Attributes = {
661 configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
662 enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
663 writable: false
664 };
665 }
666 } return $defineProperty(O, P, Attributes);
667 } : $defineProperty : function defineProperty(O, P, Attributes) {
668 anObject$3(O);
669 P = toPropertyKey(P);
670 anObject$3(Attributes);
671 if (IE8_DOM_DEFINE) try {
672 return $defineProperty(O, P, Attributes);
673 } catch (error) { /* empty */ }
674 if ('get' in Attributes || 'set' in Attributes) throw $TypeError$1('Accessors not supported');
675 if ('value' in Attributes) O[P] = Attributes.value;
676 return O;
677 };
678
679 var DESCRIPTORS$3 = descriptors;
680 var definePropertyModule$3 = objectDefineProperty;
681 var createPropertyDescriptor = createPropertyDescriptor$2;
682
683 var createNonEnumerableProperty$2 = DESCRIPTORS$3 ? function (object, key, value) {
684 return definePropertyModule$3.f(object, key, createPropertyDescriptor(1, value));
685 } : function (object, key, value) {
686 object[key] = value;
687 return object;
688 };
689
690 var makeBuiltInExports = {};
691 var makeBuiltIn$2 = {
692 get exports(){ return makeBuiltInExports; },
693 set exports(v){ makeBuiltInExports = v; },
694 };
695
696 var DESCRIPTORS$2 = descriptors;
697 var hasOwn$4 = hasOwnProperty_1;
698
699 var FunctionPrototype = Function.prototype;
700 // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
701 var getDescriptor = DESCRIPTORS$2 && Object.getOwnPropertyDescriptor;
702
703 var EXISTS = hasOwn$4(FunctionPrototype, 'name');
704 // additional protection from minified / mangled / dropped function names
705 var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
706 var CONFIGURABLE = EXISTS && (!DESCRIPTORS$2 || (DESCRIPTORS$2 && getDescriptor(FunctionPrototype, 'name').configurable));
707
708 var functionName = {
709 EXISTS: EXISTS,
710 PROPER: PROPER,
711 CONFIGURABLE: CONFIGURABLE
712 };
713
714 var uncurryThis$8 = functionUncurryThis;
715 var isCallable$6 = isCallable$c;
716 var store$1 = sharedStore;
717
718 var functionToString = uncurryThis$8(Function.toString);
719
720 // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
721 if (!isCallable$6(store$1.inspectSource)) {
722 store$1.inspectSource = function (it) {
723 return functionToString(it);
724 };
725 }
726
727 var inspectSource$2 = store$1.inspectSource;
728
729 var global$3 = global$a;
730 var isCallable$5 = isCallable$c;
731
732 var WeakMap$1 = global$3.WeakMap;
733
734 var weakMapBasicDetection = isCallable$5(WeakMap$1) && /native code/.test(String(WeakMap$1));
735
736 var shared$1 = sharedExports;
737 var uid = uid$2;
738
739 var keys = shared$1('keys');
740
741 var sharedKey$2 = function (key) {
742 return keys[key] || (keys[key] = uid(key));
743 };
744
745 var hiddenKeys$4 = {};
746
747 var NATIVE_WEAK_MAP = weakMapBasicDetection;
748 var global$2 = global$a;
749 var isObject$2 = isObject$7;
750 var createNonEnumerableProperty$1 = createNonEnumerableProperty$2;
751 var hasOwn$3 = hasOwnProperty_1;
752 var shared = sharedStore;
753 var sharedKey$1 = sharedKey$2;
754 var hiddenKeys$3 = hiddenKeys$4;
755
756 var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
757 var TypeError$1 = global$2.TypeError;
758 var WeakMap = global$2.WeakMap;
759 var set, get, has;
760
761 var enforce = function (it) {
762 return has(it) ? get(it) : set(it, {});
763 };
764
765 var getterFor = function (TYPE) {
766 return function (it) {
767 var state;
768 if (!isObject$2(it) || (state = get(it)).type !== TYPE) {
769 throw TypeError$1('Incompatible receiver, ' + TYPE + ' required');
770 } return state;
771 };
772 };
773
774 if (NATIVE_WEAK_MAP || shared.state) {
775 var store = shared.state || (shared.state = new WeakMap());
776 /* eslint-disable no-self-assign -- prototype methods protection */
777 store.get = store.get;
778 store.has = store.has;
779 store.set = store.set;
780 /* eslint-enable no-self-assign -- prototype methods protection */
781 set = function (it, metadata) {
782 if (store.has(it)) throw TypeError$1(OBJECT_ALREADY_INITIALIZED);
783 metadata.facade = it;
784 store.set(it, metadata);
785 return metadata;
786 };
787 get = function (it) {
788 return store.get(it) || {};
789 };
790 has = function (it) {
791 return store.has(it);
792 };
793 } else {
794 var STATE = sharedKey$1('state');
795 hiddenKeys$3[STATE] = true;
796 set = function (it, metadata) {
797 if (hasOwn$3(it, STATE)) throw TypeError$1(OBJECT_ALREADY_INITIALIZED);
798 metadata.facade = it;
799 createNonEnumerableProperty$1(it, STATE, metadata);
800 return metadata;
801 };
802 get = function (it) {
803 return hasOwn$3(it, STATE) ? it[STATE] : {};
804 };
805 has = function (it) {
806 return hasOwn$3(it, STATE);
807 };
808 }
809
810 var internalState = {
811 set: set,
812 get: get,
813 has: has,
814 enforce: enforce,
815 getterFor: getterFor
816 };
817
818 var uncurryThis$7 = functionUncurryThis;
819 var fails$3 = fails$a;
820 var isCallable$4 = isCallable$c;
821 var hasOwn$2 = hasOwnProperty_1;
822 var DESCRIPTORS$1 = descriptors;
823 var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
824 var inspectSource$1 = inspectSource$2;
825 var InternalStateModule = internalState;
826
827 var enforceInternalState = InternalStateModule.enforce;
828 var getInternalState = InternalStateModule.get;
829 var $String$1 = String;
830 // eslint-disable-next-line es/no-object-defineproperty -- safe
831 var defineProperty$1 = Object.defineProperty;
832 var stringSlice = uncurryThis$7(''.slice);
833 var replace = uncurryThis$7(''.replace);
834 var join = uncurryThis$7([].join);
835
836 var CONFIGURABLE_LENGTH = DESCRIPTORS$1 && !fails$3(function () {
837 return defineProperty$1(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
838 });
839
840 var TEMPLATE = String(String).split('String');
841
842 var makeBuiltIn$1 = makeBuiltIn$2.exports = function (value, name, options) {
843 if (stringSlice($String$1(name), 0, 7) === 'Symbol(') {
844 name = '[' + replace($String$1(name), /^Symbol\(([^)]*)\)/, '$1') + ']';
845 }
846 if (options && options.getter) name = 'get ' + name;
847 if (options && options.setter) name = 'set ' + name;
848 if (!hasOwn$2(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
849 if (DESCRIPTORS$1) defineProperty$1(value, 'name', { value: name, configurable: true });
850 else value.name = name;
851 }
852 if (CONFIGURABLE_LENGTH && options && hasOwn$2(options, 'arity') && value.length !== options.arity) {
853 defineProperty$1(value, 'length', { value: options.arity });
854 }
855 try {
856 if (options && hasOwn$2(options, 'constructor') && options.constructor) {
857 if (DESCRIPTORS$1) defineProperty$1(value, 'prototype', { writable: false });
858 // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
859 } else if (value.prototype) value.prototype = undefined;
860 } catch (error) { /* empty */ }
861 var state = enforceInternalState(value);
862 if (!hasOwn$2(state, 'source')) {
863 state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
864 } return value;
865 };
866
867 // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
868 // eslint-disable-next-line no-extend-native -- required
869 Function.prototype.toString = makeBuiltIn$1(function toString() {
870 return isCallable$4(this) && getInternalState(this).source || inspectSource$1(this);
871 }, 'toString');
872
873 var isCallable$3 = isCallable$c;
874 var definePropertyModule$2 = objectDefineProperty;
875 var makeBuiltIn = makeBuiltInExports;
876 var defineGlobalProperty$1 = defineGlobalProperty$3;
877
878 var defineBuiltIn$2 = function (O, key, value, options) {
879 if (!options) options = {};
880 var simple = options.enumerable;
881 var name = options.name !== undefined ? options.name : key;
882 if (isCallable$3(value)) makeBuiltIn(value, name, options);
883 if (options.global) {
884 if (simple) O[key] = value;
885 else defineGlobalProperty$1(key, value);
886 } else {
887 try {
888 if (!options.unsafe) delete O[key];
889 else if (O[key]) simple = true;
890 } catch (error) { /* empty */ }
891 if (simple) O[key] = value;
892 else definePropertyModule$2.f(O, key, {
893 value: value,
894 enumerable: false,
895 configurable: !options.nonConfigurable,
896 writable: !options.nonWritable
897 });
898 } return O;
899 };
900
901 var objectGetOwnPropertyNames = {};
902
903 var ceil = Math.ceil;
904 var floor = Math.floor;
905
906 // `Math.trunc` method
907 // https://tc39.es/ecma262/#sec-math.trunc
908 // eslint-disable-next-line es/no-math-trunc -- safe
909 var mathTrunc = Math.trunc || function trunc(x) {
910 var n = +x;
911 return (n > 0 ? floor : ceil)(n);
912 };
913
914 var trunc = mathTrunc;
915
916 // `ToIntegerOrInfinity` abstract operation
917 // https://tc39.es/ecma262/#sec-tointegerorinfinity
918 var toIntegerOrInfinity$2 = function (argument) {
919 var number = +argument;
920 // eslint-disable-next-line no-self-compare -- NaN check
921 return number !== number || number === 0 ? 0 : trunc(number);
922 };
923
924 var toIntegerOrInfinity$1 = toIntegerOrInfinity$2;
925
926 var max = Math.max;
927 var min$1 = Math.min;
928
929 // Helper for a popular repeating case of the spec:
930 // Let integer be ? ToInteger(index).
931 // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
932 var toAbsoluteIndex$1 = function (index, length) {
933 var integer = toIntegerOrInfinity$1(index);
934 return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
935 };
936
937 var toIntegerOrInfinity = toIntegerOrInfinity$2;
938
939 var min = Math.min;
940
941 // `ToLength` abstract operation
942 // https://tc39.es/ecma262/#sec-tolength
943 var toLength$1 = function (argument) {
944 return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
945 };
946
947 var toLength = toLength$1;
948
949 // `LengthOfArrayLike` abstract operation
950 // https://tc39.es/ecma262/#sec-lengthofarraylike
951 var lengthOfArrayLike$2 = function (obj) {
952 return toLength(obj.length);
953 };
954
955 var toIndexedObject$2 = toIndexedObject$4;
956 var toAbsoluteIndex = toAbsoluteIndex$1;
957 var lengthOfArrayLike$1 = lengthOfArrayLike$2;
958
959 // `Array.prototype.{ indexOf, includes }` methods implementation
960 var createMethod$1 = function (IS_INCLUDES) {
961 return function ($this, el, fromIndex) {
962 var O = toIndexedObject$2($this);
963 var length = lengthOfArrayLike$1(O);
964 var index = toAbsoluteIndex(fromIndex, length);
965 var value;
966 // Array#includes uses SameValueZero equality algorithm
967 // eslint-disable-next-line no-self-compare -- NaN check
968 if (IS_INCLUDES && el != el) while (length > index) {
969 value = O[index++];
970 // eslint-disable-next-line no-self-compare -- NaN check
971 if (value != value) return true;
972 // Array#indexOf ignores holes, Array#includes - not
973 } else for (;length > index; index++) {
974 if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
975 } return !IS_INCLUDES && -1;
976 };
977 };
978
979 var arrayIncludes = {
980 // `Array.prototype.includes` method
981 // https://tc39.es/ecma262/#sec-array.prototype.includes
982 includes: createMethod$1(true),
983 // `Array.prototype.indexOf` method
984 // https://tc39.es/ecma262/#sec-array.prototype.indexof
985 indexOf: createMethod$1(false)
986 };
987
988 var uncurryThis$6 = functionUncurryThis;
989 var hasOwn$1 = hasOwnProperty_1;
990 var toIndexedObject$1 = toIndexedObject$4;
991 var indexOf = arrayIncludes.indexOf;
992 var hiddenKeys$2 = hiddenKeys$4;
993
994 var push$1 = uncurryThis$6([].push);
995
996 var objectKeysInternal = function (object, names) {
997 var O = toIndexedObject$1(object);
998 var i = 0;
999 var result = [];
1000 var key;
1001 for (key in O) !hasOwn$1(hiddenKeys$2, key) && hasOwn$1(O, key) && push$1(result, key);
1002 // Don't enum bug & hidden keys
1003 while (names.length > i) if (hasOwn$1(O, key = names[i++])) {
1004 ~indexOf(result, key) || push$1(result, key);
1005 }
1006 return result;
1007 };
1008
1009 // IE8- don't enum bug keys
1010 var enumBugKeys$3 = [
1011 'constructor',
1012 'hasOwnProperty',
1013 'isPrototypeOf',
1014 'propertyIsEnumerable',
1015 'toLocaleString',
1016 'toString',
1017 'valueOf'
1018 ];
1019
1020 var internalObjectKeys$1 = objectKeysInternal;
1021 var enumBugKeys$2 = enumBugKeys$3;
1022
1023 var hiddenKeys$1 = enumBugKeys$2.concat('length', 'prototype');
1024
1025 // `Object.getOwnPropertyNames` method
1026 // https://tc39.es/ecma262/#sec-object.getownpropertynames
1027 // eslint-disable-next-line es/no-object-getownpropertynames -- safe
1028 objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
1029 return internalObjectKeys$1(O, hiddenKeys$1);
1030 };
1031
1032 var objectGetOwnPropertySymbols = {};
1033
1034 // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
1035 objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
1036
1037 var getBuiltIn$2 = getBuiltIn$4;
1038 var uncurryThis$5 = functionUncurryThis;
1039 var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
1040 var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
1041 var anObject$2 = anObject$4;
1042
1043 var concat = uncurryThis$5([].concat);
1044
1045 // all object keys, includes non-enumerable and symbols
1046 var ownKeys$1 = getBuiltIn$2('Reflect', 'ownKeys') || function ownKeys(it) {
1047 var keys = getOwnPropertyNamesModule.f(anObject$2(it));
1048 var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1049 return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
1050 };
1051
1052 var hasOwn = hasOwnProperty_1;
1053 var ownKeys = ownKeys$1;
1054 var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
1055 var definePropertyModule$1 = objectDefineProperty;
1056
1057 var copyConstructorProperties$1 = function (target, source, exceptions) {
1058 var keys = ownKeys(source);
1059 var defineProperty = definePropertyModule$1.f;
1060 var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
1061 for (var i = 0; i < keys.length; i++) {
1062 var key = keys[i];
1063 if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
1064 defineProperty(target, key, getOwnPropertyDescriptor(source, key));
1065 }
1066 }
1067 };
1068
1069 var fails$2 = fails$a;
1070 var isCallable$2 = isCallable$c;
1071
1072 var replacement = /#|\.prototype\./;
1073
1074 var isForced$1 = function (feature, detection) {
1075 var value = data[normalize(feature)];
1076 return value == POLYFILL ? true
1077 : value == NATIVE ? false
1078 : isCallable$2(detection) ? fails$2(detection)
1079 : !!detection;
1080 };
1081
1082 var normalize = isForced$1.normalize = function (string) {
1083 return String(string).replace(replacement, '.').toLowerCase();
1084 };
1085
1086 var data = isForced$1.data = {};
1087 var NATIVE = isForced$1.NATIVE = 'N';
1088 var POLYFILL = isForced$1.POLYFILL = 'P';
1089
1090 var isForced_1 = isForced$1;
1091
1092 var global$1 = global$a;
1093 var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
1094 var createNonEnumerableProperty = createNonEnumerableProperty$2;
1095 var defineBuiltIn$1 = defineBuiltIn$2;
1096 var defineGlobalProperty = defineGlobalProperty$3;
1097 var copyConstructorProperties = copyConstructorProperties$1;
1098 var isForced = isForced_1;
1099
1100 /*
1101 options.target - name of the target object
1102 options.global - target is the global object
1103 options.stat - export as static methods of target
1104 options.proto - export as prototype methods of target
1105 options.real - real prototype method for the `pure` version
1106 options.forced - export even if the native feature is available
1107 options.bind - bind methods to the target, required for the `pure` version
1108 options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
1109 options.unsafe - use the simple assignment of property instead of delete + defineProperty
1110 options.sham - add a flag to not completely full polyfills
1111 options.enumerable - export as enumerable property
1112 options.dontCallGetSet - prevent calling a getter on target
1113 options.name - the .name of the function if it does not match the key
1114 */
1115 var _export = function (options, source) {
1116 var TARGET = options.target;
1117 var GLOBAL = options.global;
1118 var STATIC = options.stat;
1119 var FORCED, target, key, targetProperty, sourceProperty, descriptor;
1120 if (GLOBAL) {
1121 target = global$1;
1122 } else if (STATIC) {
1123 target = global$1[TARGET] || defineGlobalProperty(TARGET, {});
1124 } else {
1125 target = (global$1[TARGET] || {}).prototype;
1126 }
1127 if (target) for (key in source) {
1128 sourceProperty = source[key];
1129 if (options.dontCallGetSet) {
1130 descriptor = getOwnPropertyDescriptor(target, key);
1131 targetProperty = descriptor && descriptor.value;
1132 } else targetProperty = target[key];
1133 FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
1134 // contained in target
1135 if (!FORCED && targetProperty !== undefined) {
1136 if (typeof sourceProperty == typeof targetProperty) continue;
1137 copyConstructorProperties(sourceProperty, targetProperty);
1138 }
1139 // add a flag to not completely full polyfills
1140 if (options.sham || (targetProperty && targetProperty.sham)) {
1141 createNonEnumerableProperty(sourceProperty, 'sham', true);
1142 }
1143 defineBuiltIn$1(target, key, sourceProperty, options);
1144 }
1145 };
1146
1147 var classofRaw$1 = classofRaw$2;
1148 var uncurryThis$4 = functionUncurryThis;
1149
1150 var functionUncurryThisClause = function (fn) {
1151 // Nashorn bug:
1152 // https://github.com/zloirock/core-js/issues/1128
1153 // https://github.com/zloirock/core-js/issues/1130
1154 if (classofRaw$1(fn) === 'Function') return uncurryThis$4(fn);
1155 };
1156
1157 var uncurryThis$3 = functionUncurryThisClause;
1158 var aCallable = aCallable$2;
1159 var NATIVE_BIND = functionBindNative;
1160
1161 var bind$1 = uncurryThis$3(uncurryThis$3.bind);
1162
1163 // optional / simple context binding
1164 var functionBindContext = function (fn, that) {
1165 aCallable(fn);
1166 return that === undefined ? fn : NATIVE_BIND ? bind$1(fn, that) : function (/* ...args */) {
1167 return fn.apply(that, arguments);
1168 };
1169 };
1170
1171 var classof$5 = classofRaw$2;
1172
1173 // `IsArray` abstract operation
1174 // https://tc39.es/ecma262/#sec-isarray
1175 // eslint-disable-next-line es/no-array-isarray -- safe
1176 var isArray$1 = Array.isArray || function isArray(argument) {
1177 return classof$5(argument) == 'Array';
1178 };
1179
1180 var wellKnownSymbol$5 = wellKnownSymbol$7;
1181
1182 var TO_STRING_TAG$1 = wellKnownSymbol$5('toStringTag');
1183 var test = {};
1184
1185 test[TO_STRING_TAG$1] = 'z';
1186
1187 var toStringTagSupport = String(test) === '[object z]';
1188
1189 var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport;
1190 var isCallable$1 = isCallable$c;
1191 var classofRaw = classofRaw$2;
1192 var wellKnownSymbol$4 = wellKnownSymbol$7;
1193
1194 var TO_STRING_TAG = wellKnownSymbol$4('toStringTag');
1195 var $Object = Object;
1196
1197 // ES3 wrong here
1198 var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
1199
1200 // fallback for IE11 Script Access Denied error
1201 var tryGet = function (it, key) {
1202 try {
1203 return it[key];
1204 } catch (error) { /* empty */ }
1205 };
1206
1207 // getting tag from ES6+ `Object.prototype.toString`
1208 var classof$4 = TO_STRING_TAG_SUPPORT$2 ? classofRaw : function (it) {
1209 var O, tag, result;
1210 return it === undefined ? 'Undefined' : it === null ? 'Null'
1211 // @@toStringTag case
1212 : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
1213 // builtinTag case
1214 : CORRECT_ARGUMENTS ? classofRaw(O)
1215 // ES3 arguments fallback
1216 : (result = classofRaw(O)) == 'Object' && isCallable$1(O.callee) ? 'Arguments' : result;
1217 };
1218
1219 var uncurryThis$2 = functionUncurryThis;
1220 var fails$1 = fails$a;
1221 var isCallable = isCallable$c;
1222 var classof$3 = classof$4;
1223 var getBuiltIn$1 = getBuiltIn$4;
1224 var inspectSource = inspectSource$2;
1225
1226 var noop = function () { /* empty */ };
1227 var empty = [];
1228 var construct = getBuiltIn$1('Reflect', 'construct');
1229 var constructorRegExp = /^\s*(?:class|function)\b/;
1230 var exec = uncurryThis$2(constructorRegExp.exec);
1231 var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
1232
1233 var isConstructorModern = function isConstructor(argument) {
1234 if (!isCallable(argument)) return false;
1235 try {
1236 construct(noop, empty, argument);
1237 return true;
1238 } catch (error) {
1239 return false;
1240 }
1241 };
1242
1243 var isConstructorLegacy = function isConstructor(argument) {
1244 if (!isCallable(argument)) return false;
1245 switch (classof$3(argument)) {
1246 case 'AsyncFunction':
1247 case 'GeneratorFunction':
1248 case 'AsyncGeneratorFunction': return false;
1249 }
1250 try {
1251 // we can't check .prototype since constructors produced by .bind haven't it
1252 // `Function#toString` throws on some built-it function in some legacy engines
1253 // (for example, `DOMQuad` and similar in FF41-)
1254 return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
1255 } catch (error) {
1256 return true;
1257 }
1258 };
1259
1260 isConstructorLegacy.sham = true;
1261
1262 // `IsConstructor` abstract operation
1263 // https://tc39.es/ecma262/#sec-isconstructor
1264 var isConstructor$1 = !construct || fails$1(function () {
1265 var called;
1266 return isConstructorModern(isConstructorModern.call)
1267 || !isConstructorModern(Object)
1268 || !isConstructorModern(function () { called = true; })
1269 || called;
1270 }) ? isConstructorLegacy : isConstructorModern;
1271
1272 var isArray = isArray$1;
1273 var isConstructor = isConstructor$1;
1274 var isObject$1 = isObject$7;
1275 var wellKnownSymbol$3 = wellKnownSymbol$7;
1276
1277 var SPECIES = wellKnownSymbol$3('species');
1278 var $Array = Array;
1279
1280 // a part of `ArraySpeciesCreate` abstract operation
1281 // https://tc39.es/ecma262/#sec-arrayspeciescreate
1282 var arraySpeciesConstructor$1 = function (originalArray) {
1283 var C;
1284 if (isArray(originalArray)) {
1285 C = originalArray.constructor;
1286 // cross-realm fallback
1287 if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;
1288 else if (isObject$1(C)) {
1289 C = C[SPECIES];
1290 if (C === null) C = undefined;
1291 }
1292 } return C === undefined ? $Array : C;
1293 };
1294
1295 var arraySpeciesConstructor = arraySpeciesConstructor$1;
1296
1297 // `ArraySpeciesCreate` abstract operation
1298 // https://tc39.es/ecma262/#sec-arrayspeciescreate
1299 var arraySpeciesCreate$1 = function (originalArray, length) {
1300 return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
1301 };
1302
1303 var bind = functionBindContext;
1304 var uncurryThis$1 = functionUncurryThis;
1305 var IndexedObject = indexedObject;
1306 var toObject = toObject$2;
1307 var lengthOfArrayLike = lengthOfArrayLike$2;
1308 var arraySpeciesCreate = arraySpeciesCreate$1;
1309
1310 var push = uncurryThis$1([].push);
1311
1312 // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
1313 var createMethod = function (TYPE) {
1314 var IS_MAP = TYPE == 1;
1315 var IS_FILTER = TYPE == 2;
1316 var IS_SOME = TYPE == 3;
1317 var IS_EVERY = TYPE == 4;
1318 var IS_FIND_INDEX = TYPE == 6;
1319 var IS_FILTER_REJECT = TYPE == 7;
1320 var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
1321 return function ($this, callbackfn, that, specificCreate) {
1322 var O = toObject($this);
1323 var self = IndexedObject(O);
1324 var boundFunction = bind(callbackfn, that);
1325 var length = lengthOfArrayLike(self);
1326 var index = 0;
1327 var create = specificCreate || arraySpeciesCreate;
1328 var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
1329 var value, result;
1330 for (;length > index; index++) if (NO_HOLES || index in self) {
1331 value = self[index];
1332 result = boundFunction(value, index, O);
1333 if (TYPE) {
1334 if (IS_MAP) target[index] = result; // map
1335 else if (result) switch (TYPE) {
1336 case 3: return true; // some
1337 case 5: return value; // find
1338 case 6: return index; // findIndex
1339 case 2: push(target, value); // filter
1340 } else switch (TYPE) {
1341 case 4: return false; // every
1342 case 7: push(target, value); // filterReject
1343 }
1344 }
1345 }
1346 return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
1347 };
1348 };
1349
1350 var arrayIteration = {
1351 // `Array.prototype.forEach` method
1352 // https://tc39.es/ecma262/#sec-array.prototype.foreach
1353 forEach: createMethod(0),
1354 // `Array.prototype.map` method
1355 // https://tc39.es/ecma262/#sec-array.prototype.map
1356 map: createMethod(1),
1357 // `Array.prototype.filter` method
1358 // https://tc39.es/ecma262/#sec-array.prototype.filter
1359 filter: createMethod(2),
1360 // `Array.prototype.some` method
1361 // https://tc39.es/ecma262/#sec-array.prototype.some
1362 some: createMethod(3),
1363 // `Array.prototype.every` method
1364 // https://tc39.es/ecma262/#sec-array.prototype.every
1365 every: createMethod(4),
1366 // `Array.prototype.find` method
1367 // https://tc39.es/ecma262/#sec-array.prototype.find
1368 find: createMethod(5),
1369 // `Array.prototype.findIndex` method
1370 // https://tc39.es/ecma262/#sec-array.prototype.findIndex
1371 findIndex: createMethod(6),
1372 // `Array.prototype.filterReject` method
1373 // https://github.com/tc39/proposal-array-filtering
1374 filterReject: createMethod(7)
1375 };
1376
1377 var objectDefineProperties = {};
1378
1379 var internalObjectKeys = objectKeysInternal;
1380 var enumBugKeys$1 = enumBugKeys$3;
1381
1382 // `Object.keys` method
1383 // https://tc39.es/ecma262/#sec-object.keys
1384 // eslint-disable-next-line es/no-object-keys -- safe
1385 var objectKeys$1 = Object.keys || function keys(O) {
1386 return internalObjectKeys(O, enumBugKeys$1);
1387 };
1388
1389 var DESCRIPTORS = descriptors;
1390 var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
1391 var definePropertyModule = objectDefineProperty;
1392 var anObject$1 = anObject$4;
1393 var toIndexedObject = toIndexedObject$4;
1394 var objectKeys = objectKeys$1;
1395
1396 // `Object.defineProperties` method
1397 // https://tc39.es/ecma262/#sec-object.defineproperties
1398 // eslint-disable-next-line es/no-object-defineproperties -- safe
1399 objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
1400 anObject$1(O);
1401 var props = toIndexedObject(Properties);
1402 var keys = objectKeys(Properties);
1403 var length = keys.length;
1404 var index = 0;
1405 var key;
1406 while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
1407 return O;
1408 };
1409
1410 var getBuiltIn = getBuiltIn$4;
1411
1412 var html$1 = getBuiltIn('document', 'documentElement');
1413
1414 /* global ActiveXObject -- old IE, WSH */
1415
1416 var anObject = anObject$4;
1417 var definePropertiesModule = objectDefineProperties;
1418 var enumBugKeys = enumBugKeys$3;
1419 var hiddenKeys = hiddenKeys$4;
1420 var html = html$1;
1421 var documentCreateElement = documentCreateElement$1;
1422 var sharedKey = sharedKey$2;
1423
1424 var GT = '>';
1425 var LT = '<';
1426 var PROTOTYPE = 'prototype';
1427 var SCRIPT = 'script';
1428 var IE_PROTO = sharedKey('IE_PROTO');
1429
1430 var EmptyConstructor = function () { /* empty */ };
1431
1432 var scriptTag = function (content) {
1433 return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
1434 };
1435
1436 // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
1437 var NullProtoObjectViaActiveX = function (activeXDocument) {
1438 activeXDocument.write(scriptTag(''));
1439 activeXDocument.close();
1440 var temp = activeXDocument.parentWindow.Object;
1441 activeXDocument = null; // avoid memory leak
1442 return temp;
1443 };
1444
1445 // Create object with fake `null` prototype: use iframe Object with cleared prototype
1446 var NullProtoObjectViaIFrame = function () {
1447 // Thrash, waste and sodomy: IE GC bug
1448 var iframe = documentCreateElement('iframe');
1449 var JS = 'java' + SCRIPT + ':';
1450 var iframeDocument;
1451 iframe.style.display = 'none';
1452 html.appendChild(iframe);
1453 // https://github.com/zloirock/core-js/issues/475
1454 iframe.src = String(JS);
1455 iframeDocument = iframe.contentWindow.document;
1456 iframeDocument.open();
1457 iframeDocument.write(scriptTag('document.F=Object'));
1458 iframeDocument.close();
1459 return iframeDocument.F;
1460 };
1461
1462 // Check for document.domain and active x support
1463 // No need to use active x approach when document.domain is not set
1464 // see https://github.com/es-shims/es5-shim/issues/150
1465 // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
1466 // avoid IE GC bug
1467 var activeXDocument;
1468 var NullProtoObject = function () {
1469 try {
1470 activeXDocument = new ActiveXObject('htmlfile');
1471 } catch (error) { /* ignore */ }
1472 NullProtoObject = typeof document != 'undefined'
1473 ? document.domain && activeXDocument
1474 ? NullProtoObjectViaActiveX(activeXDocument) // old IE
1475 : NullProtoObjectViaIFrame()
1476 : NullProtoObjectViaActiveX(activeXDocument); // WSH
1477 var length = enumBugKeys.length;
1478 while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
1479 return NullProtoObject();
1480 };
1481
1482 hiddenKeys[IE_PROTO] = true;
1483
1484 // `Object.create` method
1485 // https://tc39.es/ecma262/#sec-object.create
1486 // eslint-disable-next-line es/no-object-create -- safe
1487 var objectCreate = Object.create || function create(O, Properties) {
1488 var result;
1489 if (O !== null) {
1490 EmptyConstructor[PROTOTYPE] = anObject(O);
1491 result = new EmptyConstructor();
1492 EmptyConstructor[PROTOTYPE] = null;
1493 // add "__proto__" for Object.getPrototypeOf polyfill
1494 result[IE_PROTO] = O;
1495 } else result = NullProtoObject();
1496 return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
1497 };
1498
1499 var wellKnownSymbol$2 = wellKnownSymbol$7;
1500 var create = objectCreate;
1501 var defineProperty = objectDefineProperty.f;
1502
1503 var UNSCOPABLES = wellKnownSymbol$2('unscopables');
1504 var ArrayPrototype = Array.prototype;
1505
1506 // Array.prototype[@@unscopables]
1507 // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1508 if (ArrayPrototype[UNSCOPABLES] == undefined) {
1509 defineProperty(ArrayPrototype, UNSCOPABLES, {
1510 configurable: true,
1511 value: create(null)
1512 });
1513 }
1514
1515 // add a key to Array.prototype[@@unscopables]
1516 var addToUnscopables$2 = function (key) {
1517 ArrayPrototype[UNSCOPABLES][key] = true;
1518 };
1519
1520 var $$2 = _export;
1521 var $find = arrayIteration.find;
1522 var addToUnscopables$1 = addToUnscopables$2;
1523
1524 var FIND = 'find';
1525 var SKIPS_HOLES = true;
1526
1527 // Shouldn't skip holes
1528 if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });
1529
1530 // `Array.prototype.find` method
1531 // https://tc39.es/ecma262/#sec-array.prototype.find
1532 $$2({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
1533 find: function find(callbackfn /* , that = undefined */) {
1534 return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
1535 }
1536 });
1537
1538 // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1539 addToUnscopables$1(FIND);
1540
1541 var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport;
1542 var classof$2 = classof$4;
1543
1544 // `Object.prototype.toString` method implementation
1545 // https://tc39.es/ecma262/#sec-object.prototype.tostring
1546 var objectToString = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() {
1547 return '[object ' + classof$2(this) + ']';
1548 };
1549
1550 var TO_STRING_TAG_SUPPORT = toStringTagSupport;
1551 var defineBuiltIn = defineBuiltIn$2;
1552 var toString$2 = objectToString;
1553
1554 // `Object.prototype.toString` method
1555 // https://tc39.es/ecma262/#sec-object.prototype.tostring
1556 if (!TO_STRING_TAG_SUPPORT) {
1557 defineBuiltIn(Object.prototype, 'toString', toString$2, { unsafe: true });
1558 }
1559
1560 var $$1 = _export;
1561 var $includes = arrayIncludes.includes;
1562 var fails = fails$a;
1563 var addToUnscopables = addToUnscopables$2;
1564
1565 // FF99+ bug
1566 var BROKEN_ON_SPARSE = fails(function () {
1567 // eslint-disable-next-line es/no-array-prototype-includes -- detection
1568 return !Array(1).includes();
1569 });
1570
1571 // `Array.prototype.includes` method
1572 // https://tc39.es/ecma262/#sec-array.prototype.includes
1573 $$1({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
1574 includes: function includes(el /* , fromIndex = 0 */) {
1575 return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
1576 }
1577 });
1578
1579 // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1580 addToUnscopables('includes');
1581
1582 var isObject = isObject$7;
1583 var classof$1 = classofRaw$2;
1584 var wellKnownSymbol$1 = wellKnownSymbol$7;
1585
1586 var MATCH$1 = wellKnownSymbol$1('match');
1587
1588 // `IsRegExp` abstract operation
1589 // https://tc39.es/ecma262/#sec-isregexp
1590 var isRegexp = function (it) {
1591 var isRegExp;
1592 return isObject(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$1(it) == 'RegExp');
1593 };
1594
1595 var isRegExp = isRegexp;
1596
1597 var $TypeError = TypeError;
1598
1599 var notARegexp = function (it) {
1600 if (isRegExp(it)) {
1601 throw $TypeError("The method doesn't accept regular expressions");
1602 } return it;
1603 };
1604
1605 var classof = classof$4;
1606
1607 var $String = String;
1608
1609 var toString$1 = function (argument) {
1610 if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
1611 return $String(argument);
1612 };
1613
1614 var wellKnownSymbol = wellKnownSymbol$7;
1615
1616 var MATCH = wellKnownSymbol('match');
1617
1618 var correctIsRegexpLogic = function (METHOD_NAME) {
1619 var regexp = /./;
1620 try {
1621 '/./'[METHOD_NAME](regexp);
1622 } catch (error1) {
1623 try {
1624 regexp[MATCH] = false;
1625 return '/./'[METHOD_NAME](regexp);
1626 } catch (error2) { /* empty */ }
1627 } return false;
1628 };
1629
1630 var $ = _export;
1631 var uncurryThis = functionUncurryThis;
1632 var notARegExp = notARegexp;
1633 var requireObjectCoercible = requireObjectCoercible$3;
1634 var toString = toString$1;
1635 var correctIsRegExpLogic = correctIsRegexpLogic;
1636
1637 var stringIndexOf = uncurryThis(''.indexOf);
1638
1639 // `String.prototype.includes` method
1640 // https://tc39.es/ecma262/#sec-string.prototype.includes
1641 $({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {
1642 includes: function includes(searchString /* , position = 0 */) {
1643 return !!~stringIndexOf(
1644 toString(requireObjectCoercible(this)),
1645 toString(notARegExp(searchString)),
1646 arguments.length > 1 ? arguments[1] : undefined
1647 );
1648 }
1649 });
1650
1651 /**
1652 * @author zhixin wen <wenzhixin2010@gmail.com>
1653 * https://github.com/wenzhixin/bootstrap-table/
1654 * theme: https://github.com/zurb/foundation-sites
1655 */
1656
1657 var Utils = $$3.fn.bootstrapTable.utils;
1658 Utils.extend($$3.fn.bootstrapTable.defaults, {
1659 classes: 'table hover',
1660 buttonsPrefix: '',
1661 buttonsClass: 'button'
1662 });
1663 $$3.fn.bootstrapTable.theme = 'foundation';
1664 $$3.BootstrapTable = /*#__PURE__*/function (_$$BootstrapTable) {
1665 _inherits(_class, _$$BootstrapTable);
1666 var _super = _createSuper(_class);
1667 function _class() {
1668 _classCallCheck(this, _class);
1669 return _super.apply(this, arguments);
1670 }
1671 _createClass(_class, [{
1672 key: "initConstants",
1673 value: function initConstants() {
1674 _get(_getPrototypeOf(_class.prototype), "initConstants", this).call(this);
1675 this.constants.classes.buttonsGroup = 'button-group';
1676 this.constants.classes.buttonsDropdown = 'dropdown-container';
1677 this.constants.classes.paginationDropdown = '';
1678 this.constants.classes.dropdownActive = 'is-active';
1679 this.constants.classes.paginationActive = 'current';
1680 this.constants.classes.buttonActive = 'success';
1681 this.constants.html.toolbarDropdown = ['<div class="dropdown-pane" data-dropdown><ul class="vertical menu">', '</ul></div>'];
1682 this.constants.html.toolbarDropdownItem = '<li class="dropdown-item-marker"><label class="dropdown-item">%s</label></li>';
1683 this.constants.html.toolbarDropdownSeparator = '<li><hr></li>';
1684 this.constants.html.pageDropdown = ['<div class="dropdown-pane" id="pagination-list-id" data-dropdown><ul class="vertical menu">', '</ul></div>'];
1685 this.constants.html.pageDropdownItem = '<li class="dropdown-item %s"><a href="#">%s</a></li>';
1686 this.constants.html.dropdownCaret = '<i class="fa fa-angle-down"></i>';
1687 this.constants.html.pagination = ['<ul class="pagination%s">', '</ul>'];
1688 this.constants.html.paginationItem = '<li><a class="page-item%s" aria-label="%s" href="#">%s</a></li>';
1689 this.constants.html.inputGroup = '<div class="input-group">%s <div class="input-group-button">%s</div></div>';
1690 this.constants.html.searchInput = '<input class="%s input-%s input-group-field" type="search" placeholder="%s">';
1691 }
1692 }, {
1693 key: "initToolbar",
1694 value: function initToolbar() {
1695 _get(_getPrototypeOf(_class.prototype), "initToolbar", this).call(this);
1696 this.handleToolbar();
1697 }
1698 }, {
1699 key: "handleToolbar",
1700 value: function handleToolbar() {
1701 if (this.$toolbar.find('.dropdown-toggle').length) {
1702 this.$toolbar.find('.dropdown-toggle').each(function (i, el) {
1703 if (!$$3(el).next().length) {
1704 return;
1705 }
1706 var id = "toolbar-columns-id".concat(i);
1707 $$3(el).next().attr('id', id);
1708 $$3(el).attr('data-toggle', id);
1709 var $pane = $$3(el).next().attr('data-position', 'bottom').attr('data-alignment', 'right');
1710 new window.Foundation.Dropdown($pane);
1711 });
1712 this._initDropdown();
1713 }
1714 }
1715 }, {
1716 key: "initPagination",
1717 value: function initPagination() {
1718 _get(_getPrototypeOf(_class.prototype), "initPagination", this).call(this);
1719 if (this.options.pagination && this.paginationParts.includes('pageSize')) {
1720 var $el = this.$pagination.find('.dropdown-toggle');
1721 $el.attr('data-toggle', $el.next().attr('id'));
1722 var $pane = this.$pagination.find('.dropdown-pane').attr('data-position', 'top').attr('data-alignment', 'left');
1723 new window.Foundation.Dropdown($pane);
1724 this._initDropdown();
1725 }
1726 }
1727 }, {
1728 key: "_initDropdown",
1729 value: function _initDropdown() {
1730 var $dropdowns = this.$container.find('.dropdown-toggle');
1731 $dropdowns.off('click').on('click', function (e) {
1732 var $this = $$3(e.currentTarget);
1733 e.stopPropagation();
1734 $this.next().foundation('toggle');
1735 if ($dropdowns.not($this).length) {
1736 $dropdowns.not($this).next().foundation('close');
1737 }
1738 });
1739 $$3(document).off('click.bs.dropdown.foundation').on('click.bs.dropdown.foundation', function () {
1740 $dropdowns.next().foundation('close');
1741 });
1742 }
1743 }]);
1744 return _class;
1745 }($$3.BootstrapTable);
1746
1747}));