@ninetailed/experience.js 2.0.0-beta.22 → 2.0.0-beta.25

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 (8) hide show
  1. package/index.esm.js +889 -530
  2. package/index.umd.js +864 -497
  3. package/lib/Ninetailed.d.ts +11 -0
  4. package/lib/experience/decodeExperienceVariantsMap.d.ts +1 -0
  5. package/lib/experience/index.d.ts +2 -0
  6. package/lib/experience/isExperienceMatch.d.ts +1 -1
  7. package/lib/experience/selectDistribution.d.ts +8 -0
  8. package/package.json +2 -2
package/index.esm.js CHANGED
@@ -16,7 +16,7 @@ var check = function (it) {
16
16
  };
17
17
 
18
18
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
19
- var global$H =
19
+ var global$K =
20
20
  // eslint-disable-next-line es/no-global-this -- safe
21
21
  check(typeof globalThis == 'object' && globalThis) ||
22
22
  check(typeof window == 'object' && window) ||
@@ -28,7 +28,7 @@ var global$H =
28
28
 
29
29
  var objectGetOwnPropertyDescriptor = {};
30
30
 
31
- var fails$h = function (exec) {
31
+ var fails$k = function (exec) {
32
32
  try {
33
33
  return !!exec();
34
34
  } catch (error) {
@@ -36,17 +36,17 @@ var fails$h = function (exec) {
36
36
  }
37
37
  };
38
38
 
39
- var fails$g = fails$h;
39
+ var fails$j = fails$k;
40
40
 
41
41
  // Detect IE8's incomplete defineProperty implementation
42
- var descriptors = !fails$g(function () {
42
+ var descriptors = !fails$j(function () {
43
43
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
44
44
  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
45
45
  });
46
46
 
47
- var fails$f = fails$h;
47
+ var fails$i = fails$k;
48
48
 
49
- var functionBindNative = !fails$f(function () {
49
+ var functionBindNative = !fails$i(function () {
50
50
  var test = (function () { /* empty */ }).bind();
51
51
  // eslint-disable-next-line no-prototype-builtins -- safe
52
52
  return typeof test != 'function' || test.hasOwnProperty('prototype');
@@ -54,10 +54,10 @@ var functionBindNative = !fails$f(function () {
54
54
 
55
55
  var NATIVE_BIND$3 = functionBindNative;
56
56
 
57
- var call$e = Function.prototype.call;
57
+ var call$f = Function.prototype.call;
58
58
 
59
- var functionCall = NATIVE_BIND$3 ? call$e.bind(call$e) : function () {
60
- return call$e.apply(call$e, arguments);
59
+ var functionCall = NATIVE_BIND$3 ? call$f.bind(call$f) : function () {
60
+ return call$f.apply(call$f, arguments);
61
61
  };
62
62
 
63
63
  var objectPropertyIsEnumerable = {};
@@ -76,7 +76,7 @@ objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
76
76
  return !!descriptor && descriptor.enumerable;
77
77
  } : $propertyIsEnumerable;
78
78
 
79
- var createPropertyDescriptor$3 = function (bitmap, value) {
79
+ var createPropertyDescriptor$4 = function (bitmap, value) {
80
80
  return {
81
81
  enumerable: !(bitmap & 1),
82
82
  configurable: !(bitmap & 2),
@@ -89,36 +89,36 @@ var NATIVE_BIND$2 = functionBindNative;
89
89
 
90
90
  var FunctionPrototype$2 = Function.prototype;
91
91
  var bind$5 = FunctionPrototype$2.bind;
92
- var call$d = FunctionPrototype$2.call;
93
- var uncurryThis$k = NATIVE_BIND$2 && bind$5.bind(call$d, call$d);
92
+ var call$e = FunctionPrototype$2.call;
93
+ var uncurryThis$n = NATIVE_BIND$2 && bind$5.bind(call$e, call$e);
94
94
 
95
95
  var functionUncurryThis = NATIVE_BIND$2 ? function (fn) {
96
- return fn && uncurryThis$k(fn);
96
+ return fn && uncurryThis$n(fn);
97
97
  } : function (fn) {
98
98
  return fn && function () {
99
- return call$d.apply(fn, arguments);
99
+ return call$e.apply(fn, arguments);
100
100
  };
101
101
  };
102
102
 
103
- var uncurryThis$j = functionUncurryThis;
103
+ var uncurryThis$m = functionUncurryThis;
104
104
 
105
- var toString$6 = uncurryThis$j({}.toString);
106
- var stringSlice$5 = uncurryThis$j(''.slice);
105
+ var toString$9 = uncurryThis$m({}.toString);
106
+ var stringSlice$6 = uncurryThis$m(''.slice);
107
107
 
108
108
  var classofRaw$1 = function (it) {
109
- return stringSlice$5(toString$6(it), 8, -1);
109
+ return stringSlice$6(toString$9(it), 8, -1);
110
110
  };
111
111
 
112
- var global$G = global$H;
113
- var uncurryThis$i = functionUncurryThis;
114
- var fails$e = fails$h;
112
+ var global$J = global$K;
113
+ var uncurryThis$l = functionUncurryThis;
114
+ var fails$h = fails$k;
115
115
  var classof$7 = classofRaw$1;
116
116
 
117
- var Object$5 = global$G.Object;
118
- var split = uncurryThis$i(''.split);
117
+ var Object$5 = global$J.Object;
118
+ var split = uncurryThis$l(''.split);
119
119
 
120
120
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
121
- var indexedObject = fails$e(function () {
121
+ var indexedObject = fails$h(function () {
122
122
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
123
123
  // eslint-disable-next-line no-prototype-builtins -- safe
124
124
  return !Object$5('z').propertyIsEnumerable(0);
@@ -126,23 +126,23 @@ var indexedObject = fails$e(function () {
126
126
  return classof$7(it) == 'String' ? split(it, '') : Object$5(it);
127
127
  } : Object$5;
128
128
 
129
- var global$F = global$H;
129
+ var global$I = global$K;
130
130
 
131
- var TypeError$g = global$F.TypeError;
131
+ var TypeError$h = global$I.TypeError;
132
132
 
133
133
  // `RequireObjectCoercible` abstract operation
134
134
  // https://tc39.es/ecma262/#sec-requireobjectcoercible
135
- var requireObjectCoercible$5 = function (it) {
136
- if (it == undefined) throw TypeError$g("Can't call method on " + it);
135
+ var requireObjectCoercible$7 = function (it) {
136
+ if (it == undefined) throw TypeError$h("Can't call method on " + it);
137
137
  return it;
138
138
  };
139
139
 
140
140
  // toObject with fallback for non-array-like ES3 strings
141
- var IndexedObject$1 = indexedObject;
142
- var requireObjectCoercible$4 = requireObjectCoercible$5;
141
+ var IndexedObject$2 = indexedObject;
142
+ var requireObjectCoercible$6 = requireObjectCoercible$7;
143
143
 
144
144
  var toIndexedObject$5 = function (it) {
145
- return IndexedObject$1(requireObjectCoercible$4(it));
145
+ return IndexedObject$2(requireObjectCoercible$6(it));
146
146
  };
147
147
 
148
148
  // `IsCallable` abstract operation
@@ -157,7 +157,7 @@ var isObject$8 = function (it) {
157
157
  return typeof it == 'object' ? it !== null : isCallable$i(it);
158
158
  };
159
159
 
160
- var global$E = global$H;
160
+ var global$H = global$K;
161
161
  var isCallable$h = isCallable$j;
162
162
 
163
163
  var aFunction = function (argument) {
@@ -165,22 +165,22 @@ var aFunction = function (argument) {
165
165
  };
166
166
 
167
167
  var getBuiltIn$7 = function (namespace, method) {
168
- return arguments.length < 2 ? aFunction(global$E[namespace]) : global$E[namespace] && global$E[namespace][method];
168
+ return arguments.length < 2 ? aFunction(global$H[namespace]) : global$H[namespace] && global$H[namespace][method];
169
169
  };
170
170
 
171
- var uncurryThis$h = functionUncurryThis;
171
+ var uncurryThis$k = functionUncurryThis;
172
172
 
173
- var objectIsPrototypeOf = uncurryThis$h({}.isPrototypeOf);
173
+ var objectIsPrototypeOf = uncurryThis$k({}.isPrototypeOf);
174
174
 
175
175
  var getBuiltIn$6 = getBuiltIn$7;
176
176
 
177
177
  var engineUserAgent = getBuiltIn$6('navigator', 'userAgent') || '';
178
178
 
179
- var global$D = global$H;
179
+ var global$G = global$K;
180
180
  var userAgent$3 = engineUserAgent;
181
181
 
182
- var process$3 = global$D.process;
183
- var Deno = global$D.Deno;
182
+ var process$3 = global$G.process;
183
+ var Deno = global$G.Deno;
184
184
  var versions = process$3 && process$3.versions || Deno && Deno.version;
185
185
  var v8 = versions && versions.v8;
186
186
  var match, version;
@@ -207,10 +207,10 @@ var engineV8Version = version;
207
207
  /* eslint-disable es/no-symbol -- required for testing */
208
208
 
209
209
  var V8_VERSION$1 = engineV8Version;
210
- var fails$d = fails$h;
210
+ var fails$g = fails$k;
211
211
 
212
212
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
213
- var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$d(function () {
213
+ var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$g(function () {
214
214
  var symbol = Symbol();
215
215
  // Chrome 38 Symbol has incorrect toString conversion
216
216
  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
@@ -227,13 +227,13 @@ var useSymbolAsUid = NATIVE_SYMBOL$1
227
227
  && !Symbol.sham
228
228
  && typeof Symbol.iterator == 'symbol';
229
229
 
230
- var global$C = global$H;
230
+ var global$F = global$K;
231
231
  var getBuiltIn$5 = getBuiltIn$7;
232
232
  var isCallable$g = isCallable$j;
233
233
  var isPrototypeOf$2 = objectIsPrototypeOf;
234
234
  var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
235
235
 
236
- var Object$4 = global$C.Object;
236
+ var Object$4 = global$F.Object;
237
237
 
238
238
  var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
239
239
  return typeof it == 'symbol';
@@ -242,9 +242,9 @@ var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
242
242
  return isCallable$g($Symbol) && isPrototypeOf$2($Symbol.prototype, Object$4(it));
243
243
  };
244
244
 
245
- var global$B = global$H;
245
+ var global$E = global$K;
246
246
 
247
- var String$5 = global$B.String;
247
+ var String$5 = global$E.String;
248
248
 
249
249
  var tryToString$4 = function (argument) {
250
250
  try {
@@ -254,64 +254,64 @@ var tryToString$4 = function (argument) {
254
254
  }
255
255
  };
256
256
 
257
- var global$A = global$H;
257
+ var global$D = global$K;
258
258
  var isCallable$f = isCallable$j;
259
259
  var tryToString$3 = tryToString$4;
260
260
 
261
- var TypeError$f = global$A.TypeError;
261
+ var TypeError$g = global$D.TypeError;
262
262
 
263
263
  // `Assert: IsCallable(argument) is true`
264
- var aCallable$5 = function (argument) {
264
+ var aCallable$6 = function (argument) {
265
265
  if (isCallable$f(argument)) return argument;
266
- throw TypeError$f(tryToString$3(argument) + ' is not a function');
266
+ throw TypeError$g(tryToString$3(argument) + ' is not a function');
267
267
  };
268
268
 
269
- var aCallable$4 = aCallable$5;
269
+ var aCallable$5 = aCallable$6;
270
270
 
271
271
  // `GetMethod` abstract operation
272
272
  // https://tc39.es/ecma262/#sec-getmethod
273
- var getMethod$4 = function (V, P) {
273
+ var getMethod$5 = function (V, P) {
274
274
  var func = V[P];
275
- return func == null ? undefined : aCallable$4(func);
275
+ return func == null ? undefined : aCallable$5(func);
276
276
  };
277
277
 
278
- var global$z = global$H;
279
- var call$c = functionCall;
278
+ var global$C = global$K;
279
+ var call$d = functionCall;
280
280
  var isCallable$e = isCallable$j;
281
281
  var isObject$7 = isObject$8;
282
282
 
283
- var TypeError$e = global$z.TypeError;
283
+ var TypeError$f = global$C.TypeError;
284
284
 
285
285
  // `OrdinaryToPrimitive` abstract operation
286
286
  // https://tc39.es/ecma262/#sec-ordinarytoprimitive
287
287
  var ordinaryToPrimitive$1 = function (input, pref) {
288
288
  var fn, val;
289
- if (pref === 'string' && isCallable$e(fn = input.toString) && !isObject$7(val = call$c(fn, input))) return val;
290
- if (isCallable$e(fn = input.valueOf) && !isObject$7(val = call$c(fn, input))) return val;
291
- if (pref !== 'string' && isCallable$e(fn = input.toString) && !isObject$7(val = call$c(fn, input))) return val;
292
- throw TypeError$e("Can't convert object to primitive value");
289
+ if (pref === 'string' && isCallable$e(fn = input.toString) && !isObject$7(val = call$d(fn, input))) return val;
290
+ if (isCallable$e(fn = input.valueOf) && !isObject$7(val = call$d(fn, input))) return val;
291
+ if (pref !== 'string' && isCallable$e(fn = input.toString) && !isObject$7(val = call$d(fn, input))) return val;
292
+ throw TypeError$f("Can't convert object to primitive value");
293
293
  };
294
294
 
295
295
  var shared$4 = {exports: {}};
296
296
 
297
- var global$y = global$H;
297
+ var global$B = global$K;
298
298
 
299
299
  // eslint-disable-next-line es/no-object-defineproperty -- safe
300
300
  var defineProperty$3 = Object.defineProperty;
301
301
 
302
302
  var setGlobal$3 = function (key, value) {
303
303
  try {
304
- defineProperty$3(global$y, key, { value: value, configurable: true, writable: true });
304
+ defineProperty$3(global$B, key, { value: value, configurable: true, writable: true });
305
305
  } catch (error) {
306
- global$y[key] = value;
306
+ global$B[key] = value;
307
307
  } return value;
308
308
  };
309
309
 
310
- var global$x = global$H;
310
+ var global$A = global$K;
311
311
  var setGlobal$2 = setGlobal$3;
312
312
 
313
313
  var SHARED = '__core-js_shared__';
314
- var store$3 = global$x[SHARED] || setGlobal$2(SHARED, {});
314
+ var store$3 = global$A[SHARED] || setGlobal$2(SHARED, {});
315
315
 
316
316
  var sharedStore = store$3;
317
317
 
@@ -327,39 +327,39 @@ var store$2 = sharedStore;
327
327
  source: 'https://github.com/zloirock/core-js'
328
328
  });
329
329
 
330
- var global$w = global$H;
331
- var requireObjectCoercible$3 = requireObjectCoercible$5;
330
+ var global$z = global$K;
331
+ var requireObjectCoercible$5 = requireObjectCoercible$7;
332
332
 
333
- var Object$3 = global$w.Object;
333
+ var Object$3 = global$z.Object;
334
334
 
335
335
  // `ToObject` abstract operation
336
336
  // https://tc39.es/ecma262/#sec-toobject
337
- var toObject$4 = function (argument) {
338
- return Object$3(requireObjectCoercible$3(argument));
337
+ var toObject$5 = function (argument) {
338
+ return Object$3(requireObjectCoercible$5(argument));
339
339
  };
340
340
 
341
- var uncurryThis$g = functionUncurryThis;
342
- var toObject$3 = toObject$4;
341
+ var uncurryThis$j = functionUncurryThis;
342
+ var toObject$4 = toObject$5;
343
343
 
344
- var hasOwnProperty = uncurryThis$g({}.hasOwnProperty);
344
+ var hasOwnProperty = uncurryThis$j({}.hasOwnProperty);
345
345
 
346
346
  // `HasOwnProperty` abstract operation
347
347
  // https://tc39.es/ecma262/#sec-hasownproperty
348
348
  var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
349
- return hasOwnProperty(toObject$3(it), key);
349
+ return hasOwnProperty(toObject$4(it), key);
350
350
  };
351
351
 
352
- var uncurryThis$f = functionUncurryThis;
352
+ var uncurryThis$i = functionUncurryThis;
353
353
 
354
354
  var id = 0;
355
355
  var postfix = Math.random();
356
- var toString$5 = uncurryThis$f(1.0.toString);
356
+ var toString$8 = uncurryThis$i(1.0.toString);
357
357
 
358
358
  var uid$2 = function (key) {
359
- return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$5(++id + postfix, 36);
359
+ return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$8(++id + postfix, 36);
360
360
  };
361
361
 
362
- var global$v = global$H;
362
+ var global$y = global$K;
363
363
  var shared$3 = shared$4.exports;
364
364
  var hasOwn$9 = hasOwnProperty_1;
365
365
  var uid$1 = uid$2;
@@ -367,15 +367,15 @@ var NATIVE_SYMBOL = nativeSymbol;
367
367
  var USE_SYMBOL_AS_UID = useSymbolAsUid;
368
368
 
369
369
  var WellKnownSymbolsStore = shared$3('wks');
370
- var Symbol$1 = global$v.Symbol;
371
- var symbolFor = Symbol$1 && Symbol$1['for'];
372
- var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
370
+ var Symbol$2 = global$y.Symbol;
371
+ var symbolFor = Symbol$2 && Symbol$2['for'];
372
+ var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$2 : Symbol$2 && Symbol$2.withoutSetter || uid$1;
373
373
 
374
374
  var wellKnownSymbol$i = function (name) {
375
375
  if (!hasOwn$9(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
376
376
  var description = 'Symbol.' + name;
377
- if (NATIVE_SYMBOL && hasOwn$9(Symbol$1, name)) {
378
- WellKnownSymbolsStore[name] = Symbol$1[name];
377
+ if (NATIVE_SYMBOL && hasOwn$9(Symbol$2, name)) {
378
+ WellKnownSymbolsStore[name] = Symbol$2[name];
379
379
  } else if (USE_SYMBOL_AS_UID && symbolFor) {
380
380
  WellKnownSymbolsStore[name] = symbolFor(description);
381
381
  } else {
@@ -384,28 +384,28 @@ var wellKnownSymbol$i = function (name) {
384
384
  } return WellKnownSymbolsStore[name];
385
385
  };
386
386
 
387
- var global$u = global$H;
388
- var call$b = functionCall;
387
+ var global$x = global$K;
388
+ var call$c = functionCall;
389
389
  var isObject$6 = isObject$8;
390
390
  var isSymbol$1 = isSymbol$2;
391
- var getMethod$3 = getMethod$4;
391
+ var getMethod$4 = getMethod$5;
392
392
  var ordinaryToPrimitive = ordinaryToPrimitive$1;
393
393
  var wellKnownSymbol$h = wellKnownSymbol$i;
394
394
 
395
- var TypeError$d = global$u.TypeError;
395
+ var TypeError$e = global$x.TypeError;
396
396
  var TO_PRIMITIVE = wellKnownSymbol$h('toPrimitive');
397
397
 
398
398
  // `ToPrimitive` abstract operation
399
399
  // https://tc39.es/ecma262/#sec-toprimitive
400
400
  var toPrimitive$1 = function (input, pref) {
401
401
  if (!isObject$6(input) || isSymbol$1(input)) return input;
402
- var exoticToPrim = getMethod$3(input, TO_PRIMITIVE);
402
+ var exoticToPrim = getMethod$4(input, TO_PRIMITIVE);
403
403
  var result;
404
404
  if (exoticToPrim) {
405
405
  if (pref === undefined) pref = 'default';
406
- result = call$b(exoticToPrim, input, pref);
406
+ result = call$c(exoticToPrim, input, pref);
407
407
  if (!isObject$6(result) || isSymbol$1(result)) return result;
408
- throw TypeError$d("Can't convert object to primitive value");
408
+ throw TypeError$e("Can't convert object to primitive value");
409
409
  }
410
410
  if (pref === undefined) pref = 'number';
411
411
  return ordinaryToPrimitive(input, pref);
@@ -416,15 +416,15 @@ var isSymbol = isSymbol$2;
416
416
 
417
417
  // `ToPropertyKey` abstract operation
418
418
  // https://tc39.es/ecma262/#sec-topropertykey
419
- var toPropertyKey$2 = function (argument) {
419
+ var toPropertyKey$3 = function (argument) {
420
420
  var key = toPrimitive(argument, 'string');
421
421
  return isSymbol(key) ? key : key + '';
422
422
  };
423
423
 
424
- var global$t = global$H;
424
+ var global$w = global$K;
425
425
  var isObject$5 = isObject$8;
426
426
 
427
- var document$3 = global$t.document;
427
+ var document$3 = global$w.document;
428
428
  // typeof document.createElement is 'object' in old IE
429
429
  var EXISTS$1 = isObject$5(document$3) && isObject$5(document$3.createElement);
430
430
 
@@ -433,11 +433,11 @@ var documentCreateElement$2 = function (it) {
433
433
  };
434
434
 
435
435
  var DESCRIPTORS$9 = descriptors;
436
- var fails$c = fails$h;
436
+ var fails$f = fails$k;
437
437
  var createElement$1 = documentCreateElement$2;
438
438
 
439
439
  // Thanks to IE8 for its funny defineProperty
440
- var ie8DomDefine = !DESCRIPTORS$9 && !fails$c(function () {
440
+ var ie8DomDefine = !DESCRIPTORS$9 && !fails$f(function () {
441
441
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
442
442
  return Object.defineProperty(createElement$1('div'), 'a', {
443
443
  get: function () { return 7; }
@@ -445,11 +445,11 @@ var ie8DomDefine = !DESCRIPTORS$9 && !fails$c(function () {
445
445
  });
446
446
 
447
447
  var DESCRIPTORS$8 = descriptors;
448
- var call$a = functionCall;
448
+ var call$b = functionCall;
449
449
  var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
450
- var createPropertyDescriptor$2 = createPropertyDescriptor$3;
450
+ var createPropertyDescriptor$3 = createPropertyDescriptor$4;
451
451
  var toIndexedObject$4 = toIndexedObject$5;
452
- var toPropertyKey$1 = toPropertyKey$2;
452
+ var toPropertyKey$2 = toPropertyKey$3;
453
453
  var hasOwn$8 = hasOwnProperty_1;
454
454
  var IE8_DOM_DEFINE$1 = ie8DomDefine;
455
455
 
@@ -460,21 +460,21 @@ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
460
460
  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
461
461
  objectGetOwnPropertyDescriptor.f = DESCRIPTORS$8 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
462
462
  O = toIndexedObject$4(O);
463
- P = toPropertyKey$1(P);
463
+ P = toPropertyKey$2(P);
464
464
  if (IE8_DOM_DEFINE$1) try {
465
465
  return $getOwnPropertyDescriptor$1(O, P);
466
466
  } catch (error) { /* empty */ }
467
- if (hasOwn$8(O, P)) return createPropertyDescriptor$2(!call$a(propertyIsEnumerableModule$1.f, O, P), O[P]);
467
+ if (hasOwn$8(O, P)) return createPropertyDescriptor$3(!call$b(propertyIsEnumerableModule$1.f, O, P), O[P]);
468
468
  };
469
469
 
470
470
  var objectDefineProperty = {};
471
471
 
472
472
  var DESCRIPTORS$7 = descriptors;
473
- var fails$b = fails$h;
473
+ var fails$e = fails$k;
474
474
 
475
475
  // V8 ~ Chrome 36-
476
476
  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
477
- var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$b(function () {
477
+ var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$e(function () {
478
478
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
479
479
  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
480
480
  value: 42,
@@ -482,26 +482,26 @@ var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$b(function () {
482
482
  }).prototype != 42;
483
483
  });
484
484
 
485
- var global$s = global$H;
485
+ var global$v = global$K;
486
486
  var isObject$4 = isObject$8;
487
487
 
488
- var String$4 = global$s.String;
489
- var TypeError$c = global$s.TypeError;
488
+ var String$4 = global$v.String;
489
+ var TypeError$d = global$v.TypeError;
490
490
 
491
491
  // `Assert: Type(argument) is Object`
492
- var anObject$d = function (argument) {
492
+ var anObject$e = function (argument) {
493
493
  if (isObject$4(argument)) return argument;
494
- throw TypeError$c(String$4(argument) + ' is not an object');
494
+ throw TypeError$d(String$4(argument) + ' is not an object');
495
495
  };
496
496
 
497
- var global$r = global$H;
497
+ var global$u = global$K;
498
498
  var DESCRIPTORS$6 = descriptors;
499
499
  var IE8_DOM_DEFINE = ie8DomDefine;
500
500
  var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
501
- var anObject$c = anObject$d;
502
- var toPropertyKey = toPropertyKey$2;
501
+ var anObject$d = anObject$e;
502
+ var toPropertyKey$1 = toPropertyKey$3;
503
503
 
504
- var TypeError$b = global$r.TypeError;
504
+ var TypeError$c = global$u.TypeError;
505
505
  // eslint-disable-next-line es/no-object-defineproperty -- safe
506
506
  var $defineProperty = Object.defineProperty;
507
507
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -513,9 +513,9 @@ var WRITABLE = 'writable';
513
513
  // `Object.defineProperty` method
514
514
  // https://tc39.es/ecma262/#sec-object.defineproperty
515
515
  objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
516
- anObject$c(O);
517
- P = toPropertyKey(P);
518
- anObject$c(Attributes);
516
+ anObject$d(O);
517
+ P = toPropertyKey$1(P);
518
+ anObject$d(Attributes);
519
519
  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
520
520
  var current = $getOwnPropertyDescriptor(O, P);
521
521
  if (current && current[WRITABLE]) {
@@ -528,23 +528,23 @@ objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
528
528
  }
529
529
  } return $defineProperty(O, P, Attributes);
530
530
  } : $defineProperty : function defineProperty(O, P, Attributes) {
531
- anObject$c(O);
532
- P = toPropertyKey(P);
533
- anObject$c(Attributes);
531
+ anObject$d(O);
532
+ P = toPropertyKey$1(P);
533
+ anObject$d(Attributes);
534
534
  if (IE8_DOM_DEFINE) try {
535
535
  return $defineProperty(O, P, Attributes);
536
536
  } catch (error) { /* empty */ }
537
- if ('get' in Attributes || 'set' in Attributes) throw TypeError$b('Accessors not supported');
537
+ if ('get' in Attributes || 'set' in Attributes) throw TypeError$c('Accessors not supported');
538
538
  if ('value' in Attributes) O[P] = Attributes.value;
539
539
  return O;
540
540
  };
541
541
 
542
542
  var DESCRIPTORS$5 = descriptors;
543
- var definePropertyModule$4 = objectDefineProperty;
544
- var createPropertyDescriptor$1 = createPropertyDescriptor$3;
543
+ var definePropertyModule$5 = objectDefineProperty;
544
+ var createPropertyDescriptor$2 = createPropertyDescriptor$4;
545
545
 
546
546
  var createNonEnumerableProperty$6 = DESCRIPTORS$5 ? function (object, key, value) {
547
- return definePropertyModule$4.f(object, key, createPropertyDescriptor$1(1, value));
547
+ return definePropertyModule$5.f(object, key, createPropertyDescriptor$2(1, value));
548
548
  } : function (object, key, value) {
549
549
  object[key] = value;
550
550
  return object;
@@ -552,11 +552,11 @@ var createNonEnumerableProperty$6 = DESCRIPTORS$5 ? function (object, key, value
552
552
 
553
553
  var redefine$6 = {exports: {}};
554
554
 
555
- var uncurryThis$e = functionUncurryThis;
555
+ var uncurryThis$h = functionUncurryThis;
556
556
  var isCallable$d = isCallable$j;
557
557
  var store$1 = sharedStore;
558
558
 
559
- var functionToString = uncurryThis$e(Function.toString);
559
+ var functionToString = uncurryThis$h(Function.toString);
560
560
 
561
561
  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
562
562
  if (!isCallable$d(store$1.inspectSource)) {
@@ -567,11 +567,11 @@ if (!isCallable$d(store$1.inspectSource)) {
567
567
 
568
568
  var inspectSource$4 = store$1.inspectSource;
569
569
 
570
- var global$q = global$H;
570
+ var global$t = global$K;
571
571
  var isCallable$c = isCallable$j;
572
572
  var inspectSource$3 = inspectSource$4;
573
573
 
574
- var WeakMap$1 = global$q.WeakMap;
574
+ var WeakMap$1 = global$t.WeakMap;
575
575
 
576
576
  var nativeWeakMap = isCallable$c(WeakMap$1) && /native code/.test(inspectSource$3(WeakMap$1));
577
577
 
@@ -587,8 +587,8 @@ var sharedKey$3 = function (key) {
587
587
  var hiddenKeys$4 = {};
588
588
 
589
589
  var NATIVE_WEAK_MAP = nativeWeakMap;
590
- var global$p = global$H;
591
- var uncurryThis$d = functionUncurryThis;
590
+ var global$s = global$K;
591
+ var uncurryThis$g = functionUncurryThis;
592
592
  var isObject$3 = isObject$8;
593
593
  var createNonEnumerableProperty$5 = createNonEnumerableProperty$6;
594
594
  var hasOwn$7 = hasOwnProperty_1;
@@ -597,8 +597,8 @@ var sharedKey$2 = sharedKey$3;
597
597
  var hiddenKeys$3 = hiddenKeys$4;
598
598
 
599
599
  var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
600
- var TypeError$a = global$p.TypeError;
601
- var WeakMap = global$p.WeakMap;
600
+ var TypeError$b = global$s.TypeError;
601
+ var WeakMap = global$s.WeakMap;
602
602
  var set$2, get$1, has;
603
603
 
604
604
  var enforce = function (it) {
@@ -609,18 +609,18 @@ var getterFor = function (TYPE) {
609
609
  return function (it) {
610
610
  var state;
611
611
  if (!isObject$3(it) || (state = get$1(it)).type !== TYPE) {
612
- throw TypeError$a('Incompatible receiver, ' + TYPE + ' required');
612
+ throw TypeError$b('Incompatible receiver, ' + TYPE + ' required');
613
613
  } return state;
614
614
  };
615
615
  };
616
616
 
617
617
  if (NATIVE_WEAK_MAP || shared$1.state) {
618
618
  var store = shared$1.state || (shared$1.state = new WeakMap());
619
- var wmget = uncurryThis$d(store.get);
620
- var wmhas = uncurryThis$d(store.has);
621
- var wmset = uncurryThis$d(store.set);
619
+ var wmget = uncurryThis$g(store.get);
620
+ var wmhas = uncurryThis$g(store.has);
621
+ var wmset = uncurryThis$g(store.set);
622
622
  set$2 = function (it, metadata) {
623
- if (wmhas(store, it)) throw new TypeError$a(OBJECT_ALREADY_INITIALIZED);
623
+ if (wmhas(store, it)) throw new TypeError$b(OBJECT_ALREADY_INITIALIZED);
624
624
  metadata.facade = it;
625
625
  wmset(store, it, metadata);
626
626
  return metadata;
@@ -635,7 +635,7 @@ if (NATIVE_WEAK_MAP || shared$1.state) {
635
635
  var STATE = sharedKey$2('state');
636
636
  hiddenKeys$3[STATE] = true;
637
637
  set$2 = function (it, metadata) {
638
- if (hasOwn$7(it, STATE)) throw new TypeError$a(OBJECT_ALREADY_INITIALIZED);
638
+ if (hasOwn$7(it, STATE)) throw new TypeError$b(OBJECT_ALREADY_INITIALIZED);
639
639
  metadata.facade = it;
640
640
  createNonEnumerableProperty$5(it, STATE, metadata);
641
641
  return metadata;
@@ -674,7 +674,7 @@ var functionName = {
674
674
  CONFIGURABLE: CONFIGURABLE
675
675
  };
676
676
 
677
- var global$o = global$H;
677
+ var global$r = global$K;
678
678
  var isCallable$b = isCallable$j;
679
679
  var hasOwn$5 = hasOwnProperty_1;
680
680
  var createNonEnumerableProperty$4 = createNonEnumerableProperty$6;
@@ -705,7 +705,7 @@ var TEMPLATE = String(String).split('String');
705
705
  state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
706
706
  }
707
707
  }
708
- if (O === global$o) {
708
+ if (O === global$r) {
709
709
  if (simple) O[key] = value;
710
710
  else setGlobal$1(key, value);
711
711
  return;
@@ -736,45 +736,45 @@ var toIntegerOrInfinity$4 = function (argument) {
736
736
 
737
737
  var toIntegerOrInfinity$3 = toIntegerOrInfinity$4;
738
738
 
739
- var max$1 = Math.max;
740
- var min$3 = Math.min;
739
+ var max$2 = Math.max;
740
+ var min$4 = Math.min;
741
741
 
742
742
  // Helper for a popular repeating case of the spec:
743
743
  // Let integer be ? ToInteger(index).
744
744
  // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
745
- var toAbsoluteIndex$1 = function (index, length) {
745
+ var toAbsoluteIndex$2 = function (index, length) {
746
746
  var integer = toIntegerOrInfinity$3(index);
747
- return integer < 0 ? max$1(integer + length, 0) : min$3(integer, length);
747
+ return integer < 0 ? max$2(integer + length, 0) : min$4(integer, length);
748
748
  };
749
749
 
750
750
  var toIntegerOrInfinity$2 = toIntegerOrInfinity$4;
751
751
 
752
- var min$2 = Math.min;
752
+ var min$3 = Math.min;
753
753
 
754
754
  // `ToLength` abstract operation
755
755
  // https://tc39.es/ecma262/#sec-tolength
756
- var toLength$3 = function (argument) {
757
- return argument > 0 ? min$2(toIntegerOrInfinity$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
756
+ var toLength$4 = function (argument) {
757
+ return argument > 0 ? min$3(toIntegerOrInfinity$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
758
758
  };
759
759
 
760
- var toLength$2 = toLength$3;
760
+ var toLength$3 = toLength$4;
761
761
 
762
762
  // `LengthOfArrayLike` abstract operation
763
763
  // https://tc39.es/ecma262/#sec-lengthofarraylike
764
- var lengthOfArrayLike$2 = function (obj) {
765
- return toLength$2(obj.length);
764
+ var lengthOfArrayLike$4 = function (obj) {
765
+ return toLength$3(obj.length);
766
766
  };
767
767
 
768
768
  var toIndexedObject$3 = toIndexedObject$5;
769
- var toAbsoluteIndex = toAbsoluteIndex$1;
770
- var lengthOfArrayLike$1 = lengthOfArrayLike$2;
769
+ var toAbsoluteIndex$1 = toAbsoluteIndex$2;
770
+ var lengthOfArrayLike$3 = lengthOfArrayLike$4;
771
771
 
772
772
  // `Array.prototype.{ indexOf, includes }` methods implementation
773
- var createMethod$1 = function (IS_INCLUDES) {
773
+ var createMethod$3 = function (IS_INCLUDES) {
774
774
  return function ($this, el, fromIndex) {
775
775
  var O = toIndexedObject$3($this);
776
- var length = lengthOfArrayLike$1(O);
777
- var index = toAbsoluteIndex(fromIndex, length);
776
+ var length = lengthOfArrayLike$3(O);
777
+ var index = toAbsoluteIndex$1(fromIndex, length);
778
778
  var value;
779
779
  // Array#includes uses SameValueZero equality algorithm
780
780
  // eslint-disable-next-line no-self-compare -- NaN check
@@ -792,29 +792,29 @@ var createMethod$1 = function (IS_INCLUDES) {
792
792
  var arrayIncludes = {
793
793
  // `Array.prototype.includes` method
794
794
  // https://tc39.es/ecma262/#sec-array.prototype.includes
795
- includes: createMethod$1(true),
795
+ includes: createMethod$3(true),
796
796
  // `Array.prototype.indexOf` method
797
797
  // https://tc39.es/ecma262/#sec-array.prototype.indexof
798
- indexOf: createMethod$1(false)
798
+ indexOf: createMethod$3(false)
799
799
  };
800
800
 
801
- var uncurryThis$c = functionUncurryThis;
801
+ var uncurryThis$f = functionUncurryThis;
802
802
  var hasOwn$4 = hasOwnProperty_1;
803
803
  var toIndexedObject$2 = toIndexedObject$5;
804
804
  var indexOf$1 = arrayIncludes.indexOf;
805
805
  var hiddenKeys$2 = hiddenKeys$4;
806
806
 
807
- var push$1 = uncurryThis$c([].push);
807
+ var push$2 = uncurryThis$f([].push);
808
808
 
809
809
  var objectKeysInternal = function (object, names) {
810
810
  var O = toIndexedObject$2(object);
811
811
  var i = 0;
812
812
  var result = [];
813
813
  var key;
814
- for (key in O) !hasOwn$4(hiddenKeys$2, key) && hasOwn$4(O, key) && push$1(result, key);
814
+ for (key in O) !hasOwn$4(hiddenKeys$2, key) && hasOwn$4(O, key) && push$2(result, key);
815
815
  // Don't enum bug & hidden keys
816
816
  while (names.length > i) if (hasOwn$4(O, key = names[i++])) {
817
- ~indexOf$1(result, key) || push$1(result, key);
817
+ ~indexOf$1(result, key) || push$2(result, key);
818
818
  }
819
819
  return result;
820
820
  };
@@ -848,16 +848,16 @@ var objectGetOwnPropertySymbols = {};
848
848
  objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
849
849
 
850
850
  var getBuiltIn$4 = getBuiltIn$7;
851
- var uncurryThis$b = functionUncurryThis;
851
+ var uncurryThis$e = functionUncurryThis;
852
852
  var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
853
853
  var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
854
- var anObject$b = anObject$d;
854
+ var anObject$c = anObject$e;
855
855
 
856
- var concat$2 = uncurryThis$b([].concat);
856
+ var concat$2 = uncurryThis$e([].concat);
857
857
 
858
858
  // all object keys, includes non-enumerable and symbols
859
859
  var ownKeys$1 = getBuiltIn$4('Reflect', 'ownKeys') || function ownKeys(it) {
860
- var keys = getOwnPropertyNamesModule.f(anObject$b(it));
860
+ var keys = getOwnPropertyNamesModule.f(anObject$c(it));
861
861
  var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
862
862
  return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys;
863
863
  };
@@ -865,11 +865,11 @@ var ownKeys$1 = getBuiltIn$4('Reflect', 'ownKeys') || function ownKeys(it) {
865
865
  var hasOwn$3 = hasOwnProperty_1;
866
866
  var ownKeys = ownKeys$1;
867
867
  var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
868
- var definePropertyModule$3 = objectDefineProperty;
868
+ var definePropertyModule$4 = objectDefineProperty;
869
869
 
870
870
  var copyConstructorProperties$1 = function (target, source, exceptions) {
871
871
  var keys = ownKeys(source);
872
- var defineProperty = definePropertyModule$3.f;
872
+ var defineProperty = definePropertyModule$4.f;
873
873
  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
874
874
  for (var i = 0; i < keys.length; i++) {
875
875
  var key = keys[i];
@@ -879,7 +879,7 @@ var copyConstructorProperties$1 = function (target, source, exceptions) {
879
879
  }
880
880
  };
881
881
 
882
- var fails$a = fails$h;
882
+ var fails$d = fails$k;
883
883
  var isCallable$a = isCallable$j;
884
884
 
885
885
  var replacement = /#|\.prototype\./;
@@ -888,7 +888,7 @@ var isForced$2 = function (feature, detection) {
888
888
  var value = data[normalize$1(feature)];
889
889
  return value == POLYFILL ? true
890
890
  : value == NATIVE ? false
891
- : isCallable$a(detection) ? fails$a(detection)
891
+ : isCallable$a(detection) ? fails$d(detection)
892
892
  : !!detection;
893
893
  };
894
894
 
@@ -902,7 +902,7 @@ var POLYFILL = isForced$2.POLYFILL = 'P';
902
902
 
903
903
  var isForced_1 = isForced$2;
904
904
 
905
- var global$n = global$H;
905
+ var global$q = global$K;
906
906
  var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f;
907
907
  var createNonEnumerableProperty$3 = createNonEnumerableProperty$6;
908
908
  var redefine$5 = redefine$6.exports;
@@ -931,11 +931,11 @@ var _export = function (options, source) {
931
931
  var STATIC = options.stat;
932
932
  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
933
933
  if (GLOBAL) {
934
- target = global$n;
934
+ target = global$q;
935
935
  } else if (STATIC) {
936
- target = global$n[TARGET] || setGlobal(TARGET, {});
936
+ target = global$q[TARGET] || setGlobal(TARGET, {});
937
937
  } else {
938
- target = (global$n[TARGET] || {}).prototype;
938
+ target = (global$q[TARGET] || {}).prototype;
939
939
  }
940
940
  if (target) for (key in source) {
941
941
  sourceProperty = source[key];
@@ -958,9 +958,9 @@ var _export = function (options, source) {
958
958
  }
959
959
  };
960
960
 
961
- var global$m = global$H;
961
+ var global$p = global$K;
962
962
 
963
- var nativePromiseConstructor = global$m.Promise;
963
+ var nativePromiseConstructor = global$p.Promise;
964
964
 
965
965
  var redefine$4 = redefine$6.exports;
966
966
 
@@ -969,21 +969,21 @@ var redefineAll$1 = function (target, src, options) {
969
969
  return target;
970
970
  };
971
971
 
972
- var global$l = global$H;
972
+ var global$o = global$K;
973
973
  var isCallable$9 = isCallable$j;
974
974
 
975
- var String$3 = global$l.String;
976
- var TypeError$9 = global$l.TypeError;
975
+ var String$3 = global$o.String;
976
+ var TypeError$a = global$o.TypeError;
977
977
 
978
978
  var aPossiblePrototype$1 = function (argument) {
979
979
  if (typeof argument == 'object' || isCallable$9(argument)) return argument;
980
- throw TypeError$9("Can't set " + String$3(argument) + ' as a prototype');
980
+ throw TypeError$a("Can't set " + String$3(argument) + ' as a prototype');
981
981
  };
982
982
 
983
983
  /* eslint-disable no-proto -- safe */
984
984
 
985
- var uncurryThis$a = functionUncurryThis;
986
- var anObject$a = anObject$d;
985
+ var uncurryThis$d = functionUncurryThis;
986
+ var anObject$b = anObject$e;
987
987
  var aPossiblePrototype = aPossiblePrototype$1;
988
988
 
989
989
  // `Object.setPrototypeOf` method
@@ -996,12 +996,12 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
996
996
  var setter;
997
997
  try {
998
998
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
999
- setter = uncurryThis$a(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
999
+ setter = uncurryThis$d(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
1000
1000
  setter(test, []);
1001
1001
  CORRECT_SETTER = test instanceof Array;
1002
1002
  } catch (error) { /* empty */ }
1003
1003
  return function setPrototypeOf(O, proto) {
1004
- anObject$a(O);
1004
+ anObject$b(O);
1005
1005
  aPossiblePrototype(proto);
1006
1006
  if (CORRECT_SETTER) setter(O, proto);
1007
1007
  else O.__proto__ = proto;
@@ -1023,7 +1023,7 @@ var setToStringTag$3 = function (target, TAG, STATIC) {
1023
1023
  };
1024
1024
 
1025
1025
  var getBuiltIn$3 = getBuiltIn$7;
1026
- var definePropertyModule$2 = objectDefineProperty;
1026
+ var definePropertyModule$3 = objectDefineProperty;
1027
1027
  var wellKnownSymbol$f = wellKnownSymbol$i;
1028
1028
  var DESCRIPTORS$3 = descriptors;
1029
1029
 
@@ -1031,7 +1031,7 @@ var SPECIES$3 = wellKnownSymbol$f('species');
1031
1031
 
1032
1032
  var setSpecies$1 = function (CONSTRUCTOR_NAME) {
1033
1033
  var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
1034
- var defineProperty = definePropertyModule$2.f;
1034
+ var defineProperty = definePropertyModule$3.f;
1035
1035
 
1036
1036
  if (DESCRIPTORS$3 && Constructor && !Constructor[SPECIES$3]) {
1037
1037
  defineProperty(Constructor, SPECIES$3, {
@@ -1041,25 +1041,25 @@ var setSpecies$1 = function (CONSTRUCTOR_NAME) {
1041
1041
  }
1042
1042
  };
1043
1043
 
1044
- var global$k = global$H;
1044
+ var global$n = global$K;
1045
1045
  var isPrototypeOf$1 = objectIsPrototypeOf;
1046
1046
 
1047
- var TypeError$8 = global$k.TypeError;
1047
+ var TypeError$9 = global$n.TypeError;
1048
1048
 
1049
1049
  var anInstance$1 = function (it, Prototype) {
1050
1050
  if (isPrototypeOf$1(Prototype, it)) return it;
1051
- throw TypeError$8('Incorrect invocation');
1051
+ throw TypeError$9('Incorrect invocation');
1052
1052
  };
1053
1053
 
1054
- var uncurryThis$9 = functionUncurryThis;
1055
- var aCallable$3 = aCallable$5;
1054
+ var uncurryThis$c = functionUncurryThis;
1055
+ var aCallable$4 = aCallable$6;
1056
1056
  var NATIVE_BIND$1 = functionBindNative;
1057
1057
 
1058
- var bind$4 = uncurryThis$9(uncurryThis$9.bind);
1058
+ var bind$4 = uncurryThis$c(uncurryThis$c.bind);
1059
1059
 
1060
1060
  // optional / simple context binding
1061
1061
  var functionBindContext = function (fn, that) {
1062
- aCallable$3(fn);
1062
+ aCallable$4(fn);
1063
1063
  return that === undefined ? fn : NATIVE_BIND$1 ? bind$4(fn, that) : function (/* ...args */) {
1064
1064
  return fn.apply(that, arguments);
1065
1065
  };
@@ -1070,12 +1070,12 @@ var iterators = {};
1070
1070
  var wellKnownSymbol$e = wellKnownSymbol$i;
1071
1071
  var Iterators$4 = iterators;
1072
1072
 
1073
- var ITERATOR$5 = wellKnownSymbol$e('iterator');
1073
+ var ITERATOR$6 = wellKnownSymbol$e('iterator');
1074
1074
  var ArrayPrototype$1 = Array.prototype;
1075
1075
 
1076
1076
  // check on default Array iterator
1077
1077
  var isArrayIteratorMethod$1 = function (it) {
1078
- return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it);
1078
+ return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$6] === it);
1079
1079
  };
1080
1080
 
1081
1081
  var wellKnownSymbol$d = wellKnownSymbol$i;
@@ -1087,14 +1087,14 @@ test[TO_STRING_TAG$2] = 'z';
1087
1087
 
1088
1088
  var toStringTagSupport = String(test) === '[object z]';
1089
1089
 
1090
- var global$j = global$H;
1090
+ var global$m = global$K;
1091
1091
  var TO_STRING_TAG_SUPPORT = toStringTagSupport;
1092
1092
  var isCallable$8 = isCallable$j;
1093
1093
  var classofRaw = classofRaw$1;
1094
1094
  var wellKnownSymbol$c = wellKnownSymbol$i;
1095
1095
 
1096
1096
  var TO_STRING_TAG$1 = wellKnownSymbol$c('toStringTag');
1097
- var Object$2 = global$j.Object;
1097
+ var Object$2 = global$m.Object;
1098
1098
 
1099
1099
  // ES3 wrong here
1100
1100
  var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
@@ -1119,70 +1119,70 @@ var classof$6 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
1119
1119
  };
1120
1120
 
1121
1121
  var classof$5 = classof$6;
1122
- var getMethod$2 = getMethod$4;
1122
+ var getMethod$3 = getMethod$5;
1123
1123
  var Iterators$3 = iterators;
1124
1124
  var wellKnownSymbol$b = wellKnownSymbol$i;
1125
1125
 
1126
- var ITERATOR$4 = wellKnownSymbol$b('iterator');
1126
+ var ITERATOR$5 = wellKnownSymbol$b('iterator');
1127
1127
 
1128
1128
  var getIteratorMethod$2 = function (it) {
1129
- if (it != undefined) return getMethod$2(it, ITERATOR$4)
1130
- || getMethod$2(it, '@@iterator')
1129
+ if (it != undefined) return getMethod$3(it, ITERATOR$5)
1130
+ || getMethod$3(it, '@@iterator')
1131
1131
  || Iterators$3[classof$5(it)];
1132
1132
  };
1133
1133
 
1134
- var global$i = global$H;
1135
- var call$9 = functionCall;
1136
- var aCallable$2 = aCallable$5;
1137
- var anObject$9 = anObject$d;
1134
+ var global$l = global$K;
1135
+ var call$a = functionCall;
1136
+ var aCallable$3 = aCallable$6;
1137
+ var anObject$a = anObject$e;
1138
1138
  var tryToString$2 = tryToString$4;
1139
1139
  var getIteratorMethod$1 = getIteratorMethod$2;
1140
1140
 
1141
- var TypeError$7 = global$i.TypeError;
1141
+ var TypeError$8 = global$l.TypeError;
1142
1142
 
1143
1143
  var getIterator$1 = function (argument, usingIterator) {
1144
1144
  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
1145
- if (aCallable$2(iteratorMethod)) return anObject$9(call$9(iteratorMethod, argument));
1146
- throw TypeError$7(tryToString$2(argument) + ' is not iterable');
1145
+ if (aCallable$3(iteratorMethod)) return anObject$a(call$a(iteratorMethod, argument));
1146
+ throw TypeError$8(tryToString$2(argument) + ' is not iterable');
1147
1147
  };
1148
1148
 
1149
- var call$8 = functionCall;
1150
- var anObject$8 = anObject$d;
1151
- var getMethod$1 = getMethod$4;
1149
+ var call$9 = functionCall;
1150
+ var anObject$9 = anObject$e;
1151
+ var getMethod$2 = getMethod$5;
1152
1152
 
1153
1153
  var iteratorClose$1 = function (iterator, kind, value) {
1154
1154
  var innerResult, innerError;
1155
- anObject$8(iterator);
1155
+ anObject$9(iterator);
1156
1156
  try {
1157
- innerResult = getMethod$1(iterator, 'return');
1157
+ innerResult = getMethod$2(iterator, 'return');
1158
1158
  if (!innerResult) {
1159
1159
  if (kind === 'throw') throw value;
1160
1160
  return value;
1161
1161
  }
1162
- innerResult = call$8(innerResult, iterator);
1162
+ innerResult = call$9(innerResult, iterator);
1163
1163
  } catch (error) {
1164
1164
  innerError = true;
1165
1165
  innerResult = error;
1166
1166
  }
1167
1167
  if (kind === 'throw') throw value;
1168
1168
  if (innerError) throw innerResult;
1169
- anObject$8(innerResult);
1169
+ anObject$9(innerResult);
1170
1170
  return value;
1171
1171
  };
1172
1172
 
1173
- var global$h = global$H;
1173
+ var global$k = global$K;
1174
1174
  var bind$3 = functionBindContext;
1175
- var call$7 = functionCall;
1176
- var anObject$7 = anObject$d;
1175
+ var call$8 = functionCall;
1176
+ var anObject$8 = anObject$e;
1177
1177
  var tryToString$1 = tryToString$4;
1178
1178
  var isArrayIteratorMethod = isArrayIteratorMethod$1;
1179
- var lengthOfArrayLike = lengthOfArrayLike$2;
1179
+ var lengthOfArrayLike$2 = lengthOfArrayLike$4;
1180
1180
  var isPrototypeOf = objectIsPrototypeOf;
1181
1181
  var getIterator = getIterator$1;
1182
1182
  var getIteratorMethod = getIteratorMethod$2;
1183
1183
  var iteratorClose = iteratorClose$1;
1184
1184
 
1185
- var TypeError$6 = global$h.TypeError;
1185
+ var TypeError$7 = global$k.TypeError;
1186
1186
 
1187
1187
  var Result = function (stopped, result) {
1188
1188
  this.stopped = stopped;
@@ -1206,7 +1206,7 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1206
1206
 
1207
1207
  var callFn = function (value) {
1208
1208
  if (AS_ENTRIES) {
1209
- anObject$7(value);
1209
+ anObject$8(value);
1210
1210
  return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
1211
1211
  } return INTERRUPTED ? fn(value, stop) : fn(value);
1212
1212
  };
@@ -1215,10 +1215,10 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1215
1215
  iterator = iterable;
1216
1216
  } else {
1217
1217
  iterFn = getIteratorMethod(iterable);
1218
- if (!iterFn) throw TypeError$6(tryToString$1(iterable) + ' is not iterable');
1218
+ if (!iterFn) throw TypeError$7(tryToString$1(iterable) + ' is not iterable');
1219
1219
  // optimisation for array iterators
1220
1220
  if (isArrayIteratorMethod(iterFn)) {
1221
- for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
1221
+ for (index = 0, length = lengthOfArrayLike$2(iterable); length > index; index++) {
1222
1222
  result = callFn(iterable[index]);
1223
1223
  if (result && isPrototypeOf(ResultPrototype, result)) return result;
1224
1224
  } return new Result(false);
@@ -1227,7 +1227,7 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1227
1227
  }
1228
1228
 
1229
1229
  next = iterator.next;
1230
- while (!(step = call$7(next, iterator)).done) {
1230
+ while (!(step = call$8(next, iterator)).done) {
1231
1231
  try {
1232
1232
  result = callFn(step.value);
1233
1233
  } catch (error) {
@@ -1239,7 +1239,7 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1239
1239
 
1240
1240
  var wellKnownSymbol$a = wellKnownSymbol$i;
1241
1241
 
1242
- var ITERATOR$3 = wellKnownSymbol$a('iterator');
1242
+ var ITERATOR$4 = wellKnownSymbol$a('iterator');
1243
1243
  var SAFE_CLOSING = false;
1244
1244
 
1245
1245
  try {
@@ -1252,7 +1252,7 @@ try {
1252
1252
  SAFE_CLOSING = true;
1253
1253
  }
1254
1254
  };
1255
- iteratorWithReturn[ITERATOR$3] = function () {
1255
+ iteratorWithReturn[ITERATOR$4] = function () {
1256
1256
  return this;
1257
1257
  };
1258
1258
  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
@@ -1264,7 +1264,7 @@ var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
1264
1264
  var ITERATION_SUPPORT = false;
1265
1265
  try {
1266
1266
  var object = {};
1267
- object[ITERATOR$3] = function () {
1267
+ object[ITERATOR$4] = function () {
1268
1268
  return {
1269
1269
  next: function () {
1270
1270
  return { done: ITERATION_SUPPORT = true };
@@ -1276,8 +1276,8 @@ var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
1276
1276
  return ITERATION_SUPPORT;
1277
1277
  };
1278
1278
 
1279
- var uncurryThis$8 = functionUncurryThis;
1280
- var fails$9 = fails$h;
1279
+ var uncurryThis$b = functionUncurryThis;
1280
+ var fails$c = fails$k;
1281
1281
  var isCallable$7 = isCallable$j;
1282
1282
  var classof$4 = classof$6;
1283
1283
  var getBuiltIn$2 = getBuiltIn$7;
@@ -1287,7 +1287,7 @@ var noop = function () { /* empty */ };
1287
1287
  var empty = [];
1288
1288
  var construct = getBuiltIn$2('Reflect', 'construct');
1289
1289
  var constructorRegExp = /^\s*(?:class|function)\b/;
1290
- var exec$1 = uncurryThis$8(constructorRegExp.exec);
1290
+ var exec$3 = uncurryThis$b(constructorRegExp.exec);
1291
1291
  var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
1292
1292
 
1293
1293
  var isConstructorModern = function isConstructor(argument) {
@@ -1311,7 +1311,7 @@ var isConstructorLegacy = function isConstructor(argument) {
1311
1311
  // we can't check .prototype since constructors produced by .bind haven't it
1312
1312
  // `Function#toString` throws on some built-it function in some legacy engines
1313
1313
  // (for example, `DOMQuad` and similar in FF41-)
1314
- return INCORRECT_TO_STRING || !!exec$1(constructorRegExp, inspectSource$1(argument));
1314
+ return INCORRECT_TO_STRING || !!exec$3(constructorRegExp, inspectSource$1(argument));
1315
1315
  } catch (error) {
1316
1316
  return true;
1317
1317
  }
@@ -1321,7 +1321,7 @@ isConstructorLegacy.sham = true;
1321
1321
 
1322
1322
  // `IsConstructor` abstract operation
1323
1323
  // https://tc39.es/ecma262/#sec-isconstructor
1324
- var isConstructor$1 = !construct || fails$9(function () {
1324
+ var isConstructor$1 = !construct || fails$c(function () {
1325
1325
  var called;
1326
1326
  return isConstructorModern(isConstructorModern.call)
1327
1327
  || !isConstructorModern(Object)
@@ -1329,19 +1329,19 @@ var isConstructor$1 = !construct || fails$9(function () {
1329
1329
  || called;
1330
1330
  }) ? isConstructorLegacy : isConstructorModern;
1331
1331
 
1332
- var global$g = global$H;
1332
+ var global$j = global$K;
1333
1333
  var isConstructor = isConstructor$1;
1334
1334
  var tryToString = tryToString$4;
1335
1335
 
1336
- var TypeError$5 = global$g.TypeError;
1336
+ var TypeError$6 = global$j.TypeError;
1337
1337
 
1338
1338
  // `Assert: IsConstructor(argument) is true`
1339
1339
  var aConstructor$1 = function (argument) {
1340
1340
  if (isConstructor(argument)) return argument;
1341
- throw TypeError$5(tryToString(argument) + ' is not a constructor');
1341
+ throw TypeError$6(tryToString(argument) + ' is not a constructor');
1342
1342
  };
1343
1343
 
1344
- var anObject$6 = anObject$d;
1344
+ var anObject$7 = anObject$e;
1345
1345
  var aConstructor = aConstructor$1;
1346
1346
  var wellKnownSymbol$9 = wellKnownSymbol$i;
1347
1347
 
@@ -1349,37 +1349,37 @@ var SPECIES$2 = wellKnownSymbol$9('species');
1349
1349
 
1350
1350
  // `SpeciesConstructor` abstract operation
1351
1351
  // https://tc39.es/ecma262/#sec-speciesconstructor
1352
- var speciesConstructor$1 = function (O, defaultConstructor) {
1353
- var C = anObject$6(O).constructor;
1352
+ var speciesConstructor$2 = function (O, defaultConstructor) {
1353
+ var C = anObject$7(O).constructor;
1354
1354
  var S;
1355
- return C === undefined || (S = anObject$6(C)[SPECIES$2]) == undefined ? defaultConstructor : aConstructor(S);
1355
+ return C === undefined || (S = anObject$7(C)[SPECIES$2]) == undefined ? defaultConstructor : aConstructor(S);
1356
1356
  };
1357
1357
 
1358
1358
  var NATIVE_BIND = functionBindNative;
1359
1359
 
1360
1360
  var FunctionPrototype = Function.prototype;
1361
- var apply$2 = FunctionPrototype.apply;
1362
- var call$6 = FunctionPrototype.call;
1361
+ var apply$3 = FunctionPrototype.apply;
1362
+ var call$7 = FunctionPrototype.call;
1363
1363
 
1364
1364
  // eslint-disable-next-line es/no-reflect -- safe
1365
- var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$6.bind(apply$2) : function () {
1366
- return call$6.apply(apply$2, arguments);
1365
+ var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$7.bind(apply$3) : function () {
1366
+ return call$7.apply(apply$3, arguments);
1367
1367
  });
1368
1368
 
1369
1369
  var getBuiltIn$1 = getBuiltIn$7;
1370
1370
 
1371
1371
  var html$2 = getBuiltIn$1('document', 'documentElement');
1372
1372
 
1373
- var uncurryThis$7 = functionUncurryThis;
1373
+ var uncurryThis$a = functionUncurryThis;
1374
1374
 
1375
- var arraySlice$1 = uncurryThis$7([].slice);
1375
+ var arraySlice$2 = uncurryThis$a([].slice);
1376
1376
 
1377
- var global$f = global$H;
1377
+ var global$i = global$K;
1378
1378
 
1379
- var TypeError$4 = global$f.TypeError;
1379
+ var TypeError$5 = global$i.TypeError;
1380
1380
 
1381
1381
  var validateArgumentsLength$1 = function (passed, required) {
1382
- if (passed < required) throw TypeError$4('Not enough arguments');
1382
+ if (passed < required) throw TypeError$5('Not enough arguments');
1383
1383
  return passed;
1384
1384
  };
1385
1385
 
@@ -1388,30 +1388,30 @@ var userAgent$2 = engineUserAgent;
1388
1388
  var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
1389
1389
 
1390
1390
  var classof$3 = classofRaw$1;
1391
- var global$e = global$H;
1391
+ var global$h = global$K;
1392
1392
 
1393
- var engineIsNode = classof$3(global$e.process) == 'process';
1393
+ var engineIsNode = classof$3(global$h.process) == 'process';
1394
1394
 
1395
- var global$d = global$H;
1396
- var apply$1 = functionApply;
1395
+ var global$g = global$K;
1396
+ var apply$2 = functionApply;
1397
1397
  var bind$2 = functionBindContext;
1398
1398
  var isCallable$6 = isCallable$j;
1399
1399
  var hasOwn$1 = hasOwnProperty_1;
1400
- var fails$8 = fails$h;
1400
+ var fails$b = fails$k;
1401
1401
  var html$1 = html$2;
1402
- var arraySlice = arraySlice$1;
1402
+ var arraySlice$1 = arraySlice$2;
1403
1403
  var createElement = documentCreateElement$2;
1404
1404
  var validateArgumentsLength = validateArgumentsLength$1;
1405
1405
  var IS_IOS$1 = engineIsIos;
1406
- var IS_NODE$2 = engineIsNode;
1407
-
1408
- var set$1 = global$d.setImmediate;
1409
- var clear = global$d.clearImmediate;
1410
- var process$2 = global$d.process;
1411
- var Dispatch = global$d.Dispatch;
1412
- var Function$1 = global$d.Function;
1413
- var MessageChannel = global$d.MessageChannel;
1414
- var String$2 = global$d.String;
1406
+ var IS_NODE$3 = engineIsNode;
1407
+
1408
+ var set$1 = global$g.setImmediate;
1409
+ var clear = global$g.clearImmediate;
1410
+ var process$2 = global$g.process;
1411
+ var Dispatch = global$g.Dispatch;
1412
+ var Function$1 = global$g.Function;
1413
+ var MessageChannel = global$g.MessageChannel;
1414
+ var String$2 = global$g.String;
1415
1415
  var counter = 0;
1416
1416
  var queue$1 = {};
1417
1417
  var ONREADYSTATECHANGE = 'onreadystatechange';
@@ -1419,7 +1419,7 @@ var location, defer, channel, port;
1419
1419
 
1420
1420
  try {
1421
1421
  // Deno throws a ReferenceError on `location` access without `--location` flag
1422
- location = global$d.location;
1422
+ location = global$g.location;
1423
1423
  } catch (error) { /* empty */ }
1424
1424
 
1425
1425
  var run = function (id) {
@@ -1442,7 +1442,7 @@ var listener = function (event) {
1442
1442
 
1443
1443
  var post = function (id) {
1444
1444
  // old engines have not location.origin
1445
- global$d.postMessage(String$2(id), location.protocol + '//' + location.host);
1445
+ global$g.postMessage(String$2(id), location.protocol + '//' + location.host);
1446
1446
  };
1447
1447
 
1448
1448
  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
@@ -1450,9 +1450,9 @@ if (!set$1 || !clear) {
1450
1450
  set$1 = function setImmediate(handler) {
1451
1451
  validateArgumentsLength(arguments.length, 1);
1452
1452
  var fn = isCallable$6(handler) ? handler : Function$1(handler);
1453
- var args = arraySlice(arguments, 1);
1453
+ var args = arraySlice$1(arguments, 1);
1454
1454
  queue$1[++counter] = function () {
1455
- apply$1(fn, undefined, args);
1455
+ apply$2(fn, undefined, args);
1456
1456
  };
1457
1457
  defer(counter);
1458
1458
  return counter;
@@ -1461,7 +1461,7 @@ if (!set$1 || !clear) {
1461
1461
  delete queue$1[id];
1462
1462
  };
1463
1463
  // Node.js 0.8-
1464
- if (IS_NODE$2) {
1464
+ if (IS_NODE$3) {
1465
1465
  defer = function (id) {
1466
1466
  process$2.nextTick(runner(id));
1467
1467
  };
@@ -1480,14 +1480,14 @@ if (!set$1 || !clear) {
1480
1480
  // Browsers with postMessage, skip WebWorkers
1481
1481
  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
1482
1482
  } else if (
1483
- global$d.addEventListener &&
1484
- isCallable$6(global$d.postMessage) &&
1485
- !global$d.importScripts &&
1483
+ global$g.addEventListener &&
1484
+ isCallable$6(global$g.postMessage) &&
1485
+ !global$g.importScripts &&
1486
1486
  location && location.protocol !== 'file:' &&
1487
- !fails$8(post)
1487
+ !fails$b(post)
1488
1488
  ) {
1489
1489
  defer = post;
1490
- global$d.addEventListener('message', listener, false);
1490
+ global$g.addEventListener('message', listener, false);
1491
1491
  // IE8-
1492
1492
  } else if (ONREADYSTATECHANGE in createElement('script')) {
1493
1493
  defer = function (id) {
@@ -1510,29 +1510,29 @@ var task$1 = {
1510
1510
  };
1511
1511
 
1512
1512
  var userAgent$1 = engineUserAgent;
1513
- var global$c = global$H;
1513
+ var global$f = global$K;
1514
1514
 
1515
- var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$c.Pebble !== undefined;
1515
+ var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$f.Pebble !== undefined;
1516
1516
 
1517
1517
  var userAgent = engineUserAgent;
1518
1518
 
1519
1519
  var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
1520
1520
 
1521
- var global$b = global$H;
1521
+ var global$e = global$K;
1522
1522
  var bind$1 = functionBindContext;
1523
1523
  var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
1524
1524
  var macrotask = task$1.set;
1525
1525
  var IS_IOS = engineIsIos;
1526
1526
  var IS_IOS_PEBBLE = engineIsIosPebble;
1527
1527
  var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
1528
- var IS_NODE$1 = engineIsNode;
1528
+ var IS_NODE$2 = engineIsNode;
1529
1529
 
1530
- var MutationObserver = global$b.MutationObserver || global$b.WebKitMutationObserver;
1531
- var document$2 = global$b.document;
1532
- var process$1 = global$b.process;
1533
- var Promise$1 = global$b.Promise;
1530
+ var MutationObserver = global$e.MutationObserver || global$e.WebKitMutationObserver;
1531
+ var document$2 = global$e.document;
1532
+ var process$1 = global$e.process;
1533
+ var Promise$1 = global$e.Promise;
1534
1534
  // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
1535
- var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$b, 'queueMicrotask');
1535
+ var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$e, 'queueMicrotask');
1536
1536
  var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
1537
1537
 
1538
1538
  var flush, head, last, notify$1, toggle, node, promise, then;
@@ -1541,7 +1541,7 @@ var flush, head, last, notify$1, toggle, node, promise, then;
1541
1541
  if (!queueMicrotask) {
1542
1542
  flush = function () {
1543
1543
  var parent, fn;
1544
- if (IS_NODE$1 && (parent = process$1.domain)) parent.exit();
1544
+ if (IS_NODE$2 && (parent = process$1.domain)) parent.exit();
1545
1545
  while (head) {
1546
1546
  fn = head.fn;
1547
1547
  head = head.next;
@@ -1558,7 +1558,7 @@ if (!queueMicrotask) {
1558
1558
 
1559
1559
  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
1560
1560
  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
1561
- if (!IS_IOS && !IS_NODE$1 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
1561
+ if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
1562
1562
  toggle = true;
1563
1563
  node = document$2.createTextNode('');
1564
1564
  new MutationObserver(flush).observe(node, { characterData: true });
@@ -1576,7 +1576,7 @@ if (!queueMicrotask) {
1576
1576
  then(flush);
1577
1577
  };
1578
1578
  // Node.js without promises
1579
- } else if (IS_NODE$1) {
1579
+ } else if (IS_NODE$2) {
1580
1580
  notify$1 = function () {
1581
1581
  process$1.nextTick(flush);
1582
1582
  };
@@ -1588,7 +1588,7 @@ if (!queueMicrotask) {
1588
1588
  // - setTimeout
1589
1589
  } else {
1590
1590
  // strange IE + webpack dev server bug - use .bind(global)
1591
- macrotask = bind$1(macrotask, global$b);
1591
+ macrotask = bind$1(macrotask, global$e);
1592
1592
  notify$1 = function () {
1593
1593
  macrotask(flush);
1594
1594
  };
@@ -1606,7 +1606,7 @@ var microtask$1 = queueMicrotask || function (fn) {
1606
1606
 
1607
1607
  var newPromiseCapability$2 = {};
1608
1608
 
1609
- var aCallable$1 = aCallable$5;
1609
+ var aCallable$2 = aCallable$6;
1610
1610
 
1611
1611
  var PromiseCapability = function (C) {
1612
1612
  var resolve, reject;
@@ -1615,8 +1615,8 @@ var PromiseCapability = function (C) {
1615
1615
  resolve = $$resolve;
1616
1616
  reject = $$reject;
1617
1617
  });
1618
- this.resolve = aCallable$1(resolve);
1619
- this.reject = aCallable$1(reject);
1618
+ this.resolve = aCallable$2(resolve);
1619
+ this.reject = aCallable$2(reject);
1620
1620
  };
1621
1621
 
1622
1622
  // `NewPromiseCapability` abstract operation
@@ -1625,12 +1625,12 @@ newPromiseCapability$2.f = function (C) {
1625
1625
  return new PromiseCapability(C);
1626
1626
  };
1627
1627
 
1628
- var anObject$5 = anObject$d;
1628
+ var anObject$6 = anObject$e;
1629
1629
  var isObject$2 = isObject$8;
1630
1630
  var newPromiseCapability$1 = newPromiseCapability$2;
1631
1631
 
1632
1632
  var promiseResolve$1 = function (C, x) {
1633
- anObject$5(C);
1633
+ anObject$6(C);
1634
1634
  if (isObject$2(x) && x.constructor === C) return x;
1635
1635
  var promiseCapability = newPromiseCapability$1.f(C);
1636
1636
  var resolve = promiseCapability.resolve;
@@ -1638,10 +1638,10 @@ var promiseResolve$1 = function (C, x) {
1638
1638
  return promiseCapability.promise;
1639
1639
  };
1640
1640
 
1641
- var global$a = global$H;
1641
+ var global$d = global$K;
1642
1642
 
1643
1643
  var hostReportErrors$1 = function (a, b) {
1644
- var console = global$a.console;
1644
+ var console = global$d.console;
1645
1645
  if (console && console.error) {
1646
1646
  arguments.length == 1 ? console.error(a) : console.error(a, b);
1647
1647
  }
@@ -1681,24 +1681,24 @@ var queue = Queue$1;
1681
1681
 
1682
1682
  var engineIsBrowser = typeof window == 'object';
1683
1683
 
1684
- var $$4 = _export;
1685
- var global$9 = global$H;
1684
+ var $$6 = _export;
1685
+ var global$c = global$K;
1686
1686
  var getBuiltIn = getBuiltIn$7;
1687
- var call$5 = functionCall;
1687
+ var call$6 = functionCall;
1688
1688
  var NativePromise = nativePromiseConstructor;
1689
1689
  var redefine$3 = redefine$6.exports;
1690
1690
  var redefineAll = redefineAll$1;
1691
1691
  var setPrototypeOf$1 = objectSetPrototypeOf;
1692
1692
  var setToStringTag$2 = setToStringTag$3;
1693
1693
  var setSpecies = setSpecies$1;
1694
- var aCallable = aCallable$5;
1694
+ var aCallable$1 = aCallable$6;
1695
1695
  var isCallable$5 = isCallable$j;
1696
1696
  var isObject$1 = isObject$8;
1697
1697
  var anInstance = anInstance$1;
1698
1698
  var inspectSource = inspectSource$4;
1699
1699
  var iterate = iterate$1;
1700
1700
  var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
1701
- var speciesConstructor = speciesConstructor$1;
1701
+ var speciesConstructor$1 = speciesConstructor$2;
1702
1702
  var task = task$1.set;
1703
1703
  var microtask = microtask$1;
1704
1704
  var promiseResolve = promiseResolve$1;
@@ -1710,7 +1710,7 @@ var InternalStateModule$1 = internalState;
1710
1710
  var isForced = isForced_1;
1711
1711
  var wellKnownSymbol$8 = wellKnownSymbol$i;
1712
1712
  var IS_BROWSER = engineIsBrowser;
1713
- var IS_NODE = engineIsNode;
1713
+ var IS_NODE$1 = engineIsNode;
1714
1714
  var V8_VERSION = engineV8Version;
1715
1715
 
1716
1716
  var SPECIES$1 = wellKnownSymbol$8('species');
@@ -1722,14 +1722,14 @@ var getInternalPromiseState = InternalStateModule$1.getterFor(PROMISE);
1722
1722
  var NativePromisePrototype = NativePromise && NativePromise.prototype;
1723
1723
  var PromiseConstructor = NativePromise;
1724
1724
  var PromisePrototype = NativePromisePrototype;
1725
- var TypeError$3 = global$9.TypeError;
1726
- var document$1 = global$9.document;
1727
- var process = global$9.process;
1725
+ var TypeError$4 = global$c.TypeError;
1726
+ var document$1 = global$c.document;
1727
+ var process = global$c.process;
1728
1728
  var newPromiseCapability = newPromiseCapabilityModule.f;
1729
1729
  var newGenericPromiseCapability = newPromiseCapability;
1730
1730
 
1731
- var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$9.dispatchEvent);
1732
- var NATIVE_REJECTION_EVENT = isCallable$5(global$9.PromiseRejectionEvent);
1731
+ var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$c.dispatchEvent);
1732
+ var NATIVE_REJECTION_EVENT = isCallable$5(global$c.PromiseRejectionEvent);
1733
1733
  var UNHANDLED_REJECTION = 'unhandledrejection';
1734
1734
  var REJECTION_HANDLED = 'rejectionhandled';
1735
1735
  var PENDING = 0;
@@ -1741,7 +1741,7 @@ var SUBCLASSING = false;
1741
1741
 
1742
1742
  var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
1743
1743
 
1744
- var FORCED = isForced(PROMISE, function () {
1744
+ var FORCED$1 = isForced(PROMISE, function () {
1745
1745
  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);
1746
1746
  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);
1747
1747
  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
@@ -1765,7 +1765,7 @@ var FORCED = isForced(PROMISE, function () {
1765
1765
  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;
1766
1766
  });
1767
1767
 
1768
- var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
1768
+ var INCORRECT_ITERATION = FORCED$1 || !checkCorrectnessOfIteration(function (iterable) {
1769
1769
  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
1770
1770
  });
1771
1771
 
@@ -1799,9 +1799,9 @@ var callReaction = function (reaction, state) {
1799
1799
  }
1800
1800
  }
1801
1801
  if (result === reaction.promise) {
1802
- reject(TypeError$3('Promise-chain cycle'));
1802
+ reject(TypeError$4('Promise-chain cycle'));
1803
1803
  } else if (then = isThenable(result)) {
1804
- call$5(then, result, resolve, reject);
1804
+ call$6(then, result, resolve, reject);
1805
1805
  } else resolve(result);
1806
1806
  } else reject(value);
1807
1807
  } catch (error) {
@@ -1831,26 +1831,26 @@ var dispatchEvent = function (name, promise, reason) {
1831
1831
  event.promise = promise;
1832
1832
  event.reason = reason;
1833
1833
  event.initEvent(name, false, true);
1834
- global$9.dispatchEvent(event);
1834
+ global$c.dispatchEvent(event);
1835
1835
  } else event = { promise: promise, reason: reason };
1836
- if (!NATIVE_REJECTION_EVENT && (handler = global$9['on' + name])) handler(event);
1836
+ if (!NATIVE_REJECTION_EVENT && (handler = global$c['on' + name])) handler(event);
1837
1837
  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
1838
1838
  };
1839
1839
 
1840
1840
  var onUnhandled = function (state) {
1841
- call$5(task, global$9, function () {
1841
+ call$6(task, global$c, function () {
1842
1842
  var promise = state.facade;
1843
1843
  var value = state.value;
1844
1844
  var IS_UNHANDLED = isUnhandled(state);
1845
1845
  var result;
1846
1846
  if (IS_UNHANDLED) {
1847
1847
  result = perform(function () {
1848
- if (IS_NODE) {
1848
+ if (IS_NODE$1) {
1849
1849
  process.emit('unhandledRejection', value, promise);
1850
1850
  } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
1851
1851
  });
1852
1852
  // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
1853
- state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
1853
+ state.rejection = IS_NODE$1 || isUnhandled(state) ? UNHANDLED : HANDLED;
1854
1854
  if (result.error) throw result.value;
1855
1855
  }
1856
1856
  });
@@ -1861,9 +1861,9 @@ var isUnhandled = function (state) {
1861
1861
  };
1862
1862
 
1863
1863
  var onHandleUnhandled = function (state) {
1864
- call$5(task, global$9, function () {
1864
+ call$6(task, global$c, function () {
1865
1865
  var promise = state.facade;
1866
- if (IS_NODE) {
1866
+ if (IS_NODE$1) {
1867
1867
  process.emit('rejectionHandled', promise);
1868
1868
  } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
1869
1869
  });
@@ -1889,13 +1889,13 @@ var internalResolve = function (state, value, unwrap) {
1889
1889
  state.done = true;
1890
1890
  if (unwrap) state = unwrap;
1891
1891
  try {
1892
- if (state.facade === value) throw TypeError$3("Promise can't be resolved itself");
1892
+ if (state.facade === value) throw TypeError$4("Promise can't be resolved itself");
1893
1893
  var then = isThenable(value);
1894
1894
  if (then) {
1895
1895
  microtask(function () {
1896
1896
  var wrapper = { done: false };
1897
1897
  try {
1898
- call$5(then, value,
1898
+ call$6(then, value,
1899
1899
  bind(internalResolve, wrapper, state),
1900
1900
  bind(internalReject, wrapper, state)
1901
1901
  );
@@ -1914,12 +1914,12 @@ var internalResolve = function (state, value, unwrap) {
1914
1914
  };
1915
1915
 
1916
1916
  // constructor polyfill
1917
- if (FORCED) {
1917
+ if (FORCED$1) {
1918
1918
  // 25.4.3.1 Promise(executor)
1919
1919
  PromiseConstructor = function Promise(executor) {
1920
1920
  anInstance(this, PromisePrototype);
1921
- aCallable(executor);
1922
- call$5(Internal, this);
1921
+ aCallable$1(executor);
1922
+ call$6(Internal, this);
1923
1923
  var state = getInternalState$2(this);
1924
1924
  try {
1925
1925
  executor(bind(internalResolve, state), bind(internalReject, state));
@@ -1947,11 +1947,11 @@ if (FORCED) {
1947
1947
  // eslint-disable-next-line unicorn/no-thenable -- safe
1948
1948
  then: function then(onFulfilled, onRejected) {
1949
1949
  var state = getInternalPromiseState(this);
1950
- var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
1950
+ var reaction = newPromiseCapability(speciesConstructor$1(this, PromiseConstructor));
1951
1951
  state.parent = true;
1952
1952
  reaction.ok = isCallable$5(onFulfilled) ? onFulfilled : true;
1953
1953
  reaction.fail = isCallable$5(onRejected) && onRejected;
1954
- reaction.domain = IS_NODE ? process.domain : undefined;
1954
+ reaction.domain = IS_NODE$1 ? process.domain : undefined;
1955
1955
  if (state.state == PENDING) state.reactions.add(reaction);
1956
1956
  else microtask(function () {
1957
1957
  callReaction(reaction, state);
@@ -1985,7 +1985,7 @@ if (FORCED) {
1985
1985
  redefine$3(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
1986
1986
  var that = this;
1987
1987
  return new PromiseConstructor(function (resolve, reject) {
1988
- call$5(nativeThen, that, resolve, reject);
1988
+ call$6(nativeThen, that, resolve, reject);
1989
1989
  }).then(onFulfilled, onRejected);
1990
1990
  // https://github.com/zloirock/core-js/issues/640
1991
1991
  }, { unsafe: true });
@@ -2006,7 +2006,7 @@ if (FORCED) {
2006
2006
  }
2007
2007
  }
2008
2008
 
2009
- $$4({ global: true, wrap: true, forced: FORCED }, {
2009
+ $$6({ global: true, wrap: true, forced: FORCED$1 }, {
2010
2010
  Promise: PromiseConstructor
2011
2011
  });
2012
2012
 
@@ -2016,17 +2016,17 @@ setSpecies(PROMISE);
2016
2016
  PromiseWrapper = getBuiltIn(PROMISE);
2017
2017
 
2018
2018
  // statics
2019
- $$4({ target: PROMISE, stat: true, forced: FORCED }, {
2019
+ $$6({ target: PROMISE, stat: true, forced: FORCED$1 }, {
2020
2020
  // `Promise.reject` method
2021
2021
  // https://tc39.es/ecma262/#sec-promise.reject
2022
2022
  reject: function reject(r) {
2023
2023
  var capability = newPromiseCapability(this);
2024
- call$5(capability.reject, undefined, r);
2024
+ call$6(capability.reject, undefined, r);
2025
2025
  return capability.promise;
2026
2026
  }
2027
2027
  });
2028
2028
 
2029
- $$4({ target: PROMISE, stat: true, forced: FORCED }, {
2029
+ $$6({ target: PROMISE, stat: true, forced: FORCED$1 }, {
2030
2030
  // `Promise.resolve` method
2031
2031
  // https://tc39.es/ecma262/#sec-promise.resolve
2032
2032
  resolve: function resolve(x) {
@@ -2034,7 +2034,7 @@ $$4({ target: PROMISE, stat: true, forced: FORCED }, {
2034
2034
  }
2035
2035
  });
2036
2036
 
2037
- $$4({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2037
+ $$6({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2038
2038
  // `Promise.all` method
2039
2039
  // https://tc39.es/ecma262/#sec-promise.all
2040
2040
  all: function all(iterable) {
@@ -2043,7 +2043,7 @@ $$4({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2043
2043
  var resolve = capability.resolve;
2044
2044
  var reject = capability.reject;
2045
2045
  var result = perform(function () {
2046
- var $promiseResolve = aCallable(C.resolve);
2046
+ var $promiseResolve = aCallable$1(C.resolve);
2047
2047
  var values = [];
2048
2048
  var counter = 0;
2049
2049
  var remaining = 1;
@@ -2051,7 +2051,7 @@ $$4({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2051
2051
  var index = counter++;
2052
2052
  var alreadyCalled = false;
2053
2053
  remaining++;
2054
- call$5($promiseResolve, C, promise).then(function (value) {
2054
+ call$6($promiseResolve, C, promise).then(function (value) {
2055
2055
  if (alreadyCalled) return;
2056
2056
  alreadyCalled = true;
2057
2057
  values[index] = value;
@@ -2070,9 +2070,9 @@ $$4({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2070
2070
  var capability = newPromiseCapability(C);
2071
2071
  var reject = capability.reject;
2072
2072
  var result = perform(function () {
2073
- var $promiseResolve = aCallable(C.resolve);
2073
+ var $promiseResolve = aCallable$1(C.resolve);
2074
2074
  iterate(iterable, function (promise) {
2075
- call$5($promiseResolve, C, promise).then(capability.resolve, reject);
2075
+ call$6($promiseResolve, C, promise).then(capability.resolve, reject);
2076
2076
  });
2077
2077
  });
2078
2078
  if (result.error) reject(result.value);
@@ -2091,24 +2091,24 @@ var objectKeys$2 = Object.keys || function keys(O) {
2091
2091
  };
2092
2092
 
2093
2093
  var DESCRIPTORS$2 = descriptors;
2094
- var uncurryThis$6 = functionUncurryThis;
2095
- var call$4 = functionCall;
2096
- var fails$7 = fails$h;
2094
+ var uncurryThis$9 = functionUncurryThis;
2095
+ var call$5 = functionCall;
2096
+ var fails$a = fails$k;
2097
2097
  var objectKeys$1 = objectKeys$2;
2098
2098
  var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
2099
2099
  var propertyIsEnumerableModule = objectPropertyIsEnumerable;
2100
- var toObject$2 = toObject$4;
2101
- var IndexedObject = indexedObject;
2100
+ var toObject$3 = toObject$5;
2101
+ var IndexedObject$1 = indexedObject;
2102
2102
 
2103
2103
  // eslint-disable-next-line es/no-object-assign -- safe
2104
2104
  var $assign = Object.assign;
2105
2105
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
2106
2106
  var defineProperty$1 = Object.defineProperty;
2107
- var concat$1 = uncurryThis$6([].concat);
2107
+ var concat$1 = uncurryThis$9([].concat);
2108
2108
 
2109
2109
  // `Object.assign` method
2110
2110
  // https://tc39.es/ecma262/#sec-object.assign
2111
- var objectAssign = !$assign || fails$7(function () {
2111
+ var objectAssign = !$assign || fails$a(function () {
2112
2112
  // should have correct order of operations (Edge bug)
2113
2113
  if (DESCRIPTORS$2 && $assign({ b: 1 }, $assign(defineProperty$1({}, 'a', {
2114
2114
  enumerable: true,
@@ -2129,31 +2129,31 @@ var objectAssign = !$assign || fails$7(function () {
2129
2129
  alphabet.split('').forEach(function (chr) { B[chr] = chr; });
2130
2130
  return $assign({}, A)[symbol] != 7 || objectKeys$1($assign({}, B)).join('') != alphabet;
2131
2131
  }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
2132
- var T = toObject$2(target);
2132
+ var T = toObject$3(target);
2133
2133
  var argumentsLength = arguments.length;
2134
2134
  var index = 1;
2135
2135
  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
2136
2136
  var propertyIsEnumerable = propertyIsEnumerableModule.f;
2137
2137
  while (argumentsLength > index) {
2138
- var S = IndexedObject(arguments[index++]);
2138
+ var S = IndexedObject$1(arguments[index++]);
2139
2139
  var keys = getOwnPropertySymbols ? concat$1(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S);
2140
2140
  var length = keys.length;
2141
2141
  var j = 0;
2142
2142
  var key;
2143
2143
  while (length > j) {
2144
2144
  key = keys[j++];
2145
- if (!DESCRIPTORS$2 || call$4(propertyIsEnumerable, S, key)) T[key] = S[key];
2145
+ if (!DESCRIPTORS$2 || call$5(propertyIsEnumerable, S, key)) T[key] = S[key];
2146
2146
  }
2147
2147
  } return T;
2148
2148
  } : $assign;
2149
2149
 
2150
- var $$3 = _export;
2150
+ var $$5 = _export;
2151
2151
  var assign = objectAssign;
2152
2152
 
2153
2153
  // `Object.assign` method
2154
2154
  // https://tc39.es/ecma262/#sec-object.assign
2155
2155
  // eslint-disable-next-line es/no-object-assign -- required for testing
2156
- $$3({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
2156
+ $$5({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
2157
2157
  assign: assign
2158
2158
  });
2159
2159
 
@@ -2553,8 +2553,8 @@ var objectDefineProperties = {};
2553
2553
 
2554
2554
  var DESCRIPTORS$1 = descriptors;
2555
2555
  var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
2556
- var definePropertyModule$1 = objectDefineProperty;
2557
- var anObject$4 = anObject$d;
2556
+ var definePropertyModule$2 = objectDefineProperty;
2557
+ var anObject$5 = anObject$e;
2558
2558
  var toIndexedObject$1 = toIndexedObject$5;
2559
2559
  var objectKeys = objectKeys$2;
2560
2560
 
@@ -2562,19 +2562,19 @@ var objectKeys = objectKeys$2;
2562
2562
  // https://tc39.es/ecma262/#sec-object.defineproperties
2563
2563
  // eslint-disable-next-line es/no-object-defineproperties -- safe
2564
2564
  objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
2565
- anObject$4(O);
2565
+ anObject$5(O);
2566
2566
  var props = toIndexedObject$1(Properties);
2567
2567
  var keys = objectKeys(Properties);
2568
2568
  var length = keys.length;
2569
2569
  var index = 0;
2570
2570
  var key;
2571
- while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]);
2571
+ while (length > index) definePropertyModule$2.f(O, key = keys[index++], props[key]);
2572
2572
  return O;
2573
2573
  };
2574
2574
 
2575
2575
  /* global ActiveXObject -- old IE, WSH */
2576
2576
 
2577
- var anObject$3 = anObject$d;
2577
+ var anObject$4 = anObject$e;
2578
2578
  var definePropertiesModule = objectDefineProperties;
2579
2579
  var enumBugKeys = enumBugKeys$3;
2580
2580
  var hiddenKeys = hiddenKeys$4;
@@ -2647,7 +2647,7 @@ hiddenKeys[IE_PROTO$1] = true;
2647
2647
  var objectCreate = Object.create || function create(O, Properties) {
2648
2648
  var result;
2649
2649
  if (O !== null) {
2650
- EmptyConstructor[PROTOTYPE] = anObject$3(O);
2650
+ EmptyConstructor[PROTOTYPE] = anObject$4(O);
2651
2651
  result = new EmptyConstructor();
2652
2652
  EmptyConstructor[PROTOTYPE] = null;
2653
2653
  // add "__proto__" for Object.getPrototypeOf polyfill
@@ -2658,7 +2658,7 @@ var objectCreate = Object.create || function create(O, Properties) {
2658
2658
 
2659
2659
  var wellKnownSymbol$7 = wellKnownSymbol$i;
2660
2660
  var create$2 = objectCreate;
2661
- var definePropertyModule = objectDefineProperty;
2661
+ var definePropertyModule$1 = objectDefineProperty;
2662
2662
 
2663
2663
  var UNSCOPABLES = wellKnownSymbol$7('unscopables');
2664
2664
  var ArrayPrototype = Array.prototype;
@@ -2666,7 +2666,7 @@ var ArrayPrototype = Array.prototype;
2666
2666
  // Array.prototype[@@unscopables]
2667
2667
  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
2668
2668
  if (ArrayPrototype[UNSCOPABLES] == undefined) {
2669
- definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
2669
+ definePropertyModule$1.f(ArrayPrototype, UNSCOPABLES, {
2670
2670
  configurable: true,
2671
2671
  value: create$2(null)
2672
2672
  });
@@ -2677,30 +2677,30 @@ var addToUnscopables$1 = function (key) {
2677
2677
  ArrayPrototype[UNSCOPABLES][key] = true;
2678
2678
  };
2679
2679
 
2680
- var fails$6 = fails$h;
2680
+ var fails$9 = fails$k;
2681
2681
 
2682
- var correctPrototypeGetter = !fails$6(function () {
2682
+ var correctPrototypeGetter = !fails$9(function () {
2683
2683
  function F() { /* empty */ }
2684
2684
  F.prototype.constructor = null;
2685
2685
  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
2686
2686
  return Object.getPrototypeOf(new F()) !== F.prototype;
2687
2687
  });
2688
2688
 
2689
- var global$8 = global$H;
2689
+ var global$b = global$K;
2690
2690
  var hasOwn = hasOwnProperty_1;
2691
2691
  var isCallable$4 = isCallable$j;
2692
- var toObject$1 = toObject$4;
2692
+ var toObject$2 = toObject$5;
2693
2693
  var sharedKey = sharedKey$3;
2694
2694
  var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
2695
2695
 
2696
2696
  var IE_PROTO = sharedKey('IE_PROTO');
2697
- var Object$1 = global$8.Object;
2697
+ var Object$1 = global$b.Object;
2698
2698
  var ObjectPrototype = Object$1.prototype;
2699
2699
 
2700
2700
  // `Object.getPrototypeOf` method
2701
2701
  // https://tc39.es/ecma262/#sec-object.getprototypeof
2702
2702
  var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object$1.getPrototypeOf : function (O) {
2703
- var object = toObject$1(O);
2703
+ var object = toObject$2(O);
2704
2704
  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
2705
2705
  var constructor = object.constructor;
2706
2706
  if (isCallable$4(constructor) && object instanceof constructor) {
@@ -2708,13 +2708,13 @@ var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object$1.getPrototypeOf :
2708
2708
  } return object instanceof Object$1 ? ObjectPrototype : null;
2709
2709
  };
2710
2710
 
2711
- var fails$5 = fails$h;
2711
+ var fails$8 = fails$k;
2712
2712
  var isCallable$3 = isCallable$j;
2713
2713
  var getPrototypeOf$1 = objectGetPrototypeOf;
2714
2714
  var redefine$2 = redefine$6.exports;
2715
2715
  var wellKnownSymbol$6 = wellKnownSymbol$i;
2716
2716
 
2717
- var ITERATOR$2 = wellKnownSymbol$6('iterator');
2717
+ var ITERATOR$3 = wellKnownSymbol$6('iterator');
2718
2718
  var BUGGY_SAFARI_ITERATORS$1 = false;
2719
2719
 
2720
2720
  // `%IteratorPrototype%` object
@@ -2732,18 +2732,18 @@ if ([].keys) {
2732
2732
  }
2733
2733
  }
2734
2734
 
2735
- var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$5(function () {
2735
+ var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$8(function () {
2736
2736
  var test = {};
2737
2737
  // FF44- legacy iterators case
2738
- return IteratorPrototype$2[ITERATOR$2].call(test) !== test;
2738
+ return IteratorPrototype$2[ITERATOR$3].call(test) !== test;
2739
2739
  });
2740
2740
 
2741
2741
  if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
2742
2742
 
2743
2743
  // `%IteratorPrototype%[@@iterator]()` method
2744
2744
  // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
2745
- if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) {
2746
- redefine$2(IteratorPrototype$2, ITERATOR$2, function () {
2745
+ if (!isCallable$3(IteratorPrototype$2[ITERATOR$3])) {
2746
+ redefine$2(IteratorPrototype$2, ITERATOR$3, function () {
2747
2747
  return this;
2748
2748
  });
2749
2749
  }
@@ -2755,7 +2755,7 @@ var iteratorsCore = {
2755
2755
 
2756
2756
  var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
2757
2757
  var create$1 = objectCreate;
2758
- var createPropertyDescriptor = createPropertyDescriptor$3;
2758
+ var createPropertyDescriptor$1 = createPropertyDescriptor$4;
2759
2759
  var setToStringTag$1 = setToStringTag$3;
2760
2760
  var Iterators$2 = iterators;
2761
2761
 
@@ -2763,14 +2763,14 @@ var returnThis$1 = function () { return this; };
2763
2763
 
2764
2764
  var createIteratorConstructor$1 = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
2765
2765
  var TO_STRING_TAG = NAME + ' Iterator';
2766
- IteratorConstructor.prototype = create$1(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
2766
+ IteratorConstructor.prototype = create$1(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) });
2767
2767
  setToStringTag$1(IteratorConstructor, TO_STRING_TAG, false);
2768
2768
  Iterators$2[TO_STRING_TAG] = returnThis$1;
2769
2769
  return IteratorConstructor;
2770
2770
  };
2771
2771
 
2772
- var $$2 = _export;
2773
- var call$3 = functionCall;
2772
+ var $$4 = _export;
2773
+ var call$4 = functionCall;
2774
2774
  var FunctionName = functionName;
2775
2775
  var isCallable$2 = isCallable$j;
2776
2776
  var createIteratorConstructor = createIteratorConstructor$1;
@@ -2787,7 +2787,7 @@ var PROPER_FUNCTION_NAME = FunctionName.PROPER;
2787
2787
  var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
2788
2788
  var IteratorPrototype = IteratorsCore.IteratorPrototype;
2789
2789
  var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
2790
- var ITERATOR$1 = wellKnownSymbol$5('iterator');
2790
+ var ITERATOR$2 = wellKnownSymbol$5('iterator');
2791
2791
  var KEYS = 'keys';
2792
2792
  var VALUES = 'values';
2793
2793
  var ENTRIES = 'entries';
@@ -2810,7 +2810,7 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
2810
2810
  var TO_STRING_TAG = NAME + ' Iterator';
2811
2811
  var INCORRECT_VALUES_NAME = false;
2812
2812
  var IterablePrototype = Iterable.prototype;
2813
- var nativeIterator = IterablePrototype[ITERATOR$1]
2813
+ var nativeIterator = IterablePrototype[ITERATOR$2]
2814
2814
  || IterablePrototype['@@iterator']
2815
2815
  || DEFAULT && IterablePrototype[DEFAULT];
2816
2816
  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
@@ -2824,8 +2824,8 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
2824
2824
  if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
2825
2825
  if (setPrototypeOf) {
2826
2826
  setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
2827
- } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) {
2828
- redefine$1(CurrentIteratorPrototype, ITERATOR$1, returnThis);
2827
+ } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$2])) {
2828
+ redefine$1(CurrentIteratorPrototype, ITERATOR$2, returnThis);
2829
2829
  }
2830
2830
  }
2831
2831
  // Set @@toStringTag to native iterators
@@ -2839,7 +2839,7 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
2839
2839
  createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES);
2840
2840
  } else {
2841
2841
  INCORRECT_VALUES_NAME = true;
2842
- defaultIterator = function values() { return call$3(nativeIterator, this); };
2842
+ defaultIterator = function values() { return call$4(nativeIterator, this); };
2843
2843
  }
2844
2844
  }
2845
2845
 
@@ -2854,12 +2854,12 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
2854
2854
  if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
2855
2855
  redefine$1(IterablePrototype, KEY, methods[KEY]);
2856
2856
  }
2857
- } else $$2({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
2857
+ } else $$4({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
2858
2858
  }
2859
2859
 
2860
2860
  // define iterator
2861
- if (IterablePrototype[ITERATOR$1] !== defaultIterator) {
2862
- redefine$1(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT });
2861
+ if (IterablePrototype[ITERATOR$2] !== defaultIterator) {
2862
+ redefine$1(IterablePrototype, ITERATOR$2, defaultIterator, { name: DEFAULT });
2863
2863
  }
2864
2864
  Iterators$1[NAME] = defaultIterator;
2865
2865
 
@@ -2970,24 +2970,24 @@ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.co
2970
2970
 
2971
2971
  var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
2972
2972
 
2973
- var global$7 = global$H;
2973
+ var global$a = global$K;
2974
2974
  var DOMIterables = domIterables;
2975
2975
  var DOMTokenListPrototype = domTokenListPrototype;
2976
2976
  var ArrayIteratorMethods = es_array_iterator;
2977
2977
  var createNonEnumerableProperty$1 = createNonEnumerableProperty$6;
2978
2978
  var wellKnownSymbol$4 = wellKnownSymbol$i;
2979
2979
 
2980
- var ITERATOR = wellKnownSymbol$4('iterator');
2980
+ var ITERATOR$1 = wellKnownSymbol$4('iterator');
2981
2981
  var TO_STRING_TAG = wellKnownSymbol$4('toStringTag');
2982
2982
  var ArrayValues = ArrayIteratorMethods.values;
2983
2983
 
2984
2984
  var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
2985
2985
  if (CollectionPrototype) {
2986
2986
  // some Chrome versions have non-configurable methods on DOMTokenList
2987
- if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
2988
- createNonEnumerableProperty$1(CollectionPrototype, ITERATOR, ArrayValues);
2987
+ if (CollectionPrototype[ITERATOR$1] !== ArrayValues) try {
2988
+ createNonEnumerableProperty$1(CollectionPrototype, ITERATOR$1, ArrayValues);
2989
2989
  } catch (error) {
2990
- CollectionPrototype[ITERATOR] = ArrayValues;
2990
+ CollectionPrototype[ITERATOR$1] = ArrayValues;
2991
2991
  }
2992
2992
  if (!CollectionPrototype[TO_STRING_TAG]) {
2993
2993
  createNonEnumerableProperty$1(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
@@ -3004,7 +3004,7 @@ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
3004
3004
  };
3005
3005
 
3006
3006
  for (var COLLECTION_NAME in DOMIterables) {
3007
- handlePrototype(global$7[COLLECTION_NAME] && global$7[COLLECTION_NAME].prototype, COLLECTION_NAME);
3007
+ handlePrototype(global$a[COLLECTION_NAME] && global$a[COLLECTION_NAME].prototype, COLLECTION_NAME);
3008
3008
  }
3009
3009
 
3010
3010
  handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
@@ -3037,6 +3037,15 @@ class Ninetailed {
3037
3037
  });
3038
3038
  };
3039
3039
 
3040
+ this.trackExperience = payload => {
3041
+ return this.track('experience', payload, {
3042
+ plugins: {
3043
+ all: true,
3044
+ ninetailed: false
3045
+ }
3046
+ });
3047
+ };
3048
+
3040
3049
  this.identify = (uid, traits, options) => {
3041
3050
  return this.instance.identify(uid, traits, this.buildOptions(options));
3042
3051
  };
@@ -3236,12 +3245,12 @@ const selectHasVariants = (experience, baseline) => {
3236
3245
  return variants.length > 0;
3237
3246
  };
3238
3247
 
3239
- var global$6 = global$H;
3248
+ var global$9 = global$K;
3240
3249
  var classof$2 = classof$6;
3241
3250
 
3242
- var String$1 = global$6.String;
3251
+ var String$1 = global$9.String;
3243
3252
 
3244
- var toString$4 = function (argument) {
3253
+ var toString$7 = function (argument) {
3245
3254
  if (classof$2(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
3246
3255
  return String$1(argument);
3247
3256
  };
@@ -3259,14 +3268,14 @@ var isRegexp = function (it) {
3259
3268
  return isObject(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$1(it) == 'RegExp');
3260
3269
  };
3261
3270
 
3262
- var global$5 = global$H;
3263
- var isRegExp = isRegexp;
3271
+ var global$8 = global$K;
3272
+ var isRegExp$1 = isRegexp;
3264
3273
 
3265
- var TypeError$2 = global$5.TypeError;
3274
+ var TypeError$3 = global$8.TypeError;
3266
3275
 
3267
3276
  var notARegexp = function (it) {
3268
- if (isRegExp(it)) {
3269
- throw TypeError$2("The method doesn't accept regular expressions");
3277
+ if (isRegExp$1(it)) {
3278
+ throw TypeError$3("The method doesn't accept regular expressions");
3270
3279
  } return it;
3271
3280
  };
3272
3281
 
@@ -3286,19 +3295,19 @@ var correctIsRegexpLogic = function (METHOD_NAME) {
3286
3295
  } return false;
3287
3296
  };
3288
3297
 
3289
- var $$1 = _export;
3290
- var uncurryThis$5 = functionUncurryThis;
3298
+ var $$3 = _export;
3299
+ var uncurryThis$8 = functionUncurryThis;
3291
3300
  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
3292
- var toLength$1 = toLength$3;
3293
- var toString$3 = toString$4;
3301
+ var toLength$2 = toLength$4;
3302
+ var toString$6 = toString$7;
3294
3303
  var notARegExp = notARegexp;
3295
- var requireObjectCoercible$2 = requireObjectCoercible$5;
3304
+ var requireObjectCoercible$4 = requireObjectCoercible$7;
3296
3305
  var correctIsRegExpLogic = correctIsRegexpLogic;
3297
3306
 
3298
3307
  // eslint-disable-next-line es/no-string-prototype-startswith -- safe
3299
- var un$StartsWith = uncurryThis$5(''.startsWith);
3300
- var stringSlice$4 = uncurryThis$5(''.slice);
3301
- var min$1 = Math.min;
3308
+ var un$StartsWith = uncurryThis$8(''.startsWith);
3309
+ var stringSlice$5 = uncurryThis$8(''.slice);
3310
+ var min$2 = Math.min;
3302
3311
 
3303
3312
  var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
3304
3313
  // https://github.com/zloirock/core-js/pull/702
@@ -3309,24 +3318,24 @@ var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () {
3309
3318
 
3310
3319
  // `String.prototype.startsWith` method
3311
3320
  // https://tc39.es/ecma262/#sec-string.prototype.startswith
3312
- $$1({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
3321
+ $$3({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
3313
3322
  startsWith: function startsWith(searchString /* , position = 0 */) {
3314
- var that = toString$3(requireObjectCoercible$2(this));
3323
+ var that = toString$6(requireObjectCoercible$4(this));
3315
3324
  notARegExp(searchString);
3316
- var index = toLength$1(min$1(arguments.length > 1 ? arguments[1] : undefined, that.length));
3317
- var search = toString$3(searchString);
3325
+ var index = toLength$2(min$2(arguments.length > 1 ? arguments[1] : undefined, that.length));
3326
+ var search = toString$6(searchString);
3318
3327
  return un$StartsWith
3319
3328
  ? un$StartsWith(that, search, index)
3320
- : stringSlice$4(that, index, index + search.length) === search;
3329
+ : stringSlice$5(that, index, index + search.length) === search;
3321
3330
  }
3322
3331
  });
3323
3332
 
3324
- var anObject$2 = anObject$d;
3333
+ var anObject$3 = anObject$e;
3325
3334
 
3326
3335
  // `RegExp.prototype.flags` getter implementation
3327
3336
  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
3328
3337
  var regexpFlags$1 = function () {
3329
- var that = anObject$2(this);
3338
+ var that = anObject$3(this);
3330
3339
  var result = '';
3331
3340
  if (that.global) result += 'g';
3332
3341
  if (that.ignoreCase) result += 'i';
@@ -3337,13 +3346,13 @@ var regexpFlags$1 = function () {
3337
3346
  return result;
3338
3347
  };
3339
3348
 
3340
- var fails$4 = fails$h;
3341
- var global$4 = global$H;
3349
+ var fails$7 = fails$k;
3350
+ var global$7 = global$K;
3342
3351
 
3343
3352
  // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
3344
- var $RegExp$2 = global$4.RegExp;
3353
+ var $RegExp$2 = global$7.RegExp;
3345
3354
 
3346
- var UNSUPPORTED_Y$1 = fails$4(function () {
3355
+ var UNSUPPORTED_Y$2 = fails$7(function () {
3347
3356
  var re = $RegExp$2('a', 'y');
3348
3357
  re.lastIndex = 2;
3349
3358
  return re.exec('abcd') != null;
@@ -3351,11 +3360,11 @@ var UNSUPPORTED_Y$1 = fails$4(function () {
3351
3360
 
3352
3361
  // UC Browser bug
3353
3362
  // https://github.com/zloirock/core-js/issues/1008
3354
- var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$4(function () {
3363
+ var MISSED_STICKY = UNSUPPORTED_Y$2 || fails$7(function () {
3355
3364
  return !$RegExp$2('a', 'y').sticky;
3356
3365
  });
3357
3366
 
3358
- var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () {
3367
+ var BROKEN_CARET = UNSUPPORTED_Y$2 || fails$7(function () {
3359
3368
  // https://bugzilla.mozilla.org/show_bug.cgi?id=773687
3360
3369
  var re = $RegExp$2('^r', 'gy');
3361
3370
  re.lastIndex = 2;
@@ -3365,27 +3374,27 @@ var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () {
3365
3374
  var regexpStickyHelpers = {
3366
3375
  BROKEN_CARET: BROKEN_CARET,
3367
3376
  MISSED_STICKY: MISSED_STICKY,
3368
- UNSUPPORTED_Y: UNSUPPORTED_Y$1
3377
+ UNSUPPORTED_Y: UNSUPPORTED_Y$2
3369
3378
  };
3370
3379
 
3371
- var fails$3 = fails$h;
3372
- var global$3 = global$H;
3380
+ var fails$6 = fails$k;
3381
+ var global$6 = global$K;
3373
3382
 
3374
3383
  // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
3375
- var $RegExp$1 = global$3.RegExp;
3384
+ var $RegExp$1 = global$6.RegExp;
3376
3385
 
3377
- var regexpUnsupportedDotAll = fails$3(function () {
3386
+ var regexpUnsupportedDotAll = fails$6(function () {
3378
3387
  var re = $RegExp$1('.', 's');
3379
3388
  return !(re.dotAll && re.exec('\n') && re.flags === 's');
3380
3389
  });
3381
3390
 
3382
- var fails$2 = fails$h;
3383
- var global$2 = global$H;
3391
+ var fails$5 = fails$k;
3392
+ var global$5 = global$K;
3384
3393
 
3385
3394
  // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
3386
- var $RegExp = global$2.RegExp;
3395
+ var $RegExp = global$5.RegExp;
3387
3396
 
3388
- var regexpUnsupportedNcg = fails$2(function () {
3397
+ var regexpUnsupportedNcg = fails$5(function () {
3389
3398
  var re = $RegExp('(?<a>b)', 'g');
3390
3399
  return re.exec('b').groups.a !== 'b' ||
3391
3400
  'b'.replace(re, '$<a>c') !== 'bc';
@@ -3393,11 +3402,11 @@ var regexpUnsupportedNcg = fails$2(function () {
3393
3402
 
3394
3403
  /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
3395
3404
  /* eslint-disable regexp/no-useless-quantifier -- testing */
3396
- var call$2 = functionCall;
3397
- var uncurryThis$4 = functionUncurryThis;
3398
- var toString$2 = toString$4;
3405
+ var call$3 = functionCall;
3406
+ var uncurryThis$7 = functionUncurryThis;
3407
+ var toString$5 = toString$7;
3399
3408
  var regexpFlags = regexpFlags$1;
3400
- var stickyHelpers = regexpStickyHelpers;
3409
+ var stickyHelpers$1 = regexpStickyHelpers;
3401
3410
  var shared = shared$4.exports;
3402
3411
  var create = objectCreate;
3403
3412
  var getInternalState = internalState.get;
@@ -3407,55 +3416,55 @@ var UNSUPPORTED_NCG = regexpUnsupportedNcg;
3407
3416
  var nativeReplace = shared('native-string-replace', String.prototype.replace);
3408
3417
  var nativeExec = RegExp.prototype.exec;
3409
3418
  var patchedExec = nativeExec;
3410
- var charAt$3 = uncurryThis$4(''.charAt);
3411
- var indexOf = uncurryThis$4(''.indexOf);
3412
- var replace$1 = uncurryThis$4(''.replace);
3413
- var stringSlice$3 = uncurryThis$4(''.slice);
3419
+ var charAt$3 = uncurryThis$7(''.charAt);
3420
+ var indexOf = uncurryThis$7(''.indexOf);
3421
+ var replace$2 = uncurryThis$7(''.replace);
3422
+ var stringSlice$4 = uncurryThis$7(''.slice);
3414
3423
 
3415
3424
  var UPDATES_LAST_INDEX_WRONG = (function () {
3416
3425
  var re1 = /a/;
3417
3426
  var re2 = /b*/g;
3418
- call$2(nativeExec, re1, 'a');
3419
- call$2(nativeExec, re2, 'a');
3427
+ call$3(nativeExec, re1, 'a');
3428
+ call$3(nativeExec, re2, 'a');
3420
3429
  return re1.lastIndex !== 0 || re2.lastIndex !== 0;
3421
3430
  })();
3422
3431
 
3423
- var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
3432
+ var UNSUPPORTED_Y$1 = stickyHelpers$1.BROKEN_CARET;
3424
3433
 
3425
3434
  // nonparticipating capturing group, copied from es5-shim's String#split patch.
3426
3435
  var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
3427
3436
 
3428
- var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
3437
+ var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1 || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
3429
3438
 
3430
3439
  if (PATCH) {
3431
3440
  patchedExec = function exec(string) {
3432
3441
  var re = this;
3433
3442
  var state = getInternalState(re);
3434
- var str = toString$2(string);
3443
+ var str = toString$5(string);
3435
3444
  var raw = state.raw;
3436
3445
  var result, reCopy, lastIndex, match, i, object, group;
3437
3446
 
3438
3447
  if (raw) {
3439
3448
  raw.lastIndex = re.lastIndex;
3440
- result = call$2(patchedExec, raw, str);
3449
+ result = call$3(patchedExec, raw, str);
3441
3450
  re.lastIndex = raw.lastIndex;
3442
3451
  return result;
3443
3452
  }
3444
3453
 
3445
3454
  var groups = state.groups;
3446
- var sticky = UNSUPPORTED_Y && re.sticky;
3447
- var flags = call$2(regexpFlags, re);
3455
+ var sticky = UNSUPPORTED_Y$1 && re.sticky;
3456
+ var flags = call$3(regexpFlags, re);
3448
3457
  var source = re.source;
3449
3458
  var charsAdded = 0;
3450
3459
  var strCopy = str;
3451
3460
 
3452
3461
  if (sticky) {
3453
- flags = replace$1(flags, 'y', '');
3462
+ flags = replace$2(flags, 'y', '');
3454
3463
  if (indexOf(flags, 'g') === -1) {
3455
3464
  flags += 'g';
3456
3465
  }
3457
3466
 
3458
- strCopy = stringSlice$3(str, re.lastIndex);
3467
+ strCopy = stringSlice$4(str, re.lastIndex);
3459
3468
  // Support anchored sticky behavior.
3460
3469
  if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$3(str, re.lastIndex - 1) !== '\n')) {
3461
3470
  source = '(?: ' + source + ')';
@@ -3472,12 +3481,12 @@ if (PATCH) {
3472
3481
  }
3473
3482
  if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
3474
3483
 
3475
- match = call$2(nativeExec, sticky ? reCopy : re, strCopy);
3484
+ match = call$3(nativeExec, sticky ? reCopy : re, strCopy);
3476
3485
 
3477
3486
  if (sticky) {
3478
3487
  if (match) {
3479
- match.input = stringSlice$3(match.input, charsAdded);
3480
- match[0] = stringSlice$3(match[0], charsAdded);
3488
+ match.input = stringSlice$4(match.input, charsAdded);
3489
+ match[0] = stringSlice$4(match[0], charsAdded);
3481
3490
  match.index = re.lastIndex;
3482
3491
  re.lastIndex += match[0].length;
3483
3492
  } else re.lastIndex = 0;
@@ -3487,7 +3496,7 @@ if (PATCH) {
3487
3496
  if (NPCG_INCLUDED && match && match.length > 1) {
3488
3497
  // Fix browsers whose `exec` methods don't consistently return `undefined`
3489
3498
  // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
3490
- call$2(nativeReplace, match[0], reCopy, function () {
3499
+ call$3(nativeReplace, match[0], reCopy, function () {
3491
3500
  for (i = 1; i < arguments.length - 2; i++) {
3492
3501
  if (arguments[i] === undefined) match[i] = undefined;
3493
3502
  }
@@ -3506,23 +3515,23 @@ if (PATCH) {
3506
3515
  };
3507
3516
  }
3508
3517
 
3509
- var regexpExec$2 = patchedExec;
3518
+ var regexpExec$3 = patchedExec;
3510
3519
 
3511
- var $ = _export;
3512
- var exec = regexpExec$2;
3520
+ var $$2 = _export;
3521
+ var exec$2 = regexpExec$3;
3513
3522
 
3514
3523
  // `RegExp.prototype.exec` method
3515
3524
  // https://tc39.es/ecma262/#sec-regexp.prototype.exec
3516
- $({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
3517
- exec: exec
3525
+ $$2({ target: 'RegExp', proto: true, forced: /./.exec !== exec$2 }, {
3526
+ exec: exec$2
3518
3527
  });
3519
3528
 
3520
3529
  // TODO: Remove from `core-js@4` since it's moved to entry points
3521
3530
 
3522
- var uncurryThis$3 = functionUncurryThis;
3531
+ var uncurryThis$6 = functionUncurryThis;
3523
3532
  var redefine = redefine$6.exports;
3524
- var regexpExec$1 = regexpExec$2;
3525
- var fails$1 = fails$h;
3533
+ var regexpExec$2 = regexpExec$3;
3534
+ var fails$4 = fails$k;
3526
3535
  var wellKnownSymbol$1 = wellKnownSymbol$i;
3527
3536
  var createNonEnumerableProperty = createNonEnumerableProperty$6;
3528
3537
 
@@ -3532,14 +3541,14 @@ var RegExpPrototype = RegExp.prototype;
3532
3541
  var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
3533
3542
  var SYMBOL = wellKnownSymbol$1(KEY);
3534
3543
 
3535
- var DELEGATES_TO_SYMBOL = !fails$1(function () {
3544
+ var DELEGATES_TO_SYMBOL = !fails$4(function () {
3536
3545
  // String methods call symbol-named RegEp methods
3537
3546
  var O = {};
3538
3547
  O[SYMBOL] = function () { return 7; };
3539
3548
  return ''[KEY](O) != 7;
3540
3549
  });
3541
3550
 
3542
- var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$1(function () {
3551
+ var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$4(function () {
3543
3552
  // Symbol-named RegExp methods call .exec
3544
3553
  var execCalled = false;
3545
3554
  var re = /a/;
@@ -3568,11 +3577,11 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
3568
3577
  !DELEGATES_TO_EXEC ||
3569
3578
  FORCED
3570
3579
  ) {
3571
- var uncurriedNativeRegExpMethod = uncurryThis$3(/./[SYMBOL]);
3580
+ var uncurriedNativeRegExpMethod = uncurryThis$6(/./[SYMBOL]);
3572
3581
  var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
3573
- var uncurriedNativeMethod = uncurryThis$3(nativeMethod);
3582
+ var uncurriedNativeMethod = uncurryThis$6(nativeMethod);
3574
3583
  var $exec = regexp.exec;
3575
- if ($exec === regexpExec$1 || $exec === RegExpPrototype.exec) {
3584
+ if ($exec === regexpExec$2 || $exec === RegExpPrototype.exec) {
3576
3585
  if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
3577
3586
  // The native String method already delegates to @@method (this
3578
3587
  // polyfilled function), leasing to infinite recursion.
@@ -3591,18 +3600,18 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
3591
3600
  if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
3592
3601
  };
3593
3602
 
3594
- var uncurryThis$2 = functionUncurryThis;
3603
+ var uncurryThis$5 = functionUncurryThis;
3595
3604
  var toIntegerOrInfinity$1 = toIntegerOrInfinity$4;
3596
- var toString$1 = toString$4;
3597
- var requireObjectCoercible$1 = requireObjectCoercible$5;
3605
+ var toString$4 = toString$7;
3606
+ var requireObjectCoercible$3 = requireObjectCoercible$7;
3598
3607
 
3599
- var charAt$2 = uncurryThis$2(''.charAt);
3600
- var charCodeAt = uncurryThis$2(''.charCodeAt);
3601
- var stringSlice$2 = uncurryThis$2(''.slice);
3608
+ var charAt$2 = uncurryThis$5(''.charAt);
3609
+ var charCodeAt = uncurryThis$5(''.charCodeAt);
3610
+ var stringSlice$3 = uncurryThis$5(''.slice);
3602
3611
 
3603
- var createMethod = function (CONVERT_TO_STRING) {
3612
+ var createMethod$2 = function (CONVERT_TO_STRING) {
3604
3613
  return function ($this, pos) {
3605
- var S = toString$1(requireObjectCoercible$1($this));
3614
+ var S = toString$4(requireObjectCoercible$3($this));
3606
3615
  var position = toIntegerOrInfinity$1(pos);
3607
3616
  var size = S.length;
3608
3617
  var first, second;
@@ -3614,7 +3623,7 @@ var createMethod = function (CONVERT_TO_STRING) {
3614
3623
  ? charAt$2(S, position)
3615
3624
  : first
3616
3625
  : CONVERT_TO_STRING
3617
- ? stringSlice$2(S, position, position + 2)
3626
+ ? stringSlice$3(S, position, position + 2)
3618
3627
  : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
3619
3628
  };
3620
3629
  };
@@ -3622,27 +3631,27 @@ var createMethod = function (CONVERT_TO_STRING) {
3622
3631
  var stringMultibyte = {
3623
3632
  // `String.prototype.codePointAt` method
3624
3633
  // https://tc39.es/ecma262/#sec-string.prototype.codepointat
3625
- codeAt: createMethod(false),
3634
+ codeAt: createMethod$2(false),
3626
3635
  // `String.prototype.at` method
3627
3636
  // https://github.com/mathiasbynens/String.prototype.at
3628
- charAt: createMethod(true)
3637
+ charAt: createMethod$2(true)
3629
3638
  };
3630
3639
 
3631
3640
  var charAt$1 = stringMultibyte.charAt;
3632
3641
 
3633
3642
  // `AdvanceStringIndex` abstract operation
3634
3643
  // https://tc39.es/ecma262/#sec-advancestringindex
3635
- var advanceStringIndex$1 = function (S, index, unicode) {
3644
+ var advanceStringIndex$2 = function (S, index, unicode) {
3636
3645
  return index + (unicode ? charAt$1(S, index).length : 1);
3637
3646
  };
3638
3647
 
3639
- var uncurryThis$1 = functionUncurryThis;
3640
- var toObject = toObject$4;
3648
+ var uncurryThis$4 = functionUncurryThis;
3649
+ var toObject$1 = toObject$5;
3641
3650
 
3642
3651
  var floor = Math.floor;
3643
- var charAt = uncurryThis$1(''.charAt);
3644
- var replace = uncurryThis$1(''.replace);
3645
- var stringSlice$1 = uncurryThis$1(''.slice);
3652
+ var charAt = uncurryThis$4(''.charAt);
3653
+ var replace$1 = uncurryThis$4(''.replace);
3654
+ var stringSlice$2 = uncurryThis$4(''.slice);
3646
3655
  var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
3647
3656
  var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
3648
3657
 
@@ -3653,18 +3662,18 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
3653
3662
  var m = captures.length;
3654
3663
  var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
3655
3664
  if (namedCaptures !== undefined) {
3656
- namedCaptures = toObject(namedCaptures);
3665
+ namedCaptures = toObject$1(namedCaptures);
3657
3666
  symbols = SUBSTITUTION_SYMBOLS;
3658
3667
  }
3659
- return replace(replacement, symbols, function (match, ch) {
3668
+ return replace$1(replacement, symbols, function (match, ch) {
3660
3669
  var capture;
3661
3670
  switch (charAt(ch, 0)) {
3662
3671
  case '$': return '$';
3663
3672
  case '&': return matched;
3664
- case '`': return stringSlice$1(str, 0, position);
3665
- case "'": return stringSlice$1(str, tailPos);
3673
+ case '`': return stringSlice$2(str, 0, position);
3674
+ case "'": return stringSlice$2(str, tailPos);
3666
3675
  case '<':
3667
- capture = namedCaptures[stringSlice$1(ch, 1, -1)];
3676
+ capture = namedCaptures[stringSlice$2(ch, 1, -1)];
3668
3677
  break;
3669
3678
  default: // \d\d?
3670
3679
  var n = +ch;
@@ -3681,52 +3690,52 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
3681
3690
  });
3682
3691
  };
3683
3692
 
3684
- var global$1 = global$H;
3685
- var call$1 = functionCall;
3686
- var anObject$1 = anObject$d;
3693
+ var global$4 = global$K;
3694
+ var call$2 = functionCall;
3695
+ var anObject$2 = anObject$e;
3687
3696
  var isCallable$1 = isCallable$j;
3688
3697
  var classof = classofRaw$1;
3689
- var regexpExec = regexpExec$2;
3698
+ var regexpExec$1 = regexpExec$3;
3690
3699
 
3691
- var TypeError$1 = global$1.TypeError;
3700
+ var TypeError$2 = global$4.TypeError;
3692
3701
 
3693
3702
  // `RegExpExec` abstract operation
3694
3703
  // https://tc39.es/ecma262/#sec-regexpexec
3695
3704
  var regexpExecAbstract = function (R, S) {
3696
3705
  var exec = R.exec;
3697
3706
  if (isCallable$1(exec)) {
3698
- var result = call$1(exec, R, S);
3699
- if (result !== null) anObject$1(result);
3707
+ var result = call$2(exec, R, S);
3708
+ if (result !== null) anObject$2(result);
3700
3709
  return result;
3701
3710
  }
3702
- if (classof(R) === 'RegExp') return call$1(regexpExec, R, S);
3703
- throw TypeError$1('RegExp#exec called on incompatible receiver');
3711
+ if (classof(R) === 'RegExp') return call$2(regexpExec$1, R, S);
3712
+ throw TypeError$2('RegExp#exec called on incompatible receiver');
3704
3713
  };
3705
3714
 
3706
- var apply = functionApply;
3707
- var call = functionCall;
3708
- var uncurryThis = functionUncurryThis;
3709
- var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
3710
- var fails = fails$h;
3711
- var anObject = anObject$d;
3715
+ var apply$1 = functionApply;
3716
+ var call$1 = functionCall;
3717
+ var uncurryThis$3 = functionUncurryThis;
3718
+ var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic;
3719
+ var fails$3 = fails$k;
3720
+ var anObject$1 = anObject$e;
3712
3721
  var isCallable = isCallable$j;
3713
3722
  var toIntegerOrInfinity = toIntegerOrInfinity$4;
3714
- var toLength = toLength$3;
3715
- var toString = toString$4;
3716
- var requireObjectCoercible = requireObjectCoercible$5;
3717
- var advanceStringIndex = advanceStringIndex$1;
3718
- var getMethod = getMethod$4;
3723
+ var toLength$1 = toLength$4;
3724
+ var toString$3 = toString$7;
3725
+ var requireObjectCoercible$2 = requireObjectCoercible$7;
3726
+ var advanceStringIndex$1 = advanceStringIndex$2;
3727
+ var getMethod$1 = getMethod$5;
3719
3728
  var getSubstitution = getSubstitution$1;
3720
3729
  var regExpExec = regexpExecAbstract;
3721
3730
  var wellKnownSymbol = wellKnownSymbol$i;
3722
3731
 
3723
3732
  var REPLACE = wellKnownSymbol('replace');
3724
- var max = Math.max;
3725
- var min = Math.min;
3726
- var concat = uncurryThis([].concat);
3727
- var push = uncurryThis([].push);
3728
- var stringIndexOf = uncurryThis(''.indexOf);
3729
- var stringSlice = uncurryThis(''.slice);
3733
+ var max$1 = Math.max;
3734
+ var min$1 = Math.min;
3735
+ var concat = uncurryThis$3([].concat);
3736
+ var push$1 = uncurryThis$3([].push);
3737
+ var stringIndexOf = uncurryThis$3(''.indexOf);
3738
+ var stringSlice$1 = uncurryThis$3(''.slice);
3730
3739
 
3731
3740
  var maybeToString = function (it) {
3732
3741
  return it === undefined ? it : String(it);
@@ -3747,7 +3756,7 @@ var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
3747
3756
  return false;
3748
3757
  })();
3749
3758
 
3750
- var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
3759
+ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$3(function () {
3751
3760
  var re = /./;
3752
3761
  re.exec = function () {
3753
3762
  var result = [];
@@ -3759,24 +3768,24 @@ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
3759
3768
  });
3760
3769
 
3761
3770
  // @@replace logic
3762
- fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
3771
+ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCallNative) {
3763
3772
  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
3764
3773
 
3765
3774
  return [
3766
3775
  // `String.prototype.replace` method
3767
3776
  // https://tc39.es/ecma262/#sec-string.prototype.replace
3768
3777
  function replace(searchValue, replaceValue) {
3769
- var O = requireObjectCoercible(this);
3770
- var replacer = searchValue == undefined ? undefined : getMethod(searchValue, REPLACE);
3778
+ var O = requireObjectCoercible$2(this);
3779
+ var replacer = searchValue == undefined ? undefined : getMethod$1(searchValue, REPLACE);
3771
3780
  return replacer
3772
- ? call(replacer, searchValue, O, replaceValue)
3773
- : call(nativeReplace, toString(O), searchValue, replaceValue);
3781
+ ? call$1(replacer, searchValue, O, replaceValue)
3782
+ : call$1(nativeReplace, toString$3(O), searchValue, replaceValue);
3774
3783
  },
3775
3784
  // `RegExp.prototype[@@replace]` method
3776
3785
  // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
3777
3786
  function (string, replaceValue) {
3778
- var rx = anObject(this);
3779
- var S = toString(string);
3787
+ var rx = anObject$1(this);
3788
+ var S = toString$3(string);
3780
3789
 
3781
3790
  if (
3782
3791
  typeof replaceValue == 'string' &&
@@ -3788,7 +3797,7 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
3788
3797
  }
3789
3798
 
3790
3799
  var functionalReplace = isCallable(replaceValue);
3791
- if (!functionalReplace) replaceValue = toString(replaceValue);
3800
+ if (!functionalReplace) replaceValue = toString$3(replaceValue);
3792
3801
 
3793
3802
  var global = rx.global;
3794
3803
  if (global) {
@@ -3800,11 +3809,11 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
3800
3809
  var result = regExpExec(rx, S);
3801
3810
  if (result === null) break;
3802
3811
 
3803
- push(results, result);
3812
+ push$1(results, result);
3804
3813
  if (!global) break;
3805
3814
 
3806
- var matchStr = toString(result[0]);
3807
- if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
3815
+ var matchStr = toString$3(result[0]);
3816
+ if (matchStr === '') rx.lastIndex = advanceStringIndex$1(S, toLength$1(rx.lastIndex), fullUnicode);
3808
3817
  }
3809
3818
 
3810
3819
  var accumulatedResult = '';
@@ -3812,29 +3821,29 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
3812
3821
  for (var i = 0; i < results.length; i++) {
3813
3822
  result = results[i];
3814
3823
 
3815
- var matched = toString(result[0]);
3816
- var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
3824
+ var matched = toString$3(result[0]);
3825
+ var position = max$1(min$1(toIntegerOrInfinity(result.index), S.length), 0);
3817
3826
  var captures = [];
3818
3827
  // NOTE: This is equivalent to
3819
3828
  // captures = result.slice(1).map(maybeToString)
3820
3829
  // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
3821
3830
  // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
3822
3831
  // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
3823
- for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
3832
+ for (var j = 1; j < result.length; j++) push$1(captures, maybeToString(result[j]));
3824
3833
  var namedCaptures = result.groups;
3825
3834
  if (functionalReplace) {
3826
3835
  var replacerArgs = concat([matched], captures, position, S);
3827
- if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
3828
- var replacement = toString(apply(replaceValue, undefined, replacerArgs));
3836
+ if (namedCaptures !== undefined) push$1(replacerArgs, namedCaptures);
3837
+ var replacement = toString$3(apply$1(replaceValue, undefined, replacerArgs));
3829
3838
  } else {
3830
3839
  replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
3831
3840
  }
3832
3841
  if (position >= nextSourcePosition) {
3833
- accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
3842
+ accumulatedResult += stringSlice$1(S, nextSourcePosition, position) + replacement;
3834
3843
  nextSourcePosition = position + matched.length;
3835
3844
  }
3836
3845
  }
3837
- return accumulatedResult + stringSlice(S, nextSourcePosition);
3846
+ return accumulatedResult + stringSlice$1(S, nextSourcePosition);
3838
3847
  }
3839
3848
  ];
3840
3849
  }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
@@ -3887,7 +3896,7 @@ const isExperienceMatch = ({
3887
3896
  log(`The traffic random factor for experience ${experience.id} is ${trafficRandom}. It's traffic allocation is set to ${experience.trafficAllocation}.`);
3888
3897
  const isInTrafficRange = experience.trafficAllocation > trafficRandom;
3889
3898
  const matchesAudience = !experience.audience || includes(profile.audiences, experience.audience.id);
3890
- const hasActiveExperiment = find(activeExperiments, {
3899
+ const hasActiveExperiment = !!find(activeExperiments, {
3891
3900
  id: experience.id
3892
3901
  });
3893
3902
  log(`Is the profile in traffic allocation range? ${isInTrafficRange ? 'yes' : 'no'}.\n
@@ -3914,6 +3923,20 @@ const selectExperience = ({
3914
3923
  return selectedExperience;
3915
3924
  };
3916
3925
 
3926
+ const selectDistribution = ({
3927
+ experience,
3928
+ profile
3929
+ }) => {
3930
+ const distributionRandom = getDistributionRandom(profile, experience);
3931
+ log(`The distribution random factor for experience ${experience.id} is ${distributionRandom}. It's distribution is set to ${JSON.stringify(experience.distribution, null, 2)}.`);
3932
+ const distribution = find(experience.distribution, ({
3933
+ start,
3934
+ end
3935
+ }) => distributionRandom >= start && distributionRandom <= end // this overlaps on one value for each boundary but we just find the first match
3936
+ );
3937
+ return distribution;
3938
+ };
3939
+
3917
3940
  const selectVariant = ({
3918
3941
  baseline,
3919
3942
  experience,
@@ -3925,18 +3948,10 @@ const selectVariant = ({
3925
3948
  return null;
3926
3949
  }
3927
3950
 
3928
- if (experience.type === 'nt_personalization') {
3929
- // Personalization Expriences can have only one variant.
3930
- return variants[0];
3931
- }
3932
-
3933
- const distributionRandom = getDistributionRandom(profile, experience);
3934
- log(`The distribution random factor for experience ${experience.id} is ${distributionRandom}. It's distribution is set to ${JSON.stringify(experience.distribution, null, 2)}.`); // Experiment
3935
-
3936
- const distribution = find(experience.distribution, ({
3937
- start,
3938
- end
3939
- }) => distributionRandom > start && distributionRandom < end);
3951
+ const distribution = selectDistribution({
3952
+ experience,
3953
+ profile
3954
+ });
3940
3955
 
3941
3956
  if (!distribution) {
3942
3957
  return null;
@@ -3965,4 +3980,348 @@ const selectVariant = ({
3965
3980
  return variant;
3966
3981
  };
3967
3982
 
3968
- export { NINETAILED_TRACKER_EVENTS, Ninetailed, PLUGIN_NAME, isExperienceMatch, ninetailedPlugin, selectActiveExperiments, selectEligibleExperiences, selectExperience, selectBaselineWithVariants as selectExperienceBaselineWithVariants, selectVariant as selectExperienceVariant, selectVariants as selectExperienceVariants, selectHasVariants as selectHasExperienceVariants, selectVariant$1 as selectVariant };
3983
+ var global$3 = global$K;
3984
+ var aCallable = aCallable$6;
3985
+ var toObject = toObject$5;
3986
+ var IndexedObject = indexedObject;
3987
+ var lengthOfArrayLike$1 = lengthOfArrayLike$4;
3988
+
3989
+ var TypeError$1 = global$3.TypeError;
3990
+
3991
+ // `Array.prototype.{ reduce, reduceRight }` methods implementation
3992
+ var createMethod$1 = function (IS_RIGHT) {
3993
+ return function (that, callbackfn, argumentsLength, memo) {
3994
+ aCallable(callbackfn);
3995
+ var O = toObject(that);
3996
+ var self = IndexedObject(O);
3997
+ var length = lengthOfArrayLike$1(O);
3998
+ var index = IS_RIGHT ? length - 1 : 0;
3999
+ var i = IS_RIGHT ? -1 : 1;
4000
+ if (argumentsLength < 2) while (true) {
4001
+ if (index in self) {
4002
+ memo = self[index];
4003
+ index += i;
4004
+ break;
4005
+ }
4006
+ index += i;
4007
+ if (IS_RIGHT ? index < 0 : length <= index) {
4008
+ throw TypeError$1('Reduce of empty array with no initial value');
4009
+ }
4010
+ }
4011
+ for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
4012
+ memo = callbackfn(memo, self[index], index, O);
4013
+ }
4014
+ return memo;
4015
+ };
4016
+ };
4017
+
4018
+ var arrayReduce = {
4019
+ // `Array.prototype.reduce` method
4020
+ // https://tc39.es/ecma262/#sec-array.prototype.reduce
4021
+ left: createMethod$1(false),
4022
+ // `Array.prototype.reduceRight` method
4023
+ // https://tc39.es/ecma262/#sec-array.prototype.reduceright
4024
+ right: createMethod$1(true)
4025
+ };
4026
+
4027
+ var fails$2 = fails$k;
4028
+
4029
+ var arrayMethodIsStrict$1 = function (METHOD_NAME, argument) {
4030
+ var method = [][METHOD_NAME];
4031
+ return !!method && fails$2(function () {
4032
+ // eslint-disable-next-line no-useless-call -- required for testing
4033
+ method.call(null, argument || function () { return 1; }, 1);
4034
+ });
4035
+ };
4036
+
4037
+ var $$1 = _export;
4038
+ var $reduce = arrayReduce.left;
4039
+ var arrayMethodIsStrict = arrayMethodIsStrict$1;
4040
+ var CHROME_VERSION = engineV8Version;
4041
+ var IS_NODE = engineIsNode;
4042
+
4043
+ var STRICT_METHOD = arrayMethodIsStrict('reduce');
4044
+ // Chrome 80-82 has a critical bug
4045
+ // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
4046
+ var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83;
4047
+
4048
+ // `Array.prototype.reduce` method
4049
+ // https://tc39.es/ecma262/#sec-array.prototype.reduce
4050
+ $$1({ target: 'Array', proto: true, forced: !STRICT_METHOD || CHROME_BUG }, {
4051
+ reduce: function reduce(callbackfn /* , initialValue */) {
4052
+ var length = arguments.length;
4053
+ return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : undefined);
4054
+ }
4055
+ });
4056
+
4057
+ var toPropertyKey = toPropertyKey$3;
4058
+ var definePropertyModule = objectDefineProperty;
4059
+ var createPropertyDescriptor = createPropertyDescriptor$4;
4060
+
4061
+ var createProperty$1 = function (object, key, value) {
4062
+ var propertyKey = toPropertyKey(key);
4063
+ if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
4064
+ else object[propertyKey] = value;
4065
+ };
4066
+
4067
+ var global$2 = global$K;
4068
+ var toAbsoluteIndex = toAbsoluteIndex$2;
4069
+ var lengthOfArrayLike = lengthOfArrayLike$4;
4070
+ var createProperty = createProperty$1;
4071
+
4072
+ var Array$1 = global$2.Array;
4073
+ var max = Math.max;
4074
+
4075
+ var arraySliceSimple = function (O, start, end) {
4076
+ var length = lengthOfArrayLike(O);
4077
+ var k = toAbsoluteIndex(start, length);
4078
+ var fin = toAbsoluteIndex(end === undefined ? length : end, length);
4079
+ var result = Array$1(max(fin - k, 0));
4080
+ for (var n = 0; k < fin; k++, n++) createProperty(result, n, O[k]);
4081
+ result.length = n;
4082
+ return result;
4083
+ };
4084
+
4085
+ var apply = functionApply;
4086
+ var call = functionCall;
4087
+ var uncurryThis$2 = functionUncurryThis;
4088
+ var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
4089
+ var isRegExp = isRegexp;
4090
+ var anObject = anObject$e;
4091
+ var requireObjectCoercible$1 = requireObjectCoercible$7;
4092
+ var speciesConstructor = speciesConstructor$2;
4093
+ var advanceStringIndex = advanceStringIndex$2;
4094
+ var toLength = toLength$4;
4095
+ var toString$2 = toString$7;
4096
+ var getMethod = getMethod$5;
4097
+ var arraySlice = arraySliceSimple;
4098
+ var callRegExpExec = regexpExecAbstract;
4099
+ var regexpExec = regexpExec$3;
4100
+ var stickyHelpers = regexpStickyHelpers;
4101
+ var fails$1 = fails$k;
4102
+
4103
+ var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
4104
+ var MAX_UINT32 = 0xFFFFFFFF;
4105
+ var min = Math.min;
4106
+ var $push = [].push;
4107
+ var exec$1 = uncurryThis$2(/./.exec);
4108
+ var push = uncurryThis$2($push);
4109
+ var stringSlice = uncurryThis$2(''.slice);
4110
+
4111
+ // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
4112
+ // Weex JS has frozen built-in prototypes, so use try / catch wrapper
4113
+ var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails$1(function () {
4114
+ // eslint-disable-next-line regexp/no-empty-group -- required for testing
4115
+ var re = /(?:)/;
4116
+ var originalExec = re.exec;
4117
+ re.exec = function () { return originalExec.apply(this, arguments); };
4118
+ var result = 'ab'.split(re);
4119
+ return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
4120
+ });
4121
+
4122
+ // @@split logic
4123
+ fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
4124
+ var internalSplit;
4125
+ if (
4126
+ 'abbc'.split(/(b)*/)[1] == 'c' ||
4127
+ // eslint-disable-next-line regexp/no-empty-group -- required for testing
4128
+ 'test'.split(/(?:)/, -1).length != 4 ||
4129
+ 'ab'.split(/(?:ab)*/).length != 2 ||
4130
+ '.'.split(/(.?)(.?)/).length != 4 ||
4131
+ // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
4132
+ '.'.split(/()()/).length > 1 ||
4133
+ ''.split(/.?/).length
4134
+ ) {
4135
+ // based on es5-shim implementation, need to rework it
4136
+ internalSplit = function (separator, limit) {
4137
+ var string = toString$2(requireObjectCoercible$1(this));
4138
+ var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
4139
+ if (lim === 0) return [];
4140
+ if (separator === undefined) return [string];
4141
+ // If `separator` is not a regex, use native split
4142
+ if (!isRegExp(separator)) {
4143
+ return call(nativeSplit, string, separator, lim);
4144
+ }
4145
+ var output = [];
4146
+ var flags = (separator.ignoreCase ? 'i' : '') +
4147
+ (separator.multiline ? 'm' : '') +
4148
+ (separator.unicode ? 'u' : '') +
4149
+ (separator.sticky ? 'y' : '');
4150
+ var lastLastIndex = 0;
4151
+ // Make `global` and avoid `lastIndex` issues by working with a copy
4152
+ var separatorCopy = new RegExp(separator.source, flags + 'g');
4153
+ var match, lastIndex, lastLength;
4154
+ while (match = call(regexpExec, separatorCopy, string)) {
4155
+ lastIndex = separatorCopy.lastIndex;
4156
+ if (lastIndex > lastLastIndex) {
4157
+ push(output, stringSlice(string, lastLastIndex, match.index));
4158
+ if (match.length > 1 && match.index < string.length) apply($push, output, arraySlice(match, 1));
4159
+ lastLength = match[0].length;
4160
+ lastLastIndex = lastIndex;
4161
+ if (output.length >= lim) break;
4162
+ }
4163
+ if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
4164
+ }
4165
+ if (lastLastIndex === string.length) {
4166
+ if (lastLength || !exec$1(separatorCopy, '')) push(output, '');
4167
+ } else push(output, stringSlice(string, lastLastIndex));
4168
+ return output.length > lim ? arraySlice(output, 0, lim) : output;
4169
+ };
4170
+ // Chakra, V8
4171
+ } else if ('0'.split(undefined, 0).length) {
4172
+ internalSplit = function (separator, limit) {
4173
+ return separator === undefined && limit === 0 ? [] : call(nativeSplit, this, separator, limit);
4174
+ };
4175
+ } else internalSplit = nativeSplit;
4176
+
4177
+ return [
4178
+ // `String.prototype.split` method
4179
+ // https://tc39.es/ecma262/#sec-string.prototype.split
4180
+ function split(separator, limit) {
4181
+ var O = requireObjectCoercible$1(this);
4182
+ var splitter = separator == undefined ? undefined : getMethod(separator, SPLIT);
4183
+ return splitter
4184
+ ? call(splitter, separator, O, limit)
4185
+ : call(internalSplit, toString$2(O), separator, limit);
4186
+ },
4187
+ // `RegExp.prototype[@@split]` method
4188
+ // https://tc39.es/ecma262/#sec-regexp.prototype-@@split
4189
+ //
4190
+ // NOTE: This cannot be properly polyfilled in engines that don't support
4191
+ // the 'y' flag.
4192
+ function (string, limit) {
4193
+ var rx = anObject(this);
4194
+ var S = toString$2(string);
4195
+ var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
4196
+
4197
+ if (res.done) return res.value;
4198
+
4199
+ var C = speciesConstructor(rx, RegExp);
4200
+
4201
+ var unicodeMatching = rx.unicode;
4202
+ var flags = (rx.ignoreCase ? 'i' : '') +
4203
+ (rx.multiline ? 'm' : '') +
4204
+ (rx.unicode ? 'u' : '') +
4205
+ (UNSUPPORTED_Y ? 'g' : 'y');
4206
+
4207
+ // ^(? + rx + ) is needed, in combination with some S slicing, to
4208
+ // simulate the 'y' flag.
4209
+ var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags);
4210
+ var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
4211
+ if (lim === 0) return [];
4212
+ if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];
4213
+ var p = 0;
4214
+ var q = 0;
4215
+ var A = [];
4216
+ while (q < S.length) {
4217
+ splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
4218
+ var z = callRegExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);
4219
+ var e;
4220
+ if (
4221
+ z === null ||
4222
+ (e = min(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p
4223
+ ) {
4224
+ q = advanceStringIndex(S, q, unicodeMatching);
4225
+ } else {
4226
+ push(A, stringSlice(S, p, q));
4227
+ if (A.length === lim) return A;
4228
+ for (var i = 1; i <= z.length - 1; i++) {
4229
+ push(A, z[i]);
4230
+ if (A.length === lim) return A;
4231
+ }
4232
+ q = p = e;
4233
+ }
4234
+ }
4235
+ push(A, stringSlice(S, p));
4236
+ return A;
4237
+ }
4238
+ ];
4239
+ }, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
4240
+
4241
+ // a string of all valid unicode whitespaces
4242
+ var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
4243
+ '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
4244
+
4245
+ var uncurryThis$1 = functionUncurryThis;
4246
+ var requireObjectCoercible = requireObjectCoercible$7;
4247
+ var toString$1 = toString$7;
4248
+ var whitespaces$1 = whitespaces$2;
4249
+
4250
+ var replace = uncurryThis$1(''.replace);
4251
+ var whitespace = '[' + whitespaces$1 + ']';
4252
+ var ltrim = RegExp('^' + whitespace + whitespace + '*');
4253
+ var rtrim = RegExp(whitespace + whitespace + '*$');
4254
+
4255
+ // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
4256
+ var createMethod = function (TYPE) {
4257
+ return function ($this) {
4258
+ var string = toString$1(requireObjectCoercible($this));
4259
+ if (TYPE & 1) string = replace(string, ltrim, '');
4260
+ if (TYPE & 2) string = replace(string, rtrim, '');
4261
+ return string;
4262
+ };
4263
+ };
4264
+
4265
+ var stringTrim = {
4266
+ // `String.prototype.{ trimLeft, trimStart }` methods
4267
+ // https://tc39.es/ecma262/#sec-string.prototype.trimstart
4268
+ start: createMethod(1),
4269
+ // `String.prototype.{ trimRight, trimEnd }` methods
4270
+ // https://tc39.es/ecma262/#sec-string.prototype.trimend
4271
+ end: createMethod(2),
4272
+ // `String.prototype.trim` method
4273
+ // https://tc39.es/ecma262/#sec-string.prototype.trim
4274
+ trim: createMethod(3)
4275
+ };
4276
+
4277
+ var global$1 = global$K;
4278
+ var fails = fails$k;
4279
+ var uncurryThis = functionUncurryThis;
4280
+ var toString = toString$7;
4281
+ var trim = stringTrim.trim;
4282
+ var whitespaces = whitespaces$2;
4283
+
4284
+ var $parseInt$1 = global$1.parseInt;
4285
+ var Symbol$1 = global$1.Symbol;
4286
+ var ITERATOR = Symbol$1 && Symbol$1.iterator;
4287
+ var hex = /^[+-]?0x/i;
4288
+ var exec = uncurryThis(hex.exec);
4289
+ var FORCED = $parseInt$1(whitespaces + '08') !== 8 || $parseInt$1(whitespaces + '0x16') !== 22
4290
+ // MS Edge 18- broken with boxed symbols
4291
+ || (ITERATOR && !fails(function () { $parseInt$1(Object(ITERATOR)); }));
4292
+
4293
+ // `parseInt` method
4294
+ // https://tc39.es/ecma262/#sec-parseint-string-radix
4295
+ var numberParseInt = FORCED ? function parseInt(string, radix) {
4296
+ var S = trim(toString(string));
4297
+ return $parseInt$1(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));
4298
+ } : $parseInt$1;
4299
+
4300
+ var $ = _export;
4301
+ var $parseInt = numberParseInt;
4302
+
4303
+ // `parseInt` method
4304
+ // https://tc39.es/ecma262/#sec-parseint-string-radix
4305
+ $({ global: true, forced: parseInt != $parseInt }, {
4306
+ parseInt: $parseInt
4307
+ });
4308
+
4309
+ const decodeExperienceVariantsMap = encodedExperienceVariantsMap => {
4310
+ return encodedExperienceVariantsMap.split(',').map(experienceIdWithVariant => {
4311
+ const [experienceId, _variantIndex] = experienceIdWithVariant.split('=');
4312
+ const variantIndex = parseInt(_variantIndex);
4313
+
4314
+ if (!experienceId || !variantIndex) {
4315
+ return null;
4316
+ }
4317
+
4318
+ return {
4319
+ experienceId,
4320
+ variantIndex
4321
+ };
4322
+ }).filter(x => x).reduce((acc, curr) => Object.assign(Object.assign({}, acc), {
4323
+ [curr.experienceId]: curr.variantIndex
4324
+ }), {});
4325
+ };
4326
+
4327
+ export { NINETAILED_TRACKER_EVENTS, Ninetailed, PLUGIN_NAME, decodeExperienceVariantsMap, isExperienceMatch, ninetailedPlugin, selectActiveExperiments, selectDistribution, selectEligibleExperiences, selectExperience, selectBaselineWithVariants as selectExperienceBaselineWithVariants, selectVariant as selectExperienceVariant, selectVariants as selectExperienceVariants, selectHasVariants as selectHasExperienceVariants, selectVariant$1 as selectVariant };