@ninetailed/experience.js 2.0.0-beta.8 → 2.0.1

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 (12) hide show
  1. package/index.esm.js +947 -1272
  2. package/index.umd.js +943 -1243
  3. package/lib/Ninetailed.d.ts +14 -2
  4. package/lib/analytics/index.d.ts +1 -0
  5. package/lib/analytics/utility/debug.d.ts +2 -2
  6. package/lib/experience/decodeExperienceVariantsMap.d.ts +1 -0
  7. package/lib/experience/index.d.ts +5 -1
  8. package/lib/experience/isExperienceMatch.d.ts +9 -0
  9. package/lib/experience/selectDistribution.d.ts +8 -0
  10. package/lib/experience/{selectEglibleExperiences.d.ts → selectEligibleExperiences.d.ts} +3 -3
  11. package/lib/experience/selectVariant.d.ts +1 -2
  12. package/package.json +3 -2
package/index.esm.js CHANGED
@@ -1,6 +1,7 @@
1
1
  import get$2 from 'lodash/get';
2
2
  import unionBy from 'lodash/unionBy';
3
3
  import { buildEmptyCache, buildTrackEvent, buildIdentifyEvent, buildPageEvent } from '@ninetailed/experience.js-shared';
4
+ import * as loglevel from 'loglevel';
4
5
  import Analytics from 'analytics';
5
6
  import flatten from 'lodash/flatten';
6
7
  import find from 'lodash/find';
@@ -15,7 +16,7 @@ var check = function (it) {
15
16
  };
16
17
 
17
18
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
18
- var global$H =
19
+ var global$K =
19
20
  // eslint-disable-next-line es/no-global-this -- safe
20
21
  check(typeof globalThis == 'object' && globalThis) ||
21
22
  check(typeof window == 'object' && window) ||
@@ -27,7 +28,7 @@ var global$H =
27
28
 
28
29
  var objectGetOwnPropertyDescriptor = {};
29
30
 
30
- var fails$h = function (exec) {
31
+ var fails$k = function (exec) {
31
32
  try {
32
33
  return !!exec();
33
34
  } catch (error) {
@@ -35,17 +36,17 @@ var fails$h = function (exec) {
35
36
  }
36
37
  };
37
38
 
38
- var fails$g = fails$h;
39
+ var fails$j = fails$k;
39
40
 
40
41
  // Detect IE8's incomplete defineProperty implementation
41
- var descriptors = !fails$g(function () {
42
+ var descriptors = !fails$j(function () {
42
43
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
43
44
  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
44
45
  });
45
46
 
46
- var fails$f = fails$h;
47
+ var fails$i = fails$k;
47
48
 
48
- var functionBindNative = !fails$f(function () {
49
+ var functionBindNative = !fails$i(function () {
49
50
  var test = (function () { /* empty */ }).bind();
50
51
  // eslint-disable-next-line no-prototype-builtins -- safe
51
52
  return typeof test != 'function' || test.hasOwnProperty('prototype');
@@ -53,10 +54,10 @@ var functionBindNative = !fails$f(function () {
53
54
 
54
55
  var NATIVE_BIND$3 = functionBindNative;
55
56
 
56
- var call$e = Function.prototype.call;
57
+ var call$f = Function.prototype.call;
57
58
 
58
- var functionCall = NATIVE_BIND$3 ? call$e.bind(call$e) : function () {
59
- 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);
60
61
  };
61
62
 
62
63
  var objectPropertyIsEnumerable = {};
@@ -75,7 +76,7 @@ objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
75
76
  return !!descriptor && descriptor.enumerable;
76
77
  } : $propertyIsEnumerable;
77
78
 
78
- var createPropertyDescriptor$3 = function (bitmap, value) {
79
+ var createPropertyDescriptor$4 = function (bitmap, value) {
79
80
  return {
80
81
  enumerable: !(bitmap & 1),
81
82
  configurable: !(bitmap & 2),
@@ -88,36 +89,36 @@ var NATIVE_BIND$2 = functionBindNative;
88
89
 
89
90
  var FunctionPrototype$2 = Function.prototype;
90
91
  var bind$5 = FunctionPrototype$2.bind;
91
- var call$d = FunctionPrototype$2.call;
92
- 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);
93
94
 
94
95
  var functionUncurryThis = NATIVE_BIND$2 ? function (fn) {
95
- return fn && uncurryThis$k(fn);
96
+ return fn && uncurryThis$n(fn);
96
97
  } : function (fn) {
97
98
  return fn && function () {
98
- return call$d.apply(fn, arguments);
99
+ return call$e.apply(fn, arguments);
99
100
  };
100
101
  };
101
102
 
102
- var uncurryThis$j = functionUncurryThis;
103
+ var uncurryThis$m = functionUncurryThis;
103
104
 
104
- var toString$6 = uncurryThis$j({}.toString);
105
- var stringSlice$5 = uncurryThis$j(''.slice);
105
+ var toString$9 = uncurryThis$m({}.toString);
106
+ var stringSlice$6 = uncurryThis$m(''.slice);
106
107
 
107
108
  var classofRaw$1 = function (it) {
108
- return stringSlice$5(toString$6(it), 8, -1);
109
+ return stringSlice$6(toString$9(it), 8, -1);
109
110
  };
110
111
 
111
- var global$G = global$H;
112
- var uncurryThis$i = functionUncurryThis;
113
- var fails$e = fails$h;
112
+ var global$J = global$K;
113
+ var uncurryThis$l = functionUncurryThis;
114
+ var fails$h = fails$k;
114
115
  var classof$7 = classofRaw$1;
115
116
 
116
- var Object$5 = global$G.Object;
117
- var split = uncurryThis$i(''.split);
117
+ var Object$5 = global$J.Object;
118
+ var split = uncurryThis$l(''.split);
118
119
 
119
120
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
120
- var indexedObject = fails$e(function () {
121
+ var indexedObject = fails$h(function () {
121
122
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
122
123
  // eslint-disable-next-line no-prototype-builtins -- safe
123
124
  return !Object$5('z').propertyIsEnumerable(0);
@@ -125,23 +126,23 @@ var indexedObject = fails$e(function () {
125
126
  return classof$7(it) == 'String' ? split(it, '') : Object$5(it);
126
127
  } : Object$5;
127
128
 
128
- var global$F = global$H;
129
+ var global$I = global$K;
129
130
 
130
- var TypeError$g = global$F.TypeError;
131
+ var TypeError$h = global$I.TypeError;
131
132
 
132
133
  // `RequireObjectCoercible` abstract operation
133
134
  // https://tc39.es/ecma262/#sec-requireobjectcoercible
134
- var requireObjectCoercible$5 = function (it) {
135
- 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);
136
137
  return it;
137
138
  };
138
139
 
139
140
  // toObject with fallback for non-array-like ES3 strings
140
- var IndexedObject$1 = indexedObject;
141
- var requireObjectCoercible$4 = requireObjectCoercible$5;
141
+ var IndexedObject$2 = indexedObject;
142
+ var requireObjectCoercible$6 = requireObjectCoercible$7;
142
143
 
143
144
  var toIndexedObject$5 = function (it) {
144
- return IndexedObject$1(requireObjectCoercible$4(it));
145
+ return IndexedObject$2(requireObjectCoercible$6(it));
145
146
  };
146
147
 
147
148
  // `IsCallable` abstract operation
@@ -156,7 +157,7 @@ var isObject$8 = function (it) {
156
157
  return typeof it == 'object' ? it !== null : isCallable$i(it);
157
158
  };
158
159
 
159
- var global$E = global$H;
160
+ var global$H = global$K;
160
161
  var isCallable$h = isCallable$j;
161
162
 
162
163
  var aFunction = function (argument) {
@@ -164,23 +165,23 @@ var aFunction = function (argument) {
164
165
  };
165
166
 
166
167
  var getBuiltIn$7 = function (namespace, method) {
167
- 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];
168
169
  };
169
170
 
170
- var uncurryThis$h = functionUncurryThis;
171
+ var uncurryThis$k = functionUncurryThis;
171
172
 
172
- var objectIsPrototypeOf = uncurryThis$h({}.isPrototypeOf);
173
+ var objectIsPrototypeOf = uncurryThis$k({}.isPrototypeOf);
173
174
 
174
175
  var getBuiltIn$6 = getBuiltIn$7;
175
176
 
176
177
  var engineUserAgent = getBuiltIn$6('navigator', 'userAgent') || '';
177
178
 
178
- var global$D = global$H;
179
+ var global$G = global$K;
179
180
  var userAgent$3 = engineUserAgent;
180
181
 
181
- var process$4 = global$D.process;
182
- var Deno = global$D.Deno;
183
- var versions = process$4 && process$4.versions || Deno && Deno.version;
182
+ var process$3 = global$G.process;
183
+ var Deno = global$G.Deno;
184
+ var versions = process$3 && process$3.versions || Deno && Deno.version;
184
185
  var v8 = versions && versions.v8;
185
186
  var match, version;
186
187
 
@@ -206,10 +207,10 @@ var engineV8Version = version;
206
207
  /* eslint-disable es/no-symbol -- required for testing */
207
208
 
208
209
  var V8_VERSION$1 = engineV8Version;
209
- var fails$d = fails$h;
210
+ var fails$g = fails$k;
210
211
 
211
212
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
212
- var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$d(function () {
213
+ var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$g(function () {
213
214
  var symbol = Symbol();
214
215
  // Chrome 38 Symbol has incorrect toString conversion
215
216
  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
@@ -226,13 +227,13 @@ var useSymbolAsUid = NATIVE_SYMBOL$1
226
227
  && !Symbol.sham
227
228
  && typeof Symbol.iterator == 'symbol';
228
229
 
229
- var global$C = global$H;
230
+ var global$F = global$K;
230
231
  var getBuiltIn$5 = getBuiltIn$7;
231
232
  var isCallable$g = isCallable$j;
232
233
  var isPrototypeOf$2 = objectIsPrototypeOf;
233
234
  var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
234
235
 
235
- var Object$4 = global$C.Object;
236
+ var Object$4 = global$F.Object;
236
237
 
237
238
  var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
238
239
  return typeof it == 'symbol';
@@ -241,9 +242,9 @@ var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
241
242
  return isCallable$g($Symbol) && isPrototypeOf$2($Symbol.prototype, Object$4(it));
242
243
  };
243
244
 
244
- var global$B = global$H;
245
+ var global$E = global$K;
245
246
 
246
- var String$5 = global$B.String;
247
+ var String$5 = global$E.String;
247
248
 
248
249
  var tryToString$4 = function (argument) {
249
250
  try {
@@ -253,64 +254,64 @@ var tryToString$4 = function (argument) {
253
254
  }
254
255
  };
255
256
 
256
- var global$A = global$H;
257
+ var global$D = global$K;
257
258
  var isCallable$f = isCallable$j;
258
259
  var tryToString$3 = tryToString$4;
259
260
 
260
- var TypeError$f = global$A.TypeError;
261
+ var TypeError$g = global$D.TypeError;
261
262
 
262
263
  // `Assert: IsCallable(argument) is true`
263
- var aCallable$5 = function (argument) {
264
+ var aCallable$6 = function (argument) {
264
265
  if (isCallable$f(argument)) return argument;
265
- throw TypeError$f(tryToString$3(argument) + ' is not a function');
266
+ throw TypeError$g(tryToString$3(argument) + ' is not a function');
266
267
  };
267
268
 
268
- var aCallable$4 = aCallable$5;
269
+ var aCallable$5 = aCallable$6;
269
270
 
270
271
  // `GetMethod` abstract operation
271
272
  // https://tc39.es/ecma262/#sec-getmethod
272
- var getMethod$4 = function (V, P) {
273
+ var getMethod$5 = function (V, P) {
273
274
  var func = V[P];
274
- return func == null ? undefined : aCallable$4(func);
275
+ return func == null ? undefined : aCallable$5(func);
275
276
  };
276
277
 
277
- var global$z = global$H;
278
- var call$c = functionCall;
278
+ var global$C = global$K;
279
+ var call$d = functionCall;
279
280
  var isCallable$e = isCallable$j;
280
281
  var isObject$7 = isObject$8;
281
282
 
282
- var TypeError$e = global$z.TypeError;
283
+ var TypeError$f = global$C.TypeError;
283
284
 
284
285
  // `OrdinaryToPrimitive` abstract operation
285
286
  // https://tc39.es/ecma262/#sec-ordinarytoprimitive
286
287
  var ordinaryToPrimitive$1 = function (input, pref) {
287
288
  var fn, val;
288
- if (pref === 'string' && isCallable$e(fn = input.toString) && !isObject$7(val = call$c(fn, input))) return val;
289
- if (isCallable$e(fn = input.valueOf) && !isObject$7(val = call$c(fn, input))) return val;
290
- if (pref !== 'string' && isCallable$e(fn = input.toString) && !isObject$7(val = call$c(fn, input))) return val;
291
- 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");
292
293
  };
293
294
 
294
295
  var shared$4 = {exports: {}};
295
296
 
296
- var global$y = global$H;
297
+ var global$B = global$K;
297
298
 
298
299
  // eslint-disable-next-line es/no-object-defineproperty -- safe
299
300
  var defineProperty$3 = Object.defineProperty;
300
301
 
301
302
  var setGlobal$3 = function (key, value) {
302
303
  try {
303
- defineProperty$3(global$y, key, { value: value, configurable: true, writable: true });
304
+ defineProperty$3(global$B, key, { value: value, configurable: true, writable: true });
304
305
  } catch (error) {
305
- global$y[key] = value;
306
+ global$B[key] = value;
306
307
  } return value;
307
308
  };
308
309
 
309
- var global$x = global$H;
310
+ var global$A = global$K;
310
311
  var setGlobal$2 = setGlobal$3;
311
312
 
312
313
  var SHARED = '__core-js_shared__';
313
- var store$3 = global$x[SHARED] || setGlobal$2(SHARED, {});
314
+ var store$3 = global$A[SHARED] || setGlobal$2(SHARED, {});
314
315
 
315
316
  var sharedStore = store$3;
316
317
 
@@ -326,39 +327,39 @@ var store$2 = sharedStore;
326
327
  source: 'https://github.com/zloirock/core-js'
327
328
  });
328
329
 
329
- var global$w = global$H;
330
- var requireObjectCoercible$3 = requireObjectCoercible$5;
330
+ var global$z = global$K;
331
+ var requireObjectCoercible$5 = requireObjectCoercible$7;
331
332
 
332
- var Object$3 = global$w.Object;
333
+ var Object$3 = global$z.Object;
333
334
 
334
335
  // `ToObject` abstract operation
335
336
  // https://tc39.es/ecma262/#sec-toobject
336
- var toObject$4 = function (argument) {
337
- return Object$3(requireObjectCoercible$3(argument));
337
+ var toObject$5 = function (argument) {
338
+ return Object$3(requireObjectCoercible$5(argument));
338
339
  };
339
340
 
340
- var uncurryThis$g = functionUncurryThis;
341
- var toObject$3 = toObject$4;
341
+ var uncurryThis$j = functionUncurryThis;
342
+ var toObject$4 = toObject$5;
342
343
 
343
- var hasOwnProperty = uncurryThis$g({}.hasOwnProperty);
344
+ var hasOwnProperty = uncurryThis$j({}.hasOwnProperty);
344
345
 
345
346
  // `HasOwnProperty` abstract operation
346
347
  // https://tc39.es/ecma262/#sec-hasownproperty
347
348
  var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
348
- return hasOwnProperty(toObject$3(it), key);
349
+ return hasOwnProperty(toObject$4(it), key);
349
350
  };
350
351
 
351
- var uncurryThis$f = functionUncurryThis;
352
+ var uncurryThis$i = functionUncurryThis;
352
353
 
353
354
  var id = 0;
354
355
  var postfix = Math.random();
355
- var toString$5 = uncurryThis$f(1.0.toString);
356
+ var toString$8 = uncurryThis$i(1.0.toString);
356
357
 
357
358
  var uid$2 = function (key) {
358
- return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$5(++id + postfix, 36);
359
+ return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$8(++id + postfix, 36);
359
360
  };
360
361
 
361
- var global$v = global$H;
362
+ var global$y = global$K;
362
363
  var shared$3 = shared$4.exports;
363
364
  var hasOwn$9 = hasOwnProperty_1;
364
365
  var uid$1 = uid$2;
@@ -366,15 +367,15 @@ var NATIVE_SYMBOL = nativeSymbol;
366
367
  var USE_SYMBOL_AS_UID = useSymbolAsUid;
367
368
 
368
369
  var WellKnownSymbolsStore = shared$3('wks');
369
- var Symbol$1 = global$v.Symbol;
370
- var symbolFor = Symbol$1 && Symbol$1['for'];
371
- 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;
372
373
 
373
374
  var wellKnownSymbol$i = function (name) {
374
375
  if (!hasOwn$9(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
375
376
  var description = 'Symbol.' + name;
376
- if (NATIVE_SYMBOL && hasOwn$9(Symbol$1, name)) {
377
- WellKnownSymbolsStore[name] = Symbol$1[name];
377
+ if (NATIVE_SYMBOL && hasOwn$9(Symbol$2, name)) {
378
+ WellKnownSymbolsStore[name] = Symbol$2[name];
378
379
  } else if (USE_SYMBOL_AS_UID && symbolFor) {
379
380
  WellKnownSymbolsStore[name] = symbolFor(description);
380
381
  } else {
@@ -383,28 +384,28 @@ var wellKnownSymbol$i = function (name) {
383
384
  } return WellKnownSymbolsStore[name];
384
385
  };
385
386
 
386
- var global$u = global$H;
387
- var call$b = functionCall;
387
+ var global$x = global$K;
388
+ var call$c = functionCall;
388
389
  var isObject$6 = isObject$8;
389
390
  var isSymbol$1 = isSymbol$2;
390
- var getMethod$3 = getMethod$4;
391
+ var getMethod$4 = getMethod$5;
391
392
  var ordinaryToPrimitive = ordinaryToPrimitive$1;
392
393
  var wellKnownSymbol$h = wellKnownSymbol$i;
393
394
 
394
- var TypeError$d = global$u.TypeError;
395
+ var TypeError$e = global$x.TypeError;
395
396
  var TO_PRIMITIVE = wellKnownSymbol$h('toPrimitive');
396
397
 
397
398
  // `ToPrimitive` abstract operation
398
399
  // https://tc39.es/ecma262/#sec-toprimitive
399
400
  var toPrimitive$1 = function (input, pref) {
400
401
  if (!isObject$6(input) || isSymbol$1(input)) return input;
401
- var exoticToPrim = getMethod$3(input, TO_PRIMITIVE);
402
+ var exoticToPrim = getMethod$4(input, TO_PRIMITIVE);
402
403
  var result;
403
404
  if (exoticToPrim) {
404
405
  if (pref === undefined) pref = 'default';
405
- result = call$b(exoticToPrim, input, pref);
406
+ result = call$c(exoticToPrim, input, pref);
406
407
  if (!isObject$6(result) || isSymbol$1(result)) return result;
407
- throw TypeError$d("Can't convert object to primitive value");
408
+ throw TypeError$e("Can't convert object to primitive value");
408
409
  }
409
410
  if (pref === undefined) pref = 'number';
410
411
  return ordinaryToPrimitive(input, pref);
@@ -415,15 +416,15 @@ var isSymbol = isSymbol$2;
415
416
 
416
417
  // `ToPropertyKey` abstract operation
417
418
  // https://tc39.es/ecma262/#sec-topropertykey
418
- var toPropertyKey$2 = function (argument) {
419
+ var toPropertyKey$3 = function (argument) {
419
420
  var key = toPrimitive(argument, 'string');
420
421
  return isSymbol(key) ? key : key + '';
421
422
  };
422
423
 
423
- var global$t = global$H;
424
+ var global$w = global$K;
424
425
  var isObject$5 = isObject$8;
425
426
 
426
- var document$3 = global$t.document;
427
+ var document$3 = global$w.document;
427
428
  // typeof document.createElement is 'object' in old IE
428
429
  var EXISTS$1 = isObject$5(document$3) && isObject$5(document$3.createElement);
429
430
 
@@ -432,11 +433,11 @@ var documentCreateElement$2 = function (it) {
432
433
  };
433
434
 
434
435
  var DESCRIPTORS$9 = descriptors;
435
- var fails$c = fails$h;
436
+ var fails$f = fails$k;
436
437
  var createElement$1 = documentCreateElement$2;
437
438
 
438
439
  // Thanks to IE8 for its funny defineProperty
439
- var ie8DomDefine = !DESCRIPTORS$9 && !fails$c(function () {
440
+ var ie8DomDefine = !DESCRIPTORS$9 && !fails$f(function () {
440
441
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
441
442
  return Object.defineProperty(createElement$1('div'), 'a', {
442
443
  get: function () { return 7; }
@@ -444,11 +445,11 @@ var ie8DomDefine = !DESCRIPTORS$9 && !fails$c(function () {
444
445
  });
445
446
 
446
447
  var DESCRIPTORS$8 = descriptors;
447
- var call$a = functionCall;
448
+ var call$b = functionCall;
448
449
  var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
449
- var createPropertyDescriptor$2 = createPropertyDescriptor$3;
450
+ var createPropertyDescriptor$3 = createPropertyDescriptor$4;
450
451
  var toIndexedObject$4 = toIndexedObject$5;
451
- var toPropertyKey$1 = toPropertyKey$2;
452
+ var toPropertyKey$2 = toPropertyKey$3;
452
453
  var hasOwn$8 = hasOwnProperty_1;
453
454
  var IE8_DOM_DEFINE$1 = ie8DomDefine;
454
455
 
@@ -459,21 +460,21 @@ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
459
460
  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
460
461
  objectGetOwnPropertyDescriptor.f = DESCRIPTORS$8 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
461
462
  O = toIndexedObject$4(O);
462
- P = toPropertyKey$1(P);
463
+ P = toPropertyKey$2(P);
463
464
  if (IE8_DOM_DEFINE$1) try {
464
465
  return $getOwnPropertyDescriptor$1(O, P);
465
466
  } catch (error) { /* empty */ }
466
- 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]);
467
468
  };
468
469
 
469
470
  var objectDefineProperty = {};
470
471
 
471
472
  var DESCRIPTORS$7 = descriptors;
472
- var fails$b = fails$h;
473
+ var fails$e = fails$k;
473
474
 
474
475
  // V8 ~ Chrome 36-
475
476
  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
476
- var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$b(function () {
477
+ var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$e(function () {
477
478
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
478
479
  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
479
480
  value: 42,
@@ -481,26 +482,26 @@ var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$b(function () {
481
482
  }).prototype != 42;
482
483
  });
483
484
 
484
- var global$s = global$H;
485
+ var global$v = global$K;
485
486
  var isObject$4 = isObject$8;
486
487
 
487
- var String$4 = global$s.String;
488
- var TypeError$c = global$s.TypeError;
488
+ var String$4 = global$v.String;
489
+ var TypeError$d = global$v.TypeError;
489
490
 
490
491
  // `Assert: Type(argument) is Object`
491
- var anObject$d = function (argument) {
492
+ var anObject$e = function (argument) {
492
493
  if (isObject$4(argument)) return argument;
493
- throw TypeError$c(String$4(argument) + ' is not an object');
494
+ throw TypeError$d(String$4(argument) + ' is not an object');
494
495
  };
495
496
 
496
- var global$r = global$H;
497
+ var global$u = global$K;
497
498
  var DESCRIPTORS$6 = descriptors;
498
499
  var IE8_DOM_DEFINE = ie8DomDefine;
499
500
  var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
500
- var anObject$c = anObject$d;
501
- var toPropertyKey = toPropertyKey$2;
501
+ var anObject$d = anObject$e;
502
+ var toPropertyKey$1 = toPropertyKey$3;
502
503
 
503
- var TypeError$b = global$r.TypeError;
504
+ var TypeError$c = global$u.TypeError;
504
505
  // eslint-disable-next-line es/no-object-defineproperty -- safe
505
506
  var $defineProperty = Object.defineProperty;
506
507
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -512,9 +513,9 @@ var WRITABLE = 'writable';
512
513
  // `Object.defineProperty` method
513
514
  // https://tc39.es/ecma262/#sec-object.defineproperty
514
515
  objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
515
- anObject$c(O);
516
- P = toPropertyKey(P);
517
- anObject$c(Attributes);
516
+ anObject$d(O);
517
+ P = toPropertyKey$1(P);
518
+ anObject$d(Attributes);
518
519
  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
519
520
  var current = $getOwnPropertyDescriptor(O, P);
520
521
  if (current && current[WRITABLE]) {
@@ -527,23 +528,23 @@ objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
527
528
  }
528
529
  } return $defineProperty(O, P, Attributes);
529
530
  } : $defineProperty : function defineProperty(O, P, Attributes) {
530
- anObject$c(O);
531
- P = toPropertyKey(P);
532
- anObject$c(Attributes);
531
+ anObject$d(O);
532
+ P = toPropertyKey$1(P);
533
+ anObject$d(Attributes);
533
534
  if (IE8_DOM_DEFINE) try {
534
535
  return $defineProperty(O, P, Attributes);
535
536
  } catch (error) { /* empty */ }
536
- 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');
537
538
  if ('value' in Attributes) O[P] = Attributes.value;
538
539
  return O;
539
540
  };
540
541
 
541
542
  var DESCRIPTORS$5 = descriptors;
542
- var definePropertyModule$4 = objectDefineProperty;
543
- var createPropertyDescriptor$1 = createPropertyDescriptor$3;
543
+ var definePropertyModule$5 = objectDefineProperty;
544
+ var createPropertyDescriptor$2 = createPropertyDescriptor$4;
544
545
 
545
546
  var createNonEnumerableProperty$6 = DESCRIPTORS$5 ? function (object, key, value) {
546
- return definePropertyModule$4.f(object, key, createPropertyDescriptor$1(1, value));
547
+ return definePropertyModule$5.f(object, key, createPropertyDescriptor$2(1, value));
547
548
  } : function (object, key, value) {
548
549
  object[key] = value;
549
550
  return object;
@@ -551,11 +552,11 @@ var createNonEnumerableProperty$6 = DESCRIPTORS$5 ? function (object, key, value
551
552
 
552
553
  var redefine$6 = {exports: {}};
553
554
 
554
- var uncurryThis$e = functionUncurryThis;
555
+ var uncurryThis$h = functionUncurryThis;
555
556
  var isCallable$d = isCallable$j;
556
557
  var store$1 = sharedStore;
557
558
 
558
- var functionToString = uncurryThis$e(Function.toString);
559
+ var functionToString = uncurryThis$h(Function.toString);
559
560
 
560
561
  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
561
562
  if (!isCallable$d(store$1.inspectSource)) {
@@ -566,11 +567,11 @@ if (!isCallable$d(store$1.inspectSource)) {
566
567
 
567
568
  var inspectSource$4 = store$1.inspectSource;
568
569
 
569
- var global$q = global$H;
570
+ var global$t = global$K;
570
571
  var isCallable$c = isCallable$j;
571
572
  var inspectSource$3 = inspectSource$4;
572
573
 
573
- var WeakMap$1 = global$q.WeakMap;
574
+ var WeakMap$1 = global$t.WeakMap;
574
575
 
575
576
  var nativeWeakMap = isCallable$c(WeakMap$1) && /native code/.test(inspectSource$3(WeakMap$1));
576
577
 
@@ -586,8 +587,8 @@ var sharedKey$3 = function (key) {
586
587
  var hiddenKeys$4 = {};
587
588
 
588
589
  var NATIVE_WEAK_MAP = nativeWeakMap;
589
- var global$p = global$H;
590
- var uncurryThis$d = functionUncurryThis;
590
+ var global$s = global$K;
591
+ var uncurryThis$g = functionUncurryThis;
591
592
  var isObject$3 = isObject$8;
592
593
  var createNonEnumerableProperty$5 = createNonEnumerableProperty$6;
593
594
  var hasOwn$7 = hasOwnProperty_1;
@@ -596,8 +597,8 @@ var sharedKey$2 = sharedKey$3;
596
597
  var hiddenKeys$3 = hiddenKeys$4;
597
598
 
598
599
  var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
599
- var TypeError$a = global$p.TypeError;
600
- var WeakMap = global$p.WeakMap;
600
+ var TypeError$b = global$s.TypeError;
601
+ var WeakMap = global$s.WeakMap;
601
602
  var set$2, get$1, has;
602
603
 
603
604
  var enforce = function (it) {
@@ -608,18 +609,18 @@ var getterFor = function (TYPE) {
608
609
  return function (it) {
609
610
  var state;
610
611
  if (!isObject$3(it) || (state = get$1(it)).type !== TYPE) {
611
- throw TypeError$a('Incompatible receiver, ' + TYPE + ' required');
612
+ throw TypeError$b('Incompatible receiver, ' + TYPE + ' required');
612
613
  } return state;
613
614
  };
614
615
  };
615
616
 
616
617
  if (NATIVE_WEAK_MAP || shared$1.state) {
617
618
  var store = shared$1.state || (shared$1.state = new WeakMap());
618
- var wmget = uncurryThis$d(store.get);
619
- var wmhas = uncurryThis$d(store.has);
620
- 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);
621
622
  set$2 = function (it, metadata) {
622
- if (wmhas(store, it)) throw new TypeError$a(OBJECT_ALREADY_INITIALIZED);
623
+ if (wmhas(store, it)) throw new TypeError$b(OBJECT_ALREADY_INITIALIZED);
623
624
  metadata.facade = it;
624
625
  wmset(store, it, metadata);
625
626
  return metadata;
@@ -634,7 +635,7 @@ if (NATIVE_WEAK_MAP || shared$1.state) {
634
635
  var STATE = sharedKey$2('state');
635
636
  hiddenKeys$3[STATE] = true;
636
637
  set$2 = function (it, metadata) {
637
- 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);
638
639
  metadata.facade = it;
639
640
  createNonEnumerableProperty$5(it, STATE, metadata);
640
641
  return metadata;
@@ -673,7 +674,7 @@ var functionName = {
673
674
  CONFIGURABLE: CONFIGURABLE
674
675
  };
675
676
 
676
- var global$o = global$H;
677
+ var global$r = global$K;
677
678
  var isCallable$b = isCallable$j;
678
679
  var hasOwn$5 = hasOwnProperty_1;
679
680
  var createNonEnumerableProperty$4 = createNonEnumerableProperty$6;
@@ -704,7 +705,7 @@ var TEMPLATE = String(String).split('String');
704
705
  state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
705
706
  }
706
707
  }
707
- if (O === global$o) {
708
+ if (O === global$r) {
708
709
  if (simple) O[key] = value;
709
710
  else setGlobal$1(key, value);
710
711
  return;
@@ -735,45 +736,45 @@ var toIntegerOrInfinity$4 = function (argument) {
735
736
 
736
737
  var toIntegerOrInfinity$3 = toIntegerOrInfinity$4;
737
738
 
738
- var max$1 = Math.max;
739
- var min$3 = Math.min;
739
+ var max$2 = Math.max;
740
+ var min$4 = Math.min;
740
741
 
741
742
  // Helper for a popular repeating case of the spec:
742
743
  // Let integer be ? ToInteger(index).
743
744
  // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
744
- var toAbsoluteIndex$1 = function (index, length) {
745
+ var toAbsoluteIndex$2 = function (index, length) {
745
746
  var integer = toIntegerOrInfinity$3(index);
746
- 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);
747
748
  };
748
749
 
749
750
  var toIntegerOrInfinity$2 = toIntegerOrInfinity$4;
750
751
 
751
- var min$2 = Math.min;
752
+ var min$3 = Math.min;
752
753
 
753
754
  // `ToLength` abstract operation
754
755
  // https://tc39.es/ecma262/#sec-tolength
755
- var toLength$3 = function (argument) {
756
- 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
757
758
  };
758
759
 
759
- var toLength$2 = toLength$3;
760
+ var toLength$3 = toLength$4;
760
761
 
761
762
  // `LengthOfArrayLike` abstract operation
762
763
  // https://tc39.es/ecma262/#sec-lengthofarraylike
763
- var lengthOfArrayLike$2 = function (obj) {
764
- return toLength$2(obj.length);
764
+ var lengthOfArrayLike$4 = function (obj) {
765
+ return toLength$3(obj.length);
765
766
  };
766
767
 
767
768
  var toIndexedObject$3 = toIndexedObject$5;
768
- var toAbsoluteIndex = toAbsoluteIndex$1;
769
- var lengthOfArrayLike$1 = lengthOfArrayLike$2;
769
+ var toAbsoluteIndex$1 = toAbsoluteIndex$2;
770
+ var lengthOfArrayLike$3 = lengthOfArrayLike$4;
770
771
 
771
772
  // `Array.prototype.{ indexOf, includes }` methods implementation
772
- var createMethod$1 = function (IS_INCLUDES) {
773
+ var createMethod$3 = function (IS_INCLUDES) {
773
774
  return function ($this, el, fromIndex) {
774
775
  var O = toIndexedObject$3($this);
775
- var length = lengthOfArrayLike$1(O);
776
- var index = toAbsoluteIndex(fromIndex, length);
776
+ var length = lengthOfArrayLike$3(O);
777
+ var index = toAbsoluteIndex$1(fromIndex, length);
777
778
  var value;
778
779
  // Array#includes uses SameValueZero equality algorithm
779
780
  // eslint-disable-next-line no-self-compare -- NaN check
@@ -791,29 +792,29 @@ var createMethod$1 = function (IS_INCLUDES) {
791
792
  var arrayIncludes = {
792
793
  // `Array.prototype.includes` method
793
794
  // https://tc39.es/ecma262/#sec-array.prototype.includes
794
- includes: createMethod$1(true),
795
+ includes: createMethod$3(true),
795
796
  // `Array.prototype.indexOf` method
796
797
  // https://tc39.es/ecma262/#sec-array.prototype.indexof
797
- indexOf: createMethod$1(false)
798
+ indexOf: createMethod$3(false)
798
799
  };
799
800
 
800
- var uncurryThis$c = functionUncurryThis;
801
+ var uncurryThis$f = functionUncurryThis;
801
802
  var hasOwn$4 = hasOwnProperty_1;
802
803
  var toIndexedObject$2 = toIndexedObject$5;
803
804
  var indexOf$1 = arrayIncludes.indexOf;
804
805
  var hiddenKeys$2 = hiddenKeys$4;
805
806
 
806
- var push$1 = uncurryThis$c([].push);
807
+ var push$2 = uncurryThis$f([].push);
807
808
 
808
809
  var objectKeysInternal = function (object, names) {
809
810
  var O = toIndexedObject$2(object);
810
811
  var i = 0;
811
812
  var result = [];
812
813
  var key;
813
- 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);
814
815
  // Don't enum bug & hidden keys
815
816
  while (names.length > i) if (hasOwn$4(O, key = names[i++])) {
816
- ~indexOf$1(result, key) || push$1(result, key);
817
+ ~indexOf$1(result, key) || push$2(result, key);
817
818
  }
818
819
  return result;
819
820
  };
@@ -847,16 +848,16 @@ var objectGetOwnPropertySymbols = {};
847
848
  objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
848
849
 
849
850
  var getBuiltIn$4 = getBuiltIn$7;
850
- var uncurryThis$b = functionUncurryThis;
851
+ var uncurryThis$e = functionUncurryThis;
851
852
  var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
852
853
  var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
853
- var anObject$b = anObject$d;
854
+ var anObject$c = anObject$e;
854
855
 
855
- var concat$2 = uncurryThis$b([].concat);
856
+ var concat$2 = uncurryThis$e([].concat);
856
857
 
857
858
  // all object keys, includes non-enumerable and symbols
858
859
  var ownKeys$1 = getBuiltIn$4('Reflect', 'ownKeys') || function ownKeys(it) {
859
- var keys = getOwnPropertyNamesModule.f(anObject$b(it));
860
+ var keys = getOwnPropertyNamesModule.f(anObject$c(it));
860
861
  var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
861
862
  return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys;
862
863
  };
@@ -864,11 +865,11 @@ var ownKeys$1 = getBuiltIn$4('Reflect', 'ownKeys') || function ownKeys(it) {
864
865
  var hasOwn$3 = hasOwnProperty_1;
865
866
  var ownKeys = ownKeys$1;
866
867
  var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
867
- var definePropertyModule$3 = objectDefineProperty;
868
+ var definePropertyModule$4 = objectDefineProperty;
868
869
 
869
870
  var copyConstructorProperties$1 = function (target, source, exceptions) {
870
871
  var keys = ownKeys(source);
871
- var defineProperty = definePropertyModule$3.f;
872
+ var defineProperty = definePropertyModule$4.f;
872
873
  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
873
874
  for (var i = 0; i < keys.length; i++) {
874
875
  var key = keys[i];
@@ -878,7 +879,7 @@ var copyConstructorProperties$1 = function (target, source, exceptions) {
878
879
  }
879
880
  };
880
881
 
881
- var fails$a = fails$h;
882
+ var fails$d = fails$k;
882
883
  var isCallable$a = isCallable$j;
883
884
 
884
885
  var replacement = /#|\.prototype\./;
@@ -887,7 +888,7 @@ var isForced$2 = function (feature, detection) {
887
888
  var value = data[normalize$1(feature)];
888
889
  return value == POLYFILL ? true
889
890
  : value == NATIVE ? false
890
- : isCallable$a(detection) ? fails$a(detection)
891
+ : isCallable$a(detection) ? fails$d(detection)
891
892
  : !!detection;
892
893
  };
893
894
 
@@ -901,7 +902,7 @@ var POLYFILL = isForced$2.POLYFILL = 'P';
901
902
 
902
903
  var isForced_1 = isForced$2;
903
904
 
904
- var global$n = global$H;
905
+ var global$q = global$K;
905
906
  var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f;
906
907
  var createNonEnumerableProperty$3 = createNonEnumerableProperty$6;
907
908
  var redefine$5 = redefine$6.exports;
@@ -930,11 +931,11 @@ var _export = function (options, source) {
930
931
  var STATIC = options.stat;
931
932
  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
932
933
  if (GLOBAL) {
933
- target = global$n;
934
+ target = global$q;
934
935
  } else if (STATIC) {
935
- target = global$n[TARGET] || setGlobal(TARGET, {});
936
+ target = global$q[TARGET] || setGlobal(TARGET, {});
936
937
  } else {
937
- target = (global$n[TARGET] || {}).prototype;
938
+ target = (global$q[TARGET] || {}).prototype;
938
939
  }
939
940
  if (target) for (key in source) {
940
941
  sourceProperty = source[key];
@@ -957,9 +958,9 @@ var _export = function (options, source) {
957
958
  }
958
959
  };
959
960
 
960
- var global$m = global$H;
961
+ var global$p = global$K;
961
962
 
962
- var nativePromiseConstructor = global$m.Promise;
963
+ var nativePromiseConstructor = global$p.Promise;
963
964
 
964
965
  var redefine$4 = redefine$6.exports;
965
966
 
@@ -968,21 +969,21 @@ var redefineAll$1 = function (target, src, options) {
968
969
  return target;
969
970
  };
970
971
 
971
- var global$l = global$H;
972
+ var global$o = global$K;
972
973
  var isCallable$9 = isCallable$j;
973
974
 
974
- var String$3 = global$l.String;
975
- var TypeError$9 = global$l.TypeError;
975
+ var String$3 = global$o.String;
976
+ var TypeError$a = global$o.TypeError;
976
977
 
977
978
  var aPossiblePrototype$1 = function (argument) {
978
979
  if (typeof argument == 'object' || isCallable$9(argument)) return argument;
979
- 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');
980
981
  };
981
982
 
982
983
  /* eslint-disable no-proto -- safe */
983
984
 
984
- var uncurryThis$a = functionUncurryThis;
985
- var anObject$a = anObject$d;
985
+ var uncurryThis$d = functionUncurryThis;
986
+ var anObject$b = anObject$e;
986
987
  var aPossiblePrototype = aPossiblePrototype$1;
987
988
 
988
989
  // `Object.setPrototypeOf` method
@@ -995,12 +996,12 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
995
996
  var setter;
996
997
  try {
997
998
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
998
- setter = uncurryThis$a(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
999
+ setter = uncurryThis$d(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
999
1000
  setter(test, []);
1000
1001
  CORRECT_SETTER = test instanceof Array;
1001
1002
  } catch (error) { /* empty */ }
1002
1003
  return function setPrototypeOf(O, proto) {
1003
- anObject$a(O);
1004
+ anObject$b(O);
1004
1005
  aPossiblePrototype(proto);
1005
1006
  if (CORRECT_SETTER) setter(O, proto);
1006
1007
  else O.__proto__ = proto;
@@ -1022,7 +1023,7 @@ var setToStringTag$3 = function (target, TAG, STATIC) {
1022
1023
  };
1023
1024
 
1024
1025
  var getBuiltIn$3 = getBuiltIn$7;
1025
- var definePropertyModule$2 = objectDefineProperty;
1026
+ var definePropertyModule$3 = objectDefineProperty;
1026
1027
  var wellKnownSymbol$f = wellKnownSymbol$i;
1027
1028
  var DESCRIPTORS$3 = descriptors;
1028
1029
 
@@ -1030,7 +1031,7 @@ var SPECIES$3 = wellKnownSymbol$f('species');
1030
1031
 
1031
1032
  var setSpecies$1 = function (CONSTRUCTOR_NAME) {
1032
1033
  var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
1033
- var defineProperty = definePropertyModule$2.f;
1034
+ var defineProperty = definePropertyModule$3.f;
1034
1035
 
1035
1036
  if (DESCRIPTORS$3 && Constructor && !Constructor[SPECIES$3]) {
1036
1037
  defineProperty(Constructor, SPECIES$3, {
@@ -1040,25 +1041,25 @@ var setSpecies$1 = function (CONSTRUCTOR_NAME) {
1040
1041
  }
1041
1042
  };
1042
1043
 
1043
- var global$k = global$H;
1044
+ var global$n = global$K;
1044
1045
  var isPrototypeOf$1 = objectIsPrototypeOf;
1045
1046
 
1046
- var TypeError$8 = global$k.TypeError;
1047
+ var TypeError$9 = global$n.TypeError;
1047
1048
 
1048
1049
  var anInstance$1 = function (it, Prototype) {
1049
1050
  if (isPrototypeOf$1(Prototype, it)) return it;
1050
- throw TypeError$8('Incorrect invocation');
1051
+ throw TypeError$9('Incorrect invocation');
1051
1052
  };
1052
1053
 
1053
- var uncurryThis$9 = functionUncurryThis;
1054
- var aCallable$3 = aCallable$5;
1054
+ var uncurryThis$c = functionUncurryThis;
1055
+ var aCallable$4 = aCallable$6;
1055
1056
  var NATIVE_BIND$1 = functionBindNative;
1056
1057
 
1057
- var bind$4 = uncurryThis$9(uncurryThis$9.bind);
1058
+ var bind$4 = uncurryThis$c(uncurryThis$c.bind);
1058
1059
 
1059
1060
  // optional / simple context binding
1060
1061
  var functionBindContext = function (fn, that) {
1061
- aCallable$3(fn);
1062
+ aCallable$4(fn);
1062
1063
  return that === undefined ? fn : NATIVE_BIND$1 ? bind$4(fn, that) : function (/* ...args */) {
1063
1064
  return fn.apply(that, arguments);
1064
1065
  };
@@ -1069,12 +1070,12 @@ var iterators = {};
1069
1070
  var wellKnownSymbol$e = wellKnownSymbol$i;
1070
1071
  var Iterators$4 = iterators;
1071
1072
 
1072
- var ITERATOR$5 = wellKnownSymbol$e('iterator');
1073
+ var ITERATOR$6 = wellKnownSymbol$e('iterator');
1073
1074
  var ArrayPrototype$1 = Array.prototype;
1074
1075
 
1075
1076
  // check on default Array iterator
1076
1077
  var isArrayIteratorMethod$1 = function (it) {
1077
- 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);
1078
1079
  };
1079
1080
 
1080
1081
  var wellKnownSymbol$d = wellKnownSymbol$i;
@@ -1086,14 +1087,14 @@ test[TO_STRING_TAG$2] = 'z';
1086
1087
 
1087
1088
  var toStringTagSupport = String(test) === '[object z]';
1088
1089
 
1089
- var global$j = global$H;
1090
+ var global$m = global$K;
1090
1091
  var TO_STRING_TAG_SUPPORT = toStringTagSupport;
1091
1092
  var isCallable$8 = isCallable$j;
1092
1093
  var classofRaw = classofRaw$1;
1093
1094
  var wellKnownSymbol$c = wellKnownSymbol$i;
1094
1095
 
1095
1096
  var TO_STRING_TAG$1 = wellKnownSymbol$c('toStringTag');
1096
- var Object$2 = global$j.Object;
1097
+ var Object$2 = global$m.Object;
1097
1098
 
1098
1099
  // ES3 wrong here
1099
1100
  var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
@@ -1118,70 +1119,70 @@ var classof$6 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
1118
1119
  };
1119
1120
 
1120
1121
  var classof$5 = classof$6;
1121
- var getMethod$2 = getMethod$4;
1122
+ var getMethod$3 = getMethod$5;
1122
1123
  var Iterators$3 = iterators;
1123
1124
  var wellKnownSymbol$b = wellKnownSymbol$i;
1124
1125
 
1125
- var ITERATOR$4 = wellKnownSymbol$b('iterator');
1126
+ var ITERATOR$5 = wellKnownSymbol$b('iterator');
1126
1127
 
1127
1128
  var getIteratorMethod$2 = function (it) {
1128
- if (it != undefined) return getMethod$2(it, ITERATOR$4)
1129
- || getMethod$2(it, '@@iterator')
1129
+ if (it != undefined) return getMethod$3(it, ITERATOR$5)
1130
+ || getMethod$3(it, '@@iterator')
1130
1131
  || Iterators$3[classof$5(it)];
1131
1132
  };
1132
1133
 
1133
- var global$i = global$H;
1134
- var call$9 = functionCall;
1135
- var aCallable$2 = aCallable$5;
1136
- 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;
1137
1138
  var tryToString$2 = tryToString$4;
1138
1139
  var getIteratorMethod$1 = getIteratorMethod$2;
1139
1140
 
1140
- var TypeError$7 = global$i.TypeError;
1141
+ var TypeError$8 = global$l.TypeError;
1141
1142
 
1142
1143
  var getIterator$1 = function (argument, usingIterator) {
1143
1144
  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
1144
- if (aCallable$2(iteratorMethod)) return anObject$9(call$9(iteratorMethod, argument));
1145
- 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');
1146
1147
  };
1147
1148
 
1148
- var call$8 = functionCall;
1149
- var anObject$8 = anObject$d;
1150
- var getMethod$1 = getMethod$4;
1149
+ var call$9 = functionCall;
1150
+ var anObject$9 = anObject$e;
1151
+ var getMethod$2 = getMethod$5;
1151
1152
 
1152
1153
  var iteratorClose$1 = function (iterator, kind, value) {
1153
1154
  var innerResult, innerError;
1154
- anObject$8(iterator);
1155
+ anObject$9(iterator);
1155
1156
  try {
1156
- innerResult = getMethod$1(iterator, 'return');
1157
+ innerResult = getMethod$2(iterator, 'return');
1157
1158
  if (!innerResult) {
1158
1159
  if (kind === 'throw') throw value;
1159
1160
  return value;
1160
1161
  }
1161
- innerResult = call$8(innerResult, iterator);
1162
+ innerResult = call$9(innerResult, iterator);
1162
1163
  } catch (error) {
1163
1164
  innerError = true;
1164
1165
  innerResult = error;
1165
1166
  }
1166
1167
  if (kind === 'throw') throw value;
1167
1168
  if (innerError) throw innerResult;
1168
- anObject$8(innerResult);
1169
+ anObject$9(innerResult);
1169
1170
  return value;
1170
1171
  };
1171
1172
 
1172
- var global$h = global$H;
1173
+ var global$k = global$K;
1173
1174
  var bind$3 = functionBindContext;
1174
- var call$7 = functionCall;
1175
- var anObject$7 = anObject$d;
1175
+ var call$8 = functionCall;
1176
+ var anObject$8 = anObject$e;
1176
1177
  var tryToString$1 = tryToString$4;
1177
1178
  var isArrayIteratorMethod = isArrayIteratorMethod$1;
1178
- var lengthOfArrayLike = lengthOfArrayLike$2;
1179
+ var lengthOfArrayLike$2 = lengthOfArrayLike$4;
1179
1180
  var isPrototypeOf = objectIsPrototypeOf;
1180
1181
  var getIterator = getIterator$1;
1181
1182
  var getIteratorMethod = getIteratorMethod$2;
1182
1183
  var iteratorClose = iteratorClose$1;
1183
1184
 
1184
- var TypeError$6 = global$h.TypeError;
1185
+ var TypeError$7 = global$k.TypeError;
1185
1186
 
1186
1187
  var Result = function (stopped, result) {
1187
1188
  this.stopped = stopped;
@@ -1205,7 +1206,7 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1205
1206
 
1206
1207
  var callFn = function (value) {
1207
1208
  if (AS_ENTRIES) {
1208
- anObject$7(value);
1209
+ anObject$8(value);
1209
1210
  return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
1210
1211
  } return INTERRUPTED ? fn(value, stop) : fn(value);
1211
1212
  };
@@ -1214,10 +1215,10 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1214
1215
  iterator = iterable;
1215
1216
  } else {
1216
1217
  iterFn = getIteratorMethod(iterable);
1217
- if (!iterFn) throw TypeError$6(tryToString$1(iterable) + ' is not iterable');
1218
+ if (!iterFn) throw TypeError$7(tryToString$1(iterable) + ' is not iterable');
1218
1219
  // optimisation for array iterators
1219
1220
  if (isArrayIteratorMethod(iterFn)) {
1220
- for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
1221
+ for (index = 0, length = lengthOfArrayLike$2(iterable); length > index; index++) {
1221
1222
  result = callFn(iterable[index]);
1222
1223
  if (result && isPrototypeOf(ResultPrototype, result)) return result;
1223
1224
  } return new Result(false);
@@ -1226,7 +1227,7 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1226
1227
  }
1227
1228
 
1228
1229
  next = iterator.next;
1229
- while (!(step = call$7(next, iterator)).done) {
1230
+ while (!(step = call$8(next, iterator)).done) {
1230
1231
  try {
1231
1232
  result = callFn(step.value);
1232
1233
  } catch (error) {
@@ -1238,7 +1239,7 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1238
1239
 
1239
1240
  var wellKnownSymbol$a = wellKnownSymbol$i;
1240
1241
 
1241
- var ITERATOR$3 = wellKnownSymbol$a('iterator');
1242
+ var ITERATOR$4 = wellKnownSymbol$a('iterator');
1242
1243
  var SAFE_CLOSING = false;
1243
1244
 
1244
1245
  try {
@@ -1251,7 +1252,7 @@ try {
1251
1252
  SAFE_CLOSING = true;
1252
1253
  }
1253
1254
  };
1254
- iteratorWithReturn[ITERATOR$3] = function () {
1255
+ iteratorWithReturn[ITERATOR$4] = function () {
1255
1256
  return this;
1256
1257
  };
1257
1258
  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
@@ -1263,7 +1264,7 @@ var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
1263
1264
  var ITERATION_SUPPORT = false;
1264
1265
  try {
1265
1266
  var object = {};
1266
- object[ITERATOR$3] = function () {
1267
+ object[ITERATOR$4] = function () {
1267
1268
  return {
1268
1269
  next: function () {
1269
1270
  return { done: ITERATION_SUPPORT = true };
@@ -1275,8 +1276,8 @@ var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
1275
1276
  return ITERATION_SUPPORT;
1276
1277
  };
1277
1278
 
1278
- var uncurryThis$8 = functionUncurryThis;
1279
- var fails$9 = fails$h;
1279
+ var uncurryThis$b = functionUncurryThis;
1280
+ var fails$c = fails$k;
1280
1281
  var isCallable$7 = isCallable$j;
1281
1282
  var classof$4 = classof$6;
1282
1283
  var getBuiltIn$2 = getBuiltIn$7;
@@ -1286,7 +1287,7 @@ var noop = function () { /* empty */ };
1286
1287
  var empty = [];
1287
1288
  var construct = getBuiltIn$2('Reflect', 'construct');
1288
1289
  var constructorRegExp = /^\s*(?:class|function)\b/;
1289
- var exec$1 = uncurryThis$8(constructorRegExp.exec);
1290
+ var exec$3 = uncurryThis$b(constructorRegExp.exec);
1290
1291
  var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
1291
1292
 
1292
1293
  var isConstructorModern = function isConstructor(argument) {
@@ -1310,7 +1311,7 @@ var isConstructorLegacy = function isConstructor(argument) {
1310
1311
  // we can't check .prototype since constructors produced by .bind haven't it
1311
1312
  // `Function#toString` throws on some built-it function in some legacy engines
1312
1313
  // (for example, `DOMQuad` and similar in FF41-)
1313
- return INCORRECT_TO_STRING || !!exec$1(constructorRegExp, inspectSource$1(argument));
1314
+ return INCORRECT_TO_STRING || !!exec$3(constructorRegExp, inspectSource$1(argument));
1314
1315
  } catch (error) {
1315
1316
  return true;
1316
1317
  }
@@ -1320,7 +1321,7 @@ isConstructorLegacy.sham = true;
1320
1321
 
1321
1322
  // `IsConstructor` abstract operation
1322
1323
  // https://tc39.es/ecma262/#sec-isconstructor
1323
- var isConstructor$1 = !construct || fails$9(function () {
1324
+ var isConstructor$1 = !construct || fails$c(function () {
1324
1325
  var called;
1325
1326
  return isConstructorModern(isConstructorModern.call)
1326
1327
  || !isConstructorModern(Object)
@@ -1328,19 +1329,19 @@ var isConstructor$1 = !construct || fails$9(function () {
1328
1329
  || called;
1329
1330
  }) ? isConstructorLegacy : isConstructorModern;
1330
1331
 
1331
- var global$g = global$H;
1332
+ var global$j = global$K;
1332
1333
  var isConstructor = isConstructor$1;
1333
1334
  var tryToString = tryToString$4;
1334
1335
 
1335
- var TypeError$5 = global$g.TypeError;
1336
+ var TypeError$6 = global$j.TypeError;
1336
1337
 
1337
1338
  // `Assert: IsConstructor(argument) is true`
1338
1339
  var aConstructor$1 = function (argument) {
1339
1340
  if (isConstructor(argument)) return argument;
1340
- throw TypeError$5(tryToString(argument) + ' is not a constructor');
1341
+ throw TypeError$6(tryToString(argument) + ' is not a constructor');
1341
1342
  };
1342
1343
 
1343
- var anObject$6 = anObject$d;
1344
+ var anObject$7 = anObject$e;
1344
1345
  var aConstructor = aConstructor$1;
1345
1346
  var wellKnownSymbol$9 = wellKnownSymbol$i;
1346
1347
 
@@ -1348,37 +1349,37 @@ var SPECIES$2 = wellKnownSymbol$9('species');
1348
1349
 
1349
1350
  // `SpeciesConstructor` abstract operation
1350
1351
  // https://tc39.es/ecma262/#sec-speciesconstructor
1351
- var speciesConstructor$1 = function (O, defaultConstructor) {
1352
- var C = anObject$6(O).constructor;
1352
+ var speciesConstructor$2 = function (O, defaultConstructor) {
1353
+ var C = anObject$7(O).constructor;
1353
1354
  var S;
1354
- 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);
1355
1356
  };
1356
1357
 
1357
1358
  var NATIVE_BIND = functionBindNative;
1358
1359
 
1359
1360
  var FunctionPrototype = Function.prototype;
1360
- var apply$2 = FunctionPrototype.apply;
1361
- var call$6 = FunctionPrototype.call;
1361
+ var apply$3 = FunctionPrototype.apply;
1362
+ var call$7 = FunctionPrototype.call;
1362
1363
 
1363
1364
  // eslint-disable-next-line es/no-reflect -- safe
1364
- var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$6.bind(apply$2) : function () {
1365
- 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);
1366
1367
  });
1367
1368
 
1368
1369
  var getBuiltIn$1 = getBuiltIn$7;
1369
1370
 
1370
1371
  var html$2 = getBuiltIn$1('document', 'documentElement');
1371
1372
 
1372
- var uncurryThis$7 = functionUncurryThis;
1373
+ var uncurryThis$a = functionUncurryThis;
1373
1374
 
1374
- var arraySlice$1 = uncurryThis$7([].slice);
1375
+ var arraySlice$2 = uncurryThis$a([].slice);
1375
1376
 
1376
- var global$f = global$H;
1377
+ var global$i = global$K;
1377
1378
 
1378
- var TypeError$4 = global$f.TypeError;
1379
+ var TypeError$5 = global$i.TypeError;
1379
1380
 
1380
1381
  var validateArgumentsLength$1 = function (passed, required) {
1381
- if (passed < required) throw TypeError$4('Not enough arguments');
1382
+ if (passed < required) throw TypeError$5('Not enough arguments');
1382
1383
  return passed;
1383
1384
  };
1384
1385
 
@@ -1387,30 +1388,30 @@ var userAgent$2 = engineUserAgent;
1387
1388
  var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
1388
1389
 
1389
1390
  var classof$3 = classofRaw$1;
1390
- var global$e = global$H;
1391
+ var global$h = global$K;
1391
1392
 
1392
- var engineIsNode = classof$3(global$e.process) == 'process';
1393
+ var engineIsNode = classof$3(global$h.process) == 'process';
1393
1394
 
1394
- var global$d = global$H;
1395
- var apply$1 = functionApply;
1395
+ var global$g = global$K;
1396
+ var apply$2 = functionApply;
1396
1397
  var bind$2 = functionBindContext;
1397
1398
  var isCallable$6 = isCallable$j;
1398
1399
  var hasOwn$1 = hasOwnProperty_1;
1399
- var fails$8 = fails$h;
1400
+ var fails$b = fails$k;
1400
1401
  var html$1 = html$2;
1401
- var arraySlice = arraySlice$1;
1402
+ var arraySlice$1 = arraySlice$2;
1402
1403
  var createElement = documentCreateElement$2;
1403
1404
  var validateArgumentsLength = validateArgumentsLength$1;
1404
1405
  var IS_IOS$1 = engineIsIos;
1405
- var IS_NODE$2 = engineIsNode;
1406
-
1407
- var set$1 = global$d.setImmediate;
1408
- var clear = global$d.clearImmediate;
1409
- var process$3 = global$d.process;
1410
- var Dispatch = global$d.Dispatch;
1411
- var Function$1 = global$d.Function;
1412
- var MessageChannel = global$d.MessageChannel;
1413
- 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;
1414
1415
  var counter = 0;
1415
1416
  var queue$1 = {};
1416
1417
  var ONREADYSTATECHANGE = 'onreadystatechange';
@@ -1418,7 +1419,7 @@ var location, defer, channel, port;
1418
1419
 
1419
1420
  try {
1420
1421
  // Deno throws a ReferenceError on `location` access without `--location` flag
1421
- location = global$d.location;
1422
+ location = global$g.location;
1422
1423
  } catch (error) { /* empty */ }
1423
1424
 
1424
1425
  var run = function (id) {
@@ -1441,7 +1442,7 @@ var listener = function (event) {
1441
1442
 
1442
1443
  var post = function (id) {
1443
1444
  // old engines have not location.origin
1444
- global$d.postMessage(String$2(id), location.protocol + '//' + location.host);
1445
+ global$g.postMessage(String$2(id), location.protocol + '//' + location.host);
1445
1446
  };
1446
1447
 
1447
1448
  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
@@ -1449,9 +1450,9 @@ if (!set$1 || !clear) {
1449
1450
  set$1 = function setImmediate(handler) {
1450
1451
  validateArgumentsLength(arguments.length, 1);
1451
1452
  var fn = isCallable$6(handler) ? handler : Function$1(handler);
1452
- var args = arraySlice(arguments, 1);
1453
+ var args = arraySlice$1(arguments, 1);
1453
1454
  queue$1[++counter] = function () {
1454
- apply$1(fn, undefined, args);
1455
+ apply$2(fn, undefined, args);
1455
1456
  };
1456
1457
  defer(counter);
1457
1458
  return counter;
@@ -1460,9 +1461,9 @@ if (!set$1 || !clear) {
1460
1461
  delete queue$1[id];
1461
1462
  };
1462
1463
  // Node.js 0.8-
1463
- if (IS_NODE$2) {
1464
+ if (IS_NODE$3) {
1464
1465
  defer = function (id) {
1465
- process$3.nextTick(runner(id));
1466
+ process$2.nextTick(runner(id));
1466
1467
  };
1467
1468
  // Sphere (JS game engine) Dispatch API
1468
1469
  } else if (Dispatch && Dispatch.now) {
@@ -1479,14 +1480,14 @@ if (!set$1 || !clear) {
1479
1480
  // Browsers with postMessage, skip WebWorkers
1480
1481
  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
1481
1482
  } else if (
1482
- global$d.addEventListener &&
1483
- isCallable$6(global$d.postMessage) &&
1484
- !global$d.importScripts &&
1483
+ global$g.addEventListener &&
1484
+ isCallable$6(global$g.postMessage) &&
1485
+ !global$g.importScripts &&
1485
1486
  location && location.protocol !== 'file:' &&
1486
- !fails$8(post)
1487
+ !fails$b(post)
1487
1488
  ) {
1488
1489
  defer = post;
1489
- global$d.addEventListener('message', listener, false);
1490
+ global$g.addEventListener('message', listener, false);
1490
1491
  // IE8-
1491
1492
  } else if (ONREADYSTATECHANGE in createElement('script')) {
1492
1493
  defer = function (id) {
@@ -1509,29 +1510,29 @@ var task$1 = {
1509
1510
  };
1510
1511
 
1511
1512
  var userAgent$1 = engineUserAgent;
1512
- var global$c = global$H;
1513
+ var global$f = global$K;
1513
1514
 
1514
- 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;
1515
1516
 
1516
1517
  var userAgent = engineUserAgent;
1517
1518
 
1518
1519
  var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
1519
1520
 
1520
- var global$b = global$H;
1521
+ var global$e = global$K;
1521
1522
  var bind$1 = functionBindContext;
1522
1523
  var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
1523
1524
  var macrotask = task$1.set;
1524
1525
  var IS_IOS = engineIsIos;
1525
1526
  var IS_IOS_PEBBLE = engineIsIosPebble;
1526
1527
  var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
1527
- var IS_NODE$1 = engineIsNode;
1528
+ var IS_NODE$2 = engineIsNode;
1528
1529
 
1529
- var MutationObserver = global$b.MutationObserver || global$b.WebKitMutationObserver;
1530
- var document$2 = global$b.document;
1531
- var process$2 = global$b.process;
1532
- 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;
1533
1534
  // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
1534
- var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$b, 'queueMicrotask');
1535
+ var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$e, 'queueMicrotask');
1535
1536
  var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
1536
1537
 
1537
1538
  var flush, head, last, notify$1, toggle, node, promise, then;
@@ -1540,7 +1541,7 @@ var flush, head, last, notify$1, toggle, node, promise, then;
1540
1541
  if (!queueMicrotask) {
1541
1542
  flush = function () {
1542
1543
  var parent, fn;
1543
- if (IS_NODE$1 && (parent = process$2.domain)) parent.exit();
1544
+ if (IS_NODE$2 && (parent = process$1.domain)) parent.exit();
1544
1545
  while (head) {
1545
1546
  fn = head.fn;
1546
1547
  head = head.next;
@@ -1557,7 +1558,7 @@ if (!queueMicrotask) {
1557
1558
 
1558
1559
  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
1559
1560
  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
1560
- 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) {
1561
1562
  toggle = true;
1562
1563
  node = document$2.createTextNode('');
1563
1564
  new MutationObserver(flush).observe(node, { characterData: true });
@@ -1575,9 +1576,9 @@ if (!queueMicrotask) {
1575
1576
  then(flush);
1576
1577
  };
1577
1578
  // Node.js without promises
1578
- } else if (IS_NODE$1) {
1579
+ } else if (IS_NODE$2) {
1579
1580
  notify$1 = function () {
1580
- process$2.nextTick(flush);
1581
+ process$1.nextTick(flush);
1581
1582
  };
1582
1583
  // for other environments - macrotask based on:
1583
1584
  // - setImmediate
@@ -1587,7 +1588,7 @@ if (!queueMicrotask) {
1587
1588
  // - setTimeout
1588
1589
  } else {
1589
1590
  // strange IE + webpack dev server bug - use .bind(global)
1590
- macrotask = bind$1(macrotask, global$b);
1591
+ macrotask = bind$1(macrotask, global$e);
1591
1592
  notify$1 = function () {
1592
1593
  macrotask(flush);
1593
1594
  };
@@ -1605,7 +1606,7 @@ var microtask$1 = queueMicrotask || function (fn) {
1605
1606
 
1606
1607
  var newPromiseCapability$2 = {};
1607
1608
 
1608
- var aCallable$1 = aCallable$5;
1609
+ var aCallable$2 = aCallable$6;
1609
1610
 
1610
1611
  var PromiseCapability = function (C) {
1611
1612
  var resolve, reject;
@@ -1614,8 +1615,8 @@ var PromiseCapability = function (C) {
1614
1615
  resolve = $$resolve;
1615
1616
  reject = $$reject;
1616
1617
  });
1617
- this.resolve = aCallable$1(resolve);
1618
- this.reject = aCallable$1(reject);
1618
+ this.resolve = aCallable$2(resolve);
1619
+ this.reject = aCallable$2(reject);
1619
1620
  };
1620
1621
 
1621
1622
  // `NewPromiseCapability` abstract operation
@@ -1624,12 +1625,12 @@ newPromiseCapability$2.f = function (C) {
1624
1625
  return new PromiseCapability(C);
1625
1626
  };
1626
1627
 
1627
- var anObject$5 = anObject$d;
1628
+ var anObject$6 = anObject$e;
1628
1629
  var isObject$2 = isObject$8;
1629
1630
  var newPromiseCapability$1 = newPromiseCapability$2;
1630
1631
 
1631
1632
  var promiseResolve$1 = function (C, x) {
1632
- anObject$5(C);
1633
+ anObject$6(C);
1633
1634
  if (isObject$2(x) && x.constructor === C) return x;
1634
1635
  var promiseCapability = newPromiseCapability$1.f(C);
1635
1636
  var resolve = promiseCapability.resolve;
@@ -1637,10 +1638,10 @@ var promiseResolve$1 = function (C, x) {
1637
1638
  return promiseCapability.promise;
1638
1639
  };
1639
1640
 
1640
- var global$a = global$H;
1641
+ var global$d = global$K;
1641
1642
 
1642
1643
  var hostReportErrors$1 = function (a, b) {
1643
- var console = global$a.console;
1644
+ var console = global$d.console;
1644
1645
  if (console && console.error) {
1645
1646
  arguments.length == 1 ? console.error(a) : console.error(a, b);
1646
1647
  }
@@ -1680,24 +1681,24 @@ var queue = Queue$1;
1680
1681
 
1681
1682
  var engineIsBrowser = typeof window == 'object';
1682
1683
 
1683
- var $$4 = _export;
1684
- var global$9 = global$H;
1684
+ var $$6 = _export;
1685
+ var global$c = global$K;
1685
1686
  var getBuiltIn = getBuiltIn$7;
1686
- var call$5 = functionCall;
1687
+ var call$6 = functionCall;
1687
1688
  var NativePromise = nativePromiseConstructor;
1688
1689
  var redefine$3 = redefine$6.exports;
1689
1690
  var redefineAll = redefineAll$1;
1690
1691
  var setPrototypeOf$1 = objectSetPrototypeOf;
1691
1692
  var setToStringTag$2 = setToStringTag$3;
1692
1693
  var setSpecies = setSpecies$1;
1693
- var aCallable = aCallable$5;
1694
+ var aCallable$1 = aCallable$6;
1694
1695
  var isCallable$5 = isCallable$j;
1695
1696
  var isObject$1 = isObject$8;
1696
1697
  var anInstance = anInstance$1;
1697
1698
  var inspectSource = inspectSource$4;
1698
1699
  var iterate = iterate$1;
1699
1700
  var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
1700
- var speciesConstructor = speciesConstructor$1;
1701
+ var speciesConstructor$1 = speciesConstructor$2;
1701
1702
  var task = task$1.set;
1702
1703
  var microtask = microtask$1;
1703
1704
  var promiseResolve = promiseResolve$1;
@@ -1709,7 +1710,7 @@ var InternalStateModule$1 = internalState;
1709
1710
  var isForced = isForced_1;
1710
1711
  var wellKnownSymbol$8 = wellKnownSymbol$i;
1711
1712
  var IS_BROWSER = engineIsBrowser;
1712
- var IS_NODE = engineIsNode;
1713
+ var IS_NODE$1 = engineIsNode;
1713
1714
  var V8_VERSION = engineV8Version;
1714
1715
 
1715
1716
  var SPECIES$1 = wellKnownSymbol$8('species');
@@ -1721,14 +1722,14 @@ var getInternalPromiseState = InternalStateModule$1.getterFor(PROMISE);
1721
1722
  var NativePromisePrototype = NativePromise && NativePromise.prototype;
1722
1723
  var PromiseConstructor = NativePromise;
1723
1724
  var PromisePrototype = NativePromisePrototype;
1724
- var TypeError$3 = global$9.TypeError;
1725
- var document$1 = global$9.document;
1726
- var process$1 = global$9.process;
1725
+ var TypeError$4 = global$c.TypeError;
1726
+ var document$1 = global$c.document;
1727
+ var process = global$c.process;
1727
1728
  var newPromiseCapability = newPromiseCapabilityModule.f;
1728
1729
  var newGenericPromiseCapability = newPromiseCapability;
1729
1730
 
1730
- var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$9.dispatchEvent);
1731
- 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);
1732
1733
  var UNHANDLED_REJECTION = 'unhandledrejection';
1733
1734
  var REJECTION_HANDLED = 'rejectionhandled';
1734
1735
  var PENDING = 0;
@@ -1740,7 +1741,7 @@ var SUBCLASSING = false;
1740
1741
 
1741
1742
  var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
1742
1743
 
1743
- var FORCED = isForced(PROMISE, function () {
1744
+ var FORCED$1 = isForced(PROMISE, function () {
1744
1745
  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);
1745
1746
  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);
1746
1747
  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
@@ -1764,7 +1765,7 @@ var FORCED = isForced(PROMISE, function () {
1764
1765
  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;
1765
1766
  });
1766
1767
 
1767
- var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
1768
+ var INCORRECT_ITERATION = FORCED$1 || !checkCorrectnessOfIteration(function (iterable) {
1768
1769
  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
1769
1770
  });
1770
1771
 
@@ -1798,9 +1799,9 @@ var callReaction = function (reaction, state) {
1798
1799
  }
1799
1800
  }
1800
1801
  if (result === reaction.promise) {
1801
- reject(TypeError$3('Promise-chain cycle'));
1802
+ reject(TypeError$4('Promise-chain cycle'));
1802
1803
  } else if (then = isThenable(result)) {
1803
- call$5(then, result, resolve, reject);
1804
+ call$6(then, result, resolve, reject);
1804
1805
  } else resolve(result);
1805
1806
  } else reject(value);
1806
1807
  } catch (error) {
@@ -1830,26 +1831,26 @@ var dispatchEvent = function (name, promise, reason) {
1830
1831
  event.promise = promise;
1831
1832
  event.reason = reason;
1832
1833
  event.initEvent(name, false, true);
1833
- global$9.dispatchEvent(event);
1834
+ global$c.dispatchEvent(event);
1834
1835
  } else event = { promise: promise, reason: reason };
1835
- if (!NATIVE_REJECTION_EVENT && (handler = global$9['on' + name])) handler(event);
1836
+ if (!NATIVE_REJECTION_EVENT && (handler = global$c['on' + name])) handler(event);
1836
1837
  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
1837
1838
  };
1838
1839
 
1839
1840
  var onUnhandled = function (state) {
1840
- call$5(task, global$9, function () {
1841
+ call$6(task, global$c, function () {
1841
1842
  var promise = state.facade;
1842
1843
  var value = state.value;
1843
1844
  var IS_UNHANDLED = isUnhandled(state);
1844
1845
  var result;
1845
1846
  if (IS_UNHANDLED) {
1846
1847
  result = perform(function () {
1847
- if (IS_NODE) {
1848
- process$1.emit('unhandledRejection', value, promise);
1848
+ if (IS_NODE$1) {
1849
+ process.emit('unhandledRejection', value, promise);
1849
1850
  } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
1850
1851
  });
1851
1852
  // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
1852
- state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
1853
+ state.rejection = IS_NODE$1 || isUnhandled(state) ? UNHANDLED : HANDLED;
1853
1854
  if (result.error) throw result.value;
1854
1855
  }
1855
1856
  });
@@ -1860,10 +1861,10 @@ var isUnhandled = function (state) {
1860
1861
  };
1861
1862
 
1862
1863
  var onHandleUnhandled = function (state) {
1863
- call$5(task, global$9, function () {
1864
+ call$6(task, global$c, function () {
1864
1865
  var promise = state.facade;
1865
- if (IS_NODE) {
1866
- process$1.emit('rejectionHandled', promise);
1866
+ if (IS_NODE$1) {
1867
+ process.emit('rejectionHandled', promise);
1867
1868
  } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
1868
1869
  });
1869
1870
  };
@@ -1888,13 +1889,13 @@ var internalResolve = function (state, value, unwrap) {
1888
1889
  state.done = true;
1889
1890
  if (unwrap) state = unwrap;
1890
1891
  try {
1891
- 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");
1892
1893
  var then = isThenable(value);
1893
1894
  if (then) {
1894
1895
  microtask(function () {
1895
1896
  var wrapper = { done: false };
1896
1897
  try {
1897
- call$5(then, value,
1898
+ call$6(then, value,
1898
1899
  bind(internalResolve, wrapper, state),
1899
1900
  bind(internalReject, wrapper, state)
1900
1901
  );
@@ -1913,12 +1914,12 @@ var internalResolve = function (state, value, unwrap) {
1913
1914
  };
1914
1915
 
1915
1916
  // constructor polyfill
1916
- if (FORCED) {
1917
+ if (FORCED$1) {
1917
1918
  // 25.4.3.1 Promise(executor)
1918
1919
  PromiseConstructor = function Promise(executor) {
1919
1920
  anInstance(this, PromisePrototype);
1920
- aCallable(executor);
1921
- call$5(Internal, this);
1921
+ aCallable$1(executor);
1922
+ call$6(Internal, this);
1922
1923
  var state = getInternalState$2(this);
1923
1924
  try {
1924
1925
  executor(bind(internalResolve, state), bind(internalReject, state));
@@ -1946,11 +1947,11 @@ if (FORCED) {
1946
1947
  // eslint-disable-next-line unicorn/no-thenable -- safe
1947
1948
  then: function then(onFulfilled, onRejected) {
1948
1949
  var state = getInternalPromiseState(this);
1949
- var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
1950
+ var reaction = newPromiseCapability(speciesConstructor$1(this, PromiseConstructor));
1950
1951
  state.parent = true;
1951
1952
  reaction.ok = isCallable$5(onFulfilled) ? onFulfilled : true;
1952
1953
  reaction.fail = isCallable$5(onRejected) && onRejected;
1953
- reaction.domain = IS_NODE ? process$1.domain : undefined;
1954
+ reaction.domain = IS_NODE$1 ? process.domain : undefined;
1954
1955
  if (state.state == PENDING) state.reactions.add(reaction);
1955
1956
  else microtask(function () {
1956
1957
  callReaction(reaction, state);
@@ -1984,7 +1985,7 @@ if (FORCED) {
1984
1985
  redefine$3(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
1985
1986
  var that = this;
1986
1987
  return new PromiseConstructor(function (resolve, reject) {
1987
- call$5(nativeThen, that, resolve, reject);
1988
+ call$6(nativeThen, that, resolve, reject);
1988
1989
  }).then(onFulfilled, onRejected);
1989
1990
  // https://github.com/zloirock/core-js/issues/640
1990
1991
  }, { unsafe: true });
@@ -2005,7 +2006,7 @@ if (FORCED) {
2005
2006
  }
2006
2007
  }
2007
2008
 
2008
- $$4({ global: true, wrap: true, forced: FORCED }, {
2009
+ $$6({ global: true, wrap: true, forced: FORCED$1 }, {
2009
2010
  Promise: PromiseConstructor
2010
2011
  });
2011
2012
 
@@ -2015,17 +2016,17 @@ setSpecies(PROMISE);
2015
2016
  PromiseWrapper = getBuiltIn(PROMISE);
2016
2017
 
2017
2018
  // statics
2018
- $$4({ target: PROMISE, stat: true, forced: FORCED }, {
2019
+ $$6({ target: PROMISE, stat: true, forced: FORCED$1 }, {
2019
2020
  // `Promise.reject` method
2020
2021
  // https://tc39.es/ecma262/#sec-promise.reject
2021
2022
  reject: function reject(r) {
2022
2023
  var capability = newPromiseCapability(this);
2023
- call$5(capability.reject, undefined, r);
2024
+ call$6(capability.reject, undefined, r);
2024
2025
  return capability.promise;
2025
2026
  }
2026
2027
  });
2027
2028
 
2028
- $$4({ target: PROMISE, stat: true, forced: FORCED }, {
2029
+ $$6({ target: PROMISE, stat: true, forced: FORCED$1 }, {
2029
2030
  // `Promise.resolve` method
2030
2031
  // https://tc39.es/ecma262/#sec-promise.resolve
2031
2032
  resolve: function resolve(x) {
@@ -2033,7 +2034,7 @@ $$4({ target: PROMISE, stat: true, forced: FORCED }, {
2033
2034
  }
2034
2035
  });
2035
2036
 
2036
- $$4({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2037
+ $$6({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2037
2038
  // `Promise.all` method
2038
2039
  // https://tc39.es/ecma262/#sec-promise.all
2039
2040
  all: function all(iterable) {
@@ -2042,7 +2043,7 @@ $$4({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2042
2043
  var resolve = capability.resolve;
2043
2044
  var reject = capability.reject;
2044
2045
  var result = perform(function () {
2045
- var $promiseResolve = aCallable(C.resolve);
2046
+ var $promiseResolve = aCallable$1(C.resolve);
2046
2047
  var values = [];
2047
2048
  var counter = 0;
2048
2049
  var remaining = 1;
@@ -2050,7 +2051,7 @@ $$4({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2050
2051
  var index = counter++;
2051
2052
  var alreadyCalled = false;
2052
2053
  remaining++;
2053
- call$5($promiseResolve, C, promise).then(function (value) {
2054
+ call$6($promiseResolve, C, promise).then(function (value) {
2054
2055
  if (alreadyCalled) return;
2055
2056
  alreadyCalled = true;
2056
2057
  values[index] = value;
@@ -2069,9 +2070,9 @@ $$4({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2069
2070
  var capability = newPromiseCapability(C);
2070
2071
  var reject = capability.reject;
2071
2072
  var result = perform(function () {
2072
- var $promiseResolve = aCallable(C.resolve);
2073
+ var $promiseResolve = aCallable$1(C.resolve);
2073
2074
  iterate(iterable, function (promise) {
2074
- call$5($promiseResolve, C, promise).then(capability.resolve, reject);
2075
+ call$6($promiseResolve, C, promise).then(capability.resolve, reject);
2075
2076
  });
2076
2077
  });
2077
2078
  if (result.error) reject(result.value);
@@ -2090,24 +2091,24 @@ var objectKeys$2 = Object.keys || function keys(O) {
2090
2091
  };
2091
2092
 
2092
2093
  var DESCRIPTORS$2 = descriptors;
2093
- var uncurryThis$6 = functionUncurryThis;
2094
- var call$4 = functionCall;
2095
- var fails$7 = fails$h;
2094
+ var uncurryThis$9 = functionUncurryThis;
2095
+ var call$5 = functionCall;
2096
+ var fails$a = fails$k;
2096
2097
  var objectKeys$1 = objectKeys$2;
2097
2098
  var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
2098
2099
  var propertyIsEnumerableModule = objectPropertyIsEnumerable;
2099
- var toObject$2 = toObject$4;
2100
- var IndexedObject = indexedObject;
2100
+ var toObject$3 = toObject$5;
2101
+ var IndexedObject$1 = indexedObject;
2101
2102
 
2102
2103
  // eslint-disable-next-line es/no-object-assign -- safe
2103
2104
  var $assign = Object.assign;
2104
2105
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
2105
2106
  var defineProperty$1 = Object.defineProperty;
2106
- var concat$1 = uncurryThis$6([].concat);
2107
+ var concat$1 = uncurryThis$9([].concat);
2107
2108
 
2108
2109
  // `Object.assign` method
2109
2110
  // https://tc39.es/ecma262/#sec-object.assign
2110
- var objectAssign = !$assign || fails$7(function () {
2111
+ var objectAssign = !$assign || fails$a(function () {
2111
2112
  // should have correct order of operations (Edge bug)
2112
2113
  if (DESCRIPTORS$2 && $assign({ b: 1 }, $assign(defineProperty$1({}, 'a', {
2113
2114
  enumerable: true,
@@ -2128,31 +2129,31 @@ var objectAssign = !$assign || fails$7(function () {
2128
2129
  alphabet.split('').forEach(function (chr) { B[chr] = chr; });
2129
2130
  return $assign({}, A)[symbol] != 7 || objectKeys$1($assign({}, B)).join('') != alphabet;
2130
2131
  }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
2131
- var T = toObject$2(target);
2132
+ var T = toObject$3(target);
2132
2133
  var argumentsLength = arguments.length;
2133
2134
  var index = 1;
2134
2135
  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
2135
2136
  var propertyIsEnumerable = propertyIsEnumerableModule.f;
2136
2137
  while (argumentsLength > index) {
2137
- var S = IndexedObject(arguments[index++]);
2138
+ var S = IndexedObject$1(arguments[index++]);
2138
2139
  var keys = getOwnPropertySymbols ? concat$1(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S);
2139
2140
  var length = keys.length;
2140
2141
  var j = 0;
2141
2142
  var key;
2142
2143
  while (length > j) {
2143
2144
  key = keys[j++];
2144
- 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];
2145
2146
  }
2146
2147
  } return T;
2147
2148
  } : $assign;
2148
2149
 
2149
- var $$3 = _export;
2150
+ var $$5 = _export;
2150
2151
  var assign = objectAssign;
2151
2152
 
2152
2153
  // `Object.assign` method
2153
2154
  // https://tc39.es/ecma262/#sec-object.assign
2154
2155
  // eslint-disable-next-line es/no-object-assign -- required for testing
2155
- $$3({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
2156
+ $$5({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
2156
2157
  assign: assign
2157
2158
  });
2158
2159
 
@@ -2201,6 +2202,11 @@ const set = (cache, {
2201
2202
  instance.storage.setItem(NINETAILED_CACHE_KEY, cache);
2202
2203
  return cache;
2203
2204
  };
2205
+ const remove = ({
2206
+ instance
2207
+ }) => {
2208
+ instance.storage.removeItem(NINETAILED_CACHE_KEY);
2209
+ };
2204
2210
  const reset = ({
2205
2211
  instance
2206
2212
  }) => {
@@ -2209,6 +2215,15 @@ const reset = ({
2209
2215
  });
2210
2216
  };
2211
2217
 
2218
+ var index = /*#__PURE__*/Object.freeze({
2219
+ __proto__: null,
2220
+ initialize: initialize,
2221
+ get: get,
2222
+ set: set,
2223
+ remove: remove,
2224
+ reset: reset
2225
+ });
2226
+
2212
2227
  const buildClientLocale = () => navigator.languages && navigator.languages.length ? navigator.languages[0] : navigator.language;
2213
2228
 
2214
2229
  const buildClientNinetailedRequestContext = () => ({
@@ -2221,724 +2236,14 @@ const buildClientNinetailedRequestContext = () => ({
2221
2236
  }
2222
2237
  });
2223
2238
 
2224
- var browser = {exports: {}};
2225
-
2226
- /**
2227
- * Helpers.
2228
- */
2229
-
2230
- var s = 1000;
2231
- var m = s * 60;
2232
- var h = m * 60;
2233
- var d = h * 24;
2234
- var w = d * 7;
2235
- var y = d * 365.25;
2236
-
2237
- /**
2238
- * Parse or format the given `val`.
2239
- *
2240
- * Options:
2241
- *
2242
- * - `long` verbose formatting [false]
2243
- *
2244
- * @param {String|Number} val
2245
- * @param {Object} [options]
2246
- * @throws {Error} throw an error if val is not a non-empty string or a number
2247
- * @return {String|Number}
2248
- * @api public
2249
- */
2250
-
2251
- var ms = function(val, options) {
2252
- options = options || {};
2253
- var type = typeof val;
2254
- if (type === 'string' && val.length > 0) {
2255
- return parse(val);
2256
- } else if (type === 'number' && isFinite(val)) {
2257
- return options.long ? fmtLong(val) : fmtShort(val);
2258
- }
2259
- throw new Error(
2260
- 'val is not a non-empty string or a valid number. val=' +
2261
- JSON.stringify(val)
2262
- );
2263
- };
2264
-
2265
- /**
2266
- * Parse the given `str` and return milliseconds.
2267
- *
2268
- * @param {String} str
2269
- * @return {Number}
2270
- * @api private
2271
- */
2272
-
2273
- function parse(str) {
2274
- str = String(str);
2275
- if (str.length > 100) {
2276
- return;
2277
- }
2278
- var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
2279
- str
2280
- );
2281
- if (!match) {
2282
- return;
2283
- }
2284
- var n = parseFloat(match[1]);
2285
- var type = (match[2] || 'ms').toLowerCase();
2286
- switch (type) {
2287
- case 'years':
2288
- case 'year':
2289
- case 'yrs':
2290
- case 'yr':
2291
- case 'y':
2292
- return n * y;
2293
- case 'weeks':
2294
- case 'week':
2295
- case 'w':
2296
- return n * w;
2297
- case 'days':
2298
- case 'day':
2299
- case 'd':
2300
- return n * d;
2301
- case 'hours':
2302
- case 'hour':
2303
- case 'hrs':
2304
- case 'hr':
2305
- case 'h':
2306
- return n * h;
2307
- case 'minutes':
2308
- case 'minute':
2309
- case 'mins':
2310
- case 'min':
2311
- case 'm':
2312
- return n * m;
2313
- case 'seconds':
2314
- case 'second':
2315
- case 'secs':
2316
- case 'sec':
2317
- case 's':
2318
- return n * s;
2319
- case 'milliseconds':
2320
- case 'millisecond':
2321
- case 'msecs':
2322
- case 'msec':
2323
- case 'ms':
2324
- return n;
2325
- default:
2326
- return undefined;
2327
- }
2328
- }
2329
-
2330
- /**
2331
- * Short format for `ms`.
2332
- *
2333
- * @param {Number} ms
2334
- * @return {String}
2335
- * @api private
2336
- */
2337
-
2338
- function fmtShort(ms) {
2339
- var msAbs = Math.abs(ms);
2340
- if (msAbs >= d) {
2341
- return Math.round(ms / d) + 'd';
2342
- }
2343
- if (msAbs >= h) {
2344
- return Math.round(ms / h) + 'h';
2345
- }
2346
- if (msAbs >= m) {
2347
- return Math.round(ms / m) + 'm';
2348
- }
2349
- if (msAbs >= s) {
2350
- return Math.round(ms / s) + 's';
2351
- }
2352
- return ms + 'ms';
2353
- }
2354
-
2355
- /**
2356
- * Long format for `ms`.
2357
- *
2358
- * @param {Number} ms
2359
- * @return {String}
2360
- * @api private
2361
- */
2362
-
2363
- function fmtLong(ms) {
2364
- var msAbs = Math.abs(ms);
2365
- if (msAbs >= d) {
2366
- return plural(ms, msAbs, d, 'day');
2367
- }
2368
- if (msAbs >= h) {
2369
- return plural(ms, msAbs, h, 'hour');
2370
- }
2371
- if (msAbs >= m) {
2372
- return plural(ms, msAbs, m, 'minute');
2373
- }
2374
- if (msAbs >= s) {
2375
- return plural(ms, msAbs, s, 'second');
2376
- }
2377
- return ms + ' ms';
2378
- }
2379
-
2380
- /**
2381
- * Pluralization helper.
2382
- */
2383
-
2384
- function plural(ms, msAbs, n, name) {
2385
- var isPlural = msAbs >= n * 1.5;
2386
- return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
2387
- }
2388
-
2389
- /**
2390
- * This is the common logic for both the Node.js and web browser
2391
- * implementations of `debug()`.
2392
- */
2393
-
2394
- function setup(env) {
2395
- createDebug.debug = createDebug;
2396
- createDebug.default = createDebug;
2397
- createDebug.coerce = coerce;
2398
- createDebug.disable = disable;
2399
- createDebug.enable = enable;
2400
- createDebug.enabled = enabled;
2401
- createDebug.humanize = ms;
2402
- createDebug.destroy = destroy;
2403
-
2404
- Object.keys(env).forEach(key => {
2405
- createDebug[key] = env[key];
2406
- });
2407
-
2408
- /**
2409
- * The currently active debug mode names, and names to skip.
2410
- */
2411
-
2412
- createDebug.names = [];
2413
- createDebug.skips = [];
2414
-
2415
- /**
2416
- * Map of special "%n" handling functions, for the debug "format" argument.
2417
- *
2418
- * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
2419
- */
2420
- createDebug.formatters = {};
2421
-
2422
- /**
2423
- * Selects a color for a debug namespace
2424
- * @param {String} namespace The namespace string for the debug instance to be colored
2425
- * @return {Number|String} An ANSI color code for the given namespace
2426
- * @api private
2427
- */
2428
- function selectColor(namespace) {
2429
- let hash = 0;
2430
-
2431
- for (let i = 0; i < namespace.length; i++) {
2432
- hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
2433
- hash |= 0; // Convert to 32bit integer
2434
- }
2435
-
2436
- return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
2437
- }
2438
- createDebug.selectColor = selectColor;
2439
-
2440
- /**
2441
- * Create a debugger with the given `namespace`.
2442
- *
2443
- * @param {String} namespace
2444
- * @return {Function}
2445
- * @api public
2446
- */
2447
- function createDebug(namespace) {
2448
- let prevTime;
2449
- let enableOverride = null;
2450
- let namespacesCache;
2451
- let enabledCache;
2452
-
2453
- function debug(...args) {
2454
- // Disabled?
2455
- if (!debug.enabled) {
2456
- return;
2457
- }
2458
-
2459
- const self = debug;
2460
-
2461
- // Set `diff` timestamp
2462
- const curr = Number(new Date());
2463
- const ms = curr - (prevTime || curr);
2464
- self.diff = ms;
2465
- self.prev = prevTime;
2466
- self.curr = curr;
2467
- prevTime = curr;
2468
-
2469
- args[0] = createDebug.coerce(args[0]);
2470
-
2471
- if (typeof args[0] !== 'string') {
2472
- // Anything else let's inspect with %O
2473
- args.unshift('%O');
2474
- }
2475
-
2476
- // Apply any `formatters` transformations
2477
- let index = 0;
2478
- args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
2479
- // If we encounter an escaped % then don't increase the array index
2480
- if (match === '%%') {
2481
- return '%';
2482
- }
2483
- index++;
2484
- const formatter = createDebug.formatters[format];
2485
- if (typeof formatter === 'function') {
2486
- const val = args[index];
2487
- match = formatter.call(self, val);
2488
-
2489
- // Now we need to remove `args[index]` since it's inlined in the `format`
2490
- args.splice(index, 1);
2491
- index--;
2492
- }
2493
- return match;
2494
- });
2495
-
2496
- // Apply env-specific formatting (colors, etc.)
2497
- createDebug.formatArgs.call(self, args);
2498
-
2499
- const logFn = self.log || createDebug.log;
2500
- logFn.apply(self, args);
2501
- }
2502
-
2503
- debug.namespace = namespace;
2504
- debug.useColors = createDebug.useColors();
2505
- debug.color = createDebug.selectColor(namespace);
2506
- debug.extend = extend;
2507
- debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
2508
-
2509
- Object.defineProperty(debug, 'enabled', {
2510
- enumerable: true,
2511
- configurable: false,
2512
- get: () => {
2513
- if (enableOverride !== null) {
2514
- return enableOverride;
2515
- }
2516
- if (namespacesCache !== createDebug.namespaces) {
2517
- namespacesCache = createDebug.namespaces;
2518
- enabledCache = createDebug.enabled(namespace);
2519
- }
2520
-
2521
- return enabledCache;
2522
- },
2523
- set: v => {
2524
- enableOverride = v;
2525
- }
2526
- });
2527
-
2528
- // Env-specific initialization logic for debug instances
2529
- if (typeof createDebug.init === 'function') {
2530
- createDebug.init(debug);
2531
- }
2532
-
2533
- return debug;
2534
- }
2535
-
2536
- function extend(namespace, delimiter) {
2537
- const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
2538
- newDebug.log = this.log;
2539
- return newDebug;
2540
- }
2541
-
2542
- /**
2543
- * Enables a debug mode by namespaces. This can include modes
2544
- * separated by a colon and wildcards.
2545
- *
2546
- * @param {String} namespaces
2547
- * @api public
2548
- */
2549
- function enable(namespaces) {
2550
- createDebug.save(namespaces);
2551
- createDebug.namespaces = namespaces;
2552
-
2553
- createDebug.names = [];
2554
- createDebug.skips = [];
2555
-
2556
- let i;
2557
- const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
2558
- const len = split.length;
2559
-
2560
- for (i = 0; i < len; i++) {
2561
- if (!split[i]) {
2562
- // ignore empty strings
2563
- continue;
2564
- }
2565
-
2566
- namespaces = split[i].replace(/\*/g, '.*?');
2567
-
2568
- if (namespaces[0] === '-') {
2569
- createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
2570
- } else {
2571
- createDebug.names.push(new RegExp('^' + namespaces + '$'));
2572
- }
2573
- }
2574
- }
2575
-
2576
- /**
2577
- * Disable debug output.
2578
- *
2579
- * @return {String} namespaces
2580
- * @api public
2581
- */
2582
- function disable() {
2583
- const namespaces = [
2584
- ...createDebug.names.map(toNamespace),
2585
- ...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
2586
- ].join(',');
2587
- createDebug.enable('');
2588
- return namespaces;
2589
- }
2590
-
2591
- /**
2592
- * Returns true if the given mode name is enabled, false otherwise.
2593
- *
2594
- * @param {String} name
2595
- * @return {Boolean}
2596
- * @api public
2597
- */
2598
- function enabled(name) {
2599
- if (name[name.length - 1] === '*') {
2600
- return true;
2601
- }
2602
-
2603
- let i;
2604
- let len;
2605
-
2606
- for (i = 0, len = createDebug.skips.length; i < len; i++) {
2607
- if (createDebug.skips[i].test(name)) {
2608
- return false;
2609
- }
2610
- }
2611
-
2612
- for (i = 0, len = createDebug.names.length; i < len; i++) {
2613
- if (createDebug.names[i].test(name)) {
2614
- return true;
2615
- }
2616
- }
2617
-
2618
- return false;
2619
- }
2620
-
2621
- /**
2622
- * Convert regexp to namespace
2623
- *
2624
- * @param {RegExp} regxep
2625
- * @return {String} namespace
2626
- * @api private
2627
- */
2628
- function toNamespace(regexp) {
2629
- return regexp.toString()
2630
- .substring(2, regexp.toString().length - 2)
2631
- .replace(/\.\*\?$/, '*');
2632
- }
2633
-
2634
- /**
2635
- * Coerce `val`.
2636
- *
2637
- * @param {Mixed} val
2638
- * @return {Mixed}
2639
- * @api private
2640
- */
2641
- function coerce(val) {
2642
- if (val instanceof Error) {
2643
- return val.stack || val.message;
2644
- }
2645
- return val;
2646
- }
2647
-
2648
- /**
2649
- * XXX DO NOT USE. This is a temporary stub function.
2650
- * XXX It WILL be removed in the next major release.
2651
- */
2652
- function destroy() {
2653
- console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
2654
- }
2655
-
2656
- createDebug.enable(createDebug.load());
2657
-
2658
- return createDebug;
2659
- }
2660
-
2661
- var common = setup;
2662
-
2663
- /* eslint-env browser */
2664
-
2665
- (function (module, exports) {
2666
- /**
2667
- * This is the web browser implementation of `debug()`.
2668
- */
2669
-
2670
- exports.formatArgs = formatArgs;
2671
- exports.save = save;
2672
- exports.load = load;
2673
- exports.useColors = useColors;
2674
- exports.storage = localstorage();
2675
- exports.destroy = (() => {
2676
- let warned = false;
2677
-
2678
- return () => {
2679
- if (!warned) {
2680
- warned = true;
2681
- console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
2682
- }
2683
- };
2684
- })();
2685
-
2686
- /**
2687
- * Colors.
2688
- */
2689
-
2690
- exports.colors = [
2691
- '#0000CC',
2692
- '#0000FF',
2693
- '#0033CC',
2694
- '#0033FF',
2695
- '#0066CC',
2696
- '#0066FF',
2697
- '#0099CC',
2698
- '#0099FF',
2699
- '#00CC00',
2700
- '#00CC33',
2701
- '#00CC66',
2702
- '#00CC99',
2703
- '#00CCCC',
2704
- '#00CCFF',
2705
- '#3300CC',
2706
- '#3300FF',
2707
- '#3333CC',
2708
- '#3333FF',
2709
- '#3366CC',
2710
- '#3366FF',
2711
- '#3399CC',
2712
- '#3399FF',
2713
- '#33CC00',
2714
- '#33CC33',
2715
- '#33CC66',
2716
- '#33CC99',
2717
- '#33CCCC',
2718
- '#33CCFF',
2719
- '#6600CC',
2720
- '#6600FF',
2721
- '#6633CC',
2722
- '#6633FF',
2723
- '#66CC00',
2724
- '#66CC33',
2725
- '#9900CC',
2726
- '#9900FF',
2727
- '#9933CC',
2728
- '#9933FF',
2729
- '#99CC00',
2730
- '#99CC33',
2731
- '#CC0000',
2732
- '#CC0033',
2733
- '#CC0066',
2734
- '#CC0099',
2735
- '#CC00CC',
2736
- '#CC00FF',
2737
- '#CC3300',
2738
- '#CC3333',
2739
- '#CC3366',
2740
- '#CC3399',
2741
- '#CC33CC',
2742
- '#CC33FF',
2743
- '#CC6600',
2744
- '#CC6633',
2745
- '#CC9900',
2746
- '#CC9933',
2747
- '#CCCC00',
2748
- '#CCCC33',
2749
- '#FF0000',
2750
- '#FF0033',
2751
- '#FF0066',
2752
- '#FF0099',
2753
- '#FF00CC',
2754
- '#FF00FF',
2755
- '#FF3300',
2756
- '#FF3333',
2757
- '#FF3366',
2758
- '#FF3399',
2759
- '#FF33CC',
2760
- '#FF33FF',
2761
- '#FF6600',
2762
- '#FF6633',
2763
- '#FF9900',
2764
- '#FF9933',
2765
- '#FFCC00',
2766
- '#FFCC33'
2767
- ];
2768
-
2769
- /**
2770
- * Currently only WebKit-based Web Inspectors, Firefox >= v31,
2771
- * and the Firebug extension (any Firefox version) are known
2772
- * to support "%c" CSS customizations.
2773
- *
2774
- * TODO: add a `localStorage` variable to explicitly enable/disable colors
2775
- */
2776
-
2777
- // eslint-disable-next-line complexity
2778
- function useColors() {
2779
- // NB: In an Electron preload script, document will be defined but not fully
2780
- // initialized. Since we know we're in Chrome, we'll just detect this case
2781
- // explicitly
2782
- if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
2783
- return true;
2784
- }
2785
-
2786
- // Internet Explorer and Edge do not support colors.
2787
- if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
2788
- return false;
2789
- }
2790
-
2791
- // Is webkit? http://stackoverflow.com/a/16459606/376773
2792
- // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
2793
- return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
2794
- // Is firebug? http://stackoverflow.com/a/398120/376773
2795
- (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
2796
- // Is firefox >= v31?
2797
- // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
2798
- (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
2799
- // Double check webkit in userAgent just in case we are in a worker
2800
- (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
2801
- }
2802
-
2803
- /**
2804
- * Colorize log arguments if enabled.
2805
- *
2806
- * @api public
2807
- */
2808
-
2809
- function formatArgs(args) {
2810
- args[0] = (this.useColors ? '%c' : '') +
2811
- this.namespace +
2812
- (this.useColors ? ' %c' : ' ') +
2813
- args[0] +
2814
- (this.useColors ? '%c ' : ' ') +
2815
- '+' + module.exports.humanize(this.diff);
2816
-
2817
- if (!this.useColors) {
2818
- return;
2819
- }
2820
-
2821
- const c = 'color: ' + this.color;
2822
- args.splice(1, 0, c, 'color: inherit');
2823
-
2824
- // The final "%c" is somewhat tricky, because there could be other
2825
- // arguments passed either before or after the %c, so we need to
2826
- // figure out the correct index to insert the CSS into
2827
- let index = 0;
2828
- let lastC = 0;
2829
- args[0].replace(/%[a-zA-Z%]/g, match => {
2830
- if (match === '%%') {
2831
- return;
2832
- }
2833
- index++;
2834
- if (match === '%c') {
2835
- // We only are interested in the *last* %c
2836
- // (the user may have provided their own)
2837
- lastC = index;
2838
- }
2839
- });
2840
-
2841
- args.splice(lastC, 0, c);
2842
- }
2843
-
2844
- /**
2845
- * Invokes `console.debug()` when available.
2846
- * No-op when `console.debug` is not a "function".
2847
- * If `console.debug` is not available, falls back
2848
- * to `console.log`.
2849
- *
2850
- * @api public
2851
- */
2852
- exports.log = console.debug || console.log || (() => {});
2853
-
2854
- /**
2855
- * Save `namespaces`.
2856
- *
2857
- * @param {String} namespaces
2858
- * @api private
2859
- */
2860
- function save(namespaces) {
2861
- try {
2862
- if (namespaces) {
2863
- exports.storage.setItem('debug', namespaces);
2864
- } else {
2865
- exports.storage.removeItem('debug');
2866
- }
2867
- } catch (error) {
2868
- // Swallow
2869
- // XXX (@Qix-) should we be logging these?
2870
- }
2871
- }
2872
-
2873
- /**
2874
- * Load `namespaces`.
2875
- *
2876
- * @return {String} returns the previously persisted debug modes
2877
- * @api private
2878
- */
2879
- function load() {
2880
- let r;
2881
- try {
2882
- r = exports.storage.getItem('debug');
2883
- } catch (error) {
2884
- // Swallow
2885
- // XXX (@Qix-) should we be logging these?
2886
- }
2887
-
2888
- // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
2889
- if (!r && typeof process !== 'undefined' && 'env' in process) {
2890
- r = process.env.DEBUG;
2891
- }
2892
-
2893
- return r;
2894
- }
2895
-
2896
- /**
2897
- * Localstorage attempts to return the localstorage.
2898
- *
2899
- * This is necessary because safari throws
2900
- * when a user disables cookies/localstorage
2901
- * and you attempt to access it.
2902
- *
2903
- * @return {LocalStorage}
2904
- * @api private
2905
- */
2906
-
2907
- function localstorage() {
2908
- try {
2909
- // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
2910
- // The Browser also has localStorage in the global context.
2911
- return localStorage;
2912
- } catch (error) {
2913
- // Swallow
2914
- // XXX (@Qix-) should we be logging these?
2915
- }
2916
- }
2917
-
2918
- module.exports = common(exports);
2919
-
2920
- const {formatters} = module.exports;
2921
-
2922
- /**
2923
- * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
2924
- */
2925
-
2926
- formatters.j = function (v) {
2927
- try {
2928
- return JSON.stringify(v);
2929
- } catch (error) {
2930
- return '[UnexpectedJSONParseError]: ' + error.message;
2931
- }
2932
- };
2933
- }(browser, browser.exports));
2934
-
2935
- var Debug = browser.exports;
2936
-
2937
- const log = Debug('ninetailed:experience-sdk');
2938
2239
  const enable = () => {
2939
- Debug.enable('ninetailed:experience-sdk');
2240
+ loglevel.enableAll();
2241
+ };
2242
+ const disable = () => {
2243
+ loglevel.disableAll();
2940
2244
  };
2941
- const disable = () => Debug.disable();
2245
+ const Logger = loglevel.getLogger('ninetailed:experience.js');
2246
+ const log = Logger.log;
2942
2247
 
2943
2248
  const BASE_URL = 'https://api.ninetailed.co';
2944
2249
 
@@ -3262,8 +2567,8 @@ var objectDefineProperties = {};
3262
2567
 
3263
2568
  var DESCRIPTORS$1 = descriptors;
3264
2569
  var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
3265
- var definePropertyModule$1 = objectDefineProperty;
3266
- var anObject$4 = anObject$d;
2570
+ var definePropertyModule$2 = objectDefineProperty;
2571
+ var anObject$5 = anObject$e;
3267
2572
  var toIndexedObject$1 = toIndexedObject$5;
3268
2573
  var objectKeys = objectKeys$2;
3269
2574
 
@@ -3271,19 +2576,19 @@ var objectKeys = objectKeys$2;
3271
2576
  // https://tc39.es/ecma262/#sec-object.defineproperties
3272
2577
  // eslint-disable-next-line es/no-object-defineproperties -- safe
3273
2578
  objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
3274
- anObject$4(O);
2579
+ anObject$5(O);
3275
2580
  var props = toIndexedObject$1(Properties);
3276
2581
  var keys = objectKeys(Properties);
3277
2582
  var length = keys.length;
3278
2583
  var index = 0;
3279
2584
  var key;
3280
- while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]);
2585
+ while (length > index) definePropertyModule$2.f(O, key = keys[index++], props[key]);
3281
2586
  return O;
3282
2587
  };
3283
2588
 
3284
2589
  /* global ActiveXObject -- old IE, WSH */
3285
2590
 
3286
- var anObject$3 = anObject$d;
2591
+ var anObject$4 = anObject$e;
3287
2592
  var definePropertiesModule = objectDefineProperties;
3288
2593
  var enumBugKeys = enumBugKeys$3;
3289
2594
  var hiddenKeys = hiddenKeys$4;
@@ -3356,7 +2661,7 @@ hiddenKeys[IE_PROTO$1] = true;
3356
2661
  var objectCreate = Object.create || function create(O, Properties) {
3357
2662
  var result;
3358
2663
  if (O !== null) {
3359
- EmptyConstructor[PROTOTYPE] = anObject$3(O);
2664
+ EmptyConstructor[PROTOTYPE] = anObject$4(O);
3360
2665
  result = new EmptyConstructor();
3361
2666
  EmptyConstructor[PROTOTYPE] = null;
3362
2667
  // add "__proto__" for Object.getPrototypeOf polyfill
@@ -3367,7 +2672,7 @@ var objectCreate = Object.create || function create(O, Properties) {
3367
2672
 
3368
2673
  var wellKnownSymbol$7 = wellKnownSymbol$i;
3369
2674
  var create$2 = objectCreate;
3370
- var definePropertyModule = objectDefineProperty;
2675
+ var definePropertyModule$1 = objectDefineProperty;
3371
2676
 
3372
2677
  var UNSCOPABLES = wellKnownSymbol$7('unscopables');
3373
2678
  var ArrayPrototype = Array.prototype;
@@ -3375,7 +2680,7 @@ var ArrayPrototype = Array.prototype;
3375
2680
  // Array.prototype[@@unscopables]
3376
2681
  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
3377
2682
  if (ArrayPrototype[UNSCOPABLES] == undefined) {
3378
- definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
2683
+ definePropertyModule$1.f(ArrayPrototype, UNSCOPABLES, {
3379
2684
  configurable: true,
3380
2685
  value: create$2(null)
3381
2686
  });
@@ -3386,30 +2691,30 @@ var addToUnscopables$1 = function (key) {
3386
2691
  ArrayPrototype[UNSCOPABLES][key] = true;
3387
2692
  };
3388
2693
 
3389
- var fails$6 = fails$h;
2694
+ var fails$9 = fails$k;
3390
2695
 
3391
- var correctPrototypeGetter = !fails$6(function () {
2696
+ var correctPrototypeGetter = !fails$9(function () {
3392
2697
  function F() { /* empty */ }
3393
2698
  F.prototype.constructor = null;
3394
2699
  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
3395
2700
  return Object.getPrototypeOf(new F()) !== F.prototype;
3396
2701
  });
3397
2702
 
3398
- var global$8 = global$H;
2703
+ var global$b = global$K;
3399
2704
  var hasOwn = hasOwnProperty_1;
3400
2705
  var isCallable$4 = isCallable$j;
3401
- var toObject$1 = toObject$4;
2706
+ var toObject$2 = toObject$5;
3402
2707
  var sharedKey = sharedKey$3;
3403
2708
  var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
3404
2709
 
3405
2710
  var IE_PROTO = sharedKey('IE_PROTO');
3406
- var Object$1 = global$8.Object;
2711
+ var Object$1 = global$b.Object;
3407
2712
  var ObjectPrototype = Object$1.prototype;
3408
2713
 
3409
2714
  // `Object.getPrototypeOf` method
3410
2715
  // https://tc39.es/ecma262/#sec-object.getprototypeof
3411
2716
  var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object$1.getPrototypeOf : function (O) {
3412
- var object = toObject$1(O);
2717
+ var object = toObject$2(O);
3413
2718
  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
3414
2719
  var constructor = object.constructor;
3415
2720
  if (isCallable$4(constructor) && object instanceof constructor) {
@@ -3417,13 +2722,13 @@ var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object$1.getPrototypeOf :
3417
2722
  } return object instanceof Object$1 ? ObjectPrototype : null;
3418
2723
  };
3419
2724
 
3420
- var fails$5 = fails$h;
2725
+ var fails$8 = fails$k;
3421
2726
  var isCallable$3 = isCallable$j;
3422
2727
  var getPrototypeOf$1 = objectGetPrototypeOf;
3423
2728
  var redefine$2 = redefine$6.exports;
3424
2729
  var wellKnownSymbol$6 = wellKnownSymbol$i;
3425
2730
 
3426
- var ITERATOR$2 = wellKnownSymbol$6('iterator');
2731
+ var ITERATOR$3 = wellKnownSymbol$6('iterator');
3427
2732
  var BUGGY_SAFARI_ITERATORS$1 = false;
3428
2733
 
3429
2734
  // `%IteratorPrototype%` object
@@ -3441,18 +2746,18 @@ if ([].keys) {
3441
2746
  }
3442
2747
  }
3443
2748
 
3444
- var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$5(function () {
2749
+ var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$8(function () {
3445
2750
  var test = {};
3446
2751
  // FF44- legacy iterators case
3447
- return IteratorPrototype$2[ITERATOR$2].call(test) !== test;
2752
+ return IteratorPrototype$2[ITERATOR$3].call(test) !== test;
3448
2753
  });
3449
2754
 
3450
2755
  if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
3451
2756
 
3452
2757
  // `%IteratorPrototype%[@@iterator]()` method
3453
2758
  // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
3454
- if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) {
3455
- redefine$2(IteratorPrototype$2, ITERATOR$2, function () {
2759
+ if (!isCallable$3(IteratorPrototype$2[ITERATOR$3])) {
2760
+ redefine$2(IteratorPrototype$2, ITERATOR$3, function () {
3456
2761
  return this;
3457
2762
  });
3458
2763
  }
@@ -3464,7 +2769,7 @@ var iteratorsCore = {
3464
2769
 
3465
2770
  var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
3466
2771
  var create$1 = objectCreate;
3467
- var createPropertyDescriptor = createPropertyDescriptor$3;
2772
+ var createPropertyDescriptor$1 = createPropertyDescriptor$4;
3468
2773
  var setToStringTag$1 = setToStringTag$3;
3469
2774
  var Iterators$2 = iterators;
3470
2775
 
@@ -3472,14 +2777,14 @@ var returnThis$1 = function () { return this; };
3472
2777
 
3473
2778
  var createIteratorConstructor$1 = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
3474
2779
  var TO_STRING_TAG = NAME + ' Iterator';
3475
- IteratorConstructor.prototype = create$1(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
2780
+ IteratorConstructor.prototype = create$1(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) });
3476
2781
  setToStringTag$1(IteratorConstructor, TO_STRING_TAG, false);
3477
2782
  Iterators$2[TO_STRING_TAG] = returnThis$1;
3478
2783
  return IteratorConstructor;
3479
2784
  };
3480
2785
 
3481
- var $$2 = _export;
3482
- var call$3 = functionCall;
2786
+ var $$4 = _export;
2787
+ var call$4 = functionCall;
3483
2788
  var FunctionName = functionName;
3484
2789
  var isCallable$2 = isCallable$j;
3485
2790
  var createIteratorConstructor = createIteratorConstructor$1;
@@ -3496,7 +2801,7 @@ var PROPER_FUNCTION_NAME = FunctionName.PROPER;
3496
2801
  var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
3497
2802
  var IteratorPrototype = IteratorsCore.IteratorPrototype;
3498
2803
  var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
3499
- var ITERATOR$1 = wellKnownSymbol$5('iterator');
2804
+ var ITERATOR$2 = wellKnownSymbol$5('iterator');
3500
2805
  var KEYS = 'keys';
3501
2806
  var VALUES = 'values';
3502
2807
  var ENTRIES = 'entries';
@@ -3519,7 +2824,7 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
3519
2824
  var TO_STRING_TAG = NAME + ' Iterator';
3520
2825
  var INCORRECT_VALUES_NAME = false;
3521
2826
  var IterablePrototype = Iterable.prototype;
3522
- var nativeIterator = IterablePrototype[ITERATOR$1]
2827
+ var nativeIterator = IterablePrototype[ITERATOR$2]
3523
2828
  || IterablePrototype['@@iterator']
3524
2829
  || DEFAULT && IterablePrototype[DEFAULT];
3525
2830
  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
@@ -3533,8 +2838,8 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
3533
2838
  if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
3534
2839
  if (setPrototypeOf) {
3535
2840
  setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
3536
- } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) {
3537
- redefine$1(CurrentIteratorPrototype, ITERATOR$1, returnThis);
2841
+ } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$2])) {
2842
+ redefine$1(CurrentIteratorPrototype, ITERATOR$2, returnThis);
3538
2843
  }
3539
2844
  }
3540
2845
  // Set @@toStringTag to native iterators
@@ -3548,7 +2853,7 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
3548
2853
  createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES);
3549
2854
  } else {
3550
2855
  INCORRECT_VALUES_NAME = true;
3551
- defaultIterator = function values() { return call$3(nativeIterator, this); };
2856
+ defaultIterator = function values() { return call$4(nativeIterator, this); };
3552
2857
  }
3553
2858
  }
3554
2859
 
@@ -3563,12 +2868,12 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
3563
2868
  if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
3564
2869
  redefine$1(IterablePrototype, KEY, methods[KEY]);
3565
2870
  }
3566
- } else $$2({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
2871
+ } else $$4({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
3567
2872
  }
3568
2873
 
3569
2874
  // define iterator
3570
- if (IterablePrototype[ITERATOR$1] !== defaultIterator) {
3571
- redefine$1(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT });
2875
+ if (IterablePrototype[ITERATOR$2] !== defaultIterator) {
2876
+ redefine$1(IterablePrototype, ITERATOR$2, defaultIterator, { name: DEFAULT });
3572
2877
  }
3573
2878
  Iterators$1[NAME] = defaultIterator;
3574
2879
 
@@ -3679,24 +2984,24 @@ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.co
3679
2984
 
3680
2985
  var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
3681
2986
 
3682
- var global$7 = global$H;
2987
+ var global$a = global$K;
3683
2988
  var DOMIterables = domIterables;
3684
2989
  var DOMTokenListPrototype = domTokenListPrototype;
3685
2990
  var ArrayIteratorMethods = es_array_iterator;
3686
2991
  var createNonEnumerableProperty$1 = createNonEnumerableProperty$6;
3687
2992
  var wellKnownSymbol$4 = wellKnownSymbol$i;
3688
2993
 
3689
- var ITERATOR = wellKnownSymbol$4('iterator');
2994
+ var ITERATOR$1 = wellKnownSymbol$4('iterator');
3690
2995
  var TO_STRING_TAG = wellKnownSymbol$4('toStringTag');
3691
2996
  var ArrayValues = ArrayIteratorMethods.values;
3692
2997
 
3693
2998
  var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
3694
2999
  if (CollectionPrototype) {
3695
3000
  // some Chrome versions have non-configurable methods on DOMTokenList
3696
- if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
3697
- createNonEnumerableProperty$1(CollectionPrototype, ITERATOR, ArrayValues);
3001
+ if (CollectionPrototype[ITERATOR$1] !== ArrayValues) try {
3002
+ createNonEnumerableProperty$1(CollectionPrototype, ITERATOR$1, ArrayValues);
3698
3003
  } catch (error) {
3699
- CollectionPrototype[ITERATOR] = ArrayValues;
3004
+ CollectionPrototype[ITERATOR$1] = ArrayValues;
3700
3005
  }
3701
3006
  if (!CollectionPrototype[TO_STRING_TAG]) {
3702
3007
  createNonEnumerableProperty$1(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
@@ -3713,7 +3018,7 @@ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
3713
3018
  };
3714
3019
 
3715
3020
  for (var COLLECTION_NAME in DOMIterables) {
3716
- handlePrototype(global$7[COLLECTION_NAME] && global$7[COLLECTION_NAME].prototype, COLLECTION_NAME);
3021
+ handlePrototype(global$a[COLLECTION_NAME] && global$a[COLLECTION_NAME].prototype, COLLECTION_NAME);
3717
3022
  }
3718
3023
 
3719
3024
  handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
@@ -3721,7 +3026,8 @@ handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
3721
3026
  class Ninetailed {
3722
3027
  constructor({
3723
3028
  clientId,
3724
- environment
3029
+ environment,
3030
+ preview
3725
3031
  }, {
3726
3032
  plugins,
3727
3033
  url,
@@ -3746,6 +3052,15 @@ class Ninetailed {
3746
3052
  });
3747
3053
  };
3748
3054
 
3055
+ this.trackExperience = payload => {
3056
+ return this.track('nt_experience', payload, {
3057
+ plugins: {
3058
+ all: true,
3059
+ ninetailed: false
3060
+ }
3061
+ });
3062
+ };
3063
+
3749
3064
  this.identify = (uid, traits, options) => {
3750
3065
  return this.instance.identify(uid, traits, this.buildOptions(options));
3751
3066
  };
@@ -3797,7 +3112,8 @@ class Ninetailed {
3797
3112
  url,
3798
3113
  profile,
3799
3114
  locale,
3800
- requestTimeout
3115
+ requestTimeout,
3116
+ preview
3801
3117
  })]
3802
3118
  }); // put in private method
3803
3119
 
@@ -3926,6 +3242,8 @@ const selectVariant$1 = (baseline, variants, {
3926
3242
  };
3927
3243
  };
3928
3244
 
3245
+ const EXPERIENCE_TRAIT_PREFIX = 'nt_experiment_';
3246
+
3929
3247
  const selectBaselineWithVariants = (experience, baseline) => {
3930
3248
  return experience.components.find(baselineWithVariants => baselineWithVariants.baseline.id === baseline.id);
3931
3249
  };
@@ -3945,12 +3263,12 @@ const selectHasVariants = (experience, baseline) => {
3945
3263
  return variants.length > 0;
3946
3264
  };
3947
3265
 
3948
- var global$6 = global$H;
3266
+ var global$9 = global$K;
3949
3267
  var classof$2 = classof$6;
3950
3268
 
3951
- var String$1 = global$6.String;
3269
+ var String$1 = global$9.String;
3952
3270
 
3953
- var toString$4 = function (argument) {
3271
+ var toString$7 = function (argument) {
3954
3272
  if (classof$2(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
3955
3273
  return String$1(argument);
3956
3274
  };
@@ -3968,14 +3286,14 @@ var isRegexp = function (it) {
3968
3286
  return isObject(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$1(it) == 'RegExp');
3969
3287
  };
3970
3288
 
3971
- var global$5 = global$H;
3972
- var isRegExp = isRegexp;
3289
+ var global$8 = global$K;
3290
+ var isRegExp$1 = isRegexp;
3973
3291
 
3974
- var TypeError$2 = global$5.TypeError;
3292
+ var TypeError$3 = global$8.TypeError;
3975
3293
 
3976
3294
  var notARegexp = function (it) {
3977
- if (isRegExp(it)) {
3978
- throw TypeError$2("The method doesn't accept regular expressions");
3295
+ if (isRegExp$1(it)) {
3296
+ throw TypeError$3("The method doesn't accept regular expressions");
3979
3297
  } return it;
3980
3298
  };
3981
3299
 
@@ -3995,19 +3313,19 @@ var correctIsRegexpLogic = function (METHOD_NAME) {
3995
3313
  } return false;
3996
3314
  };
3997
3315
 
3998
- var $$1 = _export;
3999
- var uncurryThis$5 = functionUncurryThis;
3316
+ var $$3 = _export;
3317
+ var uncurryThis$8 = functionUncurryThis;
4000
3318
  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
4001
- var toLength$1 = toLength$3;
4002
- var toString$3 = toString$4;
3319
+ var toLength$2 = toLength$4;
3320
+ var toString$6 = toString$7;
4003
3321
  var notARegExp = notARegexp;
4004
- var requireObjectCoercible$2 = requireObjectCoercible$5;
3322
+ var requireObjectCoercible$4 = requireObjectCoercible$7;
4005
3323
  var correctIsRegExpLogic = correctIsRegexpLogic;
4006
3324
 
4007
3325
  // eslint-disable-next-line es/no-string-prototype-startswith -- safe
4008
- var un$StartsWith = uncurryThis$5(''.startsWith);
4009
- var stringSlice$4 = uncurryThis$5(''.slice);
4010
- var min$1 = Math.min;
3326
+ var un$StartsWith = uncurryThis$8(''.startsWith);
3327
+ var stringSlice$5 = uncurryThis$8(''.slice);
3328
+ var min$2 = Math.min;
4011
3329
 
4012
3330
  var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
4013
3331
  // https://github.com/zloirock/core-js/pull/702
@@ -4018,24 +3336,24 @@ var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () {
4018
3336
 
4019
3337
  // `String.prototype.startsWith` method
4020
3338
  // https://tc39.es/ecma262/#sec-string.prototype.startswith
4021
- $$1({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
3339
+ $$3({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
4022
3340
  startsWith: function startsWith(searchString /* , position = 0 */) {
4023
- var that = toString$3(requireObjectCoercible$2(this));
3341
+ var that = toString$6(requireObjectCoercible$4(this));
4024
3342
  notARegExp(searchString);
4025
- var index = toLength$1(min$1(arguments.length > 1 ? arguments[1] : undefined, that.length));
4026
- var search = toString$3(searchString);
3343
+ var index = toLength$2(min$2(arguments.length > 1 ? arguments[1] : undefined, that.length));
3344
+ var search = toString$6(searchString);
4027
3345
  return un$StartsWith
4028
3346
  ? un$StartsWith(that, search, index)
4029
- : stringSlice$4(that, index, index + search.length) === search;
3347
+ : stringSlice$5(that, index, index + search.length) === search;
4030
3348
  }
4031
3349
  });
4032
3350
 
4033
- var anObject$2 = anObject$d;
3351
+ var anObject$3 = anObject$e;
4034
3352
 
4035
3353
  // `RegExp.prototype.flags` getter implementation
4036
3354
  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
4037
3355
  var regexpFlags$1 = function () {
4038
- var that = anObject$2(this);
3356
+ var that = anObject$3(this);
4039
3357
  var result = '';
4040
3358
  if (that.global) result += 'g';
4041
3359
  if (that.ignoreCase) result += 'i';
@@ -4046,13 +3364,13 @@ var regexpFlags$1 = function () {
4046
3364
  return result;
4047
3365
  };
4048
3366
 
4049
- var fails$4 = fails$h;
4050
- var global$4 = global$H;
3367
+ var fails$7 = fails$k;
3368
+ var global$7 = global$K;
4051
3369
 
4052
3370
  // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
4053
- var $RegExp$2 = global$4.RegExp;
3371
+ var $RegExp$2 = global$7.RegExp;
4054
3372
 
4055
- var UNSUPPORTED_Y$1 = fails$4(function () {
3373
+ var UNSUPPORTED_Y$2 = fails$7(function () {
4056
3374
  var re = $RegExp$2('a', 'y');
4057
3375
  re.lastIndex = 2;
4058
3376
  return re.exec('abcd') != null;
@@ -4060,11 +3378,11 @@ var UNSUPPORTED_Y$1 = fails$4(function () {
4060
3378
 
4061
3379
  // UC Browser bug
4062
3380
  // https://github.com/zloirock/core-js/issues/1008
4063
- var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$4(function () {
3381
+ var MISSED_STICKY = UNSUPPORTED_Y$2 || fails$7(function () {
4064
3382
  return !$RegExp$2('a', 'y').sticky;
4065
3383
  });
4066
3384
 
4067
- var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () {
3385
+ var BROKEN_CARET = UNSUPPORTED_Y$2 || fails$7(function () {
4068
3386
  // https://bugzilla.mozilla.org/show_bug.cgi?id=773687
4069
3387
  var re = $RegExp$2('^r', 'gy');
4070
3388
  re.lastIndex = 2;
@@ -4074,27 +3392,27 @@ var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () {
4074
3392
  var regexpStickyHelpers = {
4075
3393
  BROKEN_CARET: BROKEN_CARET,
4076
3394
  MISSED_STICKY: MISSED_STICKY,
4077
- UNSUPPORTED_Y: UNSUPPORTED_Y$1
3395
+ UNSUPPORTED_Y: UNSUPPORTED_Y$2
4078
3396
  };
4079
3397
 
4080
- var fails$3 = fails$h;
4081
- var global$3 = global$H;
3398
+ var fails$6 = fails$k;
3399
+ var global$6 = global$K;
4082
3400
 
4083
3401
  // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
4084
- var $RegExp$1 = global$3.RegExp;
3402
+ var $RegExp$1 = global$6.RegExp;
4085
3403
 
4086
- var regexpUnsupportedDotAll = fails$3(function () {
3404
+ var regexpUnsupportedDotAll = fails$6(function () {
4087
3405
  var re = $RegExp$1('.', 's');
4088
3406
  return !(re.dotAll && re.exec('\n') && re.flags === 's');
4089
3407
  });
4090
3408
 
4091
- var fails$2 = fails$h;
4092
- var global$2 = global$H;
3409
+ var fails$5 = fails$k;
3410
+ var global$5 = global$K;
4093
3411
 
4094
3412
  // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
4095
- var $RegExp = global$2.RegExp;
3413
+ var $RegExp = global$5.RegExp;
4096
3414
 
4097
- var regexpUnsupportedNcg = fails$2(function () {
3415
+ var regexpUnsupportedNcg = fails$5(function () {
4098
3416
  var re = $RegExp('(?<a>b)', 'g');
4099
3417
  return re.exec('b').groups.a !== 'b' ||
4100
3418
  'b'.replace(re, '$<a>c') !== 'bc';
@@ -4102,11 +3420,11 @@ var regexpUnsupportedNcg = fails$2(function () {
4102
3420
 
4103
3421
  /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
4104
3422
  /* eslint-disable regexp/no-useless-quantifier -- testing */
4105
- var call$2 = functionCall;
4106
- var uncurryThis$4 = functionUncurryThis;
4107
- var toString$2 = toString$4;
3423
+ var call$3 = functionCall;
3424
+ var uncurryThis$7 = functionUncurryThis;
3425
+ var toString$5 = toString$7;
4108
3426
  var regexpFlags = regexpFlags$1;
4109
- var stickyHelpers = regexpStickyHelpers;
3427
+ var stickyHelpers$1 = regexpStickyHelpers;
4110
3428
  var shared = shared$4.exports;
4111
3429
  var create = objectCreate;
4112
3430
  var getInternalState = internalState.get;
@@ -4116,55 +3434,55 @@ var UNSUPPORTED_NCG = regexpUnsupportedNcg;
4116
3434
  var nativeReplace = shared('native-string-replace', String.prototype.replace);
4117
3435
  var nativeExec = RegExp.prototype.exec;
4118
3436
  var patchedExec = nativeExec;
4119
- var charAt$3 = uncurryThis$4(''.charAt);
4120
- var indexOf = uncurryThis$4(''.indexOf);
4121
- var replace$1 = uncurryThis$4(''.replace);
4122
- var stringSlice$3 = uncurryThis$4(''.slice);
3437
+ var charAt$3 = uncurryThis$7(''.charAt);
3438
+ var indexOf = uncurryThis$7(''.indexOf);
3439
+ var replace$2 = uncurryThis$7(''.replace);
3440
+ var stringSlice$4 = uncurryThis$7(''.slice);
4123
3441
 
4124
3442
  var UPDATES_LAST_INDEX_WRONG = (function () {
4125
3443
  var re1 = /a/;
4126
3444
  var re2 = /b*/g;
4127
- call$2(nativeExec, re1, 'a');
4128
- call$2(nativeExec, re2, 'a');
3445
+ call$3(nativeExec, re1, 'a');
3446
+ call$3(nativeExec, re2, 'a');
4129
3447
  return re1.lastIndex !== 0 || re2.lastIndex !== 0;
4130
3448
  })();
4131
3449
 
4132
- var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
3450
+ var UNSUPPORTED_Y$1 = stickyHelpers$1.BROKEN_CARET;
4133
3451
 
4134
3452
  // nonparticipating capturing group, copied from es5-shim's String#split patch.
4135
3453
  var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
4136
3454
 
4137
- var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
3455
+ var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1 || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
4138
3456
 
4139
3457
  if (PATCH) {
4140
3458
  patchedExec = function exec(string) {
4141
3459
  var re = this;
4142
3460
  var state = getInternalState(re);
4143
- var str = toString$2(string);
3461
+ var str = toString$5(string);
4144
3462
  var raw = state.raw;
4145
3463
  var result, reCopy, lastIndex, match, i, object, group;
4146
3464
 
4147
3465
  if (raw) {
4148
3466
  raw.lastIndex = re.lastIndex;
4149
- result = call$2(patchedExec, raw, str);
3467
+ result = call$3(patchedExec, raw, str);
4150
3468
  re.lastIndex = raw.lastIndex;
4151
3469
  return result;
4152
3470
  }
4153
3471
 
4154
3472
  var groups = state.groups;
4155
- var sticky = UNSUPPORTED_Y && re.sticky;
4156
- var flags = call$2(regexpFlags, re);
3473
+ var sticky = UNSUPPORTED_Y$1 && re.sticky;
3474
+ var flags = call$3(regexpFlags, re);
4157
3475
  var source = re.source;
4158
3476
  var charsAdded = 0;
4159
3477
  var strCopy = str;
4160
3478
 
4161
3479
  if (sticky) {
4162
- flags = replace$1(flags, 'y', '');
3480
+ flags = replace$2(flags, 'y', '');
4163
3481
  if (indexOf(flags, 'g') === -1) {
4164
3482
  flags += 'g';
4165
3483
  }
4166
3484
 
4167
- strCopy = stringSlice$3(str, re.lastIndex);
3485
+ strCopy = stringSlice$4(str, re.lastIndex);
4168
3486
  // Support anchored sticky behavior.
4169
3487
  if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$3(str, re.lastIndex - 1) !== '\n')) {
4170
3488
  source = '(?: ' + source + ')';
@@ -4181,12 +3499,12 @@ if (PATCH) {
4181
3499
  }
4182
3500
  if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
4183
3501
 
4184
- match = call$2(nativeExec, sticky ? reCopy : re, strCopy);
3502
+ match = call$3(nativeExec, sticky ? reCopy : re, strCopy);
4185
3503
 
4186
3504
  if (sticky) {
4187
3505
  if (match) {
4188
- match.input = stringSlice$3(match.input, charsAdded);
4189
- match[0] = stringSlice$3(match[0], charsAdded);
3506
+ match.input = stringSlice$4(match.input, charsAdded);
3507
+ match[0] = stringSlice$4(match[0], charsAdded);
4190
3508
  match.index = re.lastIndex;
4191
3509
  re.lastIndex += match[0].length;
4192
3510
  } else re.lastIndex = 0;
@@ -4196,7 +3514,7 @@ if (PATCH) {
4196
3514
  if (NPCG_INCLUDED && match && match.length > 1) {
4197
3515
  // Fix browsers whose `exec` methods don't consistently return `undefined`
4198
3516
  // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
4199
- call$2(nativeReplace, match[0], reCopy, function () {
3517
+ call$3(nativeReplace, match[0], reCopy, function () {
4200
3518
  for (i = 1; i < arguments.length - 2; i++) {
4201
3519
  if (arguments[i] === undefined) match[i] = undefined;
4202
3520
  }
@@ -4215,23 +3533,23 @@ if (PATCH) {
4215
3533
  };
4216
3534
  }
4217
3535
 
4218
- var regexpExec$2 = patchedExec;
3536
+ var regexpExec$3 = patchedExec;
4219
3537
 
4220
- var $ = _export;
4221
- var exec = regexpExec$2;
3538
+ var $$2 = _export;
3539
+ var exec$2 = regexpExec$3;
4222
3540
 
4223
3541
  // `RegExp.prototype.exec` method
4224
3542
  // https://tc39.es/ecma262/#sec-regexp.prototype.exec
4225
- $({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
4226
- exec: exec
3543
+ $$2({ target: 'RegExp', proto: true, forced: /./.exec !== exec$2 }, {
3544
+ exec: exec$2
4227
3545
  });
4228
3546
 
4229
3547
  // TODO: Remove from `core-js@4` since it's moved to entry points
4230
3548
 
4231
- var uncurryThis$3 = functionUncurryThis;
3549
+ var uncurryThis$6 = functionUncurryThis;
4232
3550
  var redefine = redefine$6.exports;
4233
- var regexpExec$1 = regexpExec$2;
4234
- var fails$1 = fails$h;
3551
+ var regexpExec$2 = regexpExec$3;
3552
+ var fails$4 = fails$k;
4235
3553
  var wellKnownSymbol$1 = wellKnownSymbol$i;
4236
3554
  var createNonEnumerableProperty = createNonEnumerableProperty$6;
4237
3555
 
@@ -4241,14 +3559,14 @@ var RegExpPrototype = RegExp.prototype;
4241
3559
  var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
4242
3560
  var SYMBOL = wellKnownSymbol$1(KEY);
4243
3561
 
4244
- var DELEGATES_TO_SYMBOL = !fails$1(function () {
3562
+ var DELEGATES_TO_SYMBOL = !fails$4(function () {
4245
3563
  // String methods call symbol-named RegEp methods
4246
3564
  var O = {};
4247
3565
  O[SYMBOL] = function () { return 7; };
4248
3566
  return ''[KEY](O) != 7;
4249
3567
  });
4250
3568
 
4251
- var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$1(function () {
3569
+ var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$4(function () {
4252
3570
  // Symbol-named RegExp methods call .exec
4253
3571
  var execCalled = false;
4254
3572
  var re = /a/;
@@ -4277,11 +3595,11 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
4277
3595
  !DELEGATES_TO_EXEC ||
4278
3596
  FORCED
4279
3597
  ) {
4280
- var uncurriedNativeRegExpMethod = uncurryThis$3(/./[SYMBOL]);
3598
+ var uncurriedNativeRegExpMethod = uncurryThis$6(/./[SYMBOL]);
4281
3599
  var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
4282
- var uncurriedNativeMethod = uncurryThis$3(nativeMethod);
3600
+ var uncurriedNativeMethod = uncurryThis$6(nativeMethod);
4283
3601
  var $exec = regexp.exec;
4284
- if ($exec === regexpExec$1 || $exec === RegExpPrototype.exec) {
3602
+ if ($exec === regexpExec$2 || $exec === RegExpPrototype.exec) {
4285
3603
  if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
4286
3604
  // The native String method already delegates to @@method (this
4287
3605
  // polyfilled function), leasing to infinite recursion.
@@ -4300,18 +3618,18 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
4300
3618
  if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
4301
3619
  };
4302
3620
 
4303
- var uncurryThis$2 = functionUncurryThis;
3621
+ var uncurryThis$5 = functionUncurryThis;
4304
3622
  var toIntegerOrInfinity$1 = toIntegerOrInfinity$4;
4305
- var toString$1 = toString$4;
4306
- var requireObjectCoercible$1 = requireObjectCoercible$5;
3623
+ var toString$4 = toString$7;
3624
+ var requireObjectCoercible$3 = requireObjectCoercible$7;
4307
3625
 
4308
- var charAt$2 = uncurryThis$2(''.charAt);
4309
- var charCodeAt = uncurryThis$2(''.charCodeAt);
4310
- var stringSlice$2 = uncurryThis$2(''.slice);
3626
+ var charAt$2 = uncurryThis$5(''.charAt);
3627
+ var charCodeAt = uncurryThis$5(''.charCodeAt);
3628
+ var stringSlice$3 = uncurryThis$5(''.slice);
4311
3629
 
4312
- var createMethod = function (CONVERT_TO_STRING) {
3630
+ var createMethod$2 = function (CONVERT_TO_STRING) {
4313
3631
  return function ($this, pos) {
4314
- var S = toString$1(requireObjectCoercible$1($this));
3632
+ var S = toString$4(requireObjectCoercible$3($this));
4315
3633
  var position = toIntegerOrInfinity$1(pos);
4316
3634
  var size = S.length;
4317
3635
  var first, second;
@@ -4323,7 +3641,7 @@ var createMethod = function (CONVERT_TO_STRING) {
4323
3641
  ? charAt$2(S, position)
4324
3642
  : first
4325
3643
  : CONVERT_TO_STRING
4326
- ? stringSlice$2(S, position, position + 2)
3644
+ ? stringSlice$3(S, position, position + 2)
4327
3645
  : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
4328
3646
  };
4329
3647
  };
@@ -4331,27 +3649,27 @@ var createMethod = function (CONVERT_TO_STRING) {
4331
3649
  var stringMultibyte = {
4332
3650
  // `String.prototype.codePointAt` method
4333
3651
  // https://tc39.es/ecma262/#sec-string.prototype.codepointat
4334
- codeAt: createMethod(false),
3652
+ codeAt: createMethod$2(false),
4335
3653
  // `String.prototype.at` method
4336
3654
  // https://github.com/mathiasbynens/String.prototype.at
4337
- charAt: createMethod(true)
3655
+ charAt: createMethod$2(true)
4338
3656
  };
4339
3657
 
4340
3658
  var charAt$1 = stringMultibyte.charAt;
4341
3659
 
4342
3660
  // `AdvanceStringIndex` abstract operation
4343
3661
  // https://tc39.es/ecma262/#sec-advancestringindex
4344
- var advanceStringIndex$1 = function (S, index, unicode) {
3662
+ var advanceStringIndex$2 = function (S, index, unicode) {
4345
3663
  return index + (unicode ? charAt$1(S, index).length : 1);
4346
3664
  };
4347
3665
 
4348
- var uncurryThis$1 = functionUncurryThis;
4349
- var toObject = toObject$4;
3666
+ var uncurryThis$4 = functionUncurryThis;
3667
+ var toObject$1 = toObject$5;
4350
3668
 
4351
3669
  var floor = Math.floor;
4352
- var charAt = uncurryThis$1(''.charAt);
4353
- var replace = uncurryThis$1(''.replace);
4354
- var stringSlice$1 = uncurryThis$1(''.slice);
3670
+ var charAt = uncurryThis$4(''.charAt);
3671
+ var replace$1 = uncurryThis$4(''.replace);
3672
+ var stringSlice$2 = uncurryThis$4(''.slice);
4355
3673
  var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
4356
3674
  var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
4357
3675
 
@@ -4362,18 +3680,18 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
4362
3680
  var m = captures.length;
4363
3681
  var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
4364
3682
  if (namedCaptures !== undefined) {
4365
- namedCaptures = toObject(namedCaptures);
3683
+ namedCaptures = toObject$1(namedCaptures);
4366
3684
  symbols = SUBSTITUTION_SYMBOLS;
4367
3685
  }
4368
- return replace(replacement, symbols, function (match, ch) {
3686
+ return replace$1(replacement, symbols, function (match, ch) {
4369
3687
  var capture;
4370
3688
  switch (charAt(ch, 0)) {
4371
3689
  case '$': return '$';
4372
3690
  case '&': return matched;
4373
- case '`': return stringSlice$1(str, 0, position);
4374
- case "'": return stringSlice$1(str, tailPos);
3691
+ case '`': return stringSlice$2(str, 0, position);
3692
+ case "'": return stringSlice$2(str, tailPos);
4375
3693
  case '<':
4376
- capture = namedCaptures[stringSlice$1(ch, 1, -1)];
3694
+ capture = namedCaptures[stringSlice$2(ch, 1, -1)];
4377
3695
  break;
4378
3696
  default: // \d\d?
4379
3697
  var n = +ch;
@@ -4390,52 +3708,52 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
4390
3708
  });
4391
3709
  };
4392
3710
 
4393
- var global$1 = global$H;
4394
- var call$1 = functionCall;
4395
- var anObject$1 = anObject$d;
3711
+ var global$4 = global$K;
3712
+ var call$2 = functionCall;
3713
+ var anObject$2 = anObject$e;
4396
3714
  var isCallable$1 = isCallable$j;
4397
3715
  var classof = classofRaw$1;
4398
- var regexpExec = regexpExec$2;
3716
+ var regexpExec$1 = regexpExec$3;
4399
3717
 
4400
- var TypeError$1 = global$1.TypeError;
3718
+ var TypeError$2 = global$4.TypeError;
4401
3719
 
4402
3720
  // `RegExpExec` abstract operation
4403
3721
  // https://tc39.es/ecma262/#sec-regexpexec
4404
3722
  var regexpExecAbstract = function (R, S) {
4405
3723
  var exec = R.exec;
4406
3724
  if (isCallable$1(exec)) {
4407
- var result = call$1(exec, R, S);
4408
- if (result !== null) anObject$1(result);
3725
+ var result = call$2(exec, R, S);
3726
+ if (result !== null) anObject$2(result);
4409
3727
  return result;
4410
3728
  }
4411
- if (classof(R) === 'RegExp') return call$1(regexpExec, R, S);
4412
- throw TypeError$1('RegExp#exec called on incompatible receiver');
3729
+ if (classof(R) === 'RegExp') return call$2(regexpExec$1, R, S);
3730
+ throw TypeError$2('RegExp#exec called on incompatible receiver');
4413
3731
  };
4414
3732
 
4415
- var apply = functionApply;
4416
- var call = functionCall;
4417
- var uncurryThis = functionUncurryThis;
4418
- var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
4419
- var fails = fails$h;
4420
- var anObject = anObject$d;
3733
+ var apply$1 = functionApply;
3734
+ var call$1 = functionCall;
3735
+ var uncurryThis$3 = functionUncurryThis;
3736
+ var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic;
3737
+ var fails$3 = fails$k;
3738
+ var anObject$1 = anObject$e;
4421
3739
  var isCallable = isCallable$j;
4422
3740
  var toIntegerOrInfinity = toIntegerOrInfinity$4;
4423
- var toLength = toLength$3;
4424
- var toString = toString$4;
4425
- var requireObjectCoercible = requireObjectCoercible$5;
4426
- var advanceStringIndex = advanceStringIndex$1;
4427
- var getMethod = getMethod$4;
3741
+ var toLength$1 = toLength$4;
3742
+ var toString$3 = toString$7;
3743
+ var requireObjectCoercible$2 = requireObjectCoercible$7;
3744
+ var advanceStringIndex$1 = advanceStringIndex$2;
3745
+ var getMethod$1 = getMethod$5;
4428
3746
  var getSubstitution = getSubstitution$1;
4429
3747
  var regExpExec = regexpExecAbstract;
4430
3748
  var wellKnownSymbol = wellKnownSymbol$i;
4431
3749
 
4432
3750
  var REPLACE = wellKnownSymbol('replace');
4433
- var max = Math.max;
4434
- var min = Math.min;
4435
- var concat = uncurryThis([].concat);
4436
- var push = uncurryThis([].push);
4437
- var stringIndexOf = uncurryThis(''.indexOf);
4438
- var stringSlice = uncurryThis(''.slice);
3751
+ var max$1 = Math.max;
3752
+ var min$1 = Math.min;
3753
+ var concat = uncurryThis$3([].concat);
3754
+ var push$1 = uncurryThis$3([].push);
3755
+ var stringIndexOf = uncurryThis$3(''.indexOf);
3756
+ var stringSlice$1 = uncurryThis$3(''.slice);
4439
3757
 
4440
3758
  var maybeToString = function (it) {
4441
3759
  return it === undefined ? it : String(it);
@@ -4456,7 +3774,7 @@ var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
4456
3774
  return false;
4457
3775
  })();
4458
3776
 
4459
- var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
3777
+ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$3(function () {
4460
3778
  var re = /./;
4461
3779
  re.exec = function () {
4462
3780
  var result = [];
@@ -4468,24 +3786,24 @@ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
4468
3786
  });
4469
3787
 
4470
3788
  // @@replace logic
4471
- fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
3789
+ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCallNative) {
4472
3790
  var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
4473
3791
 
4474
3792
  return [
4475
3793
  // `String.prototype.replace` method
4476
3794
  // https://tc39.es/ecma262/#sec-string.prototype.replace
4477
3795
  function replace(searchValue, replaceValue) {
4478
- var O = requireObjectCoercible(this);
4479
- var replacer = searchValue == undefined ? undefined : getMethod(searchValue, REPLACE);
3796
+ var O = requireObjectCoercible$2(this);
3797
+ var replacer = searchValue == undefined ? undefined : getMethod$1(searchValue, REPLACE);
4480
3798
  return replacer
4481
- ? call(replacer, searchValue, O, replaceValue)
4482
- : call(nativeReplace, toString(O), searchValue, replaceValue);
3799
+ ? call$1(replacer, searchValue, O, replaceValue)
3800
+ : call$1(nativeReplace, toString$3(O), searchValue, replaceValue);
4483
3801
  },
4484
3802
  // `RegExp.prototype[@@replace]` method
4485
3803
  // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
4486
3804
  function (string, replaceValue) {
4487
- var rx = anObject(this);
4488
- var S = toString(string);
3805
+ var rx = anObject$1(this);
3806
+ var S = toString$3(string);
4489
3807
 
4490
3808
  if (
4491
3809
  typeof replaceValue == 'string' &&
@@ -4497,7 +3815,7 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
4497
3815
  }
4498
3816
 
4499
3817
  var functionalReplace = isCallable(replaceValue);
4500
- if (!functionalReplace) replaceValue = toString(replaceValue);
3818
+ if (!functionalReplace) replaceValue = toString$3(replaceValue);
4501
3819
 
4502
3820
  var global = rx.global;
4503
3821
  if (global) {
@@ -4509,11 +3827,11 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
4509
3827
  var result = regExpExec(rx, S);
4510
3828
  if (result === null) break;
4511
3829
 
4512
- push(results, result);
3830
+ push$1(results, result);
4513
3831
  if (!global) break;
4514
3832
 
4515
- var matchStr = toString(result[0]);
4516
- if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
3833
+ var matchStr = toString$3(result[0]);
3834
+ if (matchStr === '') rx.lastIndex = advanceStringIndex$1(S, toLength$1(rx.lastIndex), fullUnicode);
4517
3835
  }
4518
3836
 
4519
3837
  var accumulatedResult = '';
@@ -4521,35 +3839,33 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
4521
3839
  for (var i = 0; i < results.length; i++) {
4522
3840
  result = results[i];
4523
3841
 
4524
- var matched = toString(result[0]);
4525
- var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
3842
+ var matched = toString$3(result[0]);
3843
+ var position = max$1(min$1(toIntegerOrInfinity(result.index), S.length), 0);
4526
3844
  var captures = [];
4527
3845
  // NOTE: This is equivalent to
4528
3846
  // captures = result.slice(1).map(maybeToString)
4529
3847
  // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
4530
3848
  // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
4531
3849
  // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
4532
- for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
3850
+ for (var j = 1; j < result.length; j++) push$1(captures, maybeToString(result[j]));
4533
3851
  var namedCaptures = result.groups;
4534
3852
  if (functionalReplace) {
4535
3853
  var replacerArgs = concat([matched], captures, position, S);
4536
- if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
4537
- var replacement = toString(apply(replaceValue, undefined, replacerArgs));
3854
+ if (namedCaptures !== undefined) push$1(replacerArgs, namedCaptures);
3855
+ var replacement = toString$3(apply$1(replaceValue, undefined, replacerArgs));
4538
3856
  } else {
4539
3857
  replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
4540
3858
  }
4541
3859
  if (position >= nextSourcePosition) {
4542
- accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
3860
+ accumulatedResult += stringSlice$1(S, nextSourcePosition, position) + replacement;
4543
3861
  nextSourcePosition = position + matched.length;
4544
3862
  }
4545
3863
  }
4546
- return accumulatedResult + stringSlice(S, nextSourcePosition);
3864
+ return accumulatedResult + stringSlice$1(S, nextSourcePosition);
4547
3865
  }
4548
3866
  ];
4549
3867
  }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
4550
3868
 
4551
- const EXPERIENCE_TRAIT_PREFIX = 'nt_experiment_';
4552
-
4553
3869
  const selectActiveExperiments = (experiments, profile) => {
4554
3870
  const experimentTraits = pickBy(profile.traits, (value, key) => key.startsWith(EXPERIENCE_TRAIT_PREFIX) && value === true);
4555
3871
  const experimentTraitsIds = Object.keys(experimentTraits).map(id => id.replace(EXPERIENCE_TRAIT_PREFIX, '')); // a experiment is active when the use has it set as a true value on the traits and the experiment config is still active
@@ -4559,12 +3875,12 @@ const selectActiveExperiments = (experiments, profile) => {
4559
3875
  };
4560
3876
 
4561
3877
  /**
4562
- * We can use any personalization as eglible experience
3878
+ * We can use any personalization as eligible experience
4563
3879
  * When going for an experiment we can only select a active experiment when 1 or more experiments are active
4564
3880
  * If the profile is not in any active experiments, we can select any expermiment
4565
3881
  */
4566
3882
 
4567
- const selectEglibleExperiences = ({
3883
+ const selectEligibleExperiences = ({
4568
3884
  experiences,
4569
3885
  activeExperiments
4570
3886
  }) => {
@@ -4587,25 +3903,56 @@ const getRandom = text => {
4587
3903
  const getTrafficRandom = (profile, experience) => getRandom(`traffic-${experience.id}-${profile.id}`);
4588
3904
  const getDistributionRandom = (profile, experience) => getRandom(`distribution-${experience.id}-${profile.id}`);
4589
3905
 
3906
+ const isExperienceMatch = ({
3907
+ experience,
3908
+ activeExperiments,
3909
+ profile
3910
+ }) => {
3911
+ const trafficRandom = getTrafficRandom(profile, experience);
3912
+ log(`The traffic random factor for experience ${experience.id} is ${trafficRandom}. It's traffic allocation is set to ${experience.trafficAllocation}.`);
3913
+ const isInTrafficRange = experience.trafficAllocation > trafficRandom;
3914
+ const matchesAudience = !experience.audience || includes(profile.audiences, experience.audience.id);
3915
+ const hasActiveExperiment = !!find(activeExperiments, {
3916
+ id: experience.id
3917
+ });
3918
+ log(`Is the profile in traffic allocation range? ${isInTrafficRange ? 'yes' : 'no'}.\n
3919
+ Does the profile match the audience of the experience? ${matchesAudience ? 'yes' : 'no'}.\n
3920
+ Is there an active experiment for this profile? ${hasActiveExperiment ? 'yes' : 'no'}.`);
3921
+ return isInTrafficRange && (matchesAudience || // if the expriment is active already then it's selectible without further contraints to be fullfilled
3922
+ hasActiveExperiment);
3923
+ };
3924
+
4590
3925
  const selectExperience = ({
4591
3926
  experiences,
4592
3927
  activeExperiments,
4593
3928
  profile
4594
3929
  }) => {
4595
- const eglibleExperiences = selectEglibleExperiences({
3930
+ const eligibleExperiences = selectEligibleExperiences({
4596
3931
  experiences,
4597
3932
  activeExperiments
4598
3933
  });
4599
- const selectedExperience = eglibleExperiences.find(experience => {
4600
- const trafficRandom = getTrafficRandom(profile, experience);
4601
- return experience.trafficAllocation > trafficRandom && (includes(profile.audiences, experience.audience.id) || // if the expriment is active already then it's selectible without further contraints to be fullfilled
4602
- find(activeExperiments, {
4603
- id: experience.id
4604
- }));
4605
- });
3934
+ const selectedExperience = eligibleExperiences.find(experience => isExperienceMatch({
3935
+ experience,
3936
+ activeExperiments,
3937
+ profile
3938
+ }));
4606
3939
  return selectedExperience;
4607
3940
  };
4608
3941
 
3942
+ const selectDistribution = ({
3943
+ experience,
3944
+ profile
3945
+ }) => {
3946
+ const distributionRandom = getDistributionRandom(profile, experience);
3947
+ log(`The distribution random factor for experience ${experience.id} is ${distributionRandom}. It's distribution is set to ${JSON.stringify(experience.distribution, null, 2)}.`);
3948
+ const distribution = find(experience.distribution, ({
3949
+ start,
3950
+ end
3951
+ }) => distributionRandom >= start && distributionRandom <= end // this overlaps on one value for each boundary but we just find the first match
3952
+ );
3953
+ return distribution;
3954
+ };
3955
+
4609
3956
  const selectVariant = ({
4610
3957
  baseline,
4611
3958
  experience,
@@ -4615,28 +3962,12 @@ const selectVariant = ({
4615
3962
 
4616
3963
  if (!variants.length) {
4617
3964
  return null;
4618
- } // Personalization
4619
-
4620
-
4621
- if (experience.type === 'nt_personalization') {
4622
- const trafficRandom = getTrafficRandom(profile, experience);
4623
-
4624
- if (1 - experience.trafficAllocation > trafficRandom) {
4625
- return Object.assign(Object.assign({}, baseline), {
4626
- hidden: false
4627
- });
4628
- } // Personalization Expriences can have only one variant.
4629
-
4630
-
4631
- return variants[0];
4632
3965
  }
4633
3966
 
4634
- const distributionRandom = getDistributionRandom(profile, experience); // Experiment
4635
-
4636
- const distribution = find(experience.distribution, ({
4637
- start,
4638
- end
4639
- }) => distributionRandom > start && distributionRandom < end);
3967
+ const distribution = selectDistribution({
3968
+ experience,
3969
+ profile
3970
+ });
4640
3971
 
4641
3972
  if (!distribution) {
4642
3973
  return null;
@@ -4665,4 +3996,348 @@ const selectVariant = ({
4665
3996
  return variant;
4666
3997
  };
4667
3998
 
4668
- export { NINETAILED_TRACKER_EVENTS, Ninetailed, PLUGIN_NAME, ninetailedPlugin, selectActiveExperiments, selectEglibleExperiences, selectExperience, selectBaselineWithVariants as selectExperienceBaselineWithVariants, selectVariant as selectExperienceVariant, selectVariants as selectExperienceVariants, selectHasVariants as selectHasExperienceVariants, selectVariant$1 as selectVariant };
3999
+ var global$3 = global$K;
4000
+ var aCallable = aCallable$6;
4001
+ var toObject = toObject$5;
4002
+ var IndexedObject = indexedObject;
4003
+ var lengthOfArrayLike$1 = lengthOfArrayLike$4;
4004
+
4005
+ var TypeError$1 = global$3.TypeError;
4006
+
4007
+ // `Array.prototype.{ reduce, reduceRight }` methods implementation
4008
+ var createMethod$1 = function (IS_RIGHT) {
4009
+ return function (that, callbackfn, argumentsLength, memo) {
4010
+ aCallable(callbackfn);
4011
+ var O = toObject(that);
4012
+ var self = IndexedObject(O);
4013
+ var length = lengthOfArrayLike$1(O);
4014
+ var index = IS_RIGHT ? length - 1 : 0;
4015
+ var i = IS_RIGHT ? -1 : 1;
4016
+ if (argumentsLength < 2) while (true) {
4017
+ if (index in self) {
4018
+ memo = self[index];
4019
+ index += i;
4020
+ break;
4021
+ }
4022
+ index += i;
4023
+ if (IS_RIGHT ? index < 0 : length <= index) {
4024
+ throw TypeError$1('Reduce of empty array with no initial value');
4025
+ }
4026
+ }
4027
+ for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
4028
+ memo = callbackfn(memo, self[index], index, O);
4029
+ }
4030
+ return memo;
4031
+ };
4032
+ };
4033
+
4034
+ var arrayReduce = {
4035
+ // `Array.prototype.reduce` method
4036
+ // https://tc39.es/ecma262/#sec-array.prototype.reduce
4037
+ left: createMethod$1(false),
4038
+ // `Array.prototype.reduceRight` method
4039
+ // https://tc39.es/ecma262/#sec-array.prototype.reduceright
4040
+ right: createMethod$1(true)
4041
+ };
4042
+
4043
+ var fails$2 = fails$k;
4044
+
4045
+ var arrayMethodIsStrict$1 = function (METHOD_NAME, argument) {
4046
+ var method = [][METHOD_NAME];
4047
+ return !!method && fails$2(function () {
4048
+ // eslint-disable-next-line no-useless-call -- required for testing
4049
+ method.call(null, argument || function () { return 1; }, 1);
4050
+ });
4051
+ };
4052
+
4053
+ var $$1 = _export;
4054
+ var $reduce = arrayReduce.left;
4055
+ var arrayMethodIsStrict = arrayMethodIsStrict$1;
4056
+ var CHROME_VERSION = engineV8Version;
4057
+ var IS_NODE = engineIsNode;
4058
+
4059
+ var STRICT_METHOD = arrayMethodIsStrict('reduce');
4060
+ // Chrome 80-82 has a critical bug
4061
+ // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
4062
+ var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83;
4063
+
4064
+ // `Array.prototype.reduce` method
4065
+ // https://tc39.es/ecma262/#sec-array.prototype.reduce
4066
+ $$1({ target: 'Array', proto: true, forced: !STRICT_METHOD || CHROME_BUG }, {
4067
+ reduce: function reduce(callbackfn /* , initialValue */) {
4068
+ var length = arguments.length;
4069
+ return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : undefined);
4070
+ }
4071
+ });
4072
+
4073
+ var toPropertyKey = toPropertyKey$3;
4074
+ var definePropertyModule = objectDefineProperty;
4075
+ var createPropertyDescriptor = createPropertyDescriptor$4;
4076
+
4077
+ var createProperty$1 = function (object, key, value) {
4078
+ var propertyKey = toPropertyKey(key);
4079
+ if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
4080
+ else object[propertyKey] = value;
4081
+ };
4082
+
4083
+ var global$2 = global$K;
4084
+ var toAbsoluteIndex = toAbsoluteIndex$2;
4085
+ var lengthOfArrayLike = lengthOfArrayLike$4;
4086
+ var createProperty = createProperty$1;
4087
+
4088
+ var Array$1 = global$2.Array;
4089
+ var max = Math.max;
4090
+
4091
+ var arraySliceSimple = function (O, start, end) {
4092
+ var length = lengthOfArrayLike(O);
4093
+ var k = toAbsoluteIndex(start, length);
4094
+ var fin = toAbsoluteIndex(end === undefined ? length : end, length);
4095
+ var result = Array$1(max(fin - k, 0));
4096
+ for (var n = 0; k < fin; k++, n++) createProperty(result, n, O[k]);
4097
+ result.length = n;
4098
+ return result;
4099
+ };
4100
+
4101
+ var apply = functionApply;
4102
+ var call = functionCall;
4103
+ var uncurryThis$2 = functionUncurryThis;
4104
+ var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
4105
+ var isRegExp = isRegexp;
4106
+ var anObject = anObject$e;
4107
+ var requireObjectCoercible$1 = requireObjectCoercible$7;
4108
+ var speciesConstructor = speciesConstructor$2;
4109
+ var advanceStringIndex = advanceStringIndex$2;
4110
+ var toLength = toLength$4;
4111
+ var toString$2 = toString$7;
4112
+ var getMethod = getMethod$5;
4113
+ var arraySlice = arraySliceSimple;
4114
+ var callRegExpExec = regexpExecAbstract;
4115
+ var regexpExec = regexpExec$3;
4116
+ var stickyHelpers = regexpStickyHelpers;
4117
+ var fails$1 = fails$k;
4118
+
4119
+ var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
4120
+ var MAX_UINT32 = 0xFFFFFFFF;
4121
+ var min = Math.min;
4122
+ var $push = [].push;
4123
+ var exec$1 = uncurryThis$2(/./.exec);
4124
+ var push = uncurryThis$2($push);
4125
+ var stringSlice = uncurryThis$2(''.slice);
4126
+
4127
+ // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
4128
+ // Weex JS has frozen built-in prototypes, so use try / catch wrapper
4129
+ var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails$1(function () {
4130
+ // eslint-disable-next-line regexp/no-empty-group -- required for testing
4131
+ var re = /(?:)/;
4132
+ var originalExec = re.exec;
4133
+ re.exec = function () { return originalExec.apply(this, arguments); };
4134
+ var result = 'ab'.split(re);
4135
+ return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
4136
+ });
4137
+
4138
+ // @@split logic
4139
+ fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
4140
+ var internalSplit;
4141
+ if (
4142
+ 'abbc'.split(/(b)*/)[1] == 'c' ||
4143
+ // eslint-disable-next-line regexp/no-empty-group -- required for testing
4144
+ 'test'.split(/(?:)/, -1).length != 4 ||
4145
+ 'ab'.split(/(?:ab)*/).length != 2 ||
4146
+ '.'.split(/(.?)(.?)/).length != 4 ||
4147
+ // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
4148
+ '.'.split(/()()/).length > 1 ||
4149
+ ''.split(/.?/).length
4150
+ ) {
4151
+ // based on es5-shim implementation, need to rework it
4152
+ internalSplit = function (separator, limit) {
4153
+ var string = toString$2(requireObjectCoercible$1(this));
4154
+ var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
4155
+ if (lim === 0) return [];
4156
+ if (separator === undefined) return [string];
4157
+ // If `separator` is not a regex, use native split
4158
+ if (!isRegExp(separator)) {
4159
+ return call(nativeSplit, string, separator, lim);
4160
+ }
4161
+ var output = [];
4162
+ var flags = (separator.ignoreCase ? 'i' : '') +
4163
+ (separator.multiline ? 'm' : '') +
4164
+ (separator.unicode ? 'u' : '') +
4165
+ (separator.sticky ? 'y' : '');
4166
+ var lastLastIndex = 0;
4167
+ // Make `global` and avoid `lastIndex` issues by working with a copy
4168
+ var separatorCopy = new RegExp(separator.source, flags + 'g');
4169
+ var match, lastIndex, lastLength;
4170
+ while (match = call(regexpExec, separatorCopy, string)) {
4171
+ lastIndex = separatorCopy.lastIndex;
4172
+ if (lastIndex > lastLastIndex) {
4173
+ push(output, stringSlice(string, lastLastIndex, match.index));
4174
+ if (match.length > 1 && match.index < string.length) apply($push, output, arraySlice(match, 1));
4175
+ lastLength = match[0].length;
4176
+ lastLastIndex = lastIndex;
4177
+ if (output.length >= lim) break;
4178
+ }
4179
+ if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
4180
+ }
4181
+ if (lastLastIndex === string.length) {
4182
+ if (lastLength || !exec$1(separatorCopy, '')) push(output, '');
4183
+ } else push(output, stringSlice(string, lastLastIndex));
4184
+ return output.length > lim ? arraySlice(output, 0, lim) : output;
4185
+ };
4186
+ // Chakra, V8
4187
+ } else if ('0'.split(undefined, 0).length) {
4188
+ internalSplit = function (separator, limit) {
4189
+ return separator === undefined && limit === 0 ? [] : call(nativeSplit, this, separator, limit);
4190
+ };
4191
+ } else internalSplit = nativeSplit;
4192
+
4193
+ return [
4194
+ // `String.prototype.split` method
4195
+ // https://tc39.es/ecma262/#sec-string.prototype.split
4196
+ function split(separator, limit) {
4197
+ var O = requireObjectCoercible$1(this);
4198
+ var splitter = separator == undefined ? undefined : getMethod(separator, SPLIT);
4199
+ return splitter
4200
+ ? call(splitter, separator, O, limit)
4201
+ : call(internalSplit, toString$2(O), separator, limit);
4202
+ },
4203
+ // `RegExp.prototype[@@split]` method
4204
+ // https://tc39.es/ecma262/#sec-regexp.prototype-@@split
4205
+ //
4206
+ // NOTE: This cannot be properly polyfilled in engines that don't support
4207
+ // the 'y' flag.
4208
+ function (string, limit) {
4209
+ var rx = anObject(this);
4210
+ var S = toString$2(string);
4211
+ var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
4212
+
4213
+ if (res.done) return res.value;
4214
+
4215
+ var C = speciesConstructor(rx, RegExp);
4216
+
4217
+ var unicodeMatching = rx.unicode;
4218
+ var flags = (rx.ignoreCase ? 'i' : '') +
4219
+ (rx.multiline ? 'm' : '') +
4220
+ (rx.unicode ? 'u' : '') +
4221
+ (UNSUPPORTED_Y ? 'g' : 'y');
4222
+
4223
+ // ^(? + rx + ) is needed, in combination with some S slicing, to
4224
+ // simulate the 'y' flag.
4225
+ var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags);
4226
+ var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
4227
+ if (lim === 0) return [];
4228
+ if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];
4229
+ var p = 0;
4230
+ var q = 0;
4231
+ var A = [];
4232
+ while (q < S.length) {
4233
+ splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
4234
+ var z = callRegExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);
4235
+ var e;
4236
+ if (
4237
+ z === null ||
4238
+ (e = min(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p
4239
+ ) {
4240
+ q = advanceStringIndex(S, q, unicodeMatching);
4241
+ } else {
4242
+ push(A, stringSlice(S, p, q));
4243
+ if (A.length === lim) return A;
4244
+ for (var i = 1; i <= z.length - 1; i++) {
4245
+ push(A, z[i]);
4246
+ if (A.length === lim) return A;
4247
+ }
4248
+ q = p = e;
4249
+ }
4250
+ }
4251
+ push(A, stringSlice(S, p));
4252
+ return A;
4253
+ }
4254
+ ];
4255
+ }, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
4256
+
4257
+ // a string of all valid unicode whitespaces
4258
+ var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
4259
+ '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
4260
+
4261
+ var uncurryThis$1 = functionUncurryThis;
4262
+ var requireObjectCoercible = requireObjectCoercible$7;
4263
+ var toString$1 = toString$7;
4264
+ var whitespaces$1 = whitespaces$2;
4265
+
4266
+ var replace = uncurryThis$1(''.replace);
4267
+ var whitespace = '[' + whitespaces$1 + ']';
4268
+ var ltrim = RegExp('^' + whitespace + whitespace + '*');
4269
+ var rtrim = RegExp(whitespace + whitespace + '*$');
4270
+
4271
+ // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
4272
+ var createMethod = function (TYPE) {
4273
+ return function ($this) {
4274
+ var string = toString$1(requireObjectCoercible($this));
4275
+ if (TYPE & 1) string = replace(string, ltrim, '');
4276
+ if (TYPE & 2) string = replace(string, rtrim, '');
4277
+ return string;
4278
+ };
4279
+ };
4280
+
4281
+ var stringTrim = {
4282
+ // `String.prototype.{ trimLeft, trimStart }` methods
4283
+ // https://tc39.es/ecma262/#sec-string.prototype.trimstart
4284
+ start: createMethod(1),
4285
+ // `String.prototype.{ trimRight, trimEnd }` methods
4286
+ // https://tc39.es/ecma262/#sec-string.prototype.trimend
4287
+ end: createMethod(2),
4288
+ // `String.prototype.trim` method
4289
+ // https://tc39.es/ecma262/#sec-string.prototype.trim
4290
+ trim: createMethod(3)
4291
+ };
4292
+
4293
+ var global$1 = global$K;
4294
+ var fails = fails$k;
4295
+ var uncurryThis = functionUncurryThis;
4296
+ var toString = toString$7;
4297
+ var trim = stringTrim.trim;
4298
+ var whitespaces = whitespaces$2;
4299
+
4300
+ var $parseInt$1 = global$1.parseInt;
4301
+ var Symbol$1 = global$1.Symbol;
4302
+ var ITERATOR = Symbol$1 && Symbol$1.iterator;
4303
+ var hex = /^[+-]?0x/i;
4304
+ var exec = uncurryThis(hex.exec);
4305
+ var FORCED = $parseInt$1(whitespaces + '08') !== 8 || $parseInt$1(whitespaces + '0x16') !== 22
4306
+ // MS Edge 18- broken with boxed symbols
4307
+ || (ITERATOR && !fails(function () { $parseInt$1(Object(ITERATOR)); }));
4308
+
4309
+ // `parseInt` method
4310
+ // https://tc39.es/ecma262/#sec-parseint-string-radix
4311
+ var numberParseInt = FORCED ? function parseInt(string, radix) {
4312
+ var S = trim(toString(string));
4313
+ return $parseInt$1(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));
4314
+ } : $parseInt$1;
4315
+
4316
+ var $ = _export;
4317
+ var $parseInt = numberParseInt;
4318
+
4319
+ // `parseInt` method
4320
+ // https://tc39.es/ecma262/#sec-parseint-string-radix
4321
+ $({ global: true, forced: parseInt != $parseInt }, {
4322
+ parseInt: $parseInt
4323
+ });
4324
+
4325
+ const decodeExperienceVariantsMap = encodedExperienceVariantsMap => {
4326
+ return encodedExperienceVariantsMap.split(',').map(experienceIdWithVariant => {
4327
+ const [experienceId, _variantIndex] = experienceIdWithVariant.split('=');
4328
+ const variantIndex = parseInt(_variantIndex);
4329
+
4330
+ if (!experienceId || !variantIndex) {
4331
+ return null;
4332
+ }
4333
+
4334
+ return {
4335
+ experienceId,
4336
+ variantIndex
4337
+ };
4338
+ }).filter(x => x).reduce((acc, curr) => Object.assign(Object.assign({}, acc), {
4339
+ [curr.experienceId]: curr.variantIndex
4340
+ }), {});
4341
+ };
4342
+
4343
+ export { index as Cache, EXPERIENCE_TRAIT_PREFIX, 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 };