@dotcms/experiments 0.0.1-alpha.28 → 0.0.1-alpha.29

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/index.esm.js +1071 -620
  2. package/package.json +2 -2
package/index.esm.js CHANGED
@@ -10,7 +10,7 @@ var check = function (it) {
10
10
  };
11
11
 
12
12
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
13
- var global$o =
13
+ var global$p =
14
14
  // eslint-disable-next-line es/no-global-this -- safe
15
15
  check(typeof globalThis == 'object' && globalThis) ||
16
16
  check(typeof window == 'object' && window) ||
@@ -23,7 +23,7 @@ var global$o =
23
23
 
24
24
  var objectGetOwnPropertyDescriptor = {};
25
25
 
26
- var fails$l = function (exec) {
26
+ var fails$n = function (exec) {
27
27
  try {
28
28
  return !!exec();
29
29
  } catch (error) {
@@ -31,17 +31,17 @@ var fails$l = function (exec) {
31
31
  }
32
32
  };
33
33
 
34
- var fails$k = fails$l;
34
+ var fails$m = fails$n;
35
35
 
36
36
  // Detect IE8's incomplete defineProperty implementation
37
- var descriptors = !fails$k(function () {
37
+ var descriptors = !fails$m(function () {
38
38
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
39
39
  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
40
40
  });
41
41
 
42
- var fails$j = fails$l;
42
+ var fails$l = fails$n;
43
43
 
44
- var functionBindNative = !fails$j(function () {
44
+ var functionBindNative = !fails$l(function () {
45
45
  // eslint-disable-next-line es/no-function-prototype-bind -- safe
46
46
  var test = (function () { /* empty */ }).bind();
47
47
  // eslint-disable-next-line no-prototype-builtins -- safe
@@ -50,10 +50,10 @@ var functionBindNative = !fails$j(function () {
50
50
 
51
51
  var NATIVE_BIND$3 = functionBindNative;
52
52
 
53
- var call$l = Function.prototype.call;
53
+ var call$n = Function.prototype.call;
54
54
 
55
- var functionCall = NATIVE_BIND$3 ? call$l.bind(call$l) : function () {
56
- return call$l.apply(call$l, arguments);
55
+ var functionCall = NATIVE_BIND$3 ? call$n.bind(call$n) : function () {
56
+ return call$n.apply(call$n, arguments);
57
57
  };
58
58
 
59
59
  var objectPropertyIsEnumerable = {};
@@ -72,7 +72,7 @@ objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
72
72
  return !!descriptor && descriptor.enumerable;
73
73
  } : $propertyIsEnumerable;
74
74
 
75
- var createPropertyDescriptor$5 = function (bitmap, value) {
75
+ var createPropertyDescriptor$6 = function (bitmap, value) {
76
76
  return {
77
77
  enumerable: !(bitmap & 1),
78
78
  configurable: !(bitmap & 2),
@@ -84,38 +84,38 @@ var createPropertyDescriptor$5 = function (bitmap, value) {
84
84
  var NATIVE_BIND$2 = functionBindNative;
85
85
 
86
86
  var FunctionPrototype$2 = Function.prototype;
87
- var call$k = FunctionPrototype$2.call;
88
- var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$2.bind.bind(call$k, call$k);
87
+ var call$m = FunctionPrototype$2.call;
88
+ var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$2.bind.bind(call$m, call$m);
89
89
 
90
90
  var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function (fn) {
91
91
  return function () {
92
- return call$k.apply(fn, arguments);
92
+ return call$m.apply(fn, arguments);
93
93
  };
94
94
  };
95
95
 
96
- var uncurryThis$l = functionUncurryThis;
96
+ var uncurryThis$r = functionUncurryThis;
97
97
 
98
- var toString$8 = uncurryThis$l({}.toString);
99
- var stringSlice$6 = uncurryThis$l(''.slice);
98
+ var toString$d = uncurryThis$r({}.toString);
99
+ var stringSlice$6 = uncurryThis$r(''.slice);
100
100
 
101
101
  var classofRaw$2 = function (it) {
102
- return stringSlice$6(toString$8(it), 8, -1);
102
+ return stringSlice$6(toString$d(it), 8, -1);
103
103
  };
104
104
 
105
- var uncurryThis$k = functionUncurryThis;
106
- var fails$i = fails$l;
107
- var classof$8 = classofRaw$2;
105
+ var uncurryThis$q = functionUncurryThis;
106
+ var fails$k = fails$n;
107
+ var classof$b = classofRaw$2;
108
108
 
109
109
  var $Object$4 = Object;
110
- var split$3 = uncurryThis$k(''.split);
110
+ var split$3 = uncurryThis$q(''.split);
111
111
 
112
112
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
113
- var indexedObject = fails$i(function () {
113
+ var indexedObject = fails$k(function () {
114
114
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
115
115
  // eslint-disable-next-line no-prototype-builtins -- safe
116
116
  return !$Object$4('z').propertyIsEnumerable(0);
117
117
  }) ? function (it) {
118
- return classof$8(it) === 'String' ? split$3(it, '') : $Object$4(it);
118
+ return classof$b(it) === 'String' ? split$3(it, '') : $Object$4(it);
119
119
  } : $Object$4;
120
120
 
121
121
  // we can't use just `it == null` since of `document.all` special case
@@ -126,12 +126,12 @@ var isNullOrUndefined$5 = function (it) {
126
126
 
127
127
  var isNullOrUndefined$4 = isNullOrUndefined$5;
128
128
 
129
- var $TypeError$e = TypeError;
129
+ var $TypeError$f = TypeError;
130
130
 
131
131
  // `RequireObjectCoercible` abstract operation
132
132
  // https://tc39.es/ecma262/#sec-requireobjectcoercible
133
133
  var requireObjectCoercible$6 = function (it) {
134
- if (isNullOrUndefined$4(it)) throw new $TypeError$e("Can't call method on " + it);
134
+ if (isNullOrUndefined$4(it)) throw new $TypeError$f("Can't call method on " + it);
135
135
  return it;
136
136
  };
137
137
 
@@ -149,40 +149,40 @@ var documentAll = typeof document == 'object' && document.all;
149
149
  // `IsCallable` abstract operation
150
150
  // https://tc39.es/ecma262/#sec-iscallable
151
151
  // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
152
- var isCallable$m = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
152
+ var isCallable$p = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
153
153
  return typeof argument == 'function' || argument === documentAll;
154
154
  } : function (argument) {
155
155
  return typeof argument == 'function';
156
156
  };
157
157
 
158
- var isCallable$l = isCallable$m;
158
+ var isCallable$o = isCallable$p;
159
159
 
160
- var isObject$d = function (it) {
161
- return typeof it == 'object' ? it !== null : isCallable$l(it);
160
+ var isObject$e = function (it) {
161
+ return typeof it == 'object' ? it !== null : isCallable$o(it);
162
162
  };
163
163
 
164
- var global$n = global$o;
165
- var isCallable$k = isCallable$m;
164
+ var global$o = global$p;
165
+ var isCallable$n = isCallable$p;
166
166
 
167
167
  var aFunction = function (argument) {
168
- return isCallable$k(argument) ? argument : undefined;
168
+ return isCallable$n(argument) ? argument : undefined;
169
169
  };
170
170
 
171
- var getBuiltIn$7 = function (namespace, method) {
172
- return arguments.length < 2 ? aFunction(global$n[namespace]) : global$n[namespace] && global$n[namespace][method];
171
+ var getBuiltIn$9 = function (namespace, method) {
172
+ return arguments.length < 2 ? aFunction(global$o[namespace]) : global$o[namespace] && global$o[namespace][method];
173
173
  };
174
174
 
175
- var uncurryThis$j = functionUncurryThis;
175
+ var uncurryThis$p = functionUncurryThis;
176
176
 
177
- var objectIsPrototypeOf = uncurryThis$j({}.isPrototypeOf);
177
+ var objectIsPrototypeOf = uncurryThis$p({}.isPrototypeOf);
178
178
 
179
179
  var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
180
180
 
181
- var global$m = global$o;
181
+ var global$n = global$p;
182
182
  var userAgent$3 = engineUserAgent;
183
183
 
184
- var process$3 = global$m.process;
185
- var Deno$1 = global$m.Deno;
184
+ var process$3 = global$n.process;
185
+ var Deno$1 = global$n.Deno;
186
186
  var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version;
187
187
  var v8 = versions && versions.v8;
188
188
  var match, version;
@@ -208,63 +208,63 @@ var engineV8Version = version;
208
208
 
209
209
  /* eslint-disable es/no-symbol -- required for testing */
210
210
  var V8_VERSION$1 = engineV8Version;
211
- var fails$h = fails$l;
212
- var global$l = global$o;
211
+ var fails$j = fails$n;
212
+ var global$m = global$p;
213
213
 
214
- var $String$5 = global$l.String;
214
+ var $String$6 = global$m.String;
215
215
 
216
216
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
217
- var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$h(function () {
217
+ var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$j(function () {
218
218
  var symbol = Symbol('symbol detection');
219
219
  // Chrome 38 Symbol has incorrect toString conversion
220
220
  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
221
221
  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
222
222
  // of course, fail.
223
- return !$String$5(symbol) || !(Object(symbol) instanceof Symbol) ||
223
+ return !$String$6(symbol) || !(Object(symbol) instanceof Symbol) ||
224
224
  // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
225
225
  !Symbol.sham && V8_VERSION$1 && V8_VERSION$1 < 41;
226
226
  });
227
227
 
228
228
  /* eslint-disable es/no-symbol -- required for testing */
229
- var NATIVE_SYMBOL$1 = symbolConstructorDetection;
229
+ var NATIVE_SYMBOL$2 = symbolConstructorDetection;
230
230
 
231
- var useSymbolAsUid = NATIVE_SYMBOL$1
231
+ var useSymbolAsUid = NATIVE_SYMBOL$2
232
232
  && !Symbol.sham
233
233
  && typeof Symbol.iterator == 'symbol';
234
234
 
235
- var getBuiltIn$6 = getBuiltIn$7;
236
- var isCallable$j = isCallable$m;
237
- var isPrototypeOf$4 = objectIsPrototypeOf;
235
+ var getBuiltIn$8 = getBuiltIn$9;
236
+ var isCallable$m = isCallable$p;
237
+ var isPrototypeOf$5 = objectIsPrototypeOf;
238
238
  var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
239
239
 
240
240
  var $Object$3 = Object;
241
241
 
242
- var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
242
+ var isSymbol$3 = USE_SYMBOL_AS_UID$1 ? function (it) {
243
243
  return typeof it == 'symbol';
244
244
  } : function (it) {
245
- var $Symbol = getBuiltIn$6('Symbol');
246
- return isCallable$j($Symbol) && isPrototypeOf$4($Symbol.prototype, $Object$3(it));
245
+ var $Symbol = getBuiltIn$8('Symbol');
246
+ return isCallable$m($Symbol) && isPrototypeOf$5($Symbol.prototype, $Object$3(it));
247
247
  };
248
248
 
249
- var $String$4 = String;
249
+ var $String$5 = String;
250
250
 
251
251
  var tryToString$4 = function (argument) {
252
252
  try {
253
- return $String$4(argument);
253
+ return $String$5(argument);
254
254
  } catch (error) {
255
255
  return 'Object';
256
256
  }
257
257
  };
258
258
 
259
- var isCallable$i = isCallable$m;
259
+ var isCallable$l = isCallable$p;
260
260
  var tryToString$3 = tryToString$4;
261
261
 
262
- var $TypeError$d = TypeError;
262
+ var $TypeError$e = TypeError;
263
263
 
264
264
  // `Assert: IsCallable(argument) is true`
265
265
  var aCallable$8 = function (argument) {
266
- if (isCallable$i(argument)) return argument;
267
- throw new $TypeError$d(tryToString$3(argument) + ' is not a function');
266
+ if (isCallable$l(argument)) return argument;
267
+ throw new $TypeError$e(tryToString$3(argument) + ' is not a function');
268
268
  };
269
269
 
270
270
  var aCallable$7 = aCallable$8;
@@ -277,50 +277,50 @@ var getMethod$4 = function (V, P) {
277
277
  return isNullOrUndefined$3(func) ? undefined : aCallable$7(func);
278
278
  };
279
279
 
280
- var call$j = functionCall;
281
- var isCallable$h = isCallable$m;
282
- var isObject$c = isObject$d;
280
+ var call$l = functionCall;
281
+ var isCallable$k = isCallable$p;
282
+ var isObject$d = isObject$e;
283
283
 
284
- var $TypeError$c = TypeError;
284
+ var $TypeError$d = TypeError;
285
285
 
286
286
  // `OrdinaryToPrimitive` abstract operation
287
287
  // https://tc39.es/ecma262/#sec-ordinarytoprimitive
288
288
  var ordinaryToPrimitive$1 = function (input, pref) {
289
289
  var fn, val;
290
- if (pref === 'string' && isCallable$h(fn = input.toString) && !isObject$c(val = call$j(fn, input))) return val;
291
- if (isCallable$h(fn = input.valueOf) && !isObject$c(val = call$j(fn, input))) return val;
292
- if (pref !== 'string' && isCallable$h(fn = input.toString) && !isObject$c(val = call$j(fn, input))) return val;
293
- throw new $TypeError$c("Can't convert object to primitive value");
290
+ if (pref === 'string' && isCallable$k(fn = input.toString) && !isObject$d(val = call$l(fn, input))) return val;
291
+ if (isCallable$k(fn = input.valueOf) && !isObject$d(val = call$l(fn, input))) return val;
292
+ if (pref !== 'string' && isCallable$k(fn = input.toString) && !isObject$d(val = call$l(fn, input))) return val;
293
+ throw new $TypeError$d("Can't convert object to primitive value");
294
294
  };
295
295
 
296
296
  var sharedStore = {exports: {}};
297
297
 
298
298
  var isPure = false;
299
299
 
300
- var global$k = global$o;
300
+ var global$l = global$p;
301
301
 
302
302
  // eslint-disable-next-line es/no-object-defineproperty -- safe
303
303
  var defineProperty$7 = Object.defineProperty;
304
304
 
305
305
  var defineGlobalProperty$3 = function (key, value) {
306
306
  try {
307
- defineProperty$7(global$k, key, { value: value, configurable: true, writable: true });
307
+ defineProperty$7(global$l, key, { value: value, configurable: true, writable: true });
308
308
  } catch (error) {
309
- global$k[key] = value;
309
+ global$l[key] = value;
310
310
  } return value;
311
311
  };
312
312
 
313
- var globalThis$1 = global$o;
313
+ var globalThis$1 = global$p;
314
314
  var defineGlobalProperty$2 = defineGlobalProperty$3;
315
315
 
316
316
  var SHARED = '__core-js_shared__';
317
317
  var store$3 = sharedStore.exports = globalThis$1[SHARED] || defineGlobalProperty$2(SHARED, {});
318
318
 
319
319
  (store$3.versions || (store$3.versions = [])).push({
320
- version: '3.37.1',
320
+ version: '3.36.1',
321
321
  mode: 'global',
322
322
  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
323
- license: 'https://github.com/zloirock/core-js/blob/v3.37.1/LICENSE',
323
+ license: 'https://github.com/zloirock/core-js/blob/v3.36.1/LICENSE',
324
324
  source: 'https://github.com/zloirock/core-js'
325
325
  });
326
326
 
@@ -340,10 +340,10 @@ var toObject$4 = function (argument) {
340
340
  return $Object$2(requireObjectCoercible$4(argument));
341
341
  };
342
342
 
343
- var uncurryThis$i = functionUncurryThis;
343
+ var uncurryThis$o = functionUncurryThis;
344
344
  var toObject$3 = toObject$4;
345
345
 
346
- var hasOwnProperty = uncurryThis$i({}.hasOwnProperty);
346
+ var hasOwnProperty = uncurryThis$o({}.hasOwnProperty);
347
347
 
348
348
  // `HasOwnProperty` abstract operation
349
349
  // https://tc39.es/ecma262/#sec-hasownproperty
@@ -352,101 +352,101 @@ var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
352
352
  return hasOwnProperty(toObject$3(it), key);
353
353
  };
354
354
 
355
- var uncurryThis$h = functionUncurryThis;
355
+ var uncurryThis$n = functionUncurryThis;
356
356
 
357
357
  var id = 0;
358
358
  var postfix = Math.random();
359
- var toString$7 = uncurryThis$h(1.0.toString);
359
+ var toString$c = uncurryThis$n(1.0.toString);
360
360
 
361
361
  var uid$2 = function (key) {
362
- return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$7(++id + postfix, 36);
362
+ return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$c(++id + postfix, 36);
363
363
  };
364
364
 
365
- var global$j = global$o;
365
+ var global$k = global$p;
366
366
  var shared$3 = shared$4;
367
- var hasOwn$d = hasOwnProperty_1;
367
+ var hasOwn$e = hasOwnProperty_1;
368
368
  var uid$1 = uid$2;
369
- var NATIVE_SYMBOL = symbolConstructorDetection;
369
+ var NATIVE_SYMBOL$1 = symbolConstructorDetection;
370
370
  var USE_SYMBOL_AS_UID = useSymbolAsUid;
371
371
 
372
- var Symbol$1 = global$j.Symbol;
372
+ var Symbol$1 = global$k.Symbol;
373
373
  var WellKnownSymbolsStore = shared$3('wks');
374
374
  var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
375
375
 
376
376
  var wellKnownSymbol$k = function (name) {
377
- if (!hasOwn$d(WellKnownSymbolsStore, name)) {
378
- WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$d(Symbol$1, name)
377
+ if (!hasOwn$e(WellKnownSymbolsStore, name)) {
378
+ WellKnownSymbolsStore[name] = NATIVE_SYMBOL$1 && hasOwn$e(Symbol$1, name)
379
379
  ? Symbol$1[name]
380
380
  : createWellKnownSymbol('Symbol.' + name);
381
381
  } return WellKnownSymbolsStore[name];
382
382
  };
383
383
 
384
- var call$i = functionCall;
385
- var isObject$b = isObject$d;
386
- var isSymbol$1 = isSymbol$2;
384
+ var call$k = functionCall;
385
+ var isObject$c = isObject$e;
386
+ var isSymbol$2 = isSymbol$3;
387
387
  var getMethod$3 = getMethod$4;
388
388
  var ordinaryToPrimitive = ordinaryToPrimitive$1;
389
389
  var wellKnownSymbol$j = wellKnownSymbol$k;
390
390
 
391
- var $TypeError$b = TypeError;
391
+ var $TypeError$c = TypeError;
392
392
  var TO_PRIMITIVE = wellKnownSymbol$j('toPrimitive');
393
393
 
394
394
  // `ToPrimitive` abstract operation
395
395
  // https://tc39.es/ecma262/#sec-toprimitive
396
396
  var toPrimitive$1 = function (input, pref) {
397
- if (!isObject$b(input) || isSymbol$1(input)) return input;
397
+ if (!isObject$c(input) || isSymbol$2(input)) return input;
398
398
  var exoticToPrim = getMethod$3(input, TO_PRIMITIVE);
399
399
  var result;
400
400
  if (exoticToPrim) {
401
401
  if (pref === undefined) pref = 'default';
402
- result = call$i(exoticToPrim, input, pref);
403
- if (!isObject$b(result) || isSymbol$1(result)) return result;
404
- throw new $TypeError$b("Can't convert object to primitive value");
402
+ result = call$k(exoticToPrim, input, pref);
403
+ if (!isObject$c(result) || isSymbol$2(result)) return result;
404
+ throw new $TypeError$c("Can't convert object to primitive value");
405
405
  }
406
406
  if (pref === undefined) pref = 'number';
407
407
  return ordinaryToPrimitive(input, pref);
408
408
  };
409
409
 
410
410
  var toPrimitive = toPrimitive$1;
411
- var isSymbol = isSymbol$2;
411
+ var isSymbol$1 = isSymbol$3;
412
412
 
413
413
  // `ToPropertyKey` abstract operation
414
414
  // https://tc39.es/ecma262/#sec-topropertykey
415
415
  var toPropertyKey$2 = function (argument) {
416
416
  var key = toPrimitive(argument, 'string');
417
- return isSymbol(key) ? key : key + '';
417
+ return isSymbol$1(key) ? key : key + '';
418
418
  };
419
419
 
420
- var global$i = global$o;
421
- var isObject$a = isObject$d;
420
+ var global$j = global$p;
421
+ var isObject$b = isObject$e;
422
422
 
423
- var document$3 = global$i.document;
423
+ var document$3 = global$j.document;
424
424
  // typeof document.createElement is 'object' in old IE
425
- var EXISTS$1 = isObject$a(document$3) && isObject$a(document$3.createElement);
425
+ var EXISTS$1 = isObject$b(document$3) && isObject$b(document$3.createElement);
426
426
 
427
427
  var documentCreateElement$2 = function (it) {
428
428
  return EXISTS$1 ? document$3.createElement(it) : {};
429
429
  };
430
430
 
431
- var DESCRIPTORS$g = descriptors;
432
- var fails$g = fails$l;
431
+ var DESCRIPTORS$j = descriptors;
432
+ var fails$i = fails$n;
433
433
  var createElement$1 = documentCreateElement$2;
434
434
 
435
435
  // Thanks to IE8 for its funny defineProperty
436
- var ie8DomDefine = !DESCRIPTORS$g && !fails$g(function () {
436
+ var ie8DomDefine = !DESCRIPTORS$j && !fails$i(function () {
437
437
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
438
438
  return Object.defineProperty(createElement$1('div'), 'a', {
439
439
  get: function () { return 7; }
440
440
  }).a !== 7;
441
441
  });
442
442
 
443
- var DESCRIPTORS$f = descriptors;
444
- var call$h = functionCall;
443
+ var DESCRIPTORS$i = descriptors;
444
+ var call$j = functionCall;
445
445
  var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
446
- var createPropertyDescriptor$4 = createPropertyDescriptor$5;
446
+ var createPropertyDescriptor$5 = createPropertyDescriptor$6;
447
447
  var toIndexedObject$4 = toIndexedObject$5;
448
448
  var toPropertyKey$1 = toPropertyKey$2;
449
- var hasOwn$c = hasOwnProperty_1;
449
+ var hasOwn$d = hasOwnProperty_1;
450
450
  var IE8_DOM_DEFINE$1 = ie8DomDefine;
451
451
 
452
452
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -454,23 +454,23 @@ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
454
454
 
455
455
  // `Object.getOwnPropertyDescriptor` method
456
456
  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
457
- objectGetOwnPropertyDescriptor.f = DESCRIPTORS$f ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
457
+ objectGetOwnPropertyDescriptor.f = DESCRIPTORS$i ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
458
458
  O = toIndexedObject$4(O);
459
459
  P = toPropertyKey$1(P);
460
460
  if (IE8_DOM_DEFINE$1) try {
461
461
  return $getOwnPropertyDescriptor$1(O, P);
462
462
  } catch (error) { /* empty */ }
463
- if (hasOwn$c(O, P)) return createPropertyDescriptor$4(!call$h(propertyIsEnumerableModule$1.f, O, P), O[P]);
463
+ if (hasOwn$d(O, P)) return createPropertyDescriptor$5(!call$j(propertyIsEnumerableModule$1.f, O, P), O[P]);
464
464
  };
465
465
 
466
466
  var objectDefineProperty = {};
467
467
 
468
- var DESCRIPTORS$e = descriptors;
469
- var fails$f = fails$l;
468
+ var DESCRIPTORS$h = descriptors;
469
+ var fails$h = fails$n;
470
470
 
471
471
  // V8 ~ Chrome 36-
472
472
  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
473
- var v8PrototypeDefineBug = DESCRIPTORS$e && fails$f(function () {
473
+ var v8PrototypeDefineBug = DESCRIPTORS$h && fails$h(function () {
474
474
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
475
475
  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
476
476
  value: 42,
@@ -478,24 +478,24 @@ var v8PrototypeDefineBug = DESCRIPTORS$e && fails$f(function () {
478
478
  }).prototype !== 42;
479
479
  });
480
480
 
481
- var isObject$9 = isObject$d;
481
+ var isObject$a = isObject$e;
482
482
 
483
- var $String$3 = String;
484
- var $TypeError$a = TypeError;
483
+ var $String$4 = String;
484
+ var $TypeError$b = TypeError;
485
485
 
486
486
  // `Assert: Type(argument) is Object`
487
- var anObject$f = function (argument) {
488
- if (isObject$9(argument)) return argument;
489
- throw new $TypeError$a($String$3(argument) + ' is not an object');
487
+ var anObject$g = function (argument) {
488
+ if (isObject$a(argument)) return argument;
489
+ throw new $TypeError$b($String$4(argument) + ' is not an object');
490
490
  };
491
491
 
492
- var DESCRIPTORS$d = descriptors;
492
+ var DESCRIPTORS$g = descriptors;
493
493
  var IE8_DOM_DEFINE = ie8DomDefine;
494
494
  var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
495
- var anObject$e = anObject$f;
495
+ var anObject$f = anObject$g;
496
496
  var toPropertyKey = toPropertyKey$2;
497
497
 
498
- var $TypeError$9 = TypeError;
498
+ var $TypeError$a = TypeError;
499
499
  // eslint-disable-next-line es/no-object-defineproperty -- safe
500
500
  var $defineProperty = Object.defineProperty;
501
501
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -506,10 +506,10 @@ var WRITABLE = 'writable';
506
506
 
507
507
  // `Object.defineProperty` method
508
508
  // https://tc39.es/ecma262/#sec-object.defineproperty
509
- objectDefineProperty.f = DESCRIPTORS$d ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
510
- anObject$e(O);
509
+ objectDefineProperty.f = DESCRIPTORS$g ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
510
+ anObject$f(O);
511
511
  P = toPropertyKey(P);
512
- anObject$e(Attributes);
512
+ anObject$f(Attributes);
513
513
  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
514
514
  var current = $getOwnPropertyDescriptor(O, P);
515
515
  if (current && current[WRITABLE]) {
@@ -522,23 +522,23 @@ objectDefineProperty.f = DESCRIPTORS$d ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
522
522
  }
523
523
  } return $defineProperty(O, P, Attributes);
524
524
  } : $defineProperty : function defineProperty(O, P, Attributes) {
525
- anObject$e(O);
525
+ anObject$f(O);
526
526
  P = toPropertyKey(P);
527
- anObject$e(Attributes);
527
+ anObject$f(Attributes);
528
528
  if (IE8_DOM_DEFINE) try {
529
529
  return $defineProperty(O, P, Attributes);
530
530
  } catch (error) { /* empty */ }
531
- if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$9('Accessors not supported');
531
+ if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$a('Accessors not supported');
532
532
  if ('value' in Attributes) O[P] = Attributes.value;
533
533
  return O;
534
534
  };
535
535
 
536
- var DESCRIPTORS$c = descriptors;
536
+ var DESCRIPTORS$f = descriptors;
537
537
  var definePropertyModule$4 = objectDefineProperty;
538
- var createPropertyDescriptor$3 = createPropertyDescriptor$5;
538
+ var createPropertyDescriptor$4 = createPropertyDescriptor$6;
539
539
 
540
- var createNonEnumerableProperty$6 = DESCRIPTORS$c ? function (object, key, value) {
541
- return definePropertyModule$4.f(object, key, createPropertyDescriptor$3(1, value));
540
+ var createNonEnumerableProperty$9 = DESCRIPTORS$f ? function (object, key, value) {
541
+ return definePropertyModule$4.f(object, key, createPropertyDescriptor$4(1, value));
542
542
  } : function (object, key, value) {
543
543
  object[key] = value;
544
544
  return object;
@@ -546,17 +546,17 @@ var createNonEnumerableProperty$6 = DESCRIPTORS$c ? function (object, key, value
546
546
 
547
547
  var makeBuiltIn$3 = {exports: {}};
548
548
 
549
- var DESCRIPTORS$b = descriptors;
550
- var hasOwn$b = hasOwnProperty_1;
549
+ var DESCRIPTORS$e = descriptors;
550
+ var hasOwn$c = hasOwnProperty_1;
551
551
 
552
552
  var FunctionPrototype$1 = Function.prototype;
553
553
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
554
- var getDescriptor = DESCRIPTORS$b && Object.getOwnPropertyDescriptor;
554
+ var getDescriptor = DESCRIPTORS$e && Object.getOwnPropertyDescriptor;
555
555
 
556
- var EXISTS = hasOwn$b(FunctionPrototype$1, 'name');
556
+ var EXISTS = hasOwn$c(FunctionPrototype$1, 'name');
557
557
  // additional protection from minified / mangled / dropped function names
558
558
  var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
559
- var CONFIGURABLE = EXISTS && (!DESCRIPTORS$b || (DESCRIPTORS$b && getDescriptor(FunctionPrototype$1, 'name').configurable));
559
+ var CONFIGURABLE = EXISTS && (!DESCRIPTORS$e || (DESCRIPTORS$e && getDescriptor(FunctionPrototype$1, 'name').configurable));
560
560
 
561
561
  var functionName = {
562
562
  EXISTS: EXISTS,
@@ -564,14 +564,14 @@ var functionName = {
564
564
  CONFIGURABLE: CONFIGURABLE
565
565
  };
566
566
 
567
- var uncurryThis$g = functionUncurryThis;
568
- var isCallable$g = isCallable$m;
567
+ var uncurryThis$m = functionUncurryThis;
568
+ var isCallable$j = isCallable$p;
569
569
  var store$1 = sharedStore.exports;
570
570
 
571
- var functionToString = uncurryThis$g(Function.toString);
571
+ var functionToString = uncurryThis$m(Function.toString);
572
572
 
573
573
  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
574
- if (!isCallable$g(store$1.inspectSource)) {
574
+ if (!isCallable$j(store$1.inspectSource)) {
575
575
  store$1.inspectSource = function (it) {
576
576
  return functionToString(it);
577
577
  };
@@ -579,12 +579,12 @@ if (!isCallable$g(store$1.inspectSource)) {
579
579
 
580
580
  var inspectSource$3 = store$1.inspectSource;
581
581
 
582
- var global$h = global$o;
583
- var isCallable$f = isCallable$m;
582
+ var global$i = global$p;
583
+ var isCallable$i = isCallable$p;
584
584
 
585
- var WeakMap$1 = global$h.WeakMap;
585
+ var WeakMap$1 = global$i.WeakMap;
586
586
 
587
- var weakMapBasicDetection = isCallable$f(WeakMap$1) && /native code/.test(String(WeakMap$1));
587
+ var weakMapBasicDetection = isCallable$i(WeakMap$1) && /native code/.test(String(WeakMap$1));
588
588
 
589
589
  var shared$2 = shared$4;
590
590
  var uid = uid$2;
@@ -598,17 +598,17 @@ var sharedKey$3 = function (key) {
598
598
  var hiddenKeys$4 = {};
599
599
 
600
600
  var NATIVE_WEAK_MAP = weakMapBasicDetection;
601
- var global$g = global$o;
602
- var isObject$8 = isObject$d;
603
- var createNonEnumerableProperty$5 = createNonEnumerableProperty$6;
604
- var hasOwn$a = hasOwnProperty_1;
601
+ var global$h = global$p;
602
+ var isObject$9 = isObject$e;
603
+ var createNonEnumerableProperty$8 = createNonEnumerableProperty$9;
604
+ var hasOwn$b = hasOwnProperty_1;
605
605
  var shared$1 = sharedStore.exports;
606
606
  var sharedKey$2 = sharedKey$3;
607
607
  var hiddenKeys$3 = hiddenKeys$4;
608
608
 
609
609
  var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
610
- var TypeError$4 = global$g.TypeError;
611
- var WeakMap = global$g.WeakMap;
610
+ var TypeError$4 = global$h.TypeError;
611
+ var WeakMap = global$h.WeakMap;
612
612
  var set$1, get, has;
613
613
 
614
614
  var enforce = function (it) {
@@ -618,7 +618,7 @@ var enforce = function (it) {
618
618
  var getterFor = function (TYPE) {
619
619
  return function (it) {
620
620
  var state;
621
- if (!isObject$8(it) || (state = get(it)).type !== TYPE) {
621
+ if (!isObject$9(it) || (state = get(it)).type !== TYPE) {
622
622
  throw new TypeError$4('Incompatible receiver, ' + TYPE + ' required');
623
623
  } return state;
624
624
  };
@@ -647,16 +647,16 @@ if (NATIVE_WEAK_MAP || shared$1.state) {
647
647
  var STATE = sharedKey$2('state');
648
648
  hiddenKeys$3[STATE] = true;
649
649
  set$1 = function (it, metadata) {
650
- if (hasOwn$a(it, STATE)) throw new TypeError$4(OBJECT_ALREADY_INITIALIZED);
650
+ if (hasOwn$b(it, STATE)) throw new TypeError$4(OBJECT_ALREADY_INITIALIZED);
651
651
  metadata.facade = it;
652
- createNonEnumerableProperty$5(it, STATE, metadata);
652
+ createNonEnumerableProperty$8(it, STATE, metadata);
653
653
  return metadata;
654
654
  };
655
655
  get = function (it) {
656
- return hasOwn$a(it, STATE) ? it[STATE] : {};
656
+ return hasOwn$b(it, STATE) ? it[STATE] : {};
657
657
  };
658
658
  has = function (it) {
659
- return hasOwn$a(it, STATE);
659
+ return hasOwn$b(it, STATE);
660
660
  };
661
661
  }
662
662
 
@@ -668,51 +668,51 @@ var internalState = {
668
668
  getterFor: getterFor
669
669
  };
670
670
 
671
- var uncurryThis$f = functionUncurryThis;
672
- var fails$e = fails$l;
673
- var isCallable$e = isCallable$m;
674
- var hasOwn$9 = hasOwnProperty_1;
675
- var DESCRIPTORS$a = descriptors;
671
+ var uncurryThis$l = functionUncurryThis;
672
+ var fails$g = fails$n;
673
+ var isCallable$h = isCallable$p;
674
+ var hasOwn$a = hasOwnProperty_1;
675
+ var DESCRIPTORS$d = descriptors;
676
676
  var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
677
677
  var inspectSource$2 = inspectSource$3;
678
678
  var InternalStateModule$5 = internalState;
679
679
 
680
680
  var enforceInternalState$1 = InternalStateModule$5.enforce;
681
- var getInternalState$3 = InternalStateModule$5.get;
682
- var $String$2 = String;
681
+ var getInternalState$4 = InternalStateModule$5.get;
682
+ var $String$3 = String;
683
683
  // eslint-disable-next-line es/no-object-defineproperty -- safe
684
684
  var defineProperty$6 = Object.defineProperty;
685
- var stringSlice$5 = uncurryThis$f(''.slice);
686
- var replace$5 = uncurryThis$f(''.replace);
687
- var join$3 = uncurryThis$f([].join);
685
+ var stringSlice$5 = uncurryThis$l(''.slice);
686
+ var replace$7 = uncurryThis$l(''.replace);
687
+ var join$3 = uncurryThis$l([].join);
688
688
 
689
- var CONFIGURABLE_LENGTH = DESCRIPTORS$a && !fails$e(function () {
689
+ var CONFIGURABLE_LENGTH = DESCRIPTORS$d && !fails$g(function () {
690
690
  return defineProperty$6(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
691
691
  });
692
692
 
693
693
  var TEMPLATE = String(String).split('String');
694
694
 
695
695
  var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
696
- if (stringSlice$5($String$2(name), 0, 7) === 'Symbol(') {
697
- name = '[' + replace$5($String$2(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
696
+ if (stringSlice$5($String$3(name), 0, 7) === 'Symbol(') {
697
+ name = '[' + replace$7($String$3(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
698
698
  }
699
699
  if (options && options.getter) name = 'get ' + name;
700
700
  if (options && options.setter) name = 'set ' + name;
701
- if (!hasOwn$9(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
702
- if (DESCRIPTORS$a) defineProperty$6(value, 'name', { value: name, configurable: true });
701
+ if (!hasOwn$a(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
702
+ if (DESCRIPTORS$d) defineProperty$6(value, 'name', { value: name, configurable: true });
703
703
  else value.name = name;
704
704
  }
705
- if (CONFIGURABLE_LENGTH && options && hasOwn$9(options, 'arity') && value.length !== options.arity) {
705
+ if (CONFIGURABLE_LENGTH && options && hasOwn$a(options, 'arity') && value.length !== options.arity) {
706
706
  defineProperty$6(value, 'length', { value: options.arity });
707
707
  }
708
708
  try {
709
- if (options && hasOwn$9(options, 'constructor') && options.constructor) {
710
- if (DESCRIPTORS$a) defineProperty$6(value, 'prototype', { writable: false });
709
+ if (options && hasOwn$a(options, 'constructor') && options.constructor) {
710
+ if (DESCRIPTORS$d) defineProperty$6(value, 'prototype', { writable: false });
711
711
  // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
712
712
  } else if (value.prototype) value.prototype = undefined;
713
713
  } catch (error) { /* empty */ }
714
714
  var state = enforceInternalState$1(value);
715
- if (!hasOwn$9(state, 'source')) {
715
+ if (!hasOwn$a(state, 'source')) {
716
716
  state.source = join$3(TEMPLATE, typeof name == 'string' ? name : '');
717
717
  } return value;
718
718
  };
@@ -720,19 +720,19 @@ var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
720
720
  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
721
721
  // eslint-disable-next-line no-extend-native -- required
722
722
  Function.prototype.toString = makeBuiltIn$2(function toString() {
723
- return isCallable$e(this) && getInternalState$3(this).source || inspectSource$2(this);
723
+ return isCallable$h(this) && getInternalState$4(this).source || inspectSource$2(this);
724
724
  }, 'toString');
725
725
 
726
- var isCallable$d = isCallable$m;
726
+ var isCallable$g = isCallable$p;
727
727
  var definePropertyModule$3 = objectDefineProperty;
728
728
  var makeBuiltIn$1 = makeBuiltIn$3.exports;
729
729
  var defineGlobalProperty$1 = defineGlobalProperty$3;
730
730
 
731
- var defineBuiltIn$b = function (O, key, value, options) {
731
+ var defineBuiltIn$d = function (O, key, value, options) {
732
732
  if (!options) options = {};
733
733
  var simple = options.enumerable;
734
734
  var name = options.name !== undefined ? options.name : key;
735
- if (isCallable$d(value)) makeBuiltIn$1(value, name, options);
735
+ if (isCallable$g(value)) makeBuiltIn$1(value, name, options);
736
736
  if (options.global) {
737
737
  if (simple) O[key] = value;
738
738
  else defineGlobalProperty$1(key, value);
@@ -840,23 +840,23 @@ var arrayIncludes = {
840
840
  indexOf: createMethod$1(false)
841
841
  };
842
842
 
843
- var uncurryThis$e = functionUncurryThis;
844
- var hasOwn$8 = hasOwnProperty_1;
843
+ var uncurryThis$k = functionUncurryThis;
844
+ var hasOwn$9 = hasOwnProperty_1;
845
845
  var toIndexedObject$2 = toIndexedObject$5;
846
846
  var indexOf$1 = arrayIncludes.indexOf;
847
847
  var hiddenKeys$2 = hiddenKeys$4;
848
848
 
849
- var push$3 = uncurryThis$e([].push);
849
+ var push$5 = uncurryThis$k([].push);
850
850
 
851
851
  var objectKeysInternal = function (object, names) {
852
852
  var O = toIndexedObject$2(object);
853
853
  var i = 0;
854
854
  var result = [];
855
855
  var key;
856
- for (key in O) !hasOwn$8(hiddenKeys$2, key) && hasOwn$8(O, key) && push$3(result, key);
856
+ for (key in O) !hasOwn$9(hiddenKeys$2, key) && hasOwn$9(O, key) && push$5(result, key);
857
857
  // Don't enum bug & hidden keys
858
- while (names.length > i) if (hasOwn$8(O, key = names[i++])) {
859
- ~indexOf$1(result, key) || push$3(result, key);
858
+ while (names.length > i) if (hasOwn$9(O, key = names[i++])) {
859
+ ~indexOf$1(result, key) || push$5(result, key);
860
860
  }
861
861
  return result;
862
862
  };
@@ -889,40 +889,40 @@ var objectGetOwnPropertySymbols = {};
889
889
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
890
890
  objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
891
891
 
892
- var getBuiltIn$5 = getBuiltIn$7;
893
- var uncurryThis$d = functionUncurryThis;
892
+ var getBuiltIn$7 = getBuiltIn$9;
893
+ var uncurryThis$j = functionUncurryThis;
894
894
  var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
895
895
  var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
896
- var anObject$d = anObject$f;
896
+ var anObject$e = anObject$g;
897
897
 
898
- var concat$1 = uncurryThis$d([].concat);
898
+ var concat$1 = uncurryThis$j([].concat);
899
899
 
900
900
  // all object keys, includes non-enumerable and symbols
901
- var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) {
902
- var keys = getOwnPropertyNamesModule.f(anObject$d(it));
901
+ var ownKeys$1 = getBuiltIn$7('Reflect', 'ownKeys') || function ownKeys(it) {
902
+ var keys = getOwnPropertyNamesModule.f(anObject$e(it));
903
903
  var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
904
904
  return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys;
905
905
  };
906
906
 
907
- var hasOwn$7 = hasOwnProperty_1;
907
+ var hasOwn$8 = hasOwnProperty_1;
908
908
  var ownKeys = ownKeys$1;
909
909
  var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
910
910
  var definePropertyModule$2 = objectDefineProperty;
911
911
 
912
- var copyConstructorProperties$1 = function (target, source, exceptions) {
912
+ var copyConstructorProperties$2 = function (target, source, exceptions) {
913
913
  var keys = ownKeys(source);
914
914
  var defineProperty = definePropertyModule$2.f;
915
915
  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
916
916
  for (var i = 0; i < keys.length; i++) {
917
917
  var key = keys[i];
918
- if (!hasOwn$7(target, key) && !(exceptions && hasOwn$7(exceptions, key))) {
918
+ if (!hasOwn$8(target, key) && !(exceptions && hasOwn$8(exceptions, key))) {
919
919
  defineProperty(target, key, getOwnPropertyDescriptor(source, key));
920
920
  }
921
921
  }
922
922
  };
923
923
 
924
- var fails$d = fails$l;
925
- var isCallable$c = isCallable$m;
924
+ var fails$f = fails$n;
925
+ var isCallable$f = isCallable$p;
926
926
 
927
927
  var replacement = /#|\.prototype\./;
928
928
 
@@ -930,7 +930,7 @@ var isForced$3 = function (feature, detection) {
930
930
  var value = data[normalize(feature)];
931
931
  return value === POLYFILL ? true
932
932
  : value === NATIVE ? false
933
- : isCallable$c(detection) ? fails$d(detection)
933
+ : isCallable$f(detection) ? fails$f(detection)
934
934
  : !!detection;
935
935
  };
936
936
 
@@ -944,12 +944,12 @@ var POLYFILL = isForced$3.POLYFILL = 'P';
944
944
 
945
945
  var isForced_1 = isForced$3;
946
946
 
947
- var global$f = global$o;
947
+ var global$g = global$p;
948
948
  var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
949
- var createNonEnumerableProperty$4 = createNonEnumerableProperty$6;
950
- var defineBuiltIn$a = defineBuiltIn$b;
949
+ var createNonEnumerableProperty$7 = createNonEnumerableProperty$9;
950
+ var defineBuiltIn$c = defineBuiltIn$d;
951
951
  var defineGlobalProperty = defineGlobalProperty$3;
952
- var copyConstructorProperties = copyConstructorProperties$1;
952
+ var copyConstructorProperties$1 = copyConstructorProperties$2;
953
953
  var isForced$2 = isForced_1;
954
954
 
955
955
  /*
@@ -973,11 +973,11 @@ var _export = function (options, source) {
973
973
  var STATIC = options.stat;
974
974
  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
975
975
  if (GLOBAL) {
976
- target = global$f;
976
+ target = global$g;
977
977
  } else if (STATIC) {
978
- target = global$f[TARGET] || defineGlobalProperty(TARGET, {});
978
+ target = global$g[TARGET] || defineGlobalProperty(TARGET, {});
979
979
  } else {
980
- target = global$f[TARGET] && global$f[TARGET].prototype;
980
+ target = global$g[TARGET] && global$g[TARGET].prototype;
981
981
  }
982
982
  if (target) for (key in source) {
983
983
  sourceProperty = source[key];
@@ -989,13 +989,13 @@ var _export = function (options, source) {
989
989
  // contained in target
990
990
  if (!FORCED && targetProperty !== undefined) {
991
991
  if (typeof sourceProperty == typeof targetProperty) continue;
992
- copyConstructorProperties(sourceProperty, targetProperty);
992
+ copyConstructorProperties$1(sourceProperty, targetProperty);
993
993
  }
994
994
  // add a flag to not completely full polyfills
995
995
  if (options.sham || (targetProperty && targetProperty.sham)) {
996
- createNonEnumerableProperty$4(sourceProperty, 'sham', true);
996
+ createNonEnumerableProperty$7(sourceProperty, 'sham', true);
997
997
  }
998
- defineBuiltIn$a(target, key, sourceProperty, options);
998
+ defineBuiltIn$c(target, key, sourceProperty, options);
999
999
  }
1000
1000
  };
1001
1001
 
@@ -1009,10 +1009,10 @@ var objectKeys$2 = Object.keys || function keys(O) {
1009
1009
  return internalObjectKeys(O, enumBugKeys$1);
1010
1010
  };
1011
1011
 
1012
- var DESCRIPTORS$9 = descriptors;
1013
- var uncurryThis$c = functionUncurryThis;
1014
- var call$g = functionCall;
1015
- var fails$c = fails$l;
1012
+ var DESCRIPTORS$c = descriptors;
1013
+ var uncurryThis$i = functionUncurryThis;
1014
+ var call$i = functionCall;
1015
+ var fails$e = fails$n;
1016
1016
  var objectKeys$1 = objectKeys$2;
1017
1017
  var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
1018
1018
  var propertyIsEnumerableModule = objectPropertyIsEnumerable;
@@ -1023,13 +1023,13 @@ var IndexedObject = indexedObject;
1023
1023
  var $assign = Object.assign;
1024
1024
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
1025
1025
  var defineProperty$5 = Object.defineProperty;
1026
- var concat = uncurryThis$c([].concat);
1026
+ var concat = uncurryThis$i([].concat);
1027
1027
 
1028
1028
  // `Object.assign` method
1029
1029
  // https://tc39.es/ecma262/#sec-object.assign
1030
- var objectAssign = !$assign || fails$c(function () {
1030
+ var objectAssign = !$assign || fails$e(function () {
1031
1031
  // should have correct order of operations (Edge bug)
1032
- if (DESCRIPTORS$9 && $assign({ b: 1 }, $assign(defineProperty$5({}, 'a', {
1032
+ if (DESCRIPTORS$c && $assign({ b: 1 }, $assign(defineProperty$5({}, 'a', {
1033
1033
  enumerable: true,
1034
1034
  get: function () {
1035
1035
  defineProperty$5(this, 'b', {
@@ -1061,18 +1061,18 @@ var objectAssign = !$assign || fails$c(function () {
1061
1061
  var key;
1062
1062
  while (length > j) {
1063
1063
  key = keys[j++];
1064
- if (!DESCRIPTORS$9 || call$g(propertyIsEnumerable, S, key)) T[key] = S[key];
1064
+ if (!DESCRIPTORS$c || call$i(propertyIsEnumerable, S, key)) T[key] = S[key];
1065
1065
  }
1066
1066
  } return T;
1067
1067
  } : $assign;
1068
1068
 
1069
- var $$d = _export;
1069
+ var $$g = _export;
1070
1070
  var assign$1 = objectAssign;
1071
1071
 
1072
1072
  // `Object.assign` method
1073
1073
  // https://tc39.es/ecma262/#sec-object.assign
1074
1074
  // eslint-disable-next-line es/no-object-assign -- required for testing
1075
- $$d({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign$1 }, {
1075
+ $$g({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign$1 }, {
1076
1076
  assign: assign$1
1077
1077
  });
1078
1078
 
@@ -1080,7 +1080,7 @@ function _objectWithoutPropertiesLoose(r, e) {
1080
1080
  if (null == r) return {};
1081
1081
  var t = {};
1082
1082
  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
1083
- if (e.indexOf(n) >= 0) continue;
1083
+ if (e.includes(n)) continue;
1084
1084
  t[n] = r[n];
1085
1085
  }
1086
1086
  return t;
@@ -1088,18 +1088,18 @@ function _objectWithoutPropertiesLoose(r, e) {
1088
1088
 
1089
1089
  var objectDefineProperties = {};
1090
1090
 
1091
- var DESCRIPTORS$8 = descriptors;
1091
+ var DESCRIPTORS$b = descriptors;
1092
1092
  var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
1093
1093
  var definePropertyModule$1 = objectDefineProperty;
1094
- var anObject$c = anObject$f;
1094
+ var anObject$d = anObject$g;
1095
1095
  var toIndexedObject$1 = toIndexedObject$5;
1096
1096
  var objectKeys = objectKeys$2;
1097
1097
 
1098
1098
  // `Object.defineProperties` method
1099
1099
  // https://tc39.es/ecma262/#sec-object.defineproperties
1100
1100
  // eslint-disable-next-line es/no-object-defineproperties -- safe
1101
- objectDefineProperties.f = DESCRIPTORS$8 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
1102
- anObject$c(O);
1101
+ objectDefineProperties.f = DESCRIPTORS$b && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
1102
+ anObject$d(O);
1103
1103
  var props = toIndexedObject$1(Properties);
1104
1104
  var keys = objectKeys(Properties);
1105
1105
  var length = keys.length;
@@ -1109,12 +1109,12 @@ objectDefineProperties.f = DESCRIPTORS$8 && !V8_PROTOTYPE_DEFINE_BUG ? Object.de
1109
1109
  return O;
1110
1110
  };
1111
1111
 
1112
- var getBuiltIn$4 = getBuiltIn$7;
1112
+ var getBuiltIn$6 = getBuiltIn$9;
1113
1113
 
1114
- var html$2 = getBuiltIn$4('document', 'documentElement');
1114
+ var html$2 = getBuiltIn$6('document', 'documentElement');
1115
1115
 
1116
1116
  /* global ActiveXObject -- old IE, WSH */
1117
- var anObject$b = anObject$f;
1117
+ var anObject$c = anObject$g;
1118
1118
  var definePropertiesModule = objectDefineProperties;
1119
1119
  var enumBugKeys = enumBugKeys$3;
1120
1120
  var hiddenKeys = hiddenKeys$4;
@@ -1188,7 +1188,7 @@ hiddenKeys[IE_PROTO$1] = true;
1188
1188
  var objectCreate = Object.create || function create(O, Properties) {
1189
1189
  var result;
1190
1190
  if (O !== null) {
1191
- EmptyConstructor[PROTOTYPE] = anObject$b(O);
1191
+ EmptyConstructor[PROTOTYPE] = anObject$c(O);
1192
1192
  result = new EmptyConstructor();
1193
1193
  EmptyConstructor[PROTOTYPE] = null;
1194
1194
  // add "__proto__" for Object.getPrototypeOf polyfill
@@ -1220,17 +1220,17 @@ var addToUnscopables$2 = function (key) {
1220
1220
 
1221
1221
  var iterators = {};
1222
1222
 
1223
- var fails$b = fails$l;
1223
+ var fails$d = fails$n;
1224
1224
 
1225
- var correctPrototypeGetter = !fails$b(function () {
1225
+ var correctPrototypeGetter = !fails$d(function () {
1226
1226
  function F() { /* empty */ }
1227
1227
  F.prototype.constructor = null;
1228
1228
  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
1229
1229
  return Object.getPrototypeOf(new F()) !== F.prototype;
1230
1230
  });
1231
1231
 
1232
- var hasOwn$6 = hasOwnProperty_1;
1233
- var isCallable$b = isCallable$m;
1232
+ var hasOwn$7 = hasOwnProperty_1;
1233
+ var isCallable$e = isCallable$p;
1234
1234
  var toObject$1 = toObject$4;
1235
1235
  var sharedKey = sharedKey$3;
1236
1236
  var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
@@ -1244,18 +1244,18 @@ var ObjectPrototype = $Object$1.prototype;
1244
1244
  // eslint-disable-next-line es/no-object-getprototypeof -- safe
1245
1245
  var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object$1.getPrototypeOf : function (O) {
1246
1246
  var object = toObject$1(O);
1247
- if (hasOwn$6(object, IE_PROTO)) return object[IE_PROTO];
1247
+ if (hasOwn$7(object, IE_PROTO)) return object[IE_PROTO];
1248
1248
  var constructor = object.constructor;
1249
- if (isCallable$b(constructor) && object instanceof constructor) {
1249
+ if (isCallable$e(constructor) && object instanceof constructor) {
1250
1250
  return constructor.prototype;
1251
1251
  } return object instanceof $Object$1 ? ObjectPrototype : null;
1252
1252
  };
1253
1253
 
1254
- var fails$a = fails$l;
1255
- var isCallable$a = isCallable$m;
1256
- var isObject$7 = isObject$d;
1254
+ var fails$c = fails$n;
1255
+ var isCallable$d = isCallable$p;
1256
+ var isObject$8 = isObject$e;
1257
1257
  var getPrototypeOf$1 = objectGetPrototypeOf;
1258
- var defineBuiltIn$9 = defineBuiltIn$b;
1258
+ var defineBuiltIn$b = defineBuiltIn$d;
1259
1259
  var wellKnownSymbol$h = wellKnownSymbol$k;
1260
1260
 
1261
1261
  var ITERATOR$7 = wellKnownSymbol$h('iterator');
@@ -1276,7 +1276,7 @@ if ([].keys) {
1276
1276
  }
1277
1277
  }
1278
1278
 
1279
- var NEW_ITERATOR_PROTOTYPE = !isObject$7(IteratorPrototype$2) || fails$a(function () {
1279
+ var NEW_ITERATOR_PROTOTYPE = !isObject$8(IteratorPrototype$2) || fails$c(function () {
1280
1280
  var test = {};
1281
1281
  // FF44- legacy iterators case
1282
1282
  return IteratorPrototype$2[ITERATOR$7].call(test) !== test;
@@ -1286,8 +1286,8 @@ if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
1286
1286
 
1287
1287
  // `%IteratorPrototype%[@@iterator]()` method
1288
1288
  // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
1289
- if (!isCallable$a(IteratorPrototype$2[ITERATOR$7])) {
1290
- defineBuiltIn$9(IteratorPrototype$2, ITERATOR$7, function () {
1289
+ if (!isCallable$d(IteratorPrototype$2[ITERATOR$7])) {
1290
+ defineBuiltIn$b(IteratorPrototype$2, ITERATOR$7, function () {
1291
1291
  return this;
1292
1292
  });
1293
1293
  }
@@ -1298,21 +1298,21 @@ var iteratorsCore = {
1298
1298
  };
1299
1299
 
1300
1300
  var defineProperty$3 = objectDefineProperty.f;
1301
- var hasOwn$5 = hasOwnProperty_1;
1301
+ var hasOwn$6 = hasOwnProperty_1;
1302
1302
  var wellKnownSymbol$g = wellKnownSymbol$k;
1303
1303
 
1304
1304
  var TO_STRING_TAG$2 = wellKnownSymbol$g('toStringTag');
1305
1305
 
1306
1306
  var setToStringTag$6 = function (target, TAG, STATIC) {
1307
1307
  if (target && !STATIC) target = target.prototype;
1308
- if (target && !hasOwn$5(target, TO_STRING_TAG$2)) {
1308
+ if (target && !hasOwn$6(target, TO_STRING_TAG$2)) {
1309
1309
  defineProperty$3(target, TO_STRING_TAG$2, { configurable: true, value: TAG });
1310
1310
  }
1311
1311
  };
1312
1312
 
1313
1313
  var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
1314
1314
  var create$3 = objectCreate;
1315
- var createPropertyDescriptor$2 = createPropertyDescriptor$5;
1315
+ var createPropertyDescriptor$3 = createPropertyDescriptor$6;
1316
1316
  var setToStringTag$5 = setToStringTag$6;
1317
1317
  var Iterators$4 = iterators;
1318
1318
 
@@ -1320,41 +1320,41 @@ var returnThis$1 = function () { return this; };
1320
1320
 
1321
1321
  var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
1322
1322
  var TO_STRING_TAG = NAME + ' Iterator';
1323
- IteratorConstructor.prototype = create$3(IteratorPrototype$1, { next: createPropertyDescriptor$2(+!ENUMERABLE_NEXT, next) });
1323
+ IteratorConstructor.prototype = create$3(IteratorPrototype$1, { next: createPropertyDescriptor$3(+!ENUMERABLE_NEXT, next) });
1324
1324
  setToStringTag$5(IteratorConstructor, TO_STRING_TAG, false);
1325
1325
  Iterators$4[TO_STRING_TAG] = returnThis$1;
1326
1326
  return IteratorConstructor;
1327
1327
  };
1328
1328
 
1329
- var uncurryThis$b = functionUncurryThis;
1329
+ var uncurryThis$h = functionUncurryThis;
1330
1330
  var aCallable$6 = aCallable$8;
1331
1331
 
1332
1332
  var functionUncurryThisAccessor = function (object, key, method) {
1333
1333
  try {
1334
1334
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1335
- return uncurryThis$b(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method]));
1335
+ return uncurryThis$h(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method]));
1336
1336
  } catch (error) { /* empty */ }
1337
1337
  };
1338
1338
 
1339
- var isObject$6 = isObject$d;
1339
+ var isObject$7 = isObject$e;
1340
1340
 
1341
1341
  var isPossiblePrototype$1 = function (argument) {
1342
- return isObject$6(argument) || argument === null;
1342
+ return isObject$7(argument) || argument === null;
1343
1343
  };
1344
1344
 
1345
1345
  var isPossiblePrototype = isPossiblePrototype$1;
1346
1346
 
1347
- var $String$1 = String;
1348
- var $TypeError$8 = TypeError;
1347
+ var $String$2 = String;
1348
+ var $TypeError$9 = TypeError;
1349
1349
 
1350
1350
  var aPossiblePrototype$1 = function (argument) {
1351
1351
  if (isPossiblePrototype(argument)) return argument;
1352
- throw new $TypeError$8("Can't set " + $String$1(argument) + ' as a prototype');
1352
+ throw new $TypeError$9("Can't set " + $String$2(argument) + ' as a prototype');
1353
1353
  };
1354
1354
 
1355
1355
  /* eslint-disable no-proto -- safe */
1356
1356
  var uncurryThisAccessor = functionUncurryThisAccessor;
1357
- var isObject$5 = isObject$d;
1357
+ var isObject$6 = isObject$e;
1358
1358
  var requireObjectCoercible$3 = requireObjectCoercible$6;
1359
1359
  var aPossiblePrototype = aPossiblePrototype$1;
1360
1360
 
@@ -1374,23 +1374,23 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
1374
1374
  return function setPrototypeOf(O, proto) {
1375
1375
  requireObjectCoercible$3(O);
1376
1376
  aPossiblePrototype(proto);
1377
- if (!isObject$5(O)) return O;
1377
+ if (!isObject$6(O)) return O;
1378
1378
  if (CORRECT_SETTER) setter(O, proto);
1379
1379
  else O.__proto__ = proto;
1380
1380
  return O;
1381
1381
  };
1382
1382
  }() : undefined);
1383
1383
 
1384
- var $$c = _export;
1385
- var call$f = functionCall;
1384
+ var $$f = _export;
1385
+ var call$h = functionCall;
1386
1386
  var FunctionName = functionName;
1387
- var isCallable$9 = isCallable$m;
1387
+ var isCallable$c = isCallable$p;
1388
1388
  var createIteratorConstructor$1 = iteratorCreateConstructor;
1389
1389
  var getPrototypeOf = objectGetPrototypeOf;
1390
- var setPrototypeOf$2 = objectSetPrototypeOf;
1390
+ var setPrototypeOf$3 = objectSetPrototypeOf;
1391
1391
  var setToStringTag$4 = setToStringTag$6;
1392
- var createNonEnumerableProperty$3 = createNonEnumerableProperty$6;
1393
- var defineBuiltIn$8 = defineBuiltIn$b;
1392
+ var createNonEnumerableProperty$6 = createNonEnumerableProperty$9;
1393
+ var defineBuiltIn$a = defineBuiltIn$d;
1394
1394
  var wellKnownSymbol$f = wellKnownSymbol$k;
1395
1395
  var Iterators$3 = iterators;
1396
1396
  var IteratorsCore = iteratorsCore;
@@ -1437,10 +1437,10 @@ var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAUL
1437
1437
  CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
1438
1438
  if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
1439
1439
  if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
1440
- if (setPrototypeOf$2) {
1441
- setPrototypeOf$2(CurrentIteratorPrototype, IteratorPrototype);
1442
- } else if (!isCallable$9(CurrentIteratorPrototype[ITERATOR$6])) {
1443
- defineBuiltIn$8(CurrentIteratorPrototype, ITERATOR$6, returnThis);
1440
+ if (setPrototypeOf$3) {
1441
+ setPrototypeOf$3(CurrentIteratorPrototype, IteratorPrototype);
1442
+ } else if (!isCallable$c(CurrentIteratorPrototype[ITERATOR$6])) {
1443
+ defineBuiltIn$a(CurrentIteratorPrototype, ITERATOR$6, returnThis);
1444
1444
  }
1445
1445
  }
1446
1446
  // Set @@toStringTag to native iterators
@@ -1451,10 +1451,10 @@ var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAUL
1451
1451
  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
1452
1452
  if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
1453
1453
  if (CONFIGURABLE_FUNCTION_NAME) {
1454
- createNonEnumerableProperty$3(IterablePrototype, 'name', VALUES);
1454
+ createNonEnumerableProperty$6(IterablePrototype, 'name', VALUES);
1455
1455
  } else {
1456
1456
  INCORRECT_VALUES_NAME = true;
1457
- defaultIterator = function values() { return call$f(nativeIterator, this); };
1457
+ defaultIterator = function values() { return call$h(nativeIterator, this); };
1458
1458
  }
1459
1459
  }
1460
1460
 
@@ -1467,14 +1467,14 @@ var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAUL
1467
1467
  };
1468
1468
  if (FORCED) for (KEY in methods) {
1469
1469
  if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
1470
- defineBuiltIn$8(IterablePrototype, KEY, methods[KEY]);
1470
+ defineBuiltIn$a(IterablePrototype, KEY, methods[KEY]);
1471
1471
  }
1472
- } else $$c({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
1472
+ } else $$f({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
1473
1473
  }
1474
1474
 
1475
1475
  // define iterator
1476
1476
  if (IterablePrototype[ITERATOR$6] !== defaultIterator) {
1477
- defineBuiltIn$8(IterablePrototype, ITERATOR$6, defaultIterator, { name: DEFAULT });
1477
+ defineBuiltIn$a(IterablePrototype, ITERATOR$6, defaultIterator, { name: DEFAULT });
1478
1478
  }
1479
1479
  Iterators$3[NAME] = defaultIterator;
1480
1480
 
@@ -1494,11 +1494,11 @@ var InternalStateModule$4 = internalState;
1494
1494
  var defineProperty$2 = objectDefineProperty.f;
1495
1495
  var defineIterator$1 = iteratorDefine;
1496
1496
  var createIterResultObject$2 = createIterResultObject$3;
1497
- var DESCRIPTORS$7 = descriptors;
1497
+ var DESCRIPTORS$a = descriptors;
1498
1498
 
1499
1499
  var ARRAY_ITERATOR = 'Array Iterator';
1500
1500
  var setInternalState$4 = InternalStateModule$4.set;
1501
- var getInternalState$2 = InternalStateModule$4.getterFor(ARRAY_ITERATOR);
1501
+ var getInternalState$3 = InternalStateModule$4.getterFor(ARRAY_ITERATOR);
1502
1502
 
1503
1503
  // `Array.prototype.entries` method
1504
1504
  // https://tc39.es/ecma262/#sec-array.prototype.entries
@@ -1520,7 +1520,7 @@ var es_array_iterator = defineIterator$1(Array, 'Array', function (iterated, kin
1520
1520
  // `%ArrayIteratorPrototype%.next` method
1521
1521
  // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
1522
1522
  }, function () {
1523
- var state = getInternalState$2(this);
1523
+ var state = getInternalState$3(this);
1524
1524
  var target = state.target;
1525
1525
  var index = state.index++;
1526
1526
  if (!target || index >= target.length) {
@@ -1544,7 +1544,7 @@ addToUnscopables$1('values');
1544
1544
  addToUnscopables$1('entries');
1545
1545
 
1546
1546
  // V8 ~ Chrome 45- bug
1547
- if (DESCRIPTORS$7 && values.name !== 'values') try {
1547
+ if (DESCRIPTORS$a && values.name !== 'values') try {
1548
1548
  defineProperty$2(values, 'name', { value: 'values' });
1549
1549
  } catch (error) { /* empty */ }
1550
1550
 
@@ -1592,11 +1592,11 @@ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.co
1592
1592
 
1593
1593
  var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
1594
1594
 
1595
- var global$e = global$o;
1595
+ var global$f = global$p;
1596
1596
  var DOMIterables = domIterables;
1597
1597
  var DOMTokenListPrototype = domTokenListPrototype;
1598
1598
  var ArrayIteratorMethods = es_array_iterator;
1599
- var createNonEnumerableProperty$2 = createNonEnumerableProperty$6;
1599
+ var createNonEnumerableProperty$5 = createNonEnumerableProperty$9;
1600
1600
  var setToStringTag$3 = setToStringTag$6;
1601
1601
  var wellKnownSymbol$e = wellKnownSymbol$k;
1602
1602
 
@@ -1607,7 +1607,7 @@ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
1607
1607
  if (CollectionPrototype) {
1608
1608
  // some Chrome versions have non-configurable methods on DOMTokenList
1609
1609
  if (CollectionPrototype[ITERATOR$5] !== ArrayValues) try {
1610
- createNonEnumerableProperty$2(CollectionPrototype, ITERATOR$5, ArrayValues);
1610
+ createNonEnumerableProperty$5(CollectionPrototype, ITERATOR$5, ArrayValues);
1611
1611
  } catch (error) {
1612
1612
  CollectionPrototype[ITERATOR$5] = ArrayValues;
1613
1613
  }
@@ -1615,7 +1615,7 @@ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
1615
1615
  if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
1616
1616
  // some Chrome versions have non-configurable methods on DOMTokenList
1617
1617
  if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
1618
- createNonEnumerableProperty$2(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
1618
+ createNonEnumerableProperty$5(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
1619
1619
  } catch (error) {
1620
1620
  CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
1621
1621
  }
@@ -1624,7 +1624,7 @@ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
1624
1624
  };
1625
1625
 
1626
1626
  for (var COLLECTION_NAME in DOMIterables) {
1627
- handlePrototype(global$e[COLLECTION_NAME] && global$e[COLLECTION_NAME].prototype, COLLECTION_NAME);
1627
+ handlePrototype(global$f[COLLECTION_NAME] && global$f[COLLECTION_NAME].prototype, COLLECTION_NAME);
1628
1628
  }
1629
1629
 
1630
1630
  handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
@@ -1718,50 +1718,49 @@ const DotExperimentHandlingComponent = _ref => {
1718
1718
  return jsx(WrappedComponent, Object.assign({}, props));
1719
1719
  };
1720
1720
 
1721
- var global$d = global$o;
1722
- var classof$7 = classofRaw$2;
1723
-
1724
- var engineIsNode = classof$7(global$d.process) === 'process';
1725
-
1726
- var makeBuiltIn = makeBuiltIn$3.exports;
1727
- var defineProperty$1 = objectDefineProperty;
1728
-
1729
- var defineBuiltInAccessor$3 = function (target, name, descriptor) {
1730
- if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
1731
- if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
1732
- return defineProperty$1.f(target, name, descriptor);
1733
- };
1721
+ var NATIVE_BIND$1 = functionBindNative;
1734
1722
 
1735
- var getBuiltIn$3 = getBuiltIn$7;
1736
- var defineBuiltInAccessor$2 = defineBuiltInAccessor$3;
1737
- var wellKnownSymbol$d = wellKnownSymbol$k;
1738
- var DESCRIPTORS$6 = descriptors;
1723
+ var FunctionPrototype = Function.prototype;
1724
+ var apply$3 = FunctionPrototype.apply;
1725
+ var call$g = FunctionPrototype.call;
1739
1726
 
1740
- var SPECIES$3 = wellKnownSymbol$d('species');
1727
+ // eslint-disable-next-line es/no-reflect -- safe
1728
+ var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$g.bind(apply$3) : function () {
1729
+ return call$g.apply(apply$3, arguments);
1730
+ });
1741
1731
 
1742
- var setSpecies$2 = function (CONSTRUCTOR_NAME) {
1743
- var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
1732
+ var defineProperty$1 = objectDefineProperty.f;
1744
1733
 
1745
- if (DESCRIPTORS$6 && Constructor && !Constructor[SPECIES$3]) {
1746
- defineBuiltInAccessor$2(Constructor, SPECIES$3, {
1747
- configurable: true,
1748
- get: function () { return this; }
1749
- });
1750
- }
1734
+ var proxyAccessor$2 = function (Target, Source, key) {
1735
+ key in Target || defineProperty$1(Target, key, {
1736
+ configurable: true,
1737
+ get: function () { return Source[key]; },
1738
+ set: function (it) { Source[key] = it; }
1739
+ });
1751
1740
  };
1752
1741
 
1753
- var isPrototypeOf$3 = objectIsPrototypeOf;
1754
-
1755
- var $TypeError$7 = TypeError;
1742
+ var isCallable$b = isCallable$p;
1743
+ var isObject$5 = isObject$e;
1744
+ var setPrototypeOf$2 = objectSetPrototypeOf;
1756
1745
 
1757
- var anInstance$3 = function (it, Prototype) {
1758
- if (isPrototypeOf$3(Prototype, it)) return it;
1759
- throw new $TypeError$7('Incorrect invocation');
1746
+ // makes subclassing work correct for wrapped built-ins
1747
+ var inheritIfRequired$2 = function ($this, dummy, Wrapper) {
1748
+ var NewTarget, NewTargetPrototype;
1749
+ if (
1750
+ // it can work only with native `setPrototypeOf`
1751
+ setPrototypeOf$2 &&
1752
+ // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
1753
+ isCallable$b(NewTarget = dummy.constructor) &&
1754
+ NewTarget !== Wrapper &&
1755
+ isObject$5(NewTargetPrototype = NewTarget.prototype) &&
1756
+ NewTargetPrototype !== Wrapper.prototype
1757
+ ) setPrototypeOf$2($this, NewTargetPrototype);
1758
+ return $this;
1760
1759
  };
1761
1760
 
1762
- var wellKnownSymbol$c = wellKnownSymbol$k;
1761
+ var wellKnownSymbol$d = wellKnownSymbol$k;
1763
1762
 
1764
- var TO_STRING_TAG$1 = wellKnownSymbol$c('toStringTag');
1763
+ var TO_STRING_TAG$1 = wellKnownSymbol$d('toStringTag');
1765
1764
  var test = {};
1766
1765
 
1767
1766
  test[TO_STRING_TAG$1] = 'z';
@@ -1769,11 +1768,11 @@ test[TO_STRING_TAG$1] = 'z';
1769
1768
  var toStringTagSupport = String(test) === '[object z]';
1770
1769
 
1771
1770
  var TO_STRING_TAG_SUPPORT = toStringTagSupport;
1772
- var isCallable$8 = isCallable$m;
1771
+ var isCallable$a = isCallable$p;
1773
1772
  var classofRaw$1 = classofRaw$2;
1774
- var wellKnownSymbol$b = wellKnownSymbol$k;
1773
+ var wellKnownSymbol$c = wellKnownSymbol$k;
1775
1774
 
1776
- var TO_STRING_TAG = wellKnownSymbol$b('toStringTag');
1775
+ var TO_STRING_TAG = wellKnownSymbol$c('toStringTag');
1777
1776
  var $Object = Object;
1778
1777
 
1779
1778
  // ES3 wrong here
@@ -1787,7 +1786,7 @@ var tryGet = function (it, key) {
1787
1786
  };
1788
1787
 
1789
1788
  // getting tag from ES6+ `Object.prototype.toString`
1790
- var classof$6 = TO_STRING_TAG_SUPPORT ? classofRaw$1 : function (it) {
1789
+ var classof$a = TO_STRING_TAG_SUPPORT ? classofRaw$1 : function (it) {
1791
1790
  var O, tag, result;
1792
1791
  return it === undefined ? 'Undefined' : it === null ? 'Null'
1793
1792
  // @@toStringTag case
@@ -1795,20 +1794,366 @@ var classof$6 = TO_STRING_TAG_SUPPORT ? classofRaw$1 : function (it) {
1795
1794
  // builtinTag case
1796
1795
  : CORRECT_ARGUMENTS ? classofRaw$1(O)
1797
1796
  // ES3 arguments fallback
1798
- : (result = classofRaw$1(O)) === 'Object' && isCallable$8(O.callee) ? 'Arguments' : result;
1797
+ : (result = classofRaw$1(O)) === 'Object' && isCallable$a(O.callee) ? 'Arguments' : result;
1798
+ };
1799
+
1800
+ var classof$9 = classof$a;
1801
+
1802
+ var $String$1 = String;
1803
+
1804
+ var toString$b = function (argument) {
1805
+ if (classof$9(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
1806
+ return $String$1(argument);
1807
+ };
1808
+
1809
+ var toString$a = toString$b;
1810
+
1811
+ var normalizeStringArgument$1 = function (argument, $default) {
1812
+ return argument === undefined ? arguments.length < 2 ? '' : $default : toString$a(argument);
1813
+ };
1814
+
1815
+ var isObject$4 = isObject$e;
1816
+ var createNonEnumerableProperty$4 = createNonEnumerableProperty$9;
1817
+
1818
+ // `InstallErrorCause` abstract operation
1819
+ // https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause
1820
+ var installErrorCause$1 = function (O, options) {
1821
+ if (isObject$4(options) && 'cause' in options) {
1822
+ createNonEnumerableProperty$4(O, 'cause', options.cause);
1823
+ }
1824
+ };
1825
+
1826
+ var uncurryThis$g = functionUncurryThis;
1827
+
1828
+ var $Error = Error;
1829
+ var replace$6 = uncurryThis$g(''.replace);
1830
+
1831
+ var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
1832
+ // eslint-disable-next-line redos/no-vulnerable -- safe
1833
+ var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
1834
+ var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
1835
+
1836
+ var errorStackClear = function (stack, dropEntries) {
1837
+ if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
1838
+ while (dropEntries--) stack = replace$6(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
1839
+ } return stack;
1840
+ };
1841
+
1842
+ var fails$b = fails$n;
1843
+ var createPropertyDescriptor$2 = createPropertyDescriptor$6;
1844
+
1845
+ var errorStackInstallable = !fails$b(function () {
1846
+ var error = new Error('a');
1847
+ if (!('stack' in error)) return true;
1848
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
1849
+ Object.defineProperty(error, 'stack', createPropertyDescriptor$2(1, 7));
1850
+ return error.stack !== 7;
1851
+ });
1852
+
1853
+ var createNonEnumerableProperty$3 = createNonEnumerableProperty$9;
1854
+ var clearErrorStack = errorStackClear;
1855
+ var ERROR_STACK_INSTALLABLE = errorStackInstallable;
1856
+
1857
+ // non-standard V8
1858
+ var captureStackTrace = Error.captureStackTrace;
1859
+
1860
+ var errorStackInstall = function (error, C, stack, dropEntries) {
1861
+ if (ERROR_STACK_INSTALLABLE) {
1862
+ if (captureStackTrace) captureStackTrace(error, C);
1863
+ else createNonEnumerableProperty$3(error, 'stack', clearErrorStack(stack, dropEntries));
1864
+ }
1865
+ };
1866
+
1867
+ var getBuiltIn$5 = getBuiltIn$9;
1868
+ var hasOwn$5 = hasOwnProperty_1;
1869
+ var createNonEnumerableProperty$2 = createNonEnumerableProperty$9;
1870
+ var isPrototypeOf$4 = objectIsPrototypeOf;
1871
+ var setPrototypeOf$1 = objectSetPrototypeOf;
1872
+ var copyConstructorProperties = copyConstructorProperties$2;
1873
+ var proxyAccessor$1 = proxyAccessor$2;
1874
+ var inheritIfRequired$1 = inheritIfRequired$2;
1875
+ var normalizeStringArgument = normalizeStringArgument$1;
1876
+ var installErrorCause = installErrorCause$1;
1877
+ var installErrorStack = errorStackInstall;
1878
+ var DESCRIPTORS$9 = descriptors;
1879
+
1880
+ var wrapErrorConstructorWithCause$1 = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) {
1881
+ var STACK_TRACE_LIMIT = 'stackTraceLimit';
1882
+ var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1;
1883
+ var path = FULL_NAME.split('.');
1884
+ var ERROR_NAME = path[path.length - 1];
1885
+ var OriginalError = getBuiltIn$5.apply(null, path);
1886
+
1887
+ if (!OriginalError) return;
1888
+
1889
+ var OriginalErrorPrototype = OriginalError.prototype;
1890
+
1891
+ // V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006
1892
+ if (hasOwn$5(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause;
1893
+
1894
+ if (!FORCED) return OriginalError;
1895
+
1896
+ var BaseError = getBuiltIn$5('Error');
1897
+
1898
+ var WrappedError = wrapper(function (a, b) {
1899
+ var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined);
1900
+ var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError();
1901
+ if (message !== undefined) createNonEnumerableProperty$2(result, 'message', message);
1902
+ installErrorStack(result, WrappedError, result.stack, 2);
1903
+ if (this && isPrototypeOf$4(OriginalErrorPrototype, this)) inheritIfRequired$1(result, this, WrappedError);
1904
+ if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]);
1905
+ return result;
1906
+ });
1907
+
1908
+ WrappedError.prototype = OriginalErrorPrototype;
1909
+
1910
+ if (ERROR_NAME !== 'Error') {
1911
+ if (setPrototypeOf$1) setPrototypeOf$1(WrappedError, BaseError);
1912
+ else copyConstructorProperties(WrappedError, BaseError, { name: true });
1913
+ } else if (DESCRIPTORS$9 && STACK_TRACE_LIMIT in OriginalError) {
1914
+ proxyAccessor$1(WrappedError, OriginalError, STACK_TRACE_LIMIT);
1915
+ proxyAccessor$1(WrappedError, OriginalError, 'prepareStackTrace');
1916
+ }
1917
+
1918
+ copyConstructorProperties(WrappedError, OriginalError);
1919
+
1920
+ try {
1921
+ // Safari 13- bug: WebAssembly errors does not have a proper `.name`
1922
+ if (OriginalErrorPrototype.name !== ERROR_NAME) {
1923
+ createNonEnumerableProperty$2(OriginalErrorPrototype, 'name', ERROR_NAME);
1924
+ }
1925
+ OriginalErrorPrototype.constructor = WrappedError;
1926
+ } catch (error) { /* empty */ }
1927
+
1928
+ return WrappedError;
1929
+ };
1930
+
1931
+ /* eslint-disable no-unused-vars -- required for functions `.length` */
1932
+ var $$e = _export;
1933
+ var global$e = global$p;
1934
+ var apply$2 = functionApply;
1935
+ var wrapErrorConstructorWithCause = wrapErrorConstructorWithCause$1;
1936
+
1937
+ var WEB_ASSEMBLY = 'WebAssembly';
1938
+ var WebAssembly = global$e[WEB_ASSEMBLY];
1939
+
1940
+ // eslint-disable-next-line es/no-error-cause -- feature detection
1941
+ var FORCED = new Error('e', { cause: 7 }).cause !== 7;
1942
+
1943
+ var exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) {
1944
+ var O = {};
1945
+ O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED);
1946
+ $$e({ global: true, constructor: true, arity: 1, forced: FORCED }, O);
1947
+ };
1948
+
1949
+ var exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) {
1950
+ if (WebAssembly && WebAssembly[ERROR_NAME]) {
1951
+ var O = {};
1952
+ O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED);
1953
+ $$e({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED }, O);
1954
+ }
1955
+ };
1956
+
1957
+ // https://tc39.es/ecma262/#sec-nativeerror
1958
+ exportGlobalErrorCauseWrapper('Error', function (init) {
1959
+ return function Error(message) { return apply$2(init, this, arguments); };
1960
+ });
1961
+ exportGlobalErrorCauseWrapper('EvalError', function (init) {
1962
+ return function EvalError(message) { return apply$2(init, this, arguments); };
1963
+ });
1964
+ exportGlobalErrorCauseWrapper('RangeError', function (init) {
1965
+ return function RangeError(message) { return apply$2(init, this, arguments); };
1966
+ });
1967
+ exportGlobalErrorCauseWrapper('ReferenceError', function (init) {
1968
+ return function ReferenceError(message) { return apply$2(init, this, arguments); };
1969
+ });
1970
+ exportGlobalErrorCauseWrapper('SyntaxError', function (init) {
1971
+ return function SyntaxError(message) { return apply$2(init, this, arguments); };
1972
+ });
1973
+ exportGlobalErrorCauseWrapper('TypeError', function (init) {
1974
+ return function TypeError(message) { return apply$2(init, this, arguments); };
1975
+ });
1976
+ exportGlobalErrorCauseWrapper('URIError', function (init) {
1977
+ return function URIError(message) { return apply$2(init, this, arguments); };
1978
+ });
1979
+ exportWebAssemblyErrorCauseWrapper('CompileError', function (init) {
1980
+ return function CompileError(message) { return apply$2(init, this, arguments); };
1981
+ });
1982
+ exportWebAssemblyErrorCauseWrapper('LinkError', function (init) {
1983
+ return function LinkError(message) { return apply$2(init, this, arguments); };
1984
+ });
1985
+ exportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) {
1986
+ return function RuntimeError(message) { return apply$2(init, this, arguments); };
1987
+ });
1988
+
1989
+ var uncurryThis$f = functionUncurryThis;
1990
+
1991
+ var arraySlice$4 = uncurryThis$f([].slice);
1992
+
1993
+ var classof$8 = classofRaw$2;
1994
+
1995
+ // `IsArray` abstract operation
1996
+ // https://tc39.es/ecma262/#sec-isarray
1997
+ // eslint-disable-next-line es/no-array-isarray -- safe
1998
+ var isArray$1 = Array.isArray || function isArray(argument) {
1999
+ return classof$8(argument) === 'Array';
2000
+ };
2001
+
2002
+ var uncurryThis$e = functionUncurryThis;
2003
+ var isArray = isArray$1;
2004
+ var isCallable$9 = isCallable$p;
2005
+ var classof$7 = classofRaw$2;
2006
+ var toString$9 = toString$b;
2007
+
2008
+ var push$4 = uncurryThis$e([].push);
2009
+
2010
+ var getJsonReplacerFunction = function (replacer) {
2011
+ if (isCallable$9(replacer)) return replacer;
2012
+ if (!isArray(replacer)) return;
2013
+ var rawLength = replacer.length;
2014
+ var keys = [];
2015
+ for (var i = 0; i < rawLength; i++) {
2016
+ var element = replacer[i];
2017
+ if (typeof element == 'string') push$4(keys, element);
2018
+ else if (typeof element == 'number' || classof$7(element) === 'Number' || classof$7(element) === 'String') push$4(keys, toString$9(element));
2019
+ }
2020
+ var keysLength = keys.length;
2021
+ var root = true;
2022
+ return function (key, value) {
2023
+ if (root) {
2024
+ root = false;
2025
+ return value;
2026
+ }
2027
+ if (isArray(this)) return value;
2028
+ for (var j = 0; j < keysLength; j++) if (keys[j] === key) return value;
2029
+ };
2030
+ };
2031
+
2032
+ var $$d = _export;
2033
+ var getBuiltIn$4 = getBuiltIn$9;
2034
+ var apply$1 = functionApply;
2035
+ var call$f = functionCall;
2036
+ var uncurryThis$d = functionUncurryThis;
2037
+ var fails$a = fails$n;
2038
+ var isCallable$8 = isCallable$p;
2039
+ var isSymbol = isSymbol$3;
2040
+ var arraySlice$3 = arraySlice$4;
2041
+ var getReplacerFunction = getJsonReplacerFunction;
2042
+ var NATIVE_SYMBOL = symbolConstructorDetection;
2043
+
2044
+ var $String = String;
2045
+ var $stringify = getBuiltIn$4('JSON', 'stringify');
2046
+ var exec$5 = uncurryThis$d(/./.exec);
2047
+ var charAt$6 = uncurryThis$d(''.charAt);
2048
+ var charCodeAt$2 = uncurryThis$d(''.charCodeAt);
2049
+ var replace$5 = uncurryThis$d(''.replace);
2050
+ var numberToString$1 = uncurryThis$d(1.0.toString);
2051
+
2052
+ var tester = /[\uD800-\uDFFF]/g;
2053
+ var low = /^[\uD800-\uDBFF]$/;
2054
+ var hi = /^[\uDC00-\uDFFF]$/;
2055
+
2056
+ var WRONG_SYMBOLS_CONVERSION = !NATIVE_SYMBOL || fails$a(function () {
2057
+ var symbol = getBuiltIn$4('Symbol')('stringify detection');
2058
+ // MS Edge converts symbol values to JSON as {}
2059
+ return $stringify([symbol]) !== '[null]'
2060
+ // WebKit converts symbol values to JSON as null
2061
+ || $stringify({ a: symbol }) !== '{}'
2062
+ // V8 throws on boxed symbols
2063
+ || $stringify(Object(symbol)) !== '{}';
2064
+ });
2065
+
2066
+ // https://github.com/tc39/proposal-well-formed-stringify
2067
+ var ILL_FORMED_UNICODE = fails$a(function () {
2068
+ return $stringify('\uDF06\uD834') !== '"\\udf06\\ud834"'
2069
+ || $stringify('\uDEAD') !== '"\\udead"';
2070
+ });
2071
+
2072
+ var stringifyWithSymbolsFix = function (it, replacer) {
2073
+ var args = arraySlice$3(arguments);
2074
+ var $replacer = getReplacerFunction(replacer);
2075
+ if (!isCallable$8($replacer) && (it === undefined || isSymbol(it))) return; // IE8 returns string on undefined
2076
+ args[1] = function (key, value) {
2077
+ // some old implementations (like WebKit) could pass numbers as keys
2078
+ if (isCallable$8($replacer)) value = call$f($replacer, this, $String(key), value);
2079
+ if (!isSymbol(value)) return value;
2080
+ };
2081
+ return apply$1($stringify, null, args);
2082
+ };
2083
+
2084
+ var fixIllFormed = function (match, offset, string) {
2085
+ var prev = charAt$6(string, offset - 1);
2086
+ var next = charAt$6(string, offset + 1);
2087
+ if ((exec$5(low, match) && !exec$5(hi, next)) || (exec$5(hi, match) && !exec$5(low, prev))) {
2088
+ return '\\u' + numberToString$1(charCodeAt$2(match, 0), 16);
2089
+ } return match;
2090
+ };
2091
+
2092
+ if ($stringify) {
2093
+ // `JSON.stringify` method
2094
+ // https://tc39.es/ecma262/#sec-json.stringify
2095
+ $$d({ target: 'JSON', stat: true, arity: 3, forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE }, {
2096
+ // eslint-disable-next-line no-unused-vars -- required for `.length`
2097
+ stringify: function stringify(it, replacer, space) {
2098
+ var args = arraySlice$3(arguments);
2099
+ var result = apply$1(WRONG_SYMBOLS_CONVERSION ? stringifyWithSymbolsFix : $stringify, null, args);
2100
+ return ILL_FORMED_UNICODE && typeof result == 'string' ? replace$5(result, tester, fixIllFormed) : result;
2101
+ }
2102
+ });
2103
+ }
2104
+
2105
+ var global$d = global$p;
2106
+ var classof$6 = classofRaw$2;
2107
+
2108
+ var engineIsNode = classof$6(global$d.process) === 'process';
2109
+
2110
+ var makeBuiltIn = makeBuiltIn$3.exports;
2111
+ var defineProperty = objectDefineProperty;
2112
+
2113
+ var defineBuiltInAccessor$5 = function (target, name, descriptor) {
2114
+ if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
2115
+ if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
2116
+ return defineProperty.f(target, name, descriptor);
2117
+ };
2118
+
2119
+ var getBuiltIn$3 = getBuiltIn$9;
2120
+ var defineBuiltInAccessor$4 = defineBuiltInAccessor$5;
2121
+ var wellKnownSymbol$b = wellKnownSymbol$k;
2122
+ var DESCRIPTORS$8 = descriptors;
2123
+
2124
+ var SPECIES$3 = wellKnownSymbol$b('species');
2125
+
2126
+ var setSpecies$2 = function (CONSTRUCTOR_NAME) {
2127
+ var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
2128
+
2129
+ if (DESCRIPTORS$8 && Constructor && !Constructor[SPECIES$3]) {
2130
+ defineBuiltInAccessor$4(Constructor, SPECIES$3, {
2131
+ configurable: true,
2132
+ get: function () { return this; }
2133
+ });
2134
+ }
1799
2135
  };
1800
2136
 
1801
- var uncurryThis$a = functionUncurryThis;
1802
- var fails$9 = fails$l;
1803
- var isCallable$7 = isCallable$m;
1804
- var classof$5 = classof$6;
1805
- var getBuiltIn$2 = getBuiltIn$7;
2137
+ var isPrototypeOf$3 = objectIsPrototypeOf;
2138
+
2139
+ var $TypeError$8 = TypeError;
2140
+
2141
+ var anInstance$3 = function (it, Prototype) {
2142
+ if (isPrototypeOf$3(Prototype, it)) return it;
2143
+ throw new $TypeError$8('Incorrect invocation');
2144
+ };
2145
+
2146
+ var uncurryThis$c = functionUncurryThis;
2147
+ var fails$9 = fails$n;
2148
+ var isCallable$7 = isCallable$p;
2149
+ var classof$5 = classof$a;
2150
+ var getBuiltIn$2 = getBuiltIn$9;
1806
2151
  var inspectSource$1 = inspectSource$3;
1807
2152
 
1808
2153
  var noop = function () { /* empty */ };
1809
2154
  var construct = getBuiltIn$2('Reflect', 'construct');
1810
2155
  var constructorRegExp = /^\s*(?:class|function)\b/;
1811
- var exec$4 = uncurryThis$a(constructorRegExp.exec);
2156
+ var exec$4 = uncurryThis$c(constructorRegExp.exec);
1812
2157
  var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
1813
2158
 
1814
2159
  var isConstructorModern = function isConstructor(argument) {
@@ -1853,15 +2198,15 @@ var isConstructor$2 = !construct || fails$9(function () {
1853
2198
  var isConstructor$1 = isConstructor$2;
1854
2199
  var tryToString$2 = tryToString$4;
1855
2200
 
1856
- var $TypeError$6 = TypeError;
2201
+ var $TypeError$7 = TypeError;
1857
2202
 
1858
2203
  // `Assert: IsConstructor(argument) is true`
1859
2204
  var aConstructor$1 = function (argument) {
1860
2205
  if (isConstructor$1(argument)) return argument;
1861
- throw new $TypeError$6(tryToString$2(argument) + ' is not a constructor');
2206
+ throw new $TypeError$7(tryToString$2(argument) + ' is not a constructor');
1862
2207
  };
1863
2208
 
1864
- var anObject$a = anObject$f;
2209
+ var anObject$b = anObject$g;
1865
2210
  var aConstructor = aConstructor$1;
1866
2211
  var isNullOrUndefined$2 = isNullOrUndefined$5;
1867
2212
  var wellKnownSymbol$a = wellKnownSymbol$k;
@@ -1871,37 +2216,26 @@ var SPECIES$2 = wellKnownSymbol$a('species');
1871
2216
  // `SpeciesConstructor` abstract operation
1872
2217
  // https://tc39.es/ecma262/#sec-speciesconstructor
1873
2218
  var speciesConstructor$1 = function (O, defaultConstructor) {
1874
- var C = anObject$a(O).constructor;
2219
+ var C = anObject$b(O).constructor;
1875
2220
  var S;
1876
- return C === undefined || isNullOrUndefined$2(S = anObject$a(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S);
2221
+ return C === undefined || isNullOrUndefined$2(S = anObject$b(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S);
1877
2222
  };
1878
2223
 
1879
- var NATIVE_BIND$1 = functionBindNative;
1880
-
1881
- var FunctionPrototype = Function.prototype;
1882
- var apply$1 = FunctionPrototype.apply;
1883
- var call$e = FunctionPrototype.call;
1884
-
1885
- // eslint-disable-next-line es/no-reflect -- safe
1886
- var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$e.bind(apply$1) : function () {
1887
- return call$e.apply(apply$1, arguments);
1888
- });
1889
-
1890
2224
  var classofRaw = classofRaw$2;
1891
- var uncurryThis$9 = functionUncurryThis;
2225
+ var uncurryThis$b = functionUncurryThis;
1892
2226
 
1893
2227
  var functionUncurryThisClause = function (fn) {
1894
2228
  // Nashorn bug:
1895
2229
  // https://github.com/zloirock/core-js/issues/1128
1896
2230
  // https://github.com/zloirock/core-js/issues/1130
1897
- if (classofRaw(fn) === 'Function') return uncurryThis$9(fn);
2231
+ if (classofRaw(fn) === 'Function') return uncurryThis$b(fn);
1898
2232
  };
1899
2233
 
1900
- var uncurryThis$8 = functionUncurryThisClause;
2234
+ var uncurryThis$a = functionUncurryThisClause;
1901
2235
  var aCallable$5 = aCallable$8;
1902
2236
  var NATIVE_BIND = functionBindNative;
1903
2237
 
1904
- var bind$7 = uncurryThis$8(uncurryThis$8.bind);
2238
+ var bind$7 = uncurryThis$a(uncurryThis$a.bind);
1905
2239
 
1906
2240
  // optional / simple context binding
1907
2241
  var functionBindContext = function (fn, that) {
@@ -1911,14 +2245,10 @@ var functionBindContext = function (fn, that) {
1911
2245
  };
1912
2246
  };
1913
2247
 
1914
- var uncurryThis$7 = functionUncurryThis;
1915
-
1916
- var arraySlice$3 = uncurryThis$7([].slice);
1917
-
1918
- var $TypeError$5 = TypeError;
2248
+ var $TypeError$6 = TypeError;
1919
2249
 
1920
- var validateArgumentsLength$3 = function (passed, required) {
1921
- if (passed < required) throw new $TypeError$5('Not enough arguments');
2250
+ var validateArgumentsLength$5 = function (passed, required) {
2251
+ if (passed < required) throw new $TypeError$6('Not enough arguments');
1922
2252
  return passed;
1923
2253
  };
1924
2254
 
@@ -1927,16 +2257,16 @@ var userAgent$2 = engineUserAgent;
1927
2257
  // eslint-disable-next-line redos/no-vulnerable -- safe
1928
2258
  var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
1929
2259
 
1930
- var global$c = global$o;
2260
+ var global$c = global$p;
1931
2261
  var apply = functionApply;
1932
2262
  var bind$6 = functionBindContext;
1933
- var isCallable$6 = isCallable$m;
2263
+ var isCallable$6 = isCallable$p;
1934
2264
  var hasOwn$4 = hasOwnProperty_1;
1935
- var fails$8 = fails$l;
2265
+ var fails$8 = fails$n;
1936
2266
  var html = html$2;
1937
- var arraySlice$2 = arraySlice$3;
2267
+ var arraySlice$2 = arraySlice$4;
1938
2268
  var createElement = documentCreateElement$2;
1939
- var validateArgumentsLength$2 = validateArgumentsLength$3;
2269
+ var validateArgumentsLength$4 = validateArgumentsLength$5;
1940
2270
  var IS_IOS$1 = engineIsIos;
1941
2271
  var IS_NODE$3 = engineIsNode;
1942
2272
 
@@ -1983,7 +2313,7 @@ var globalPostMessageDefer = function (id) {
1983
2313
  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
1984
2314
  if (!set || !clear) {
1985
2315
  set = function setImmediate(handler) {
1986
- validateArgumentsLength$2(arguments.length, 1);
2316
+ validateArgumentsLength$4(arguments.length, 1);
1987
2317
  var fn = isCallable$6(handler) ? handler : Function$1(handler);
1988
2318
  var args = arraySlice$2(arguments, 1);
1989
2319
  queue$2[++counter] = function () {
@@ -2044,15 +2374,15 @@ var task$1 = {
2044
2374
  clear: clear
2045
2375
  };
2046
2376
 
2047
- var global$b = global$o;
2048
- var DESCRIPTORS$5 = descriptors;
2377
+ var global$b = global$p;
2378
+ var DESCRIPTORS$7 = descriptors;
2049
2379
 
2050
2380
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2051
2381
  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2052
2382
 
2053
2383
  // Avoid NodeJS experimental warning
2054
2384
  var safeGetBuiltIn$2 = function (name) {
2055
- if (!DESCRIPTORS$5) return global$b[name];
2385
+ if (!DESCRIPTORS$7) return global$b[name];
2056
2386
  var descriptor = getOwnPropertyDescriptor(global$b, name);
2057
2387
  return descriptor && descriptor.value;
2058
2388
  };
@@ -2090,7 +2420,7 @@ var userAgent = engineUserAgent;
2090
2420
 
2091
2421
  var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
2092
2422
 
2093
- var global$a = global$o;
2423
+ var global$a = global$p;
2094
2424
  var safeGetBuiltIn$1 = safeGetBuiltIn$2;
2095
2425
  var bind$5 = functionBindContext;
2096
2426
  var macrotask = task$1.set;
@@ -2184,7 +2514,7 @@ var perform$3 = function (exec) {
2184
2514
  }
2185
2515
  };
2186
2516
 
2187
- var global$9 = global$o;
2517
+ var global$9 = global$p;
2188
2518
 
2189
2519
  var promiseNativeConstructor = global$9.Promise;
2190
2520
 
@@ -2198,9 +2528,9 @@ var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1
2198
2528
  && typeof window == 'object'
2199
2529
  && typeof document == 'object';
2200
2530
 
2201
- var global$8 = global$o;
2531
+ var global$8 = global$p;
2202
2532
  var NativePromiseConstructor$3 = promiseNativeConstructor;
2203
- var isCallable$5 = isCallable$m;
2533
+ var isCallable$5 = isCallable$p;
2204
2534
  var isForced$1 = isForced_1;
2205
2535
  var inspectSource = inspectSource$3;
2206
2536
  var wellKnownSymbol$9 = wellKnownSymbol$k;
@@ -2247,12 +2577,12 @@ var newPromiseCapability$2 = {};
2247
2577
 
2248
2578
  var aCallable$4 = aCallable$8;
2249
2579
 
2250
- var $TypeError$4 = TypeError;
2580
+ var $TypeError$5 = TypeError;
2251
2581
 
2252
2582
  var PromiseCapability = function (C) {
2253
2583
  var resolve, reject;
2254
2584
  this.promise = new C(function ($$resolve, $$reject) {
2255
- if (resolve !== undefined || reject !== undefined) throw new $TypeError$4('Bad Promise constructor');
2585
+ if (resolve !== undefined || reject !== undefined) throw new $TypeError$5('Bad Promise constructor');
2256
2586
  resolve = $$resolve;
2257
2587
  reject = $$reject;
2258
2588
  });
@@ -2266,17 +2596,17 @@ newPromiseCapability$2.f = function (C) {
2266
2596
  return new PromiseCapability(C);
2267
2597
  };
2268
2598
 
2269
- var $$b = _export;
2599
+ var $$c = _export;
2270
2600
  var IS_NODE = engineIsNode;
2271
- var global$7 = global$o;
2272
- var call$d = functionCall;
2273
- var defineBuiltIn$7 = defineBuiltIn$b;
2274
- var setPrototypeOf$1 = objectSetPrototypeOf;
2601
+ var global$7 = global$p;
2602
+ var call$e = functionCall;
2603
+ var defineBuiltIn$9 = defineBuiltIn$d;
2604
+ var setPrototypeOf = objectSetPrototypeOf;
2275
2605
  var setToStringTag$2 = setToStringTag$6;
2276
2606
  var setSpecies$1 = setSpecies$2;
2277
2607
  var aCallable$3 = aCallable$8;
2278
- var isCallable$4 = isCallable$m;
2279
- var isObject$4 = isObject$d;
2608
+ var isCallable$4 = isCallable$p;
2609
+ var isObject$3 = isObject$e;
2280
2610
  var anInstance$2 = anInstance$3;
2281
2611
  var speciesConstructor = speciesConstructor$1;
2282
2612
  var task = task$1.set;
@@ -2318,7 +2648,7 @@ var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
2318
2648
  // helpers
2319
2649
  var isThenable = function (it) {
2320
2650
  var then;
2321
- return isObject$4(it) && isCallable$4(then = it.then) ? then : false;
2651
+ return isObject$3(it) && isCallable$4(then = it.then) ? then : false;
2322
2652
  };
2323
2653
 
2324
2654
  var callReaction = function (reaction, state) {
@@ -2347,7 +2677,7 @@ var callReaction = function (reaction, state) {
2347
2677
  if (result === reaction.promise) {
2348
2678
  reject(new TypeError$3('Promise-chain cycle'));
2349
2679
  } else if (then = isThenable(result)) {
2350
- call$d(then, result, resolve, reject);
2680
+ call$e(then, result, resolve, reject);
2351
2681
  } else resolve(result);
2352
2682
  } else reject(value);
2353
2683
  } catch (error) {
@@ -2384,7 +2714,7 @@ var dispatchEvent = function (name, promise, reason) {
2384
2714
  };
2385
2715
 
2386
2716
  var onUnhandled = function (state) {
2387
- call$d(task, global$7, function () {
2717
+ call$e(task, global$7, function () {
2388
2718
  var promise = state.facade;
2389
2719
  var value = state.value;
2390
2720
  var IS_UNHANDLED = isUnhandled(state);
@@ -2407,7 +2737,7 @@ var isUnhandled = function (state) {
2407
2737
  };
2408
2738
 
2409
2739
  var onHandleUnhandled = function (state) {
2410
- call$d(task, global$7, function () {
2740
+ call$e(task, global$7, function () {
2411
2741
  var promise = state.facade;
2412
2742
  if (IS_NODE) {
2413
2743
  process.emit('rejectionHandled', promise);
@@ -2441,7 +2771,7 @@ var internalResolve = function (state, value, unwrap) {
2441
2771
  microtask(function () {
2442
2772
  var wrapper = { done: false };
2443
2773
  try {
2444
- call$d(then, value,
2774
+ call$e(then, value,
2445
2775
  bind$4(internalResolve, wrapper, state),
2446
2776
  bind$4(internalReject, wrapper, state)
2447
2777
  );
@@ -2465,7 +2795,7 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
2465
2795
  PromiseConstructor = function Promise(executor) {
2466
2796
  anInstance$2(this, PromisePrototype);
2467
2797
  aCallable$3(executor);
2468
- call$d(Internal, this);
2798
+ call$e(Internal, this);
2469
2799
  var state = getInternalPromiseState(this);
2470
2800
  try {
2471
2801
  executor(bind$4(internalResolve, state), bind$4(internalReject, state));
@@ -2492,7 +2822,7 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
2492
2822
 
2493
2823
  // `Promise.prototype.then` method
2494
2824
  // https://tc39.es/ecma262/#sec-promise.prototype.then
2495
- Internal.prototype = defineBuiltIn$7(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
2825
+ Internal.prototype = defineBuiltIn$9(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
2496
2826
  var state = getInternalPromiseState(this);
2497
2827
  var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor));
2498
2828
  state.parent = true;
@@ -2525,10 +2855,10 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
2525
2855
 
2526
2856
  if (!NATIVE_PROMISE_SUBCLASSING) {
2527
2857
  // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
2528
- defineBuiltIn$7(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) {
2858
+ defineBuiltIn$9(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) {
2529
2859
  var that = this;
2530
2860
  return new PromiseConstructor(function (resolve, reject) {
2531
- call$d(nativeThen, that, resolve, reject);
2861
+ call$e(nativeThen, that, resolve, reject);
2532
2862
  }).then(onFulfilled, onRejected);
2533
2863
  // https://github.com/zloirock/core-js/issues/640
2534
2864
  }, { unsafe: true });
@@ -2540,13 +2870,13 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
2540
2870
  } catch (error) { /* empty */ }
2541
2871
 
2542
2872
  // make `instanceof Promise` work for native promise-based APIs
2543
- if (setPrototypeOf$1) {
2544
- setPrototypeOf$1(NativePromisePrototype$1, PromisePrototype);
2873
+ if (setPrototypeOf) {
2874
+ setPrototypeOf(NativePromisePrototype$1, PromisePrototype);
2545
2875
  }
2546
2876
  }
2547
2877
  }
2548
2878
 
2549
- $$b({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
2879
+ $$c({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
2550
2880
  Promise: PromiseConstructor
2551
2881
  });
2552
2882
 
@@ -2564,7 +2894,7 @@ var isArrayIteratorMethod$2 = function (it) {
2564
2894
  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$4] === it);
2565
2895
  };
2566
2896
 
2567
- var classof$4 = classof$6;
2897
+ var classof$4 = classof$a;
2568
2898
  var getMethod$2 = getMethod$4;
2569
2899
  var isNullOrUndefined$1 = isNullOrUndefined$5;
2570
2900
  var Iterators = iterators;
@@ -2578,47 +2908,47 @@ var getIteratorMethod$4 = function (it) {
2578
2908
  || Iterators[classof$4(it)];
2579
2909
  };
2580
2910
 
2581
- var call$c = functionCall;
2911
+ var call$d = functionCall;
2582
2912
  var aCallable$2 = aCallable$8;
2583
- var anObject$9 = anObject$f;
2913
+ var anObject$a = anObject$g;
2584
2914
  var tryToString$1 = tryToString$4;
2585
2915
  var getIteratorMethod$3 = getIteratorMethod$4;
2586
2916
 
2587
- var $TypeError$3 = TypeError;
2917
+ var $TypeError$4 = TypeError;
2588
2918
 
2589
2919
  var getIterator$3 = function (argument, usingIterator) {
2590
2920
  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$3(argument) : usingIterator;
2591
- if (aCallable$2(iteratorMethod)) return anObject$9(call$c(iteratorMethod, argument));
2592
- throw new $TypeError$3(tryToString$1(argument) + ' is not iterable');
2921
+ if (aCallable$2(iteratorMethod)) return anObject$a(call$d(iteratorMethod, argument));
2922
+ throw new $TypeError$4(tryToString$1(argument) + ' is not iterable');
2593
2923
  };
2594
2924
 
2595
- var call$b = functionCall;
2596
- var anObject$8 = anObject$f;
2925
+ var call$c = functionCall;
2926
+ var anObject$9 = anObject$g;
2597
2927
  var getMethod$1 = getMethod$4;
2598
2928
 
2599
2929
  var iteratorClose$2 = function (iterator, kind, value) {
2600
2930
  var innerResult, innerError;
2601
- anObject$8(iterator);
2931
+ anObject$9(iterator);
2602
2932
  try {
2603
2933
  innerResult = getMethod$1(iterator, 'return');
2604
2934
  if (!innerResult) {
2605
2935
  if (kind === 'throw') throw value;
2606
2936
  return value;
2607
2937
  }
2608
- innerResult = call$b(innerResult, iterator);
2938
+ innerResult = call$c(innerResult, iterator);
2609
2939
  } catch (error) {
2610
2940
  innerError = true;
2611
2941
  innerResult = error;
2612
2942
  }
2613
2943
  if (kind === 'throw') throw value;
2614
2944
  if (innerError) throw innerResult;
2615
- anObject$8(innerResult);
2945
+ anObject$9(innerResult);
2616
2946
  return value;
2617
2947
  };
2618
2948
 
2619
2949
  var bind$3 = functionBindContext;
2620
- var call$a = functionCall;
2621
- var anObject$7 = anObject$f;
2950
+ var call$b = functionCall;
2951
+ var anObject$8 = anObject$g;
2622
2952
  var tryToString = tryToString$4;
2623
2953
  var isArrayIteratorMethod$1 = isArrayIteratorMethod$2;
2624
2954
  var lengthOfArrayLike$1 = lengthOfArrayLike$3;
@@ -2627,7 +2957,7 @@ var getIterator$2 = getIterator$3;
2627
2957
  var getIteratorMethod$2 = getIteratorMethod$4;
2628
2958
  var iteratorClose$1 = iteratorClose$2;
2629
2959
 
2630
- var $TypeError$2 = TypeError;
2960
+ var $TypeError$3 = TypeError;
2631
2961
 
2632
2962
  var Result = function (stopped, result) {
2633
2963
  this.stopped = stopped;
@@ -2652,7 +2982,7 @@ var iterate$2 = function (iterable, unboundFunction, options) {
2652
2982
 
2653
2983
  var callFn = function (value) {
2654
2984
  if (AS_ENTRIES) {
2655
- anObject$7(value);
2985
+ anObject$8(value);
2656
2986
  return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
2657
2987
  } return INTERRUPTED ? fn(value, stop) : fn(value);
2658
2988
  };
@@ -2663,7 +2993,7 @@ var iterate$2 = function (iterable, unboundFunction, options) {
2663
2993
  iterator = iterable;
2664
2994
  } else {
2665
2995
  iterFn = getIteratorMethod$2(iterable);
2666
- if (!iterFn) throw new $TypeError$2(tryToString(iterable) + ' is not iterable');
2996
+ if (!iterFn) throw new $TypeError$3(tryToString(iterable) + ' is not iterable');
2667
2997
  // optimisation for array iterators
2668
2998
  if (isArrayIteratorMethod$1(iterFn)) {
2669
2999
  for (index = 0, length = lengthOfArrayLike$1(iterable); length > index; index++) {
@@ -2675,7 +3005,7 @@ var iterate$2 = function (iterable, unboundFunction, options) {
2675
3005
  }
2676
3006
 
2677
3007
  next = IS_RECORD ? iterable.next : iterator.next;
2678
- while (!(step = call$a(next, iterator)).done) {
3008
+ while (!(step = call$b(next, iterator)).done) {
2679
3009
  try {
2680
3010
  result = callFn(step.value);
2681
3011
  } catch (error) {
@@ -2734,8 +3064,8 @@ var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCor
2734
3064
  NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ });
2735
3065
  });
2736
3066
 
2737
- var $$a = _export;
2738
- var call$9 = functionCall;
3067
+ var $$b = _export;
3068
+ var call$a = functionCall;
2739
3069
  var aCallable$1 = aCallable$8;
2740
3070
  var newPromiseCapabilityModule$2 = newPromiseCapability$2;
2741
3071
  var perform$1 = perform$3;
@@ -2744,7 +3074,7 @@ var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration;
2744
3074
 
2745
3075
  // `Promise.all` method
2746
3076
  // https://tc39.es/ecma262/#sec-promise.all
2747
- $$a({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
3077
+ $$b({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
2748
3078
  all: function all(iterable) {
2749
3079
  var C = this;
2750
3080
  var capability = newPromiseCapabilityModule$2.f(C);
@@ -2759,7 +3089,7 @@ $$a({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
2759
3089
  var index = counter++;
2760
3090
  var alreadyCalled = false;
2761
3091
  remaining++;
2762
- call$9($promiseResolve, C, promise).then(function (value) {
3092
+ call$a($promiseResolve, C, promise).then(function (value) {
2763
3093
  if (alreadyCalled) return;
2764
3094
  alreadyCalled = true;
2765
3095
  values[index] = value;
@@ -2773,18 +3103,18 @@ $$a({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
2773
3103
  }
2774
3104
  });
2775
3105
 
2776
- var $$9 = _export;
3106
+ var $$a = _export;
2777
3107
  var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
2778
3108
  var NativePromiseConstructor = promiseNativeConstructor;
2779
- var getBuiltIn$1 = getBuiltIn$7;
2780
- var isCallable$3 = isCallable$m;
2781
- var defineBuiltIn$6 = defineBuiltIn$b;
3109
+ var getBuiltIn$1 = getBuiltIn$9;
3110
+ var isCallable$3 = isCallable$p;
3111
+ var defineBuiltIn$8 = defineBuiltIn$d;
2782
3112
 
2783
3113
  var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
2784
3114
 
2785
3115
  // `Promise.prototype.catch` method
2786
3116
  // https://tc39.es/ecma262/#sec-promise.prototype.catch
2787
- $$9({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
3117
+ $$a({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
2788
3118
  'catch': function (onRejected) {
2789
3119
  return this.then(undefined, onRejected);
2790
3120
  }
@@ -2794,12 +3124,12 @@ $$9({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real
2794
3124
  if (isCallable$3(NativePromiseConstructor)) {
2795
3125
  var method = getBuiltIn$1('Promise').prototype['catch'];
2796
3126
  if (NativePromisePrototype['catch'] !== method) {
2797
- defineBuiltIn$6(NativePromisePrototype, 'catch', method, { unsafe: true });
3127
+ defineBuiltIn$8(NativePromisePrototype, 'catch', method, { unsafe: true });
2798
3128
  }
2799
3129
  }
2800
3130
 
2801
- var $$8 = _export;
2802
- var call$8 = functionCall;
3131
+ var $$9 = _export;
3132
+ var call$9 = functionCall;
2803
3133
  var aCallable = aCallable$8;
2804
3134
  var newPromiseCapabilityModule$1 = newPromiseCapability$2;
2805
3135
  var perform = perform$3;
@@ -2808,7 +3138,7 @@ var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration;
2808
3138
 
2809
3139
  // `Promise.race` method
2810
3140
  // https://tc39.es/ecma262/#sec-promise.race
2811
- $$8({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
3141
+ $$9({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
2812
3142
  race: function race(iterable) {
2813
3143
  var C = this;
2814
3144
  var capability = newPromiseCapabilityModule$1.f(C);
@@ -2816,7 +3146,7 @@ $$8({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
2816
3146
  var result = perform(function () {
2817
3147
  var $promiseResolve = aCallable(C.resolve);
2818
3148
  iterate(iterable, function (promise) {
2819
- call$8($promiseResolve, C, promise).then(capability.resolve, reject);
3149
+ call$9($promiseResolve, C, promise).then(capability.resolve, reject);
2820
3150
  });
2821
3151
  });
2822
3152
  if (result.error) reject(result.value);
@@ -2824,13 +3154,13 @@ $$8({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
2824
3154
  }
2825
3155
  });
2826
3156
 
2827
- var $$7 = _export;
3157
+ var $$8 = _export;
2828
3158
  var newPromiseCapabilityModule = newPromiseCapability$2;
2829
3159
  var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
2830
3160
 
2831
3161
  // `Promise.reject` method
2832
3162
  // https://tc39.es/ecma262/#sec-promise.reject
2833
- $$7({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
3163
+ $$8({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
2834
3164
  reject: function reject(r) {
2835
3165
  var capability = newPromiseCapabilityModule.f(this);
2836
3166
  var capabilityReject = capability.reject;
@@ -2839,21 +3169,21 @@ $$7({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
2839
3169
  }
2840
3170
  });
2841
3171
 
2842
- var anObject$6 = anObject$f;
2843
- var isObject$3 = isObject$d;
3172
+ var anObject$7 = anObject$g;
3173
+ var isObject$2 = isObject$e;
2844
3174
  var newPromiseCapability = newPromiseCapability$2;
2845
3175
 
2846
3176
  var promiseResolve$1 = function (C, x) {
2847
- anObject$6(C);
2848
- if (isObject$3(x) && x.constructor === C) return x;
3177
+ anObject$7(C);
3178
+ if (isObject$2(x) && x.constructor === C) return x;
2849
3179
  var promiseCapability = newPromiseCapability.f(C);
2850
3180
  var resolve = promiseCapability.resolve;
2851
3181
  resolve(x);
2852
3182
  return promiseCapability.promise;
2853
3183
  };
2854
3184
 
2855
- var $$6 = _export;
2856
- var getBuiltIn = getBuiltIn$7;
3185
+ var $$7 = _export;
3186
+ var getBuiltIn = getBuiltIn$9;
2857
3187
  var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR;
2858
3188
  var promiseResolve = promiseResolve$1;
2859
3189
 
@@ -2861,27 +3191,18 @@ getBuiltIn('Promise');
2861
3191
 
2862
3192
  // `Promise.resolve` method
2863
3193
  // https://tc39.es/ecma262/#sec-promise.resolve
2864
- $$6({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
3194
+ $$7({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
2865
3195
  resolve: function resolve(x) {
2866
3196
  return promiseResolve(this, x);
2867
3197
  }
2868
3198
  });
2869
3199
 
2870
- var classof$3 = classof$6;
2871
-
2872
- var $String = String;
2873
-
2874
- var toString$6 = function (argument) {
2875
- if (classof$3(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
2876
- return $String(argument);
2877
- };
2878
-
2879
- var anObject$5 = anObject$f;
3200
+ var anObject$6 = anObject$g;
2880
3201
 
2881
3202
  // `RegExp.prototype.flags` getter implementation
2882
3203
  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
2883
3204
  var regexpFlags$1 = function () {
2884
- var that = anObject$5(this);
3205
+ var that = anObject$6(this);
2885
3206
  var result = '';
2886
3207
  if (that.hasIndices) result += 'd';
2887
3208
  if (that.global) result += 'g';
@@ -2894,8 +3215,8 @@ var regexpFlags$1 = function () {
2894
3215
  return result;
2895
3216
  };
2896
3217
 
2897
- var fails$7 = fails$l;
2898
- var global$6 = global$o;
3218
+ var fails$7 = fails$n;
3219
+ var global$6 = global$p;
2899
3220
 
2900
3221
  // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
2901
3222
  var $RegExp$2 = global$6.RegExp;
@@ -2925,8 +3246,8 @@ var regexpStickyHelpers = {
2925
3246
  UNSUPPORTED_Y: UNSUPPORTED_Y$2
2926
3247
  };
2927
3248
 
2928
- var fails$6 = fails$l;
2929
- var global$5 = global$o;
3249
+ var fails$6 = fails$n;
3250
+ var global$5 = global$p;
2930
3251
 
2931
3252
  // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
2932
3253
  var $RegExp$1 = global$5.RegExp;
@@ -2936,8 +3257,8 @@ var regexpUnsupportedDotAll = fails$6(function () {
2936
3257
  return !(re.dotAll && re.test('\n') && re.flags === 's');
2937
3258
  });
2938
3259
 
2939
- var fails$5 = fails$l;
2940
- var global$4 = global$o;
3260
+ var fails$5 = fails$n;
3261
+ var global$4 = global$p;
2941
3262
 
2942
3263
  // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
2943
3264
  var $RegExp = global$4.RegExp;
@@ -2950,30 +3271,30 @@ var regexpUnsupportedNcg = fails$5(function () {
2950
3271
 
2951
3272
  /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
2952
3273
  /* eslint-disable regexp/no-useless-quantifier -- testing */
2953
- var call$7 = functionCall;
2954
- var uncurryThis$6 = functionUncurryThis;
2955
- var toString$5 = toString$6;
3274
+ var call$8 = functionCall;
3275
+ var uncurryThis$9 = functionUncurryThis;
3276
+ var toString$8 = toString$b;
2956
3277
  var regexpFlags = regexpFlags$1;
2957
3278
  var stickyHelpers$1 = regexpStickyHelpers;
2958
3279
  var shared = shared$4;
2959
3280
  var create$2 = objectCreate;
2960
- var getInternalState$1 = internalState.get;
2961
- var UNSUPPORTED_DOT_ALL$1 = regexpUnsupportedDotAll;
3281
+ var getInternalState$2 = internalState.get;
3282
+ var UNSUPPORTED_DOT_ALL$2 = regexpUnsupportedDotAll;
2962
3283
  var UNSUPPORTED_NCG$1 = regexpUnsupportedNcg;
2963
3284
 
2964
3285
  var nativeReplace = shared('native-string-replace', String.prototype.replace);
2965
3286
  var nativeExec = RegExp.prototype.exec;
2966
3287
  var patchedExec = nativeExec;
2967
- var charAt$5 = uncurryThis$6(''.charAt);
2968
- var indexOf = uncurryThis$6(''.indexOf);
2969
- var replace$4 = uncurryThis$6(''.replace);
2970
- var stringSlice$4 = uncurryThis$6(''.slice);
3288
+ var charAt$5 = uncurryThis$9(''.charAt);
3289
+ var indexOf = uncurryThis$9(''.indexOf);
3290
+ var replace$4 = uncurryThis$9(''.replace);
3291
+ var stringSlice$4 = uncurryThis$9(''.slice);
2971
3292
 
2972
3293
  var UPDATES_LAST_INDEX_WRONG = (function () {
2973
3294
  var re1 = /a/;
2974
3295
  var re2 = /b*/g;
2975
- call$7(nativeExec, re1, 'a');
2976
- call$7(nativeExec, re2, 'a');
3296
+ call$8(nativeExec, re1, 'a');
3297
+ call$8(nativeExec, re2, 'a');
2977
3298
  return re1.lastIndex !== 0 || re2.lastIndex !== 0;
2978
3299
  })();
2979
3300
 
@@ -2982,26 +3303,26 @@ var UNSUPPORTED_Y$1 = stickyHelpers$1.BROKEN_CARET;
2982
3303
  // nonparticipating capturing group, copied from es5-shim's String#split patch.
2983
3304
  var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
2984
3305
 
2985
- var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1 || UNSUPPORTED_DOT_ALL$1 || UNSUPPORTED_NCG$1;
3306
+ var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1 || UNSUPPORTED_DOT_ALL$2 || UNSUPPORTED_NCG$1;
2986
3307
 
2987
3308
  if (PATCH) {
2988
3309
  patchedExec = function exec(string) {
2989
3310
  var re = this;
2990
- var state = getInternalState$1(re);
2991
- var str = toString$5(string);
3311
+ var state = getInternalState$2(re);
3312
+ var str = toString$8(string);
2992
3313
  var raw = state.raw;
2993
3314
  var result, reCopy, lastIndex, match, i, object, group;
2994
3315
 
2995
3316
  if (raw) {
2996
3317
  raw.lastIndex = re.lastIndex;
2997
- result = call$7(patchedExec, raw, str);
3318
+ result = call$8(patchedExec, raw, str);
2998
3319
  re.lastIndex = raw.lastIndex;
2999
3320
  return result;
3000
3321
  }
3001
3322
 
3002
3323
  var groups = state.groups;
3003
3324
  var sticky = UNSUPPORTED_Y$1 && re.sticky;
3004
- var flags = call$7(regexpFlags, re);
3325
+ var flags = call$8(regexpFlags, re);
3005
3326
  var source = re.source;
3006
3327
  var charsAdded = 0;
3007
3328
  var strCopy = str;
@@ -3029,7 +3350,7 @@ if (PATCH) {
3029
3350
  }
3030
3351
  if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
3031
3352
 
3032
- match = call$7(nativeExec, sticky ? reCopy : re, strCopy);
3353
+ match = call$8(nativeExec, sticky ? reCopy : re, strCopy);
3033
3354
 
3034
3355
  if (sticky) {
3035
3356
  if (match) {
@@ -3044,7 +3365,7 @@ if (PATCH) {
3044
3365
  if (NPCG_INCLUDED && match && match.length > 1) {
3045
3366
  // Fix browsers whose `exec` methods don't consistently return `undefined`
3046
3367
  // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
3047
- call$7(nativeReplace, match[0], reCopy, function () {
3368
+ call$8(nativeReplace, match[0], reCopy, function () {
3048
3369
  for (i = 1; i < arguments.length - 2; i++) {
3049
3370
  if (arguments[i] === undefined) match[i] = undefined;
3050
3371
  }
@@ -3065,26 +3386,26 @@ if (PATCH) {
3065
3386
 
3066
3387
  var regexpExec$2 = patchedExec;
3067
3388
 
3068
- var $$5 = _export;
3389
+ var $$6 = _export;
3069
3390
  var exec$3 = regexpExec$2;
3070
3391
 
3071
3392
  // `RegExp.prototype.exec` method
3072
3393
  // https://tc39.es/ecma262/#sec-regexp.prototype.exec
3073
- $$5({ target: 'RegExp', proto: true, forced: /./.exec !== exec$3 }, {
3394
+ $$6({ target: 'RegExp', proto: true, forced: /./.exec !== exec$3 }, {
3074
3395
  exec: exec$3
3075
3396
  });
3076
3397
 
3077
3398
  // TODO: Remove from `core-js@4` since it's moved to entry points
3078
3399
 
3079
- var call$6 = functionCall;
3080
- var defineBuiltIn$5 = defineBuiltIn$b;
3400
+ var call$7 = functionCall;
3401
+ var defineBuiltIn$7 = defineBuiltIn$d;
3081
3402
  var regexpExec$1 = regexpExec$2;
3082
- var fails$4 = fails$l;
3403
+ var fails$4 = fails$n;
3083
3404
  var wellKnownSymbol$5 = wellKnownSymbol$k;
3084
- var createNonEnumerableProperty$1 = createNonEnumerableProperty$6;
3405
+ var createNonEnumerableProperty$1 = createNonEnumerableProperty$9;
3085
3406
 
3086
3407
  var SPECIES = wellKnownSymbol$5('species');
3087
- var RegExpPrototype$3 = RegExp.prototype;
3408
+ var RegExpPrototype$4 = RegExp.prototype;
3088
3409
 
3089
3410
  var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
3090
3411
  var SYMBOL = wellKnownSymbol$5(KEY);
@@ -3131,23 +3452,23 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
3131
3452
  var nativeRegExpMethod = /./[SYMBOL];
3132
3453
  var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
3133
3454
  var $exec = regexp.exec;
3134
- if ($exec === regexpExec$1 || $exec === RegExpPrototype$3.exec) {
3455
+ if ($exec === regexpExec$1 || $exec === RegExpPrototype$4.exec) {
3135
3456
  if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
3136
3457
  // The native String method already delegates to @@method (this
3137
3458
  // polyfilled function), leasing to infinite recursion.
3138
3459
  // We avoid it by directly calling the native @@method method.
3139
- return { done: true, value: call$6(nativeRegExpMethod, regexp, str, arg2) };
3460
+ return { done: true, value: call$7(nativeRegExpMethod, regexp, str, arg2) };
3140
3461
  }
3141
- return { done: true, value: call$6(nativeMethod, str, regexp, arg2) };
3462
+ return { done: true, value: call$7(nativeMethod, str, regexp, arg2) };
3142
3463
  }
3143
3464
  return { done: false };
3144
3465
  });
3145
3466
 
3146
- defineBuiltIn$5(String.prototype, KEY, methods[0]);
3147
- defineBuiltIn$5(RegExpPrototype$3, SYMBOL, methods[1]);
3467
+ defineBuiltIn$7(String.prototype, KEY, methods[0]);
3468
+ defineBuiltIn$7(RegExpPrototype$4, SYMBOL, methods[1]);
3148
3469
  }
3149
3470
 
3150
- if (SHAM) createNonEnumerableProperty$1(RegExpPrototype$3[SYMBOL], 'sham', true);
3471
+ if (SHAM) createNonEnumerableProperty$1(RegExpPrototype$4[SYMBOL], 'sham', true);
3151
3472
  };
3152
3473
 
3153
3474
  // `SameValue` abstract operation
@@ -3158,34 +3479,34 @@ var sameValue$1 = Object.is || function is(x, y) {
3158
3479
  return x === y ? x !== 0 || 1 / x === 1 / y : x !== x && y !== y;
3159
3480
  };
3160
3481
 
3161
- var call$5 = functionCall;
3162
- var anObject$4 = anObject$f;
3163
- var isCallable$2 = isCallable$m;
3164
- var classof$2 = classofRaw$2;
3482
+ var call$6 = functionCall;
3483
+ var anObject$5 = anObject$g;
3484
+ var isCallable$2 = isCallable$p;
3485
+ var classof$3 = classofRaw$2;
3165
3486
  var regexpExec = regexpExec$2;
3166
3487
 
3167
- var $TypeError$1 = TypeError;
3488
+ var $TypeError$2 = TypeError;
3168
3489
 
3169
3490
  // `RegExpExec` abstract operation
3170
3491
  // https://tc39.es/ecma262/#sec-regexpexec
3171
3492
  var regexpExecAbstract = function (R, S) {
3172
3493
  var exec = R.exec;
3173
3494
  if (isCallable$2(exec)) {
3174
- var result = call$5(exec, R, S);
3175
- if (result !== null) anObject$4(result);
3495
+ var result = call$6(exec, R, S);
3496
+ if (result !== null) anObject$5(result);
3176
3497
  return result;
3177
3498
  }
3178
- if (classof$2(R) === 'RegExp') return call$5(regexpExec, R, S);
3179
- throw new $TypeError$1('RegExp#exec called on incompatible receiver');
3499
+ if (classof$3(R) === 'RegExp') return call$6(regexpExec, R, S);
3500
+ throw new $TypeError$2('RegExp#exec called on incompatible receiver');
3180
3501
  };
3181
3502
 
3182
- var call$4 = functionCall;
3503
+ var call$5 = functionCall;
3183
3504
  var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
3184
- var anObject$3 = anObject$f;
3505
+ var anObject$4 = anObject$g;
3185
3506
  var isNullOrUndefined = isNullOrUndefined$5;
3186
3507
  var requireObjectCoercible$2 = requireObjectCoercible$6;
3187
3508
  var sameValue = sameValue$1;
3188
- var toString$4 = toString$6;
3509
+ var toString$7 = toString$b;
3189
3510
  var getMethod = getMethod$4;
3190
3511
  var regExpExec = regexpExecAbstract;
3191
3512
 
@@ -3197,13 +3518,13 @@ fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCal
3197
3518
  function search(regexp) {
3198
3519
  var O = requireObjectCoercible$2(this);
3199
3520
  var searcher = isNullOrUndefined(regexp) ? undefined : getMethod(regexp, SEARCH);
3200
- return searcher ? call$4(searcher, regexp, O) : new RegExp(regexp)[SEARCH](toString$4(O));
3521
+ return searcher ? call$5(searcher, regexp, O) : new RegExp(regexp)[SEARCH](toString$7(O));
3201
3522
  },
3202
3523
  // `RegExp.prototype[@@search]` method
3203
3524
  // https://tc39.es/ecma262/#sec-regexp.prototype-@@search
3204
3525
  function (string) {
3205
- var rx = anObject$3(this);
3206
- var S = toString$4(string);
3526
+ var rx = anObject$4(this);
3527
+ var S = toString$7(string);
3207
3528
  var res = maybeCallNative(nativeSearch, rx, S);
3208
3529
 
3209
3530
  if (res.done) return res.value;
@@ -3217,9 +3538,9 @@ fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCal
3217
3538
  ];
3218
3539
  });
3219
3540
 
3220
- var fails$3 = fails$l;
3541
+ var fails$3 = fails$n;
3221
3542
  var wellKnownSymbol$4 = wellKnownSymbol$k;
3222
- var DESCRIPTORS$4 = descriptors;
3543
+ var DESCRIPTORS$6 = descriptors;
3223
3544
  var IS_PURE = isPure;
3224
3545
 
3225
3546
  var ITERATOR$1 = wellKnownSymbol$4('iterator');
@@ -3240,7 +3561,7 @@ var urlConstructorDetection = !fails$3(function () {
3240
3561
  // https://bugs.chromium.org/p/v8/issues/detail?id=14222
3241
3562
  params2['delete']('b', undefined);
3242
3563
  return (IS_PURE && (!url.toJSON || !params2.has('a', 1) || params2.has('a', 2) || !params2.has('a', undefined) || params2.has('b')))
3243
- || (!params.size && (IS_PURE || !DESCRIPTORS$4))
3564
+ || (!params.size && (IS_PURE || !DESCRIPTORS$6))
3244
3565
  || !params.sort
3245
3566
  || url.href !== 'http://a/c%20d?a=1&c=3'
3246
3567
  || params.get('c') !== '3'
@@ -3259,14 +3580,14 @@ var urlConstructorDetection = !fails$3(function () {
3259
3580
  || new URL('http://x', undefined).host !== 'x';
3260
3581
  });
3261
3582
 
3262
- var defineBuiltIn$4 = defineBuiltIn$b;
3583
+ var defineBuiltIn$6 = defineBuiltIn$d;
3263
3584
 
3264
3585
  var defineBuiltIns$1 = function (target, src, options) {
3265
- for (var key in src) defineBuiltIn$4(target, key, src[key], options);
3586
+ for (var key in src) defineBuiltIn$6(target, key, src[key], options);
3266
3587
  return target;
3267
3588
  };
3268
3589
 
3269
- var arraySlice$1 = arraySlice$3;
3590
+ var arraySlice$1 = arraySlice$4;
3270
3591
 
3271
3592
  var floor$2 = Math.floor;
3272
3593
 
@@ -3310,33 +3631,33 @@ var arraySort$1 = sort;
3310
3631
 
3311
3632
  // TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
3312
3633
 
3313
- var $$4 = _export;
3314
- var global$3 = global$o;
3634
+ var $$5 = _export;
3635
+ var global$3 = global$p;
3315
3636
  var safeGetBuiltIn = safeGetBuiltIn$2;
3316
- var call$3 = functionCall;
3317
- var uncurryThis$5 = functionUncurryThis;
3318
- var DESCRIPTORS$3 = descriptors;
3637
+ var call$4 = functionCall;
3638
+ var uncurryThis$8 = functionUncurryThis;
3639
+ var DESCRIPTORS$5 = descriptors;
3319
3640
  var USE_NATIVE_URL$1 = urlConstructorDetection;
3320
- var defineBuiltIn$3 = defineBuiltIn$b;
3321
- var defineBuiltInAccessor$1 = defineBuiltInAccessor$3;
3641
+ var defineBuiltIn$5 = defineBuiltIn$d;
3642
+ var defineBuiltInAccessor$3 = defineBuiltInAccessor$5;
3322
3643
  var defineBuiltIns = defineBuiltIns$1;
3323
3644
  var setToStringTag$1 = setToStringTag$6;
3324
3645
  var createIteratorConstructor = iteratorCreateConstructor;
3325
3646
  var InternalStateModule$2 = internalState;
3326
3647
  var anInstance$1 = anInstance$3;
3327
- var isCallable$1 = isCallable$m;
3648
+ var isCallable$1 = isCallable$p;
3328
3649
  var hasOwn$3 = hasOwnProperty_1;
3329
3650
  var bind$2 = functionBindContext;
3330
- var classof$1 = classof$6;
3331
- var anObject$2 = anObject$f;
3332
- var isObject$2 = isObject$d;
3333
- var $toString$2 = toString$6;
3651
+ var classof$2 = classof$a;
3652
+ var anObject$3 = anObject$g;
3653
+ var isObject$1 = isObject$e;
3654
+ var $toString$2 = toString$b;
3334
3655
  var create$1 = objectCreate;
3335
- var createPropertyDescriptor$1 = createPropertyDescriptor$5;
3656
+ var createPropertyDescriptor$1 = createPropertyDescriptor$6;
3336
3657
  var getIterator$1 = getIterator$3;
3337
3658
  var getIteratorMethod$1 = getIteratorMethod$4;
3338
3659
  var createIterResultObject$1 = createIterResultObject$3;
3339
- var validateArgumentsLength$1 = validateArgumentsLength$3;
3660
+ var validateArgumentsLength$3 = validateArgumentsLength$5;
3340
3661
  var wellKnownSymbol$3 = wellKnownSymbol$k;
3341
3662
  var arraySort = arraySort$1;
3342
3663
 
@@ -3356,14 +3677,14 @@ var RegExp$1 = global$3.RegExp;
3356
3677
  var TypeError$2 = global$3.TypeError;
3357
3678
  var decodeURIComponent = global$3.decodeURIComponent;
3358
3679
  var encodeURIComponent$1 = global$3.encodeURIComponent;
3359
- var charAt$4 = uncurryThis$5(''.charAt);
3360
- var join$2 = uncurryThis$5([].join);
3361
- var push$2 = uncurryThis$5([].push);
3362
- var replace$3 = uncurryThis$5(''.replace);
3363
- var shift$1 = uncurryThis$5([].shift);
3364
- var splice = uncurryThis$5([].splice);
3365
- var split$2 = uncurryThis$5(''.split);
3366
- var stringSlice$3 = uncurryThis$5(''.slice);
3680
+ var charAt$4 = uncurryThis$8(''.charAt);
3681
+ var join$2 = uncurryThis$8([].join);
3682
+ var push$3 = uncurryThis$8([].push);
3683
+ var replace$3 = uncurryThis$8(''.replace);
3684
+ var shift$1 = uncurryThis$8([].shift);
3685
+ var splice = uncurryThis$8([].splice);
3686
+ var split$2 = uncurryThis$8(''.split);
3687
+ var stringSlice$3 = uncurryThis$8(''.slice);
3367
3688
 
3368
3689
  var plus = /\+/g;
3369
3690
  var sequences = Array(4);
@@ -3439,7 +3760,7 @@ var URLSearchParamsState = function (init) {
3439
3760
  this.url = null;
3440
3761
 
3441
3762
  if (init !== undefined) {
3442
- if (isObject$2(init)) this.parseObject(init);
3763
+ if (isObject$1(init)) this.parseObject(init);
3443
3764
  else this.parseQuery(typeof init == 'string' ? charAt$4(init, 0) === '?' ? stringSlice$3(init, 1) : init : $toString$2(init));
3444
3765
  }
3445
3766
  };
@@ -3458,18 +3779,18 @@ URLSearchParamsState.prototype = {
3458
3779
  if (iteratorMethod) {
3459
3780
  iterator = getIterator$1(object, iteratorMethod);
3460
3781
  next = iterator.next;
3461
- while (!(step = call$3(next, iterator)).done) {
3462
- entryIterator = getIterator$1(anObject$2(step.value));
3782
+ while (!(step = call$4(next, iterator)).done) {
3783
+ entryIterator = getIterator$1(anObject$3(step.value));
3463
3784
  entryNext = entryIterator.next;
3464
3785
  if (
3465
- (first = call$3(entryNext, entryIterator)).done ||
3466
- (second = call$3(entryNext, entryIterator)).done ||
3467
- !call$3(entryNext, entryIterator).done
3786
+ (first = call$4(entryNext, entryIterator)).done ||
3787
+ (second = call$4(entryNext, entryIterator)).done ||
3788
+ !call$4(entryNext, entryIterator).done
3468
3789
  ) throw new TypeError$2('Expected sequence with length 2');
3469
- push$2(entries, { key: $toString$2(first.value), value: $toString$2(second.value) });
3790
+ push$3(entries, { key: $toString$2(first.value), value: $toString$2(second.value) });
3470
3791
  }
3471
3792
  } else for (var key in object) if (hasOwn$3(object, key)) {
3472
- push$2(entries, { key: key, value: $toString$2(object[key]) });
3793
+ push$3(entries, { key: key, value: $toString$2(object[key]) });
3473
3794
  }
3474
3795
  },
3475
3796
  parseQuery: function (query) {
@@ -3482,7 +3803,7 @@ URLSearchParamsState.prototype = {
3482
3803
  attribute = attributes[index++];
3483
3804
  if (attribute.length) {
3484
3805
  entry = split$2(attribute, '=');
3485
- push$2(entries, {
3806
+ push$3(entries, {
3486
3807
  key: deserialize(shift$1(entry)),
3487
3808
  value: deserialize(join$2(entry, '='))
3488
3809
  });
@@ -3497,7 +3818,7 @@ URLSearchParamsState.prototype = {
3497
3818
  var entry;
3498
3819
  while (index < entries.length) {
3499
3820
  entry = entries[index++];
3500
- push$2(result, serialize(entry.key) + '=' + serialize(entry.value));
3821
+ push$3(result, serialize(entry.key) + '=' + serialize(entry.value));
3501
3822
  } return join$2(result, '&');
3502
3823
  },
3503
3824
  update: function () {
@@ -3512,29 +3833,29 @@ URLSearchParamsState.prototype = {
3512
3833
  // `URLSearchParams` constructor
3513
3834
  // https://url.spec.whatwg.org/#interface-urlsearchparams
3514
3835
  var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
3515
- anInstance$1(this, URLSearchParamsPrototype);
3836
+ anInstance$1(this, URLSearchParamsPrototype$3);
3516
3837
  var init = arguments.length > 0 ? arguments[0] : undefined;
3517
3838
  var state = setInternalState$2(this, new URLSearchParamsState(init));
3518
- if (!DESCRIPTORS$3) this.size = state.entries.length;
3839
+ if (!DESCRIPTORS$5) this.size = state.entries.length;
3519
3840
  };
3520
3841
 
3521
- var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
3842
+ var URLSearchParamsPrototype$3 = URLSearchParamsConstructor.prototype;
3522
3843
 
3523
- defineBuiltIns(URLSearchParamsPrototype, {
3844
+ defineBuiltIns(URLSearchParamsPrototype$3, {
3524
3845
  // `URLSearchParams.prototype.append` method
3525
3846
  // https://url.spec.whatwg.org/#dom-urlsearchparams-append
3526
3847
  append: function append(name, value) {
3527
3848
  var state = getInternalParamsState(this);
3528
- validateArgumentsLength$1(arguments.length, 2);
3529
- push$2(state.entries, { key: $toString$2(name), value: $toString$2(value) });
3530
- if (!DESCRIPTORS$3) this.length++;
3849
+ validateArgumentsLength$3(arguments.length, 2);
3850
+ push$3(state.entries, { key: $toString$2(name), value: $toString$2(value) });
3851
+ if (!DESCRIPTORS$5) this.length++;
3531
3852
  state.updateURL();
3532
3853
  },
3533
3854
  // `URLSearchParams.prototype.delete` method
3534
3855
  // https://url.spec.whatwg.org/#dom-urlsearchparams-delete
3535
3856
  'delete': function (name /* , value */) {
3536
3857
  var state = getInternalParamsState(this);
3537
- var length = validateArgumentsLength$1(arguments.length, 1);
3858
+ var length = validateArgumentsLength$3(arguments.length, 1);
3538
3859
  var entries = state.entries;
3539
3860
  var key = $toString$2(name);
3540
3861
  var $value = length < 2 ? undefined : arguments[1];
@@ -3547,14 +3868,14 @@ defineBuiltIns(URLSearchParamsPrototype, {
3547
3868
  if (value !== undefined) break;
3548
3869
  } else index++;
3549
3870
  }
3550
- if (!DESCRIPTORS$3) this.size = entries.length;
3871
+ if (!DESCRIPTORS$5) this.size = entries.length;
3551
3872
  state.updateURL();
3552
3873
  },
3553
3874
  // `URLSearchParams.prototype.get` method
3554
3875
  // https://url.spec.whatwg.org/#dom-urlsearchparams-get
3555
3876
  get: function get(name) {
3556
3877
  var entries = getInternalParamsState(this).entries;
3557
- validateArgumentsLength$1(arguments.length, 1);
3878
+ validateArgumentsLength$3(arguments.length, 1);
3558
3879
  var key = $toString$2(name);
3559
3880
  var index = 0;
3560
3881
  for (; index < entries.length; index++) {
@@ -3566,12 +3887,12 @@ defineBuiltIns(URLSearchParamsPrototype, {
3566
3887
  // https://url.spec.whatwg.org/#dom-urlsearchparams-getall
3567
3888
  getAll: function getAll(name) {
3568
3889
  var entries = getInternalParamsState(this).entries;
3569
- validateArgumentsLength$1(arguments.length, 1);
3890
+ validateArgumentsLength$3(arguments.length, 1);
3570
3891
  var key = $toString$2(name);
3571
3892
  var result = [];
3572
3893
  var index = 0;
3573
3894
  for (; index < entries.length; index++) {
3574
- if (entries[index].key === key) push$2(result, entries[index].value);
3895
+ if (entries[index].key === key) push$3(result, entries[index].value);
3575
3896
  }
3576
3897
  return result;
3577
3898
  },
@@ -3579,7 +3900,7 @@ defineBuiltIns(URLSearchParamsPrototype, {
3579
3900
  // https://url.spec.whatwg.org/#dom-urlsearchparams-has
3580
3901
  has: function has(name /* , value */) {
3581
3902
  var entries = getInternalParamsState(this).entries;
3582
- var length = validateArgumentsLength$1(arguments.length, 1);
3903
+ var length = validateArgumentsLength$3(arguments.length, 1);
3583
3904
  var key = $toString$2(name);
3584
3905
  var $value = length < 2 ? undefined : arguments[1];
3585
3906
  var value = $value === undefined ? $value : $toString$2($value);
@@ -3594,7 +3915,7 @@ defineBuiltIns(URLSearchParamsPrototype, {
3594
3915
  // https://url.spec.whatwg.org/#dom-urlsearchparams-set
3595
3916
  set: function set(name, value) {
3596
3917
  var state = getInternalParamsState(this);
3597
- validateArgumentsLength$1(arguments.length, 1);
3918
+ validateArgumentsLength$3(arguments.length, 1);
3598
3919
  var entries = state.entries;
3599
3920
  var found = false;
3600
3921
  var key = $toString$2(name);
@@ -3611,8 +3932,8 @@ defineBuiltIns(URLSearchParamsPrototype, {
3611
3932
  }
3612
3933
  }
3613
3934
  }
3614
- if (!found) push$2(entries, { key: key, value: val });
3615
- if (!DESCRIPTORS$3) this.size = entries.length;
3935
+ if (!found) push$3(entries, { key: key, value: val });
3936
+ if (!DESCRIPTORS$5) this.size = entries.length;
3616
3937
  state.updateURL();
3617
3938
  },
3618
3939
  // `URLSearchParams.prototype.sort` method
@@ -3650,17 +3971,17 @@ defineBuiltIns(URLSearchParamsPrototype, {
3650
3971
  }, { enumerable: true });
3651
3972
 
3652
3973
  // `URLSearchParams.prototype[@@iterator]` method
3653
- defineBuiltIn$3(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries, { name: 'entries' });
3974
+ defineBuiltIn$5(URLSearchParamsPrototype$3, ITERATOR, URLSearchParamsPrototype$3.entries, { name: 'entries' });
3654
3975
 
3655
3976
  // `URLSearchParams.prototype.toString` method
3656
3977
  // https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
3657
- defineBuiltIn$3(URLSearchParamsPrototype, 'toString', function toString() {
3978
+ defineBuiltIn$5(URLSearchParamsPrototype$3, 'toString', function toString() {
3658
3979
  return getInternalParamsState(this).serialize();
3659
3980
  }, { enumerable: true });
3660
3981
 
3661
3982
  // `URLSearchParams.prototype.size` getter
3662
3983
  // https://github.com/whatwg/url/pull/734
3663
- if (DESCRIPTORS$3) defineBuiltInAccessor$1(URLSearchParamsPrototype, 'size', {
3984
+ if (DESCRIPTORS$5) defineBuiltInAccessor$3(URLSearchParamsPrototype$3, 'size', {
3664
3985
  get: function size() {
3665
3986
  return getInternalParamsState(this).entries.length;
3666
3987
  },
@@ -3670,20 +3991,20 @@ if (DESCRIPTORS$3) defineBuiltInAccessor$1(URLSearchParamsPrototype, 'size', {
3670
3991
 
3671
3992
  setToStringTag$1(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
3672
3993
 
3673
- $$4({ global: true, constructor: true, forced: !USE_NATIVE_URL$1 }, {
3994
+ $$5({ global: true, constructor: true, forced: !USE_NATIVE_URL$1 }, {
3674
3995
  URLSearchParams: URLSearchParamsConstructor
3675
3996
  });
3676
3997
 
3677
3998
  // Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`
3678
3999
  if (!USE_NATIVE_URL$1 && isCallable$1(Headers)) {
3679
- var headersHas = uncurryThis$5(HeadersPrototype.has);
3680
- var headersSet = uncurryThis$5(HeadersPrototype.set);
4000
+ var headersHas = uncurryThis$8(HeadersPrototype.has);
4001
+ var headersSet = uncurryThis$8(HeadersPrototype.set);
3681
4002
 
3682
4003
  var wrapRequestOptions = function (init) {
3683
- if (isObject$2(init)) {
4004
+ if (isObject$1(init)) {
3684
4005
  var body = init.body;
3685
4006
  var headers;
3686
- if (classof$1(body) === URL_SEARCH_PARAMS) {
4007
+ if (classof$2(body) === URL_SEARCH_PARAMS) {
3687
4008
  headers = init.headers ? new Headers(init.headers) : new Headers();
3688
4009
  if (!headersHas(headers, 'content-type')) {
3689
4010
  headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
@@ -3697,7 +4018,7 @@ if (!USE_NATIVE_URL$1 && isCallable$1(Headers)) {
3697
4018
  };
3698
4019
 
3699
4020
  if (isCallable$1(nativeFetch)) {
3700
- $$4({ global: true, enumerable: true, dontCallGetSet: true, forced: true }, {
4021
+ $$5({ global: true, enumerable: true, dontCallGetSet: true, forced: true }, {
3701
4022
  fetch: function fetch(input /* , init */) {
3702
4023
  return nativeFetch(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
3703
4024
  }
@@ -3713,7 +4034,7 @@ if (!USE_NATIVE_URL$1 && isCallable$1(Headers)) {
3713
4034
  RequestPrototype.constructor = RequestConstructor;
3714
4035
  RequestConstructor.prototype = RequestPrototype;
3715
4036
 
3716
- $$4({ global: true, constructor: true, dontCallGetSet: true, forced: true }, {
4037
+ $$5({ global: true, constructor: true, dontCallGetSet: true, forced: true }, {
3717
4038
  Request: RequestConstructor
3718
4039
  });
3719
4040
  }
@@ -3724,6 +4045,104 @@ var web_urlSearchParams_constructor = {
3724
4045
  getState: getInternalParamsState
3725
4046
  };
3726
4047
 
4048
+ var defineBuiltIn$4 = defineBuiltIn$d;
4049
+ var uncurryThis$7 = functionUncurryThis;
4050
+ var toString$6 = toString$b;
4051
+ var validateArgumentsLength$2 = validateArgumentsLength$5;
4052
+
4053
+ var $URLSearchParams$1 = URLSearchParams;
4054
+ var URLSearchParamsPrototype$2 = $URLSearchParams$1.prototype;
4055
+ var append = uncurryThis$7(URLSearchParamsPrototype$2.append);
4056
+ var $delete = uncurryThis$7(URLSearchParamsPrototype$2['delete']);
4057
+ var forEach$1 = uncurryThis$7(URLSearchParamsPrototype$2.forEach);
4058
+ var push$2 = uncurryThis$7([].push);
4059
+ var params$1 = new $URLSearchParams$1('a=1&a=2&b=3');
4060
+
4061
+ params$1['delete']('a', 1);
4062
+ // `undefined` case is a Chromium 117 bug
4063
+ // https://bugs.chromium.org/p/v8/issues/detail?id=14222
4064
+ params$1['delete']('b', undefined);
4065
+
4066
+ if (params$1 + '' !== 'a=2') {
4067
+ defineBuiltIn$4(URLSearchParamsPrototype$2, 'delete', function (name /* , value */) {
4068
+ var length = arguments.length;
4069
+ var $value = length < 2 ? undefined : arguments[1];
4070
+ if (length && $value === undefined) return $delete(this, name);
4071
+ var entries = [];
4072
+ forEach$1(this, function (v, k) { // also validates `this`
4073
+ push$2(entries, { key: k, value: v });
4074
+ });
4075
+ validateArgumentsLength$2(length, 1);
4076
+ var key = toString$6(name);
4077
+ var value = toString$6($value);
4078
+ var index = 0;
4079
+ var dindex = 0;
4080
+ var found = false;
4081
+ var entriesLength = entries.length;
4082
+ var entry;
4083
+ while (index < entriesLength) {
4084
+ entry = entries[index++];
4085
+ if (found || entry.key === key) {
4086
+ found = true;
4087
+ $delete(this, entry.key);
4088
+ } else dindex++;
4089
+ }
4090
+ while (dindex < entriesLength) {
4091
+ entry = entries[dindex++];
4092
+ if (!(entry.key === key && entry.value === value)) append(this, entry.key, entry.value);
4093
+ }
4094
+ }, { enumerable: true, unsafe: true });
4095
+ }
4096
+
4097
+ var defineBuiltIn$3 = defineBuiltIn$d;
4098
+ var uncurryThis$6 = functionUncurryThis;
4099
+ var toString$5 = toString$b;
4100
+ var validateArgumentsLength$1 = validateArgumentsLength$5;
4101
+
4102
+ var $URLSearchParams = URLSearchParams;
4103
+ var URLSearchParamsPrototype$1 = $URLSearchParams.prototype;
4104
+ var getAll = uncurryThis$6(URLSearchParamsPrototype$1.getAll);
4105
+ var $has = uncurryThis$6(URLSearchParamsPrototype$1.has);
4106
+ var params = new $URLSearchParams('a=1');
4107
+
4108
+ // `undefined` case is a Chromium 117 bug
4109
+ // https://bugs.chromium.org/p/v8/issues/detail?id=14222
4110
+ if (params.has('a', 2) || !params.has('a', undefined)) {
4111
+ defineBuiltIn$3(URLSearchParamsPrototype$1, 'has', function has(name /* , value */) {
4112
+ var length = arguments.length;
4113
+ var $value = length < 2 ? undefined : arguments[1];
4114
+ if (length && $value === undefined) return $has(this, name);
4115
+ var values = getAll(this, name); // also validates `this`
4116
+ validateArgumentsLength$1(length, 1);
4117
+ var value = toString$5($value);
4118
+ var index = 0;
4119
+ while (index < values.length) {
4120
+ if (values[index++] === value) return true;
4121
+ } return false;
4122
+ }, { enumerable: true, unsafe: true });
4123
+ }
4124
+
4125
+ var DESCRIPTORS$4 = descriptors;
4126
+ var uncurryThis$5 = functionUncurryThis;
4127
+ var defineBuiltInAccessor$2 = defineBuiltInAccessor$5;
4128
+
4129
+ var URLSearchParamsPrototype = URLSearchParams.prototype;
4130
+ var forEach = uncurryThis$5(URLSearchParamsPrototype.forEach);
4131
+
4132
+ // `URLSearchParams.prototype.size` getter
4133
+ // https://github.com/whatwg/url/pull/734
4134
+ if (DESCRIPTORS$4 && !('size' in URLSearchParamsPrototype)) {
4135
+ defineBuiltInAccessor$2(URLSearchParamsPrototype, 'size', {
4136
+ get: function size() {
4137
+ var count = 0;
4138
+ forEach(this, function () { count++; });
4139
+ return count;
4140
+ },
4141
+ configurable: true,
4142
+ enumerable: true
4143
+ });
4144
+ }
4145
+
3727
4146
  /**
3728
4147
  * The key for identifying the Window key for SdkExperiment.
3729
4148
  *
@@ -3801,9 +4220,9 @@ var DEBUG_LEVELS;
3801
4220
  })(DEBUG_LEVELS || (DEBUG_LEVELS = {}));
3802
4221
  const PAGE_VIEW_EVENT_NAME = 'pageview';
3803
4222
 
3804
- var $$3 = _export;
4223
+ var $$4 = _export;
3805
4224
  var $includes = arrayIncludes.includes;
3806
- var fails$2 = fails$l;
4225
+ var fails$2 = fails$n;
3807
4226
  var addToUnscopables = addToUnscopables$2;
3808
4227
 
3809
4228
  // FF99+ bug
@@ -3814,7 +4233,7 @@ var BROKEN_ON_SPARSE = fails$2(function () {
3814
4233
 
3815
4234
  // `Array.prototype.includes` method
3816
4235
  // https://tc39.es/ecma262/#sec-array.prototype.includes
3817
- $$3({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
4236
+ $$4({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
3818
4237
  includes: function includes(el /* , fromIndex = 0 */) {
3819
4238
  return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
3820
4239
  }
@@ -3823,27 +4242,8 @@ $$3({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
3823
4242
  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
3824
4243
  addToUnscopables('includes');
3825
4244
 
3826
- var isCallable = isCallable$m;
3827
- var isObject$1 = isObject$d;
3828
- var setPrototypeOf = objectSetPrototypeOf;
3829
-
3830
- // makes subclassing work correct for wrapped built-ins
3831
- var inheritIfRequired$1 = function ($this, dummy, Wrapper) {
3832
- var NewTarget, NewTargetPrototype;
3833
- if (
3834
- // it can work only with native `setPrototypeOf`
3835
- setPrototypeOf &&
3836
- // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
3837
- isCallable(NewTarget = dummy.constructor) &&
3838
- NewTarget !== Wrapper &&
3839
- isObject$1(NewTargetPrototype = NewTarget.prototype) &&
3840
- NewTargetPrototype !== Wrapper.prototype
3841
- ) setPrototypeOf($this, NewTargetPrototype);
3842
- return $this;
3843
- };
3844
-
3845
- var isObject = isObject$d;
3846
- var classof = classofRaw$2;
4245
+ var isObject = isObject$e;
4246
+ var classof$1 = classofRaw$2;
3847
4247
  var wellKnownSymbol$2 = wellKnownSymbol$k;
3848
4248
 
3849
4249
  var MATCH$2 = wellKnownSymbol$2('match');
@@ -3852,60 +4252,50 @@ var MATCH$2 = wellKnownSymbol$2('match');
3852
4252
  // https://tc39.es/ecma262/#sec-isregexp
3853
4253
  var isRegexp = function (it) {
3854
4254
  var isRegExp;
3855
- return isObject(it) && ((isRegExp = it[MATCH$2]) !== undefined ? !!isRegExp : classof(it) === 'RegExp');
4255
+ return isObject(it) && ((isRegExp = it[MATCH$2]) !== undefined ? !!isRegExp : classof$1(it) === 'RegExp');
3856
4256
  };
3857
4257
 
3858
- var call$2 = functionCall;
4258
+ var call$3 = functionCall;
3859
4259
  var hasOwn$2 = hasOwnProperty_1;
3860
4260
  var isPrototypeOf$1 = objectIsPrototypeOf;
3861
4261
  var regExpFlags = regexpFlags$1;
3862
4262
 
3863
- var RegExpPrototype$2 = RegExp.prototype;
4263
+ var RegExpPrototype$3 = RegExp.prototype;
3864
4264
 
3865
4265
  var regexpGetFlags = function (R) {
3866
4266
  var flags = R.flags;
3867
- return flags === undefined && !('flags' in RegExpPrototype$2) && !hasOwn$2(R, 'flags') && isPrototypeOf$1(RegExpPrototype$2, R)
3868
- ? call$2(regExpFlags, R) : flags;
3869
- };
3870
-
3871
- var defineProperty = objectDefineProperty.f;
3872
-
3873
- var proxyAccessor$1 = function (Target, Source, key) {
3874
- key in Target || defineProperty(Target, key, {
3875
- configurable: true,
3876
- get: function () { return Source[key]; },
3877
- set: function (it) { Source[key] = it; }
3878
- });
4267
+ return flags === undefined && !('flags' in RegExpPrototype$3) && !hasOwn$2(R, 'flags') && isPrototypeOf$1(RegExpPrototype$3, R)
4268
+ ? call$3(regExpFlags, R) : flags;
3879
4269
  };
3880
4270
 
3881
- var DESCRIPTORS$2 = descriptors;
3882
- var global$2 = global$o;
4271
+ var DESCRIPTORS$3 = descriptors;
4272
+ var global$2 = global$p;
3883
4273
  var uncurryThis$4 = functionUncurryThis;
3884
4274
  var isForced = isForced_1;
3885
- var inheritIfRequired = inheritIfRequired$1;
3886
- var createNonEnumerableProperty = createNonEnumerableProperty$6;
4275
+ var inheritIfRequired = inheritIfRequired$2;
4276
+ var createNonEnumerableProperty = createNonEnumerableProperty$9;
3887
4277
  var create = objectCreate;
3888
4278
  var getOwnPropertyNames = objectGetOwnPropertyNames.f;
3889
4279
  var isPrototypeOf = objectIsPrototypeOf;
3890
4280
  var isRegExp$1 = isRegexp;
3891
- var toString$3 = toString$6;
4281
+ var toString$4 = toString$b;
3892
4282
  var getRegExpFlags$1 = regexpGetFlags;
3893
4283
  var stickyHelpers = regexpStickyHelpers;
3894
- var proxyAccessor = proxyAccessor$1;
3895
- var defineBuiltIn$2 = defineBuiltIn$b;
3896
- var fails$1 = fails$l;
4284
+ var proxyAccessor = proxyAccessor$2;
4285
+ var defineBuiltIn$2 = defineBuiltIn$d;
4286
+ var fails$1 = fails$n;
3897
4287
  var hasOwn$1 = hasOwnProperty_1;
3898
4288
  var enforceInternalState = internalState.enforce;
3899
4289
  var setSpecies = setSpecies$2;
3900
4290
  var wellKnownSymbol$1 = wellKnownSymbol$k;
3901
- var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
4291
+ var UNSUPPORTED_DOT_ALL$1 = regexpUnsupportedDotAll;
3902
4292
  var UNSUPPORTED_NCG = regexpUnsupportedNcg;
3903
4293
 
3904
4294
  var MATCH$1 = wellKnownSymbol$1('match');
3905
4295
  var NativeRegExp = global$2.RegExp;
3906
- var RegExpPrototype$1 = NativeRegExp.prototype;
4296
+ var RegExpPrototype$2 = NativeRegExp.prototype;
3907
4297
  var SyntaxError = global$2.SyntaxError;
3908
- var exec$2 = uncurryThis$4(RegExpPrototype$1.exec);
4298
+ var exec$2 = uncurryThis$4(RegExpPrototype$2.exec);
3909
4299
  var charAt$3 = uncurryThis$4(''.charAt);
3910
4300
  var replace$2 = uncurryThis$4(''.replace);
3911
4301
  var stringIndexOf$1 = uncurryThis$4(''.indexOf);
@@ -3921,8 +4311,8 @@ var CORRECT_NEW = new NativeRegExp(re1) !== re1;
3921
4311
  var MISSED_STICKY = stickyHelpers.MISSED_STICKY;
3922
4312
  var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
3923
4313
 
3924
- var BASE_FORCED = DESCRIPTORS$2 &&
3925
- (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG || fails$1(function () {
4314
+ var BASE_FORCED = DESCRIPTORS$3 &&
4315
+ (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL$1 || UNSUPPORTED_NCG || fails$1(function () {
3926
4316
  re2[MATCH$1] = false;
3927
4317
  // RegExp constructor can alter flags and IsRegExp works correct with @@match
3928
4318
  return NativeRegExp(re1) !== re1 || NativeRegExp(re2) === re2 || String(NativeRegExp(re1, 'i')) !== '/a/i';
@@ -4000,7 +4390,7 @@ var handleNCG = function (string) {
4000
4390
  // https://tc39.es/ecma262/#sec-regexp-constructor
4001
4391
  if (isForced('RegExp', BASE_FORCED)) {
4002
4392
  var RegExpWrapper = function RegExp(pattern, flags) {
4003
- var thisIsRegExp = isPrototypeOf(RegExpPrototype$1, this);
4393
+ var thisIsRegExp = isPrototypeOf(RegExpPrototype$2, this);
4004
4394
  var patternIsRegExp = isRegExp$1(pattern);
4005
4395
  var flagsAreUndefined = flags === undefined;
4006
4396
  var groups = [];
@@ -4011,16 +4401,16 @@ if (isForced('RegExp', BASE_FORCED)) {
4011
4401
  return pattern;
4012
4402
  }
4013
4403
 
4014
- if (patternIsRegExp || isPrototypeOf(RegExpPrototype$1, pattern)) {
4404
+ if (patternIsRegExp || isPrototypeOf(RegExpPrototype$2, pattern)) {
4015
4405
  pattern = pattern.source;
4016
4406
  if (flagsAreUndefined) flags = getRegExpFlags$1(rawPattern);
4017
4407
  }
4018
4408
 
4019
- pattern = pattern === undefined ? '' : toString$3(pattern);
4020
- flags = flags === undefined ? '' : toString$3(flags);
4409
+ pattern = pattern === undefined ? '' : toString$4(pattern);
4410
+ flags = flags === undefined ? '' : toString$4(flags);
4021
4411
  rawPattern = pattern;
4022
4412
 
4023
- if (UNSUPPORTED_DOT_ALL && 'dotAll' in re1) {
4413
+ if (UNSUPPORTED_DOT_ALL$1 && 'dotAll' in re1) {
4024
4414
  dotAll = !!flags && stringIndexOf$1(flags, 's') > -1;
4025
4415
  if (dotAll) flags = replace$2(flags, /s/g, '');
4026
4416
  }
@@ -4038,7 +4428,7 @@ if (isForced('RegExp', BASE_FORCED)) {
4038
4428
  groups = handled[1];
4039
4429
  }
4040
4430
 
4041
- result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype$1, RegExpWrapper);
4431
+ result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype$2, RegExpWrapper);
4042
4432
 
4043
4433
  if (dotAll || sticky || groups.length) {
4044
4434
  state = enforceInternalState(result);
@@ -4062,19 +4452,80 @@ if (isForced('RegExp', BASE_FORCED)) {
4062
4452
  proxyAccessor(RegExpWrapper, NativeRegExp, keys[index++]);
4063
4453
  }
4064
4454
 
4065
- RegExpPrototype$1.constructor = RegExpWrapper;
4066
- RegExpWrapper.prototype = RegExpPrototype$1;
4455
+ RegExpPrototype$2.constructor = RegExpWrapper;
4456
+ RegExpWrapper.prototype = RegExpPrototype$2;
4067
4457
  defineBuiltIn$2(global$2, 'RegExp', RegExpWrapper, { constructor: true });
4068
4458
  }
4069
4459
 
4070
4460
  // https://tc39.es/ecma262/#sec-get-regexp-@@species
4071
4461
  setSpecies('RegExp');
4072
4462
 
4463
+ var DESCRIPTORS$2 = descriptors;
4464
+ var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
4465
+ var classof = classofRaw$2;
4466
+ var defineBuiltInAccessor$1 = defineBuiltInAccessor$5;
4467
+ var getInternalState$1 = internalState.get;
4468
+
4469
+ var RegExpPrototype$1 = RegExp.prototype;
4470
+ var $TypeError$1 = TypeError;
4471
+
4472
+ // `RegExp.prototype.dotAll` getter
4473
+ // https://tc39.es/ecma262/#sec-get-regexp.prototype.dotall
4474
+ if (DESCRIPTORS$2 && UNSUPPORTED_DOT_ALL) {
4475
+ defineBuiltInAccessor$1(RegExpPrototype$1, 'dotAll', {
4476
+ configurable: true,
4477
+ get: function dotAll() {
4478
+ if (this === RegExpPrototype$1) return;
4479
+ // We can't use InternalStateModule.getterFor because
4480
+ // we don't add metadata for regexps created by a literal.
4481
+ if (classof(this) === 'RegExp') {
4482
+ return !!getInternalState$1(this).dotAll;
4483
+ }
4484
+ throw new $TypeError$1('Incompatible receiver, RegExp required');
4485
+ }
4486
+ });
4487
+ }
4488
+
4489
+ // TODO: Remove from `core-js@4` since it's moved to entry points
4490
+
4491
+ var $$3 = _export;
4492
+ var call$2 = functionCall;
4493
+ var isCallable = isCallable$p;
4494
+ var anObject$2 = anObject$g;
4495
+ var toString$3 = toString$b;
4496
+
4497
+ var DELEGATES_TO_EXEC = function () {
4498
+ var execCalled = false;
4499
+ var re = /[ac]/;
4500
+ re.exec = function () {
4501
+ execCalled = true;
4502
+ return /./.exec.apply(this, arguments);
4503
+ };
4504
+ return re.test('abc') === true && execCalled;
4505
+ }();
4506
+
4507
+ var nativeTest = /./.test;
4508
+
4509
+ // `RegExp.prototype.test` method
4510
+ // https://tc39.es/ecma262/#sec-regexp.prototype.test
4511
+ $$3({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, {
4512
+ test: function (S) {
4513
+ var R = anObject$2(this);
4514
+ var string = toString$3(S);
4515
+ var exec = R.exec;
4516
+ if (!isCallable(exec)) return call$2(nativeTest, R, string);
4517
+ var result = call$2(exec, R, string);
4518
+ if (result === null) return false;
4519
+ anObject$2(result);
4520
+ return true;
4521
+ }
4522
+ });
4523
+
4073
4524
  var PROPER_FUNCTION_NAME = functionName.PROPER;
4074
- var defineBuiltIn$1 = defineBuiltIn$b;
4075
- var anObject$1 = anObject$f;
4076
- var $toString$1 = toString$6;
4077
- var fails = fails$l;
4525
+ var defineBuiltIn$1 = defineBuiltIn$d;
4526
+ var anObject$1 = anObject$g;
4527
+ var $toString$1 = toString$b;
4528
+ var fails = fails$n;
4078
4529
  var getRegExpFlags = regexpGetFlags;
4079
4530
 
4080
4531
  var TO_STRING = 'toString';
@@ -4126,7 +4577,7 @@ var $$2 = _export;
4126
4577
  var uncurryThis$3 = functionUncurryThis;
4127
4578
  var notARegExp = notARegexp;
4128
4579
  var requireObjectCoercible$1 = requireObjectCoercible$6;
4129
- var toString$2 = toString$6;
4580
+ var toString$2 = toString$b;
4130
4581
  var correctIsRegExpLogic = correctIsRegexpLogic;
4131
4582
 
4132
4583
  var stringIndexOf = uncurryThis$3(''.indexOf);
@@ -4145,7 +4596,7 @@ $$2({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }
4145
4596
 
4146
4597
  var uncurryThis$2 = functionUncurryThis;
4147
4598
  var toIntegerOrInfinity = toIntegerOrInfinity$3;
4148
- var toString$1 = toString$6;
4599
+ var toString$1 = toString$b;
4149
4600
  var requireObjectCoercible = requireObjectCoercible$6;
4150
4601
 
4151
4602
  var charAt$2 = uncurryThis$2(''.charAt);
@@ -4181,7 +4632,7 @@ var stringMultibyte = {
4181
4632
  };
4182
4633
 
4183
4634
  var charAt$1 = stringMultibyte.charAt;
4184
- var toString = toString$6;
4635
+ var toString = toString$b;
4185
4636
  var InternalStateModule$1 = internalState;
4186
4637
  var defineIterator = iteratorDefine;
4187
4638
  var createIterResultObject = createIterResultObject$3;
@@ -4211,7 +4662,7 @@ defineIterator(String, 'String', function (iterated) {
4211
4662
  return createIterResultObject(point, false);
4212
4663
  });
4213
4664
 
4214
- var anObject = anObject$f;
4665
+ var anObject = anObject$g;
4215
4666
  var iteratorClose = iteratorClose$2;
4216
4667
 
4217
4668
  // call something on iterator step with safe closing on error
@@ -4225,7 +4676,7 @@ var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) {
4225
4676
 
4226
4677
  var DESCRIPTORS$1 = descriptors;
4227
4678
  var definePropertyModule = objectDefineProperty;
4228
- var createPropertyDescriptor = createPropertyDescriptor$5;
4679
+ var createPropertyDescriptor = createPropertyDescriptor$6;
4229
4680
 
4230
4681
  var createProperty$1 = function (object, key, value) {
4231
4682
  if (DESCRIPTORS$1) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
@@ -4464,21 +4915,21 @@ var stringPunycodeToAscii = function (input) {
4464
4915
  var $$1 = _export;
4465
4916
  var DESCRIPTORS = descriptors;
4466
4917
  var USE_NATIVE_URL = urlConstructorDetection;
4467
- var global$1 = global$o;
4918
+ var global$1 = global$p;
4468
4919
  var bind = functionBindContext;
4469
4920
  var uncurryThis = functionUncurryThis;
4470
- var defineBuiltIn = defineBuiltIn$b;
4471
- var defineBuiltInAccessor = defineBuiltInAccessor$3;
4921
+ var defineBuiltIn = defineBuiltIn$d;
4922
+ var defineBuiltInAccessor = defineBuiltInAccessor$5;
4472
4923
  var anInstance = anInstance$3;
4473
4924
  var hasOwn = hasOwnProperty_1;
4474
4925
  var assign = objectAssign;
4475
4926
  var arrayFrom = arrayFrom$1;
4476
- var arraySlice = arraySlice$3;
4927
+ var arraySlice = arraySlice$4;
4477
4928
  var codeAt = stringMultibyte.codeAt;
4478
4929
  var toASCII = stringPunycodeToAscii;
4479
- var $toString = toString$6;
4930
+ var $toString = toString$b;
4480
4931
  var setToStringTag = setToStringTag$6;
4481
- var validateArgumentsLength = validateArgumentsLength$3;
4932
+ var validateArgumentsLength = validateArgumentsLength$5;
4482
4933
  var URLSearchParamsModule = web_urlSearchParams_constructor;
4483
4934
  var InternalStateModule = internalState;
4484
4935