https://epsmasdash-ms8uwkec.manus.space/assets/index.es-BhP0CCLt.js

1import { b2 as commonjsGlobal, aZ as getDefaultExportFromCjs } from './index-CNT5CkK7.js';
2import { _ as _typeof$1 } from './jspdf.es.min-CWHF2JOV.js';
3
4var es_promise = {};
5
6var es_promise_constructor = {};
7
8var globalThis_1;
9var hasRequiredGlobalThis;
10
11function requireGlobalThis () {
12	if (hasRequiredGlobalThis) return globalThis_1;
13	hasRequiredGlobalThis = 1;
14	var check = function (it) {
15	  return it && it.Math === Math && it;
16	};
17
18	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
19	globalThis_1 =
20	  // eslint-disable-next-line es/no-global-this -- safe
21	  check(typeof globalThis == 'object' && globalThis) ||
22	  check(typeof window == 'object' && window) ||
23	  // eslint-disable-next-line no-restricted-globals -- safe
24	  check(typeof self == 'object' && self) ||
25	  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
26	  check(typeof globalThis_1 == 'object' && globalThis_1) ||
27	  // eslint-disable-next-line no-new-func -- fallback
28	  (function () { return this; })() || Function('return this')();
29	return globalThis_1;
30}
31
32var objectGetOwnPropertyDescriptor = {};
33
34var fails;
35var hasRequiredFails;
36
37function requireFails () {
38	if (hasRequiredFails) return fails;
39	hasRequiredFails = 1;
40	fails = function (exec) {
41	  try {
42	    return !!exec();
43	  } catch (error) {
44	    return true;
45	  }
46	};
47	return fails;
48}
49
50var descriptors;
51var hasRequiredDescriptors;
52
53function requireDescriptors () {
54	if (hasRequiredDescriptors) return descriptors;
55	hasRequiredDescriptors = 1;
56	var fails = requireFails();
57
58	// Detect IE8's incomplete defineProperty implementation
59	descriptors = !fails(function () {
60	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
61	  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
62	});
63	return descriptors;
64}
65
66var functionBindNative;
67var hasRequiredFunctionBindNative;
68
69function requireFunctionBindNative () {
70	if (hasRequiredFunctionBindNative) return functionBindNative;
71	hasRequiredFunctionBindNative = 1;
72	var fails = requireFails();
73
74	functionBindNative = !fails(function () {
75	  // eslint-disable-next-line es/no-function-prototype-bind -- safe
76	  var test = function () { /* empty */ }.bind();
77	  // eslint-disable-next-line no-prototype-builtins -- safe
78	  return typeof test != 'function' || test.hasOwnProperty('prototype');
79	});
80	return functionBindNative;
81}
82
83var functionCall;
84var hasRequiredFunctionCall;
85
86function requireFunctionCall () {
87	if (hasRequiredFunctionCall) return functionCall;
88	hasRequiredFunctionCall = 1;
89	var NATIVE_BIND = requireFunctionBindNative();
90
91	var call = Function.prototype.call;
92	// eslint-disable-next-line es/no-function-prototype-bind -- safe
93	functionCall = NATIVE_BIND ? call.bind(call) : function () {
94	  return call.apply(call, arguments);
95	};
96	return functionCall;
97}
98
99var objectPropertyIsEnumerable = {};
100
101var hasRequiredObjectPropertyIsEnumerable;
102
103function requireObjectPropertyIsEnumerable () {
104	if (hasRequiredObjectPropertyIsEnumerable) return objectPropertyIsEnumerable;
105	hasRequiredObjectPropertyIsEnumerable = 1;
106	var $propertyIsEnumerable = {}.propertyIsEnumerable;
107	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
108	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
109
110	// Nashorn ~ JDK8 bug
111	var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
112
113	// `Object.prototype.propertyIsEnumerable` method implementation
114	// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
115	objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
116	  var descriptor = getOwnPropertyDescriptor(this, V);
117	  return !!descriptor && descriptor.enumerable;
118	} : $propertyIsEnumerable;
119	return objectPropertyIsEnumerable;
120}
121
122var createPropertyDescriptor;
123var hasRequiredCreatePropertyDescriptor;
124
125function requireCreatePropertyDescriptor () {
126	if (hasRequiredCreatePropertyDescriptor) return createPropertyDescriptor;
127	hasRequiredCreatePropertyDescriptor = 1;
128	createPropertyDescriptor = function (bitmap, value) {
129	  return {
130	    enumerable: !(bitmap & 1),
131	    configurable: !(bitmap & 2),
132	    writable: !(bitmap & 4),
133	    value: value
134	  };
135	};
136	return createPropertyDescriptor;
137}
138
139var functionUncurryThis;
140var hasRequiredFunctionUncurryThis;
141
142function requireFunctionUncurryThis () {
143	if (hasRequiredFunctionUncurryThis) return functionUncurryThis;
144	hasRequiredFunctionUncurryThis = 1;
145	var NATIVE_BIND = requireFunctionBindNative();
146
147	var FunctionPrototype = Function.prototype;
148	var call = FunctionPrototype.call;
149	// eslint-disable-next-line es/no-function-prototype-bind -- safe
150	var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
151
152	functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
153	  return function () {
154	    return call.apply(fn, arguments);
155	  };
156	};
157	return functionUncurryThis;
158}
159
160var classofRaw;
161var hasRequiredClassofRaw;
162
163function requireClassofRaw () {
164	if (hasRequiredClassofRaw) return classofRaw;
165	hasRequiredClassofRaw = 1;
166	var uncurryThis = requireFunctionUncurryThis();
167
168	var toString = uncurryThis({}.toString);
169	var stringSlice = uncurryThis(''.slice);
170
171	classofRaw = function (it) {
172	  return stringSlice(toString(it), 8, -1);
173	};
174	return classofRaw;
175}
176
177var indexedObject;
178var hasRequiredIndexedObject;
179
180function requireIndexedObject () {
181	if (hasRequiredIndexedObject) return indexedObject;
182	hasRequiredIndexedObject = 1;
183	var uncurryThis = requireFunctionUncurryThis();
184	var fails = requireFails();
185	var classof = requireClassofRaw();
186
187	var $Object = Object;
188	var split = uncurryThis(''.split);
189
190	// fallback for non-array-like ES3 and non-enumerable old V8 strings
191	indexedObject = fails(function () {
192	  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
193	  // eslint-disable-next-line no-prototype-builtins -- safe
194	  return !$Object('z').propertyIsEnumerable(0);
195	}) ? function (it) {
196	  return classof(it) === 'String' ? split(it, '') : $Object(it);
197	} : $Object;
198	return indexedObject;
199}
200
201var isNullOrUndefined;
202var hasRequiredIsNullOrUndefined;
203
204function requireIsNullOrUndefined () {
205	if (hasRequiredIsNullOrUndefined) return isNullOrUndefined;
206	hasRequiredIsNullOrUndefined = 1;
207	// we can't use just `it == null` since of `document.all` special case
208	// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
209	isNullOrUndefined = function (it) {
210	  return it === null || it === undefined;
211	};
212	return isNullOrUndefined;
213}
214
215var requireObjectCoercible;
216var hasRequiredRequireObjectCoercible;
217
218function requireRequireObjectCoercible () {
219	if (hasRequiredRequireObjectCoercible) return requireObjectCoercible;
220	hasRequiredRequireObjectCoercible = 1;
221	var isNullOrUndefined = requireIsNullOrUndefined();
222
223	var $TypeError = TypeError;
224
225	// `RequireObjectCoercible` abstract operation
226	// https://tc39.es/ecma262/#sec-requireobjectcoercible
227	requireObjectCoercible = function (it) {
228	  if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
229	  return it;
230	};
231	return requireObjectCoercible;
232}
233
234var toIndexedObject;
235var hasRequiredToIndexedObject;
236
237function requireToIndexedObject () {
238	if (hasRequiredToIndexedObject) return toIndexedObject;
239	hasRequiredToIndexedObject = 1;
240	// toObject with fallback for non-array-like ES3 strings
241	var IndexedObject = requireIndexedObject();
242	var requireObjectCoercible = requireRequireObjectCoercible();
243
244	toIndexedObject = function (it) {
245	  return IndexedObject(requireObjectCoercible(it));
246	};
247	return toIndexedObject;
248}
249
250var isCallable;
251var hasRequiredIsCallable;
252
253function requireIsCallable () {
254	if (hasRequiredIsCallable) return isCallable;
255	hasRequiredIsCallable = 1;
256	// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
257	var documentAll = typeof document == 'object' && document.all;
258
259	// `IsCallable` abstract operation
260	// https://tc39.es/ecma262/#sec-iscallable
261	// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
262	isCallable = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
263	  return typeof argument == 'function' || argument === documentAll;
264	} : function (argument) {
265	  return typeof argument == 'function';
266	};
267	return isCallable;
268}
269
270var isObject;
271var hasRequiredIsObject;
272
273function requireIsObject () {
274	if (hasRequiredIsObject) return isObject;
275	hasRequiredIsObject = 1;
276	var isCallable = requireIsCallable();
277
278	isObject = function (it) {
279	  return typeof it == 'object' ? it !== null : isCallable(it);
280	};
281	return isObject;
282}
283
284var getBuiltIn;
285var hasRequiredGetBuiltIn;
286
287function requireGetBuiltIn () {
288	if (hasRequiredGetBuiltIn) return getBuiltIn;
289	hasRequiredGetBuiltIn = 1;
290	var globalThis = requireGlobalThis();
291	var isCallable = requireIsCallable();
292
293	var aFunction = function (argument) {
294	  return isCallable(argument) ? argument : undefined;
295	};
296
297	getBuiltIn = function (namespace, method) {
298	  return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
299	};
300	return getBuiltIn;
301}
302
303var objectIsPrototypeOf;
304var hasRequiredObjectIsPrototypeOf;
305
306function requireObjectIsPrototypeOf () {
307	if (hasRequiredObjectIsPrototypeOf) return objectIsPrototypeOf;
308	hasRequiredObjectIsPrototypeOf = 1;
309	var uncurryThis = requireFunctionUncurryThis();
310
311	objectIsPrototypeOf = uncurryThis({}.isPrototypeOf);
312	return objectIsPrototypeOf;
313}
314
315var environmentUserAgent;
316var hasRequiredEnvironmentUserAgent;
317
318function requireEnvironmentUserAgent () {
319	if (hasRequiredEnvironmentUserAgent) return environmentUserAgent;
320	hasRequiredEnvironmentUserAgent = 1;
321	var globalThis = requireGlobalThis();
322
323	var navigator = globalThis.navigator;
324	var userAgent = navigator && navigator.userAgent;
325
326	environmentUserAgent = userAgent ? String(userAgent) : '';
327	return environmentUserAgent;
328}
329
330var environmentV8Version;
331var hasRequiredEnvironmentV8Version;
332
333function requireEnvironmentV8Version () {
334	if (hasRequiredEnvironmentV8Version) return environmentV8Version;
335	hasRequiredEnvironmentV8Version = 1;
336	var globalThis = requireGlobalThis();
337	var userAgent = requireEnvironmentUserAgent();
338
339	var process = globalThis.process;
340	var Deno = globalThis.Deno;
341	var versions = process && process.versions || Deno && Deno.version;
342	var v8 = versions && versions.v8;
343	var match, version;
344
345	if (v8) {
346	  match = v8.split('.');
347	  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
348	  // but their correct versions are not interesting for us
349	  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
350	}
351
352	// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
353	// so check `userAgent` even if `.v8` exists, but 0
354	if (!version && userAgent) {
355	  match = userAgent.match(/Edge\/(\d+)/);
356	  if (!match || match[1] >= 74) {
357	    match = userAgent.match(/Chrome\/(\d+)/);
358	    if (match) version = +match[1];
359	  }
360	}
361
362	environmentV8Version = version;
363	return environmentV8Version;
364}
365
366var symbolConstructorDetection;
367var hasRequiredSymbolConstructorDetection;
368
369function requireSymbolConstructorDetection () {
370	if (hasRequiredSymbolConstructorDetection) return symbolConstructorDetection;
371	hasRequiredSymbolConstructorDetection = 1;
372	/* eslint-disable es/no-symbol -- required for testing */
373	var V8_VERSION = requireEnvironmentV8Version();
374	var fails = requireFails();
375	var globalThis = requireGlobalThis();
376
377	var $String = globalThis.String;
378
379	// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
380	symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails(function () {
381	  var symbol = Symbol('symbol detection');
382	  // Chrome 38 Symbol has incorrect toString conversion
383	  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
384	  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
385	  // of course, fail.
386	  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
387	    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
388	    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
389	});
390	return symbolConstructorDetection;
391}
392
393var useSymbolAsUid;
394var hasRequiredUseSymbolAsUid;
395
396function requireUseSymbolAsUid () {
397	if (hasRequiredUseSymbolAsUid) return useSymbolAsUid;
398	hasRequiredUseSymbolAsUid = 1;
399	/* eslint-disable es/no-symbol -- required for testing */
400	var NATIVE_SYMBOL = requireSymbolConstructorDetection();
401
402	useSymbolAsUid = NATIVE_SYMBOL &&
403	  !Symbol.sham &&
404	  typeof Symbol.iterator == 'symbol';
405	return useSymbolAsUid;
406}
407
408var isSymbol;
409var hasRequiredIsSymbol;
410
411function requireIsSymbol () {
412	if (hasRequiredIsSymbol) return isSymbol;
413	hasRequiredIsSymbol = 1;
414	var getBuiltIn = requireGetBuiltIn();
415	var isCallable = requireIsCallable();
416	var isPrototypeOf = requireObjectIsPrototypeOf();
417	var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
418
419	var $Object = Object;
420
421	isSymbol = USE_SYMBOL_AS_UID ? function (it) {
422	  return typeof it == 'symbol';
423	} : function (it) {
424	  var $Symbol = getBuiltIn('Symbol');
425	  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
426	};
427	return isSymbol;
428}
429
430var tryToString;
431var hasRequiredTryToString;
432
433function requireTryToString () {
434	if (hasRequiredTryToString) return tryToString;
435	hasRequiredTryToString = 1;
436	var $String = String;
437
438	tryToString = function (argument) {
439	  try {
440	    return $String(argument);
441	  } catch (error) {
442	    return 'Object';
443	  }
444	};
445	return tryToString;
446}
447
448var aCallable;
449var hasRequiredACallable;
450
451function requireACallable () {
452	if (hasRequiredACallable) return aCallable;
453	hasRequiredACallable = 1;
454	var isCallable = requireIsCallable();
455	var tryToString = requireTryToString();
456
457	var $TypeError = TypeError;
458
459	// `Assert: IsCallable(argument) is true`
460	aCallable = function (argument) {
461	  if (isCallable(argument)) return argument;
462	  throw new $TypeError(tryToString(argument) + ' is not a function');
463	};
464	return aCallable;
465}
466
467var getMethod;
468var hasRequiredGetMethod;
469
470function requireGetMethod () {
471	if (hasRequiredGetMethod) return getMethod;
472	hasRequiredGetMethod = 1;
473	var aCallable = requireACallable();
474	var isNullOrUndefined = requireIsNullOrUndefined();
475
476	// `GetMethod` abstract operation
477	// https://tc39.es/ecma262/#sec-getmethod
478	getMethod = function (V, P) {
479	  var func = V[P];
480	  return isNullOrUndefined(func) ? undefined : aCallable(func);
481	};
482	return getMethod;
483}
484
485var ordinaryToPrimitive;
486var hasRequiredOrdinaryToPrimitive;
487
488function requireOrdinaryToPrimitive () {
489	if (hasRequiredOrdinaryToPrimitive) return ordinaryToPrimitive;
490	hasRequiredOrdinaryToPrimitive = 1;
491	var call = requireFunctionCall();
492	var isCallable = requireIsCallable();
493	var isObject = requireIsObject();
494
495	var $TypeError = TypeError;
496
497	// `OrdinaryToPrimitive` abstract operation
498	// https://tc39.es/ecma262/#sec-ordinarytoprimitive
499	ordinaryToPrimitive = function (input, pref) {
500	  var fn, val;
501	  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
502	  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
503	  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
504	  throw new $TypeError("Can't convert object to primitive value");
505	};
506	return ordinaryToPrimitive;
507}
508
509var sharedStore = {exports: {}};
510
511var isPure;
512var hasRequiredIsPure;
513
514function requireIsPure () {
515	if (hasRequiredIsPure) return isPure;
516	hasRequiredIsPure = 1;
517	isPure = false;
518	return isPure;
519}
520
521var defineGlobalProperty;
522var hasRequiredDefineGlobalProperty;
523
524function requireDefineGlobalProperty () {
525	if (hasRequiredDefineGlobalProperty) return defineGlobalProperty;
526	hasRequiredDefineGlobalProperty = 1;
527	var globalThis = requireGlobalThis();
528
529	// eslint-disable-next-line es/no-object-defineproperty -- safe
530	var defineProperty = Object.defineProperty;
531
532	defineGlobalProperty = function (key, value) {
533	  try {
534	    defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
535	  } catch (error) {
536	    globalThis[key] = value;
537	  } return value;
538	};
539	return defineGlobalProperty;
540}
541
542var hasRequiredSharedStore;
543
544function requireSharedStore () {
545	if (hasRequiredSharedStore) return sharedStore.exports;
546	hasRequiredSharedStore = 1;
547	var IS_PURE = requireIsPure();
548	var globalThis = requireGlobalThis();
549	var defineGlobalProperty = requireDefineGlobalProperty();
550
551	var SHARED = '__core-js_shared__';
552	var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
553
554	(store.versions || (store.versions = [])).push({
555	  version: '3.49.0',
556	  mode: IS_PURE ? 'pure' : 'global',
557	  copyright: '© 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved.',
558	  license: 'https://github.com/zloirock/core-js/blob/v3.49.0/LICENSE',
559	  source: 'https://github.com/zloirock/core-js'
560	});
561	return sharedStore.exports;
562}
563
564var shared;
565var hasRequiredShared;
566
567function requireShared () {
568	if (hasRequiredShared) return shared;
569	hasRequiredShared = 1;
570	var store = requireSharedStore();
571
572	shared = function (key, value) {
573	  return store[key] || (store[key] = value || {});
574	};
575	return shared;
576}
577
578var toObject;
579var hasRequiredToObject;
580
581function requireToObject () {
582	if (hasRequiredToObject) return toObject;
583	hasRequiredToObject = 1;
584	var requireObjectCoercible = requireRequireObjectCoercible();
585
586	var $Object = Object;
587
588	// `ToObject` abstract operation
589	// https://tc39.es/ecma262/#sec-toobject
590	toObject = function (argument) {
591	  return $Object(requireObjectCoercible(argument));
592	};
593	return toObject;
594}
595
596var hasOwnProperty_1;
597var hasRequiredHasOwnProperty;
598
599function requireHasOwnProperty () {
600	if (hasRequiredHasOwnProperty) return hasOwnProperty_1;
601	hasRequiredHasOwnProperty = 1;
602	var uncurryThis = requireFunctionUncurryThis();
603	var toObject = requireToObject();
604
605	var hasOwnProperty = uncurryThis({}.hasOwnProperty);
606
607	// `HasOwnProperty` abstract operation
608	// https://tc39.es/ecma262/#sec-hasownproperty
609	// eslint-disable-next-line es/no-object-hasown -- safe
610	hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
611	  return hasOwnProperty(toObject(it), key);
612	};
613	return hasOwnProperty_1;
614}
615
616var uid;
617var hasRequiredUid;
618
619function requireUid () {
620	if (hasRequiredUid) return uid;
621	hasRequiredUid = 1;
622	var uncurryThis = requireFunctionUncurryThis();
623
624	var id = 0;
625	var postfix = Math.random();
626	var toString = uncurryThis(1.1.toString);
627
628	uid = function (key) {
629	  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
630	};
631	return uid;
632}
633
634var wellKnownSymbol;
635var hasRequiredWellKnownSymbol;
636
637function requireWellKnownSymbol () {
638	if (hasRequiredWellKnownSymbol) return wellKnownSymbol;
639	hasRequiredWellKnownSymbol = 1;
640	var globalThis = requireGlobalThis();
641	var shared = requireShared();
642	var hasOwn = requireHasOwnProperty();
643	var uid = requireUid();
644	var NATIVE_SYMBOL = requireSymbolConstructorDetection();
645	var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
646
647	var Symbol = globalThis.Symbol;
648	var WellKnownSymbolsStore = shared('wks');
649	var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
650
651	wellKnownSymbol = function (name) {
652	  if (!hasOwn(WellKnownSymbolsStore, name)) {
653	    WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
654	      ? Symbol[name]
655	      : createWellKnownSymbol('Symbol.' + name);
656	  } return WellKnownSymbolsStore[name];
657	};
658	return wellKnownSymbol;
659}
660
661var toPrimitive$1;
662var hasRequiredToPrimitive;
663
664function requireToPrimitive () {
665	if (hasRequiredToPrimitive) return toPrimitive$1;
666	hasRequiredToPrimitive = 1;
667	var call = requireFunctionCall();
668	var isObject = requireIsObject();
669	var isSymbol = requireIsSymbol();
670	var getMethod = requireGetMethod();
671	var ordinaryToPrimitive = requireOrdinaryToPrimitive();
672	var wellKnownSymbol = requireWellKnownSymbol();
673
674	var $TypeError = TypeError;
675	var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
676
677	// `ToPrimitive` abstract operation
678	// https://tc39.es/ecma262/#sec-toprimitive
679	toPrimitive$1 = function (input, pref) {
680	  if (!isObject(input) || isSymbol(input)) return input;
681	  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
682	  var result;
683	  if (exoticToPrim) {
684	    if (pref === undefined) pref = 'default';
685	    result = call(exoticToPrim, input, pref);
686	    if (!isObject(result) || isSymbol(result)) return result;
687	    throw new $TypeError("Can't convert object to primitive value");
688	  }
689	  if (pref === undefined) pref = 'number';
690	  return ordinaryToPrimitive(input, pref);
691	};
692	return toPrimitive$1;
693}
694
695var toPropertyKey$1;
696var hasRequiredToPropertyKey;
697
698function requireToPropertyKey () {
699	if (hasRequiredToPropertyKey) return toPropertyKey$1;
700	hasRequiredToPropertyKey = 1;
701	var toPrimitive = requireToPrimitive();
702	var isSymbol = requireIsSymbol();
703
704	// `ToPropertyKey` abstract operation
705	// https://tc39.es/ecma262/#sec-topropertykey
706	toPropertyKey$1 = function (argument) {
707	  var key = toPrimitive(argument, 'string');
708	  return isSymbol(key) ? key : key + '';
709	};
710	return toPropertyKey$1;
711}
712
713var documentCreateElement;
714var hasRequiredDocumentCreateElement;
715
716function requireDocumentCreateElement () {
717	if (hasRequiredDocumentCreateElement) return documentCreateElement;
718	hasRequiredDocumentCreateElement = 1;
719	var globalThis = requireGlobalThis();
720	var isObject = requireIsObject();
721
722	var document = globalThis.document;
723	// typeof document.createElement is 'object' in old IE
724	var EXISTS = isObject(document) && isObject(document.createElement);
725
726	documentCreateElement = function (it) {
727	  return EXISTS ? document.createElement(it) : {};
728	};
729	return documentCreateElement;
730}
731
732var ie8DomDefine;
733var hasRequiredIe8DomDefine;
734
735function requireIe8DomDefine () {
736	if (hasRequiredIe8DomDefine) return ie8DomDefine;
737	hasRequiredIe8DomDefine = 1;
738	var DESCRIPTORS = requireDescriptors();
739	var fails = requireFails();
740	var createElement = requireDocumentCreateElement();
741
742	// Thanks to IE8 for its funny defineProperty
743	ie8DomDefine = !DESCRIPTORS && !fails(function () {
744	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
745	  return Object.defineProperty(createElement('div'), 'a', {
746	    get: function () { return 7; }
747	  }).a !== 7;
748	});
749	return ie8DomDefine;
750}
751
752var hasRequiredObjectGetOwnPropertyDescriptor;
753
754function requireObjectGetOwnPropertyDescriptor () {
755	if (hasRequiredObjectGetOwnPropertyDescriptor) return objectGetOwnPropertyDescriptor;
756	hasRequiredObjectGetOwnPropertyDescriptor = 1;
757	var DESCRIPTORS = requireDescriptors();
758	var call = requireFunctionCall();
759	var propertyIsEnumerableModule = requireObjectPropertyIsEnumerable();
760	var createPropertyDescriptor = requireCreatePropertyDescriptor();
761	var toIndexedObject = requireToIndexedObject();
762	var toPropertyKey = requireToPropertyKey();
763	var hasOwn = requireHasOwnProperty();
764	var IE8_DOM_DEFINE = requireIe8DomDefine();
765
766	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
767	var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
768
769	// `Object.getOwnPropertyDescriptor` method
770	// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
771	objectGetOwnPropertyDescriptor.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
772	  O = toIndexedObject(O);
773	  P = toPropertyKey(P);
774	  if (IE8_DOM_DEFINE) try {
775	    return $getOwnPropertyDescriptor(O, P);
776	  } catch (error) { /* empty */ }
777	  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
778	};
779	return objectGetOwnPropertyDescriptor;
780}
781
782var objectDefineProperty = {};
783
784var v8PrototypeDefineBug;
785var hasRequiredV8PrototypeDefineBug;
786
787function requireV8PrototypeDefineBug () {
788	if (hasRequiredV8PrototypeDefineBug) return v8PrototypeDefineBug;
789	hasRequiredV8PrototypeDefineBug = 1;
790	var DESCRIPTORS = requireDescriptors();
791	var fails = requireFails();
792
793	// V8 ~ Chrome 36-
794	// https://bugs.chromium.org/p/v8/issues/detail?id=3334
795	v8PrototypeDefineBug = DESCRIPTORS && fails(function () {
796	  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
797	  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
798	    value: 42,
799	    writable: false
800	  }).prototype !== 42;
801	});
802	return v8PrototypeDefineBug;
803}
804
805var anObject;
806var hasRequiredAnObject;
807
808function requireAnObject () {
809	if (hasRequiredAnObject) return anObject;
810	hasRequiredAnObject = 1;
811	var isObject = requireIsObject();
812
813	var $String = String;
814	var $TypeError = TypeError;
815
816	// `Assert: Type(argument) is Object`
817	anObject = function (argument) {
818	  if (isObject(argument)) return argument;
819	  throw new $TypeError($String(argument) + ' is not an object');
820	};
821	return anObject;
822}
823
824var hasRequiredObjectDefineProperty;
825
826function requireObjectDefineProperty () {
827	if (hasRequiredObjectDefineProperty) return objectDefineProperty;
828	hasRequiredObjectDefineProperty = 1;
829	var DESCRIPTORS = requireDescriptors();
830	var IE8_DOM_DEFINE = requireIe8DomDefine();
831	var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
832	var anObject = requireAnObject();
833	var toPropertyKey = requireToPropertyKey();
834
835	var $TypeError = TypeError;
836	// eslint-disable-next-line es/no-object-defineproperty -- safe
837	var $defineProperty = Object.defineProperty;
838	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
839	var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
840	var ENUMERABLE = 'enumerable';
841	var CONFIGURABLE = 'configurable';
842	var WRITABLE = 'writable';
843
844	// `Object.defineProperty` method
845	// https://tc39.es/ecma262/#sec-object.defineproperty
846	objectDefineProperty.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
847	  anObject(O);
848	  P = toPropertyKey(P);
849	  anObject(Attributes);
850	  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
851	    var current = $getOwnPropertyDescriptor(O, P);
852	    if (current && current[WRITABLE]) {
853	      O[P] = Attributes.value;
854	      Attributes = {
855	        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
856	        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
857	        writable: false
858	      };
859	    }
860	  } return $defineProperty(O, P, Attributes);
861	} : $defineProperty : function defineProperty(O, P, Attributes) {
862	  anObject(O);
863	  P = toPropertyKey(P);
864	  anObject(Attributes);
865	  if (IE8_DOM_DEFINE) try {
866	    return $defineProperty(O, P, Attributes);
867	  } catch (error) { /* empty */ }
868	  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
869	  if ('value' in Attributes) O[P] = Attributes.value;
870	  return O;
871	};
872	return objectDefineProperty;
873}
874
875var createNonEnumerableProperty;
876var hasRequiredCreateNonEnumerableProperty;
877
878function requireCreateNonEnumerableProperty () {
879	if (hasRequiredCreateNonEnumerableProperty) return createNonEnumerableProperty;
880	hasRequiredCreateNonEnumerableProperty = 1;
881	var DESCRIPTORS = requireDescriptors();
882	var definePropertyModule = requireObjectDefineProperty();
883	var createPropertyDescriptor = requireCreatePropertyDescriptor();
884
885	createNonEnumerableProperty = DESCRIPTORS ? function (object, key, value) {
886	  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
887	} : function (object, key, value) {
888	  object[key] = value;
889	  return object;
890	};
891	return createNonEnumerableProperty;
892}
893
894var makeBuiltIn = {exports: {}};
895
896var functionName;
897var hasRequiredFunctionName;
898
899function requireFunctionName () {
900	if (hasRequiredFunctionName) return functionName;
901	hasRequiredFunctionName = 1;
902	var DESCRIPTORS = requireDescriptors();
903	var hasOwn = requireHasOwnProperty();
904
905	var FunctionPrototype = Function.prototype;
906	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
907	var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
908
909	var EXISTS = hasOwn(FunctionPrototype, 'name');
910	// additional protection from minified / mangled / dropped function names
911	var PROPER = EXISTS && function something() { /* empty */ }.name === 'something';
912	var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
913
914	functionName = {
915	  EXISTS: EXISTS,
916	  PROPER: PROPER,
917	  CONFIGURABLE: CONFIGURABLE
918	};
919	return functionName;
920}
921
922var inspectSource;
923var hasRequiredInspectSource;
924
925function requireInspectSource () {
926	if (hasRequiredInspectSource) return inspectSource;
927	hasRequiredInspectSource = 1;
928	var uncurryThis = requireFunctionUncurryThis();
929	var isCallable = requireIsCallable();
930	var store = requireSharedStore();
931
932	var functionToString = uncurryThis(Function.toString);
933
934	// this helper broken in `[email protected]`, so we can't use `shared` helper
935	if (!isCallable(store.inspectSource)) {
936	  store.inspectSource = function (it) {
937	    return functionToString(it);
938	  };
939	}
940
941	inspectSource = store.inspectSource;
942	return inspectSource;
943}
944
945var weakMapBasicDetection;
946var hasRequiredWeakMapBasicDetection;
947
948function requireWeakMapBasicDetection () {
949	if (hasRequiredWeakMapBasicDetection) return weakMapBasicDetection;
950	hasRequiredWeakMapBasicDetection = 1;
951	var globalThis = requireGlobalThis();
952	var isCallable = requireIsCallable();
953
954	var WeakMap = globalThis.WeakMap;
955
956	weakMapBasicDetection = isCallable(WeakMap) && /native code/.test(String(WeakMap));
957	return weakMapBasicDetection;
958}
959
960var sharedKey;
961var hasRequiredSharedKey;
962
963function requireSharedKey () {
964	if (hasRequiredSharedKey) return sharedKey;
965	hasRequiredSharedKey = 1;
966	var shared = requireShared();
967	var uid = requireUid();
968
969	var keys = shared('keys');
970
971	sharedKey = function (key) {
972	  return keys[key] || (keys[key] = uid(key));
973	};
974	return sharedKey;
975}
976
977var hiddenKeys;
978var hasRequiredHiddenKeys;
979
980function requireHiddenKeys () {
981	if (hasRequiredHiddenKeys) return hiddenKeys;
982	hasRequiredHiddenKeys = 1;
983	hiddenKeys = {};
984	return hiddenKeys;
985}
986
987var internalState;
988var hasRequiredInternalState;
989
990function requireInternalState () {
991	if (hasRequiredInternalState) return internalState;
992	hasRequiredInternalState = 1;
993	var NATIVE_WEAK_MAP = requireWeakMapBasicDetection();
994	var globalThis = requireGlobalThis();
995	var isObject = requireIsObject();
996	var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
997	var hasOwn = requireHasOwnProperty();
998	var shared = requireSharedStore();
999	var sharedKey = requireSharedKey();
1000	var hiddenKeys = requireHiddenKeys();
1001
1002	var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
1003	var TypeError = globalThis.TypeError;
1004	var WeakMap = globalThis.WeakMap;
1005	var set, get, has;
1006
1007	var enforce = function (it) {
1008	  return has(it) ? get(it) : set(it, {});
1009	};
1010
1011	var getterFor = function (TYPE) {
1012	  return function (it) {
1013	    var state;
1014	    if (!isObject(it) || (state = get(it)).type !== TYPE) {
1015	      throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
1016	    } return state;
1017	  };
1018	};
1019
1020	if (NATIVE_WEAK_MAP || shared.state) {
1021	  var store = shared.state || (shared.state = new WeakMap());
1022	  /* eslint-disable no-self-assign -- prototype methods protection */
1023	  store.get = store.get;
1024	  store.has = store.has;
1025	  store.set = store.set;
1026	  /* eslint-enable no-self-assign -- prototype methods protection */
1027	  set = function (it, metadata) {
1028	    if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
1029	    metadata.facade = it;
1030	    store.set(it, metadata);
1031	    return metadata;
1032	  };
1033	  get = function (it) {
1034	    return store.get(it) || {};
1035	  };
1036	  has = function (it) {
1037	    return store.has(it);
1038	  };
1039	} else {
1040	  var STATE = sharedKey('state');
1041	  hiddenKeys[STATE] = true;
1042	  set = function (it, metadata) {
1043	    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
1044	    metadata.facade = it;
1045	    createNonEnumerableProperty(it, STATE, metadata);
1046	    return metadata;
1047	  };
1048	  get = function (it) {
1049	    return hasOwn(it, STATE) ? it[STATE] : {};
1050	  };
1051	  has = function (it) {
1052	    return hasOwn(it, STATE);
1053	  };
1054	}
1055
1056	internalState = {
1057	  set: set,
1058	  get: get,
1059	  has: has,
1060	  enforce: enforce,
1061	  getterFor: getterFor
1062	};
1063	return internalState;
1064}
1065
1066var hasRequiredMakeBuiltIn;
1067
1068function requireMakeBuiltIn () {
1069	if (hasRequiredMakeBuiltIn) return makeBuiltIn.exports;
1070	hasRequiredMakeBuiltIn = 1;
1071	var uncurryThis = requireFunctionUncurryThis();
1072	var fails = requireFails();
1073	var isCallable = requireIsCallable();
1074	var hasOwn = requireHasOwnProperty();
1075	var DESCRIPTORS = requireDescriptors();
1076	var CONFIGURABLE_FUNCTION_NAME = requireFunctionName().CONFIGURABLE;
1077	var inspectSource = requireInspectSource();
1078	var InternalStateModule = requireInternalState();
1079
1080	var enforceInternalState = InternalStateModule.enforce;
1081	var getInternalState = InternalStateModule.get;
1082	var $String = String;
1083	// eslint-disable-next-line es/no-object-defineproperty -- safe
1084	var defineProperty = Object.defineProperty;
1085	var stringSlice = uncurryThis(''.slice);
1086	var replace = uncurryThis(''.replace);
1087	var join = uncurryThis([].join);
1088
1089	var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
1090	  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
1091	});
1092
1093	var TEMPLATE = String(String).split('String');
1094
1095	var makeBuiltIn$1 = makeBuiltIn.exports = function (value, name, options) {
1096	  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
1097	    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
1098	  }
1099	  if (options && options.getter) name = 'get ' + name;
1100	  if (options && options.setter) name = 'set ' + name;
1101	  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
1102	    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
1103	    else value.name = name;
1104	  }
1105	  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
1106	    defineProperty(value, 'length', { value: options.arity });
1107	  }
1108	  try {
1109	    if (options && hasOwn(options, 'constructor') && options.constructor) {
1110	      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
1111	    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
1112	    } else if (value.prototype) value.prototype = undefined;
1113	  } catch (error) { /* empty */ }
1114	  var state = enforceInternalState(value);
1115	  if (!hasOwn(state, 'source')) {
1116	    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
1117	  } return value;
1118	};
1119
1120	// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
1121	// eslint-disable-next-line no-extend-native -- required
1122	Function.prototype.toString = makeBuiltIn$1(function toString() {
1123	  return isCallable(this) && getInternalState(this).source || inspectSource(this);
1124	}, 'toString');
1125	return makeBuiltIn.exports;
1126}
1127
1128var defineBuiltIn;
1129var hasRequiredDefineBuiltIn;
1130
1131function requireDefineBuiltIn () {
1132	if (hasRequiredDefineBuiltIn) return defineBuiltIn;
1133	hasRequiredDefineBuiltIn = 1;
1134	var isCallable = requireIsCallable();
1135	var definePropertyModule = requireObjectDefineProperty();
1136	var makeBuiltIn = requireMakeBuiltIn();
1137	var defineGlobalProperty = requireDefineGlobalProperty();
1138
1139	defineBuiltIn = function (O, key, value, options) {
1140	  if (!options) options = {};
1141	  var simple = options.enumerable;
1142	  var name = options.name !== undefined ? options.name : key;
1143	  if (isCallable(value)) makeBuiltIn(value, name, options);
1144	  if (options.global) {
1145	    if (simple) O[key] = value;
1146	    else defineGlobalProperty(key, value);
1147	  } else {
1148	    try {
1149	      if (!options.unsafe) delete O[key];
1150	      else if (O[key]) simple = true;
1151	    } catch (error) { /* empty */ }
1152	    if (simple) O[key] = value;
1153	    else definePropertyModule.f(O, key, {
1154	      value: value,
1155	      enumerable: false,
1156	      configurable: !options.nonConfigurable,
1157	      writable: !options.nonWritable
1158	    });
1159	  } return O;
1160	};
1161	return defineBuiltIn;
1162}
1163
1164var objectGetOwnPropertyNames = {};
1165
1166var mathTrunc;
1167var hasRequiredMathTrunc;
1168
1169function requireMathTrunc () {
1170	if (hasRequiredMathTrunc) return mathTrunc;
1171	hasRequiredMathTrunc = 1;
1172	var ceil = Math.ceil;
1173	var floor = Math.floor;
1174
1175	// `Math.trunc` method
1176	// https://tc39.es/ecma262/#sec-math.trunc
1177	// eslint-disable-next-line es/no-math-trunc -- safe
1178	mathTrunc = Math.trunc || function trunc(x) {
1179	  var n = +x;
1180	  return (n > 0 ? floor : ceil)(n);
1181	};
1182	return mathTrunc;
1183}
1184
1185var toIntegerOrInfinity;
1186var hasRequiredToIntegerOrInfinity;
1187
1188function requireToIntegerOrInfinity () {
1189	if (hasRequiredToIntegerOrInfinity) return toIntegerOrInfinity;
1190	hasRequiredToIntegerOrInfinity = 1;
1191	var trunc = requireMathTrunc();
1192
1193	// `ToIntegerOrInfinity` abstract operation
1194	// https://tc39.es/ecma262/#sec-tointegerorinfinity
1195	toIntegerOrInfinity = function (argument) {
1196	  var number = +argument;
1197	  // eslint-disable-next-line no-self-compare -- NaN check
1198	  return number !== number || number === 0 ? 0 : trunc(number);
1199	};
1200	return toIntegerOrInfinity;
1201}
1202
1203var toAbsoluteIndex;
1204var hasRequiredToAbsoluteIndex;
1205
1206function requireToAbsoluteIndex () {
1207	if (hasRequiredToAbsoluteIndex) return toAbsoluteIndex;
1208	hasRequiredToAbsoluteIndex = 1;
1209	var toIntegerOrInfinity = requireToIntegerOrInfinity();
1210
1211	var max = Math.max;
1212	var min = Math.min;
1213
1214	// Helper for a popular repeating case of the spec:
1215	// Let integer be ? ToInteger(index).
1216	// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
1217	toAbsoluteIndex = function (index, length) {
1218	  var integer = toIntegerOrInfinity(index);
1219	  return integer < 0 ? max(integer + length, 0) : min(integer, length);
1220	};
1221	return toAbsoluteIndex;
1222}
1223
1224var toLength;
1225var hasRequiredToLength;
1226
1227function requireToLength () {
1228	if (hasRequiredToLength) return toLength;
1229	hasRequiredToLength = 1;
1230	var toIntegerOrInfinity = requireToIntegerOrInfinity();
1231
1232	var min = Math.min;
1233
1234	// `ToLength` abstract operation
1235	// https://tc39.es/ecma262/#sec-tolength
1236	toLength = function (argument) {
1237	  var len = toIntegerOrInfinity(argument);
1238	  return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1239	};
1240	return toLength;
1241}
1242
1243var lengthOfArrayLike;
1244var hasRequiredLengthOfArrayLike;
1245
1246function requireLengthOfArrayLike () {
1247	if (hasRequiredLengthOfArrayLike) return lengthOfArrayLike;
1248	hasRequiredLengthOfArrayLike = 1;
1249	var toLength = requireToLength();
1250
1251	// `LengthOfArrayLike` abstract operation
1252	// https://tc39.es/ecma262/#sec-lengthofarraylike
1253	lengthOfArrayLike = function (obj) {
1254	  return toLength(obj.length);
1255	};
1256	return lengthOfArrayLike;
1257}
1258
1259var arrayIncludes;
1260var hasRequiredArrayIncludes;
1261
1262function requireArrayIncludes () {
1263	if (hasRequiredArrayIncludes) return arrayIncludes;
1264	hasRequiredArrayIncludes = 1;
1265	var toIndexedObject = requireToIndexedObject();
1266	var toAbsoluteIndex = requireToAbsoluteIndex();
1267	var lengthOfArrayLike = requireLengthOfArrayLike();
1268
1269	// `Array.prototype.{ indexOf, includes }` methods implementation
1270	var createMethod = function (IS_INCLUDES) {
1271	  return function ($this, el, fromIndex) {
1272	    var O = toIndexedObject($this);
1273	    var length = lengthOfArrayLike(O);
1274	    if (length === 0) return !IS_INCLUDES && -1;
1275	    var index = toAbsoluteIndex(fromIndex, length);
1276	    var value;
1277	    // Array#includes uses SameValueZero equality algorithm
1278	    // eslint-disable-next-line no-self-compare -- NaN check
1279	    if (IS_INCLUDES && el !== el) while (length > index) {
1280	      value = O[index++];
1281	      // eslint-disable-next-line no-self-compare -- NaN check
1282	      if (value !== value) return true;
1283	    // Array#indexOf ignores holes, Array#includes - not
1284	    } else for (;length > index; index++) {
1285	      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
1286	    } return !IS_INCLUDES && -1;
1287	  };
1288	};
1289
1290	arrayIncludes = {
1291	  // `Array.prototype.includes` method
1292	  // https://tc39.es/ecma262/#sec-array.prototype.includes
1293	  includes: createMethod(true),
1294	  // `Array.prototype.indexOf` method
1295	  // https://tc39.es/ecma262/#sec-array.prototype.indexof
1296	  indexOf: createMethod(false)
1297	};
1298	return arrayIncludes;
1299}
1300
1301var objectKeysInternal;
1302var hasRequiredObjectKeysInternal;
1303
1304function requireObjectKeysInternal () {
1305	if (hasRequiredObjectKeysInternal) return objectKeysInternal;
1306	hasRequiredObjectKeysInternal = 1;
1307	var uncurryThis = requireFunctionUncurryThis();
1308	var hasOwn = requireHasOwnProperty();
1309	var toIndexedObject = requireToIndexedObject();
1310	var indexOf = requireArrayIncludes().indexOf;
1311	var hiddenKeys = requireHiddenKeys();
1312
1313	var push = uncurryThis([].push);
1314
1315	objectKeysInternal = function (object, names) {
1316	  var O = toIndexedObject(object);
1317	  var i = 0;
1318	  var result = [];
1319	  var key;
1320	  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
1321	  // Don't enum bug & hidden keys
1322	  while (names.length > i) if (hasOwn(O, key = names[i++])) {
1323	    ~indexOf(result, key) || push(result, key);
1324	  }
1325	  return result;
1326	};
1327	return objectKeysInternal;
1328}
1329
1330var enumBugKeys;
1331var hasRequiredEnumBugKeys;
1332
1333function requireEnumBugKeys () {
1334	if (hasRequiredEnumBugKeys) return enumBugKeys;
1335	hasRequiredEnumBugKeys = 1;
1336	// IE8- don't enum bug keys
1337	enumBugKeys = [
1338	  'constructor',
1339	  'hasOwnProperty',
1340	  'isPrototypeOf',
1341	  'propertyIsEnumerable',
1342	  'toLocaleString',
1343	  'toString',
1344	  'valueOf'
1345	];
1346	return enumBugKeys;
1347}
1348
1349var hasRequiredObjectGetOwnPropertyNames;
1350
1351function requireObjectGetOwnPropertyNames () {
1352	if (hasRequiredObjectGetOwnPropertyNames) return objectGetOwnPropertyNames;
1353	hasRequiredObjectGetOwnPropertyNames = 1;
1354	var internalObjectKeys = requireObjectKeysInternal();
1355	var enumBugKeys = requireEnumBugKeys();
1356
1357	var hiddenKeys = enumBugKeys.concat('length', 'prototype');
1358
1359	// `Object.getOwnPropertyNames` method
1360	// https://tc39.es/ecma262/#sec-object.getownpropertynames
1361	// eslint-disable-next-line es/no-object-getownpropertynames -- safe
1362	objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
1363	  return internalObjectKeys(O, hiddenKeys);
1364	};
1365	return objectGetOwnPropertyNames;
1366}
1367
1368var objectGetOwnPropertySymbols = {};
1369
1370var hasRequiredObjectGetOwnPropertySymbols;
1371
1372function requireObjectGetOwnPropertySymbols () {
1373	if (hasRequiredObjectGetOwnPropertySymbols) return objectGetOwnPropertySymbols;
1374	hasRequiredObjectGetOwnPropertySymbols = 1;
1375	// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
1376	objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
1377	return objectGetOwnPropertySymbols;
1378}
1379
1380var ownKeys$3;
1381var hasRequiredOwnKeys;
1382
1383function requireOwnKeys () {
1384	if (hasRequiredOwnKeys) return ownKeys$3;
1385	hasRequiredOwnKeys = 1;
1386	var getBuiltIn = requireGetBuiltIn();
1387	var uncurryThis = requireFunctionUncurryThis();
1388	var getOwnPropertyNamesModule = requireObjectGetOwnPropertyNames();
1389	var getOwnPropertySymbolsModule = requireObjectGetOwnPropertySymbols();
1390	var anObject = requireAnObject();
1391
1392	var concat = uncurryThis([].concat);
1393
1394	// all object keys, includes non-enumerable and symbols
1395	ownKeys$3 = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
1396	  var keys = getOwnPropertyNamesModule.f(anObject(it));
1397	  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1398	  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
1399	};
1400	return ownKeys$3;
1401}
1402
1403var copyConstructorProperties;
1404var hasRequiredCopyConstructorProperties;
1405
1406function requireCopyConstructorProperties () {
1407	if (hasRequiredCopyConstructorProperties) return copyConstructorProperties;
1408	hasRequiredCopyConstructorProperties = 1;
1409	var hasOwn = requireHasOwnProperty();
1410	var ownKeys = requireOwnKeys();
1411	var getOwnPropertyDescriptorModule = requireObjectGetOwnPropertyDescriptor();
1412	var definePropertyModule = requireObjectDefineProperty();
1413
1414	copyConstructorProperties = function (target, source, exceptions) {
1415	  var keys = ownKeys(source);
1416	  var defineProperty = definePropertyModule.f;
1417	  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
1418	  for (var i = 0; i < keys.length; i++) {
1419	    var key = keys[i];
1420	    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
1421	      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
1422	    }
1423	  }
1424	};
1425	return copyConstructorProperties;
1426}
1427
1428var isForced_1;
1429var hasRequiredIsForced;
1430
1431function requireIsForced () {
1432	if (hasRequiredIsForced) return isForced_1;
1433	hasRequiredIsForced = 1;
1434	var fails = requireFails();
1435	var isCallable = requireIsCallable();
1436
1437	var replacement = /#|\.prototype\./;
1438
1439	var isForced = function (feature, detection) {
1440	  var value = data[normalize(feature)];
1441	  return value === POLYFILL ? true
1442	    : value === NATIVE ? false
1443	    : isCallable(detection) ? fails(detection)
1444	    : !!detection;
1445	};
1446
1447	var normalize = isForced.normalize = function (string) {
1448	  return String(string).replace(replacement, '.').toLowerCase();
1449	};
1450
1451	var data = isForced.data = {};
1452	var NATIVE = isForced.NATIVE = 'N';
1453	var POLYFILL = isForced.POLYFILL = 'P';
1454
1455	isForced_1 = isForced;
1456	return isForced_1;
1457}
1458
1459var _export;
1460var hasRequired_export;
1461
1462function require_export () {
1463	if (hasRequired_export) return _export;
1464	hasRequired_export = 1;
1465	var globalThis = requireGlobalThis();
1466	var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
1467	var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
1468	var defineBuiltIn = requireDefineBuiltIn();
1469	var defineGlobalProperty = requireDefineGlobalProperty();
1470	var copyConstructorProperties = requireCopyConstructorProperties();
1471	var isForced = requireIsForced();
1472
1473	/*
1474	  options.target         - name of the target object
1475	  options.global         - target is the global object
1476	  options.stat           - export as static methods of target
1477	  options.proto          - export as prototype methods of target
1478	  options.real           - real prototype method for the `pure` version
1479	  options.forced         - export even if the native feature is available

1643	  var test = {};
1644	  var setter;
1645	  try {
1646	    setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
1647	    setter(test, []);
1648	    CORRECT_SETTER = test instanceof Array;
1649	  } catch (error) { /* empty */ }
1650	  return function setPrototypeOf(O, proto) {
1651	    requireObjectCoercible(O);
1652	    aPossiblePrototype(proto);
1653	    if (!isObject(O)) return O;
1654	    if (CORRECT_SETTER) setter(O, proto);
1655	    else O.__proto__ = proto;
1656	    return O;
1657	  };
1658	}() : undefined);
1659	return objectSetPrototypeOf;
1660}
1661
1662var setToStringTag;
1663var hasRequiredSetToStringTag;
1664
1665function requireSetToStringTag () {
1666	if (hasRequiredSetToStringTag) return setToStringTag;
1667	hasRequiredSetToStringTag = 1;
1668	var defineProperty = requireObjectDefineProperty().f;
1669	var hasOwn = requireHasOwnProperty();
1670	var wellKnownSymbol = requireWellKnownSymbol();
1671
1672	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1673
1674	setToStringTag = function (target, TAG, STATIC) {
1675	  if (target && !STATIC) target = target.prototype;
1676	  if (target && !hasOwn(target, TO_STRING_TAG)) {
1677	    defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });
1678	  }
1679	};
1680	return setToStringTag;
1681}
1682
1683var defineBuiltInAccessor;
1684var hasRequiredDefineBuiltInAccessor;
1685
1686function requireDefineBuiltInAccessor () {
1687	if (hasRequiredDefineBuiltInAccessor) return defineBuiltInAccessor;
1688	hasRequiredDefineBuiltInAccessor = 1;
1689	var makeBuiltIn = requireMakeBuiltIn();
1690	var defineProperty = requireObjectDefineProperty();
1691
1692	defineBuiltInAccessor = function (target, name, descriptor) {
1693	  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
1694	  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
1695	  return defineProperty.f(target, name, descriptor);
1696	};
1697	return defineBuiltInAccessor;
1698}
1699
1700var setSpecies;
1701var hasRequiredSetSpecies;
1702
1703function requireSetSpecies () {
1704	if (hasRequiredSetSpecies) return setSpecies;
1705	hasRequiredSetSpecies = 1;
1706	var getBuiltIn = requireGetBuiltIn();
1707	var defineBuiltInAccessor = requireDefineBuiltInAccessor();
1708	var wellKnownSymbol = requireWellKnownSymbol();
1709	var DESCRIPTORS = requireDescriptors();
1710
1711	var SPECIES = wellKnownSymbol('species');
1712
1713	setSpecies = function (CONSTRUCTOR_NAME) {
1714	  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
1715
1716	  if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {
1717	    defineBuiltInAccessor(Constructor, SPECIES, {
1718	      configurable: true,
1719	      get: function () { return this; }
1720	    });
1721	  }
1722	};
1723	return setSpecies;
1724}
1725
1726var anInstance;
1727var hasRequiredAnInstance;
1728
1729function requireAnInstance () {
1730	if (hasRequiredAnInstance) return anInstance;
1731	hasRequiredAnInstance = 1;
1732	var isPrototypeOf = requireObjectIsPrototypeOf();
1733
1734	var $TypeError = TypeError;
1735
1736	anInstance = function (it, Prototype) {
1737	  if (isPrototypeOf(Prototype, it)) return it;
1738	  throw new $TypeError('Incorrect invocation');
1739	};
1740	return anInstance;
1741}
1742
1743var toStringTagSupport;
1744var hasRequiredToStringTagSupport;
1745
1746function requireToStringTagSupport () {
1747	if (hasRequiredToStringTagSupport) return toStringTagSupport;
1748	hasRequiredToStringTagSupport = 1;
1749	var wellKnownSymbol = requireWellKnownSymbol();
1750
1751	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1752	var test = {};
1753	// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
1754	test[TO_STRING_TAG] = 'z';
1755
1756	toStringTagSupport = String(test) === '[object z]';
1757	return toStringTagSupport;
1758}
1759
1760var classof;
1761var hasRequiredClassof;
1762
1763function requireClassof () {
1764	if (hasRequiredClassof) return classof;
1765	hasRequiredClassof = 1;
1766	var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
1767	var isCallable = requireIsCallable();
1768	var classofRaw = requireClassofRaw();
1769	var wellKnownSymbol = requireWellKnownSymbol();
1770
1771	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1772	var $Object = Object;
1773
1774	// ES3 wrong here
1775	var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
1776
1777	// fallback for IE11 Script Access Denied error
1778	var tryGet = function (it, key) {
1779	  try {
1780	    return it[key];
1781	  } catch (error) { /* empty */ }
1782	};
1783
1784	// getting tag from ES6+ `Object.prototype.toString`
1785	classof = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
1786	  var O, tag, result;
1787	  return it === undefined ? 'Undefined' : it === null ? 'Null'
1788	    // @@toStringTag case
1789	    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
1790	    // builtinTag case
1791	    : CORRECT_ARGUMENTS ? classofRaw(O)
1792	    // ES3 arguments fallback
1793	    : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
1794	};
1795	return classof;
1796}
1797
1798var isConstructor;
1799var hasRequiredIsConstructor;
1800
1801function requireIsConstructor () {
1802	if (hasRequiredIsConstructor) return isConstructor;
1803	hasRequiredIsConstructor = 1;
1804	var uncurryThis = requireFunctionUncurryThis();
1805	var fails = requireFails();
1806	var isCallable = requireIsCallable();
1807	var classof = requireClassof();
1808	var getBuiltIn = requireGetBuiltIn();
1809	var inspectSource = requireInspectSource();
1810
1811	var noop = function () { /* empty */ };
1812	var construct = getBuiltIn('Reflect', 'construct');
1813	var constructorRegExp = /^\s*(?:class|function)\b/;
1814	var exec = uncurryThis(constructorRegExp.exec);
1815	var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
1816
1817	var isConstructorModern = function isConstructor(argument) {
1818	  if (!isCallable(argument)) return false;
1819	  try {
1820	    construct(noop, [], argument);
1821	    return true;
1822	  } catch (error) {
1823	    return false;
1824	  }
1825	};
1826
1827	var isConstructorLegacy = function isConstructor(argument) {
1828	  if (!isCallable(argument)) return false;
1829	  switch (classof(argument)) {
1830	    case 'AsyncFunction':
1831	    case 'GeneratorFunction':
1832	    case 'AsyncGeneratorFunction': return false;
1833	  }
1834	  try {
1835	    // we can't check .prototype since constructors produced by .bind haven't it
1836	    // `Function#toString` throws on some built-it function in some legacy engines
1837	    // (for example, `DOMQuad` and similar in FF41-)
1838	    return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
1839	  } catch (error) {
1840	    return true;
1841	  }
1842	};
1843
1844	isConstructorLegacy.sham = true;
1845
1846	// `IsConstructor` abstract operation
1847	// https://tc39.es/ecma262/#sec-isconstructor
1848	isConstructor = !construct || fails(function () {
1849	  var called;
1850	  return isConstructorModern(isConstructorModern.call)
1851	    || !isConstructorModern(Object)
1852	    || !isConstructorModern(function () { called = true; })
1853	    || called;
1854	}) ? isConstructorLegacy : isConstructorModern;
1855	return isConstructor;
1856}
1857
1858var aConstructor;
1859var hasRequiredAConstructor;
1860
1861function requireAConstructor () {
1862	if (hasRequiredAConstructor) return aConstructor;
1863	hasRequiredAConstructor = 1;
1864	var isConstructor = requireIsConstructor();
1865	var tryToString = requireTryToString();
1866
1867	var $TypeError = TypeError;
1868
1869	// `Assert: IsConstructor(argument) is true`
1870	aConstructor = function (argument) {
1871	  if (isConstructor(argument)) return argument;
1872	  throw new $TypeError(tryToString(argument) + ' is not a constructor');
1873	};
1874	return aConstructor;
1875}
1876
1877var speciesConstructor;
1878var hasRequiredSpeciesConstructor;
1879
1880function requireSpeciesConstructor () {
1881	if (hasRequiredSpeciesConstructor) return speciesConstructor;
1882	hasRequiredSpeciesConstructor = 1;
1883	var anObject = requireAnObject();
1884	var aConstructor = requireAConstructor();
1885	var isNullOrUndefined = requireIsNullOrUndefined();
1886	var wellKnownSymbol = requireWellKnownSymbol();
1887
1888	var SPECIES = wellKnownSymbol('species');
1889
1890	// `SpeciesConstructor` abstract operation
1891	// https://tc39.es/ecma262/#sec-speciesconstructor
1892	speciesConstructor = function (O, defaultConstructor) {
1893	  var C = anObject(O).constructor;
1894	  var S;
1895	  return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);
1896	};
1897	return speciesConstructor;
1898}
1899
1900var functionApply;
1901var hasRequiredFunctionApply;
1902
1903function requireFunctionApply () {
1904	if (hasRequiredFunctionApply) return functionApply;
1905	hasRequiredFunctionApply = 1;
1906	var NATIVE_BIND = requireFunctionBindNative();
1907
1908	var FunctionPrototype = Function.prototype;
1909	var apply = FunctionPrototype.apply;
1910	var call = FunctionPrototype.call;
1911
1912	// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
1913	functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
1914	  return call.apply(apply, arguments);
1915	});
1916	return functionApply;
1917}
1918
1919var functionUncurryThisClause;
1920var hasRequiredFunctionUncurryThisClause;
1921
1922function requireFunctionUncurryThisClause () {
1923	if (hasRequiredFunctionUncurryThisClause) return functionUncurryThisClause;
1924	hasRequiredFunctionUncurryThisClause = 1;
1925	var classofRaw = requireClassofRaw();
1926	var uncurryThis = requireFunctionUncurryThis();
1927
1928	functionUncurryThisClause = function (fn) {
1929	  // Nashorn bug:
1930	  //   https://github.com/zloirock/core-js/issues/1128
1931	  //   https://github.com/zloirock/core-js/issues/1130
1932	  if (classofRaw(fn) === 'Function') return uncurryThis(fn);
1933	};
1934	return functionUncurryThisClause;
1935}
1936
1937var functionBindContext;
1938var hasRequiredFunctionBindContext;
1939
1940function requireFunctionBindContext () {
1941	if (hasRequiredFunctionBindContext) return functionBindContext;
1942	hasRequiredFunctionBindContext = 1;
1943	var uncurryThis = requireFunctionUncurryThisClause();
1944	var aCallable = requireACallable();
1945	var NATIVE_BIND = requireFunctionBindNative();
1946
1947	var bind = uncurryThis(uncurryThis.bind);
1948

1949	// optional / simple context binding
1950	functionBindContext = function (fn, that) {
1951	  aCallable(fn);
1952	  return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
1953	    return fn.apply(that, arguments);
1954	  };
1955	};
1956	return functionBindContext;
1957}
1958
1959var html;
1960var hasRequiredHtml;
1961
1962function requireHtml () {
1963	if (hasRequiredHtml) return html;
1964	hasRequiredHtml = 1;
1965	var getBuiltIn = requireGetBuiltIn();
1966
1967	html = getBuiltIn('document', 'documentElement');
1968	return html;
1969}
1970
1971var arraySlice;
1972var hasRequiredArraySlice;
1973
1974function requireArraySlice () {
1975	if (hasRequiredArraySlice) return arraySlice;
1976	hasRequiredArraySlice = 1;
1977	var uncurryThis = requireFunctionUncurryThis();
1978
1979	arraySlice = uncurryThis([].slice);
1980	return arraySlice;
1981}
1982
1983var validateArgumentsLength;
1984var hasRequiredValidateArgumentsLength;
1985
1986function requireValidateArgumentsLength () {
1987	if (hasRequiredValidateArgumentsLength) return validateArgumentsLength;
1988	hasRequiredValidateArgumentsLength = 1;
1989	var $TypeError = TypeError;
1990
1991	validateArgumentsLength = function (passed, required) {
1992	  if (passed < required) throw new $TypeError('Not enough arguments');
1993	  return passed;
1994	};
1995	return validateArgumentsLength;
1996}
1997
1998var environmentIsIos;
1999var hasRequiredEnvironmentIsIos;
2000
2001function requireEnvironmentIsIos () {
2002	if (hasRequiredEnvironmentIsIos) return environmentIsIos;
2003	hasRequiredEnvironmentIsIos = 1;
2004	var userAgent = requireEnvironmentUserAgent();
2005
2006	environmentIsIos = /ipad|iphone|ipod/i.test(userAgent) && /applewebkit/i.test(userAgent);
2007	return environmentIsIos;
2008}
2009
2010var task;
2011var hasRequiredTask;
2012
2013function requireTask () {
2014	if (hasRequiredTask) return task;
2015	hasRequiredTask = 1;
2016	var globalThis = requireGlobalThis();
2017	var apply = requireFunctionApply();
2018	var bind = requireFunctionBindContext();
2019	var isCallable = requireIsCallable();
2020	var hasOwn = requireHasOwnProperty();
2021	var fails = requireFails();
2022	var html = requireHtml();
2023	var arraySlice = requireArraySlice();
2024	var createElement = requireDocumentCreateElement();
2025	var validateArgumentsLength = requireValidateArgumentsLength();
2026	var IS_IOS = requireEnvironmentIsIos();
2027	var IS_NODE = requireEnvironmentIsNode();
2028
2029	var set = globalThis.setImmediate;
2030	var clear = globalThis.clearImmediate;
2031	var process = globalThis.process;
2032	var Dispatch = globalThis.Dispatch;
2033	var Function = globalThis.Function;
2034	var MessageChannel = globalThis.MessageChannel;
2035	var String = globalThis.String;
2036	var counter = 0;
2037	var queue = {};
2038	var ONREADYSTATECHANGE = 'onreadystatechange';
2039	var $location, defer, channel, port;
2040
2041	fails(function () {
2042	  // Deno throws a ReferenceError on `location` access without `--location` flag
2043	  $location = globalThis.location;
2044	});
2045
2046	var run = function (id) {
2047	  if (hasOwn(queue, id)) {
2048	    var fn = queue[id];
2049	    delete queue[id];
2050	    fn();
2051	  }
2052	};
2053
2054	var runner = function (id) {
2055	  return function () {
2056	    run(id);
2057	  };
2058	};
2059
2060	var eventListener = function (event) {
2061	  run(event.data);
2062	};
2063
2064	var globalPostMessageDefer = function (id) {
2065	  // old engines have not location.origin
2066	  globalThis.postMessage(String(id), $location.protocol + '//' + $location.host);
2067	};
2068
2069	// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
2070	if (!set || !clear) {
2071	  set = function setImmediate(handler) {
2072	    validateArgumentsLength(arguments.length, 1);
2073	    var fn = isCallable(handler) ? handler : Function(handler);
2074	    var args = arraySlice(arguments, 1);
2075	    queue[++counter] = function () {
2076	      apply(fn, undefined, args);
2077	    };
2078	    defer(counter);
2079	    return counter;
2080	  };
2081	  clear = function clearImmediate(id) {
2082	    delete queue[id];
2083	  };
2084	  // Node.js 0.8-
2085	  if (IS_NODE) {
2086	    defer = function (id) {
2087	      process.nextTick(runner(id));
2088	    };
2089	  // Sphere (JS game engine) Dispatch API
2090	  } else if (Dispatch && Dispatch.now) {
2091	    defer = function (id) {
2092	      Dispatch.now(runner(id));
2093	    };
2094	  // Browsers with MessageChannel, includes WebWorkers
2095	  // except iOS - https://github.com/zloirock/core-js/issues/624
2096	  } else if (MessageChannel && !IS_IOS) {
2097	    channel = new MessageChannel();
2098	    port = channel.port2;
2099	    channel.port1.onmessage = eventListener;
2100	    defer = bind(port.postMessage, port);
2101	  // Browsers with postMessage, skip WebWorkers
2102	  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
2103	  } else if (
2104	    globalThis.addEventListener &&
2105	    isCallable(globalThis.postMessage) &&
2106	    !globalThis.importScripts &&
2107	    $location && $location.protocol !== 'file:' &&
2108	    !fails(globalPostMessageDefer)
2109	  ) {
2110	    defer = globalPostMessageDefer;
2111	    globalThis.addEventListener('message', eventListener, false);
2112	  // IE8-
2113	  } else if (ONREADYSTATECHANGE in createElement('script')) {
2114	    defer = function (id) {
2115	      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
2116	        html.removeChild(this);
2117	        run(id);
2118	      };
2119	    };
2120	  // Rest old browsers
2121	  } else {
2122	    defer = function (id) {
2123	      setTimeout(runner(id), 0);
2124	    };
2125	  }
2126	}
2127
2128	task = {
2129	  set: set,
2130	  clear: clear
2131	};
2132	return task;
2133}
2134
2135var safeGetBuiltIn;
2136var hasRequiredSafeGetBuiltIn;
2137
2138function requireSafeGetBuiltIn () {
2139	if (hasRequiredSafeGetBuiltIn) return safeGetBuiltIn;
2140	hasRequiredSafeGetBuiltIn = 1;
2141	var globalThis = requireGlobalThis();
2142	var DESCRIPTORS = requireDescriptors();
2143
2144	// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2145	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2146
2147	// Avoid NodeJS experimental warning
2148	safeGetBuiltIn = function (name) {
2149	  if (!DESCRIPTORS) return globalThis[name];
2150	  var descriptor = getOwnPropertyDescriptor(globalThis, name);
2151	  return descriptor && descriptor.value;
2152	};
2153	return safeGetBuiltIn;
2154}
2155
2156var queue;
2157var hasRequiredQueue;
2158
2159function requireQueue () {
2160	if (hasRequiredQueue) return queue;
2161	hasRequiredQueue = 1;
2162	var Queue = function () {
2163	  this.head = null;
2164	  this.tail = null;
2165	};
2166
2167	Queue.prototype = {
2168	  add: function (item) {
2169	    var entry = { item: item, next: null };
2170	    var tail = this.tail;
2171	    if (tail) tail.next = entry;
2172	    else this.head = entry;
2173	    this.tail = entry;
2174	  },
2175	  get: function () {
2176	    var entry = this.head;
2177	    if (entry) {
2178	      var next = this.head = entry.next;
2179	      if (next === null) this.tail = null;
2180	      return entry.item;
2181	    }
2182	  }
2183	};
2184
2185	queue = Queue;
2186	return queue;
2187}
2188
2189var environmentIsIosPebble;
2190var hasRequiredEnvironmentIsIosPebble;
2191
2192function requireEnvironmentIsIosPebble () {
2193	if (hasRequiredEnvironmentIsIosPebble) return environmentIsIosPebble;
2194	hasRequiredEnvironmentIsIosPebble = 1;
2195	var userAgent = requireEnvironmentUserAgent();
2196
2197	environmentIsIosPebble = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';
2198	return environmentIsIosPebble;
2199}
2200
2201var environmentIsWebosWebkit;
2202var hasRequiredEnvironmentIsWebosWebkit;
2203
2204function requireEnvironmentIsWebosWebkit () {
2205	if (hasRequiredEnvironmentIsWebosWebkit) return environmentIsWebosWebkit;
2206	hasRequiredEnvironmentIsWebosWebkit = 1;
2207	var userAgent = requireEnvironmentUserAgent();
2208
2209	environmentIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
2210	return environmentIsWebosWebkit;
2211}
2212
2213var microtask_1;
2214var hasRequiredMicrotask;
2215
2216function requireMicrotask () {
2217	if (hasRequiredMicrotask) return microtask_1;
2218	hasRequiredMicrotask = 1;
2219	var globalThis = requireGlobalThis();
2220	var safeGetBuiltIn = requireSafeGetBuiltIn();
2221	var bind = requireFunctionBindContext();
2222	var macrotask = requireTask().set;
2223	var Queue = requireQueue();
2224	var IS_IOS = requireEnvironmentIsIos();
2225	var IS_IOS_PEBBLE = requireEnvironmentIsIosPebble();
2226	var IS_WEBOS_WEBKIT = requireEnvironmentIsWebosWebkit();
2227	var IS_NODE = requireEnvironmentIsNode();
2228
2229	var MutationObserver = globalThis.MutationObserver || globalThis.WebKitMutationObserver;
2230	var document = globalThis.document;
2231	var process = globalThis.process;
2232	var Promise = globalThis.Promise;
2233	var microtask = safeGetBuiltIn('queueMicrotask');
2234	var notify, toggle, node, promise, then;
2235
2236	// modern engines have queueMicrotask method
2237	if (!microtask) {
2238	  var queue = new Queue();
2239
2240	  var flush = function () {
2241	    var parent, fn;
2242	    if (IS_NODE && (parent = process.domain)) parent.exit();
2243	    while (fn = queue.get()) try {
2244	      fn();
2245	    } catch (error) {
2246	      if (queue.head) notify();
2247	      throw error;
2248	    }
2249	    if (parent) parent.enter();
2250	  };
2251
2252	  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
2253	  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
2254	  if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {
2255	    toggle = true;
2256	    node = document.createTextNode('');
2257	    new MutationObserver(flush).observe(node, { characterData: true });
2258	    notify = function () {
2259	      node.data = toggle = !toggle;
2260	    };
2261	  // environments with maybe non-completely correct, but existent Promise
2262	  } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {
2263	    // Promise.resolve without an argument throws an error in LG WebOS 2
2264	    promise = Promise.resolve(undefined);
2265	    // workaround of WebKit ~ iOS Safari 10.1 bug
2266	    promise.constructor = Promise;
2267	    then = bind(promise.then, promise);
2268	    notify = function () {
2269	      then(flush);
2270	    };
2271	  // Node.js without promises
2272	  } else if (IS_NODE) {
2273	    notify = function () {
2274	      process.nextTick(flush);
2275	    };
2276	  // for other environments - macrotask based on:
2277	  // - setImmediate
2278	  // - MessageChannel
2279	  // - window.postMessage
2280	  // - onreadystatechange
2281	  // - setTimeout
2282	  } else {
2283	    // `webpack` dev server bug on IE global methods - use bind(fn, global)
2284	    macrotask = bind(macrotask, globalThis);
2285	    notify = function () {
2286	      macrotask(flush);
2287	    };
2288	  }
2289
2290	  microtask = function (fn) {
2291	    if (!queue.head) notify();
2292	    queue.add(fn);
2293	  };
2294	}
2295
2296	microtask_1 = microtask;
2297	return microtask_1;
2298}
2299
2300var hostReportErrors;
2301var hasRequiredHostReportErrors;
2302
2303function requireHostReportErrors () {
2304	if (hasRequiredHostReportErrors) return hostReportErrors;
2305	hasRequiredHostReportErrors = 1;
2306	hostReportErrors = function (a, b) {
2307	  try {
2308	    // eslint-disable-next-line no-console -- safe
2309	    arguments.length === 1 ? console.error(a) : console.error(a, b);
2310	  } catch (error) { /* empty */ }
2311	};
2312	return hostReportErrors;
2313}
2314
2315var perform;
2316var hasRequiredPerform;
2317
2318function requirePerform () {
2319	if (hasRequiredPerform) return perform;
2320	hasRequiredPerform = 1;
2321	perform = function (exec) {
2322	  try {
2323	    return { error: false, value: exec() };
2324	  } catch (error) {
2325	    return { error: true, value: error };
2326	  }
2327	};
2328	return perform;
2329}
2330
2331var promiseNativeConstructor;
2332var hasRequiredPromiseNativeConstructor;
2333
2334function requirePromiseNativeConstructor () {
2335	if (hasRequiredPromiseNativeConstructor) return promiseNativeConstructor;
2336	hasRequiredPromiseNativeConstructor = 1;
2337	var globalThis = requireGlobalThis();
2338
2339	promiseNativeConstructor = globalThis.Promise;
2340	return promiseNativeConstructor;
2341}
2342
2343var promiseConstructorDetection;
2344var hasRequiredPromiseConstructorDetection;
2345
2346function requirePromiseConstructorDetection () {
2347	if (hasRequiredPromiseConstructorDetection) return promiseConstructorDetection;
2348	hasRequiredPromiseConstructorDetection = 1;
2349	var globalThis = requireGlobalThis();
2350	var NativePromiseConstructor = requirePromiseNativeConstructor();
2351	var isCallable = requireIsCallable();
2352	var isForced = requireIsForced();
2353	var inspectSource = requireInspectSource();
2354	var wellKnownSymbol = requireWellKnownSymbol();
2355	var ENVIRONMENT = requireEnvironment();
2356	var IS_PURE = requireIsPure();
2357	var V8_VERSION = requireEnvironmentV8Version();
2358
2359	var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
2360	var SPECIES = wellKnownSymbol('species');
2361	var SUBCLASSING = false;
2362	var NATIVE_PROMISE_REJECTION_EVENT = isCallable(globalThis.PromiseRejectionEvent);
2363
2364	var FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {
2365	  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);
2366	  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);
2367	  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
2368	  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
2369	  // We can't detect it synchronously, so just check versions
2370	  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
2371	  // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution
2372	  if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;
2373	  // We can't use @@species feature detection in V8 since it causes
2374	  // deoptimization and performance degradation
2375	  // https://github.com/zloirock/core-js/issues/679
2376	  if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
2377	    // Detect correctness of subclassing with @@species support
2378	    var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });
2379	    var FakePromise = function (exec) {
2380	      exec(function () { /* empty */ }, function () { /* empty */ });
2381	    };
2382	    var constructor = promise.constructor = {};
2383	    constructor[SPECIES] = FakePromise;
2384	    SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
2385	    if (!SUBCLASSING) return true;
2386	  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
2387	  } return !GLOBAL_CORE_JS_PROMISE && (ENVIRONMENT === 'BROWSER' || ENVIRONMENT === 'DENO') && !NATIVE_PROMISE_REJECTION_EVENT;
2388	});
2389
2390	promiseConstructorDetection = {
2391	  CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,
2392	  REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,
2393	  SUBCLASSING: SUBCLASSING
2394	};
2395	return promiseConstructorDetection;
2396}
2397
2398var newPromiseCapability = {};
2399
2400var hasRequiredNewPromiseCapability;
2401
2402function requireNewPromiseCapability () {
2403	if (hasRequiredNewPromiseCapability) return newPromiseCapability;
2404	hasRequiredNewPromiseCapability = 1;
2405	var aCallable = requireACallable();
2406
2407	var $TypeError = TypeError;
2408
2409	var PromiseCapability = function (C) {
2410	  var resolve, reject;
2411	  this.promise = new C(function ($$resolve, $$reject) {
2412	    if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');
2413	    resolve = $$resolve;
2414	    reject = $$reject;
2415	  });
2416	  this.resolve = aCallable(resolve);
2417	  this.reject = aCallable(reject);
2418	};
2419
2420	// `NewPromiseCapability` abstract operation
2421	// https://tc39.es/ecma262/#sec-newpromisecapability
2422	newPromiseCapability.f = function (C) {
2423	  return new PromiseCapability(C);
2424	};
2425	return newPromiseCapability;
2426}
2427
2428var hasRequiredEs_promise_constructor;
2429
2430function requireEs_promise_constructor () {
2431	if (hasRequiredEs_promise_constructor) return es_promise_constructor;
2432	hasRequiredEs_promise_constructor = 1;
2433	var $ = require_export();
2434	var IS_PURE = requireIsPure();
2435	var IS_NODE = requireEnvironmentIsNode();
2436	var globalThis = requireGlobalThis();
2437	var path = requirePath();
2438	var call = requireFunctionCall();
2439	var defineBuiltIn = requireDefineBuiltIn();
2440	var setPrototypeOf = requireObjectSetPrototypeOf();
2441	var setToStringTag = requireSetToStringTag();
2442	var setSpecies = requireSetSpecies();
2443	var aCallable = requireACallable();
2444	var isCallable = requireIsCallable();
2445	var isObject = requireIsObject();
2446	var anInstance = requireAnInstance();
2447	var speciesConstructor = requireSpeciesConstructor();
2448	var task = requireTask().set;
2449	var microtask = requireMicrotask();
2450	var hostReportErrors = requireHostReportErrors();
2451	var perform = requirePerform();
2452	var Queue = requireQueue();
2453	var InternalStateModule = requireInternalState();
2454	var NativePromiseConstructor = requirePromiseNativeConstructor();
2455	var PromiseConstructorDetection = requirePromiseConstructorDetection();
2456	var newPromiseCapabilityModule = requireNewPromiseCapability();
2457
2458	var PROMISE = 'Promise';
2459	var FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;
2460	var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
2461	var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
2462	var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
2463	var setInternalState = InternalStateModule.set;
2464	var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
2465	var PromiseConstructor = NativePromiseConstructor;
2466	var PromisePrototype = NativePromisePrototype;
2467	var TypeError = globalThis.TypeError;
2468	var document = globalThis.document;
2469	var process = globalThis.process;
2470	var newPromiseCapability = newPromiseCapabilityModule.f;
2471	var newGenericPromiseCapability = newPromiseCapability;
2472
2473	var DISPATCH_EVENT = !!(document && document.createEvent && globalThis.dispatchEvent);
2474	var UNHANDLED_REJECTION = 'unhandledrejection';
2475	var REJECTION_HANDLED = 'rejectionhandled';
2476	var PENDING = 0;
2477	var FULFILLED = 1;
2478	var REJECTED = 2;
2479	var HANDLED = 1;
2480	var UNHANDLED = 2;
2481
2482	var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
2483
2484	// helpers
2485	var isThenable = function (it) {
2486	  var then;
2487	  return isObject(it) && isCallable(then = it.then) ? then : false;

2488	};
2489
2490	var callReaction = function (reaction, state) {
2491	  var value = state.value;
2492	  var ok = state.state === FULFILLED;
2493	  var handler = ok ? reaction.ok : reaction.fail;
2494	  var resolve = reaction.resolve;
2495	  var reject = reaction.reject;
2496	  var domain = reaction.domain;
2497	  var result, then, exited;
2498	  try {
2499	    if (handler) {
2500	      if (!ok) {
2501	        if (state.rejection === UNHANDLED) onHandleUnhandled(state);
2502	        state.rejection = HANDLED;
2503	      }
2504	      if (handler === true) result = value;
2505	      else {
2506	        if (domain) domain.enter();
2507	        result = handler(value); // can throw
2508	        if (domain) {
2509	          domain.exit();
2510	          exited = true;
2511	        }
2512	      }
2513	      if (result === reaction.promise) {
2514	        reject(new TypeError('Promise-chain cycle'));
2515	      } else if (then = isThenable(result)) {
2516	        call(then, result, resolve, reject);
2517	      } else resolve(result);
2518	    } else reject(value);
2519	  } catch (error) {
2520	    if (domain && !exited) domain.exit();
2521	    reject(error);
2522	  }
2523	};
2524
2525	var notify = function (state, isReject) {
2526	  if (state.notified) return;
2527	  state.notified = true;
2528	  microtask(function () {
2529	    var reactions = state.reactions;
2530	    var reaction;
2531	    while (reaction = reactions.get()) {
2532	      callReaction(reaction, state);
2533	    }
2534	    state.notified = false;
2535	    if (isReject && !state.rejection) onUnhandled(state);
2536	  });
2537	};
2538
2539	var dispatchEvent = function (name, promise, reason) {
2540	  var event, handler;
2541	  if (DISPATCH_EVENT) {
2542	    event = document.createEvent('Event');
2543	    event.promise = promise;
2544	    event.reason = reason;
2545	    event.initEvent(name, false, true);
2546	    globalThis.dispatchEvent(event);
2547	  } else event = { promise: promise, reason: reason };
2548	  if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = globalThis['on' + name])) handler(event);
2549	  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
2550	};
2551
2552	var onUnhandled = function (state) {
2553	  call(task, globalThis, function () {
2554	    var promise = state.facade;
2555	    var value = state.value;
2556	    var IS_UNHANDLED = isUnhandled(state);
2557	    var result;
2558	    if (IS_UNHANDLED) {
2559	      result = perform(function () {
2560	        if (IS_NODE) {
2561	          process.emit('unhandledRejection', value, promise);
2562	        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
2563	      });
2564	      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
2565	      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
2566	      if (result.error) throw result.value;
2567	    }
2568	  });
2569	};
2570
2571	var isUnhandled = function (state) {
2572	  return state.rejection !== HANDLED && !state.parent;
2573	};
2574
2575	var onHandleUnhandled = function (state) {
2576	  call(task, globalThis, function () {
2577	    var promise = state.facade;
2578	    if (IS_NODE) {
2579	      process.emit('rejectionHandled', promise);
2580	    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
2581	  });
2582	};
2583
2584	var bind = function (fn, state, unwrap) {
2585	  return function (value) {
2586	    fn(state, value, unwrap);
2587	  };
2588	};
2589
2590	var internalReject = function (state, value, unwrap) {
2591	  if (state.done) return;
2592	  state.done = true;
2593	  if (unwrap) state = unwrap;
2594	  state.value = value;
2595	  state.state = REJECTED;
2596	  notify(state, true);
2597	};
2598
2599	var internalResolve = function (state, value, unwrap) {
2600	  if (state.done) return;
2601	  state.done = true;
2602	  if (unwrap) state = unwrap;
2603	  try {
2604	    if (state.facade === value) throw new TypeError("Promise can't be resolved itself");
2605	    var then = isThenable(value);
2606	    if (then) {
2607	      microtask(function () {
2608	        var wrapper = { done: false };
2609	        try {
2610	          call(then, value,
2611	            bind(internalResolve, wrapper, state),
2612	            bind(internalReject, wrapper, state)
2613	          );
2614	        } catch (error) {
2615	          internalReject(wrapper, error, state);
2616	        }
2617	      });
2618	    } else {
2619	      state.value = value;
2620	      state.state = FULFILLED;
2621	      notify(state, false);
2622	    }
2623	  } catch (error) {
2624	    internalReject({ done: false }, error, state);
2625	  }
2626	};
2627
2628	// constructor polyfill
2629	if (FORCED_PROMISE_CONSTRUCTOR) {
2630	  // 25.4.3.1 Promise(executor)
2631	  PromiseConstructor = function Promise(executor) {
2632	    anInstance(this, PromisePrototype);
2633	    aCallable(executor);
2634	    call(Internal, this);
2635	    var state = getInternalPromiseState(this);
2636	    try {
2637	      executor(bind(internalResolve, state), bind(internalReject, state));
2638	    } catch (error) {
2639	      internalReject(state, error);
2640	    }
2641	  };
2642
2643	  PromisePrototype = PromiseConstructor.prototype;
2644
2645	  // eslint-disable-next-line no-unused-vars -- required for `.length`
2646	  Internal = function Promise(executor) {
2647	    setInternalState(this, {
2648	      type: PROMISE,
2649	      done: false,
2650	      notified: false,
2651	      parent: false,
2652	      reactions: new Queue(),
2653	      rejection: false,
2654	      state: PENDING,
2655	      value: null
2656	    });
2657	  };
2658
2659	  // `Promise.prototype.then` method
2660	  // https://tc39.es/ecma262/#sec-promise.prototype.then
2661	  Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
2662	    var state = getInternalPromiseState(this);
2663	    var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
2664	    state.parent = true;