@ninetailed/experience.js 1.0.0-beta.8 → 1.0.1-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/index.d.ts +1 -0
  2. package/index.esm.js +904 -501
  3. package/index.umd.js +252 -304
  4. package/lib/Ninetailed.d.ts +12 -2
  5. package/lib/analytics/get-analytics-plugin.d.ts +2 -1
  6. package/lib/selectVariant.d.ts +5 -4
  7. package/lib/types.d.ts +0 -5
  8. package/package.json +3 -3
package/index.esm.js CHANGED
@@ -6,8 +6,9 @@ import require$$1 from 'tty';
6
6
  import require$$1$1 from 'util';
7
7
  import require$$0 from 'os';
8
8
  import Analytics from 'analytics';
9
- import includes from 'lodash/includes';
9
+ import flatten from 'lodash/flatten';
10
10
  import find from 'lodash/find';
11
+ import includes from 'lodash/includes';
11
12
 
12
13
  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
13
14
 
@@ -16,7 +17,7 @@ var check = function (it) {
16
17
  };
17
18
 
18
19
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
19
- var global$A =
20
+ var global$B =
20
21
  // eslint-disable-next-line es/no-global-this -- safe
21
22
  check(typeof globalThis == 'object' && globalThis) ||
22
23
  check(typeof window == 'object' && window) ||
@@ -28,7 +29,7 @@ var global$A =
28
29
 
29
30
  var objectGetOwnPropertyDescriptor = {};
30
31
 
31
- var fails$b = function (exec) {
32
+ var fails$c = function (exec) {
32
33
  try {
33
34
  return !!exec();
34
35
  } catch (error) {
@@ -36,17 +37,17 @@ var fails$b = function (exec) {
36
37
  }
37
38
  };
38
39
 
39
- var fails$a = fails$b;
40
+ var fails$b = fails$c;
40
41
 
41
42
  // Detect IE8's incomplete defineProperty implementation
42
- var descriptors = !fails$a(function () {
43
+ var descriptors = !fails$b(function () {
43
44
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
44
45
  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
45
46
  });
46
47
 
47
- var fails$9 = fails$b;
48
+ var fails$a = fails$c;
48
49
 
49
- var functionBindNative = !fails$9(function () {
50
+ var functionBindNative = !fails$a(function () {
50
51
  var test = (function () { /* empty */ }).bind();
51
52
  // eslint-disable-next-line no-prototype-builtins -- safe
52
53
  return typeof test != 'function' || test.hasOwnProperty('prototype');
@@ -54,10 +55,10 @@ var functionBindNative = !fails$9(function () {
54
55
 
55
56
  var NATIVE_BIND$3 = functionBindNative;
56
57
 
57
- var call$a = Function.prototype.call;
58
+ var call$b = Function.prototype.call;
58
59
 
59
- var functionCall = NATIVE_BIND$3 ? call$a.bind(call$a) : function () {
60
- return call$a.apply(call$a, arguments);
60
+ var functionCall = NATIVE_BIND$3 ? call$b.bind(call$b) : function () {
61
+ return call$b.apply(call$b, arguments);
61
62
  };
62
63
 
63
64
  var objectPropertyIsEnumerable = {};
@@ -76,7 +77,7 @@ objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
76
77
  return !!descriptor && descriptor.enumerable;
77
78
  } : $propertyIsEnumerable;
78
79
 
79
- var createPropertyDescriptor$2 = function (bitmap, value) {
80
+ var createPropertyDescriptor$3 = function (bitmap, value) {
80
81
  return {
81
82
  enumerable: !(bitmap & 1),
82
83
  configurable: !(bitmap & 2),
@@ -89,14 +90,14 @@ var NATIVE_BIND$2 = functionBindNative;
89
90
 
90
91
  var FunctionPrototype$2 = Function.prototype;
91
92
  var bind$5 = FunctionPrototype$2.bind;
92
- var call$9 = FunctionPrototype$2.call;
93
- var uncurryThis$e = NATIVE_BIND$2 && bind$5.bind(call$9, call$9);
93
+ var call$a = FunctionPrototype$2.call;
94
+ var uncurryThis$e = NATIVE_BIND$2 && bind$5.bind(call$a, call$a);
94
95
 
95
96
  var functionUncurryThis = NATIVE_BIND$2 ? function (fn) {
96
97
  return fn && uncurryThis$e(fn);
97
98
  } : function (fn) {
98
99
  return fn && function () {
99
- return call$9.apply(fn, arguments);
100
+ return call$a.apply(fn, arguments);
100
101
  };
101
102
  };
102
103
 
@@ -109,63 +110,63 @@ var classofRaw$1 = function (it) {
109
110
  return stringSlice(toString$1(it), 8, -1);
110
111
  };
111
112
 
112
- var global$z = global$A;
113
+ var global$A = global$B;
113
114
  var uncurryThis$c = functionUncurryThis;
114
- var fails$8 = fails$b;
115
+ var fails$9 = fails$c;
115
116
  var classof$4 = classofRaw$1;
116
117
 
117
- var Object$4 = global$z.Object;
118
+ var Object$5 = global$A.Object;
118
119
  var split = uncurryThis$c(''.split);
119
120
 
120
121
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
121
- var indexedObject = fails$8(function () {
122
+ var indexedObject = fails$9(function () {
122
123
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
123
124
  // eslint-disable-next-line no-prototype-builtins -- safe
124
- return !Object$4('z').propertyIsEnumerable(0);
125
+ return !Object$5('z').propertyIsEnumerable(0);
125
126
  }) ? function (it) {
126
- return classof$4(it) == 'String' ? split(it, '') : Object$4(it);
127
- } : Object$4;
127
+ return classof$4(it) == 'String' ? split(it, '') : Object$5(it);
128
+ } : Object$5;
128
129
 
129
- var global$y = global$A;
130
+ var global$z = global$B;
130
131
 
131
- var TypeError$f = global$y.TypeError;
132
+ var TypeError$e = global$z.TypeError;
132
133
 
133
134
  // `RequireObjectCoercible` abstract operation
134
135
  // https://tc39.es/ecma262/#sec-requireobjectcoercible
135
136
  var requireObjectCoercible$2 = function (it) {
136
- if (it == undefined) throw TypeError$f("Can't call method on " + it);
137
+ if (it == undefined) throw TypeError$e("Can't call method on " + it);
137
138
  return it;
138
139
  };
139
140
 
140
141
  // toObject with fallback for non-array-like ES3 strings
141
- var IndexedObject$2 = indexedObject;
142
+ var IndexedObject$1 = indexedObject;
142
143
  var requireObjectCoercible$1 = requireObjectCoercible$2;
143
144
 
144
- var toIndexedObject$3 = function (it) {
145
- return IndexedObject$2(requireObjectCoercible$1(it));
145
+ var toIndexedObject$5 = function (it) {
146
+ return IndexedObject$1(requireObjectCoercible$1(it));
146
147
  };
147
148
 
148
149
  // `IsCallable` abstract operation
149
150
  // https://tc39.es/ecma262/#sec-iscallable
150
- var isCallable$e = function (argument) {
151
+ var isCallable$h = function (argument) {
151
152
  return typeof argument == 'function';
152
153
  };
153
154
 
154
- var isCallable$d = isCallable$e;
155
+ var isCallable$g = isCallable$h;
155
156
 
156
157
  var isObject$7 = function (it) {
157
- return typeof it == 'object' ? it !== null : isCallable$d(it);
158
+ return typeof it == 'object' ? it !== null : isCallable$g(it);
158
159
  };
159
160
 
160
- var global$x = global$A;
161
- var isCallable$c = isCallable$e;
161
+ var global$y = global$B;
162
+ var isCallable$f = isCallable$h;
162
163
 
163
164
  var aFunction = function (argument) {
164
- return isCallable$c(argument) ? argument : undefined;
165
+ return isCallable$f(argument) ? argument : undefined;
165
166
  };
166
167
 
167
168
  var getBuiltIn$7 = function (namespace, method) {
168
- return arguments.length < 2 ? aFunction(global$x[namespace]) : global$x[namespace] && global$x[namespace][method];
169
+ return arguments.length < 2 ? aFunction(global$y[namespace]) : global$y[namespace] && global$y[namespace][method];
169
170
  };
170
171
 
171
172
  var uncurryThis$b = functionUncurryThis;
@@ -176,11 +177,11 @@ var getBuiltIn$6 = getBuiltIn$7;
176
177
 
177
178
  var engineUserAgent = getBuiltIn$6('navigator', 'userAgent') || '';
178
179
 
179
- var global$w = global$A;
180
+ var global$x = global$B;
180
181
  var userAgent$3 = engineUserAgent;
181
182
 
182
- var process$4 = global$w.process;
183
- var Deno = global$w.Deno;
183
+ var process$4 = global$x.process;
184
+ var Deno = global$x.Deno;
184
185
  var versions = process$4 && process$4.versions || Deno && Deno.version;
185
186
  var v8 = versions && versions.v8;
186
187
  var match, version;
@@ -207,10 +208,10 @@ var engineV8Version = version;
207
208
  /* eslint-disable es/no-symbol -- required for testing */
208
209
 
209
210
  var V8_VERSION$1 = engineV8Version;
210
- var fails$7 = fails$b;
211
+ var fails$8 = fails$c;
211
212
 
212
213
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
213
- var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$7(function () {
214
+ var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$8(function () {
214
215
  var symbol = Symbol();
215
216
  // Chrome 38 Symbol has incorrect toString conversion
216
217
  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
@@ -227,24 +228,24 @@ var useSymbolAsUid = NATIVE_SYMBOL$1
227
228
  && !Symbol.sham
228
229
  && typeof Symbol.iterator == 'symbol';
229
230
 
230
- var global$v = global$A;
231
+ var global$w = global$B;
231
232
  var getBuiltIn$5 = getBuiltIn$7;
232
- var isCallable$b = isCallable$e;
233
+ var isCallable$e = isCallable$h;
233
234
  var isPrototypeOf$2 = objectIsPrototypeOf;
234
235
  var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
235
236
 
236
- var Object$3 = global$v.Object;
237
+ var Object$4 = global$w.Object;
237
238
 
238
239
  var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
239
240
  return typeof it == 'symbol';
240
241
  } : function (it) {
241
242
  var $Symbol = getBuiltIn$5('Symbol');
242
- return isCallable$b($Symbol) && isPrototypeOf$2($Symbol.prototype, Object$3(it));
243
+ return isCallable$e($Symbol) && isPrototypeOf$2($Symbol.prototype, Object$4(it));
243
244
  };
244
245
 
245
- var global$u = global$A;
246
+ var global$v = global$B;
246
247
 
247
- var String$4 = global$u.String;
248
+ var String$4 = global$v.String;
248
249
 
249
250
  var tryToString$4 = function (argument) {
250
251
  try {
@@ -254,64 +255,64 @@ var tryToString$4 = function (argument) {
254
255
  }
255
256
  };
256
257
 
257
- var global$t = global$A;
258
- var isCallable$a = isCallable$e;
258
+ var global$u = global$B;
259
+ var isCallable$d = isCallable$h;
259
260
  var tryToString$3 = tryToString$4;
260
261
 
261
- var TypeError$e = global$t.TypeError;
262
+ var TypeError$d = global$u.TypeError;
262
263
 
263
264
  // `Assert: IsCallable(argument) is true`
264
- var aCallable$6 = function (argument) {
265
- if (isCallable$a(argument)) return argument;
266
- throw TypeError$e(tryToString$3(argument) + ' is not a function');
265
+ var aCallable$5 = function (argument) {
266
+ if (isCallable$d(argument)) return argument;
267
+ throw TypeError$d(tryToString$3(argument) + ' is not a function');
267
268
  };
268
269
 
269
- var aCallable$5 = aCallable$6;
270
+ var aCallable$4 = aCallable$5;
270
271
 
271
272
  // `GetMethod` abstract operation
272
273
  // https://tc39.es/ecma262/#sec-getmethod
273
274
  var getMethod$3 = function (V, P) {
274
275
  var func = V[P];
275
- return func == null ? undefined : aCallable$5(func);
276
+ return func == null ? undefined : aCallable$4(func);
276
277
  };
277
278
 
278
- var global$s = global$A;
279
- var call$8 = functionCall;
280
- var isCallable$9 = isCallable$e;
279
+ var global$t = global$B;
280
+ var call$9 = functionCall;
281
+ var isCallable$c = isCallable$h;
281
282
  var isObject$6 = isObject$7;
282
283
 
283
- var TypeError$d = global$s.TypeError;
284
+ var TypeError$c = global$t.TypeError;
284
285
 
285
286
  // `OrdinaryToPrimitive` abstract operation
286
287
  // https://tc39.es/ecma262/#sec-ordinarytoprimitive
287
288
  var ordinaryToPrimitive$1 = function (input, pref) {
288
289
  var fn, val;
289
- if (pref === 'string' && isCallable$9(fn = input.toString) && !isObject$6(val = call$8(fn, input))) return val;
290
- if (isCallable$9(fn = input.valueOf) && !isObject$6(val = call$8(fn, input))) return val;
291
- if (pref !== 'string' && isCallable$9(fn = input.toString) && !isObject$6(val = call$8(fn, input))) return val;
292
- throw TypeError$d("Can't convert object to primitive value");
290
+ if (pref === 'string' && isCallable$c(fn = input.toString) && !isObject$6(val = call$9(fn, input))) return val;
291
+ if (isCallable$c(fn = input.valueOf) && !isObject$6(val = call$9(fn, input))) return val;
292
+ if (pref !== 'string' && isCallable$c(fn = input.toString) && !isObject$6(val = call$9(fn, input))) return val;
293
+ throw TypeError$c("Can't convert object to primitive value");
293
294
  };
294
295
 
295
296
  var shared$3 = {exports: {}};
296
297
 
297
- var global$r = global$A;
298
+ var global$s = global$B;
298
299
 
299
300
  // eslint-disable-next-line es/no-object-defineproperty -- safe
300
- var defineProperty$2 = Object.defineProperty;
301
+ var defineProperty$3 = Object.defineProperty;
301
302
 
302
303
  var setGlobal$3 = function (key, value) {
303
304
  try {
304
- defineProperty$2(global$r, key, { value: value, configurable: true, writable: true });
305
+ defineProperty$3(global$s, key, { value: value, configurable: true, writable: true });
305
306
  } catch (error) {
306
- global$r[key] = value;
307
+ global$s[key] = value;
307
308
  } return value;
308
309
  };
309
310
 
310
- var global$q = global$A;
311
+ var global$r = global$B;
311
312
  var setGlobal$2 = setGlobal$3;
312
313
 
313
314
  var SHARED = '__core-js_shared__';
314
- var store$3 = global$q[SHARED] || setGlobal$2(SHARED, {});
315
+ var store$3 = global$r[SHARED] || setGlobal$2(SHARED, {});
315
316
 
316
317
  var sharedStore = store$3;
317
318
 
@@ -327,15 +328,15 @@ var store$2 = sharedStore;
327
328
  source: 'https://github.com/zloirock/core-js'
328
329
  });
329
330
 
330
- var global$p = global$A;
331
+ var global$q = global$B;
331
332
  var requireObjectCoercible = requireObjectCoercible$2;
332
333
 
333
- var Object$2 = global$p.Object;
334
+ var Object$3 = global$q.Object;
334
335
 
335
336
  // `ToObject` abstract operation
336
337
  // https://tc39.es/ecma262/#sec-toobject
337
338
  var toObject$3 = function (argument) {
338
- return Object$2(requireObjectCoercible(argument));
339
+ return Object$3(requireObjectCoercible(argument));
339
340
  };
340
341
 
341
342
  var uncurryThis$a = functionUncurryThis;
@@ -359,22 +360,22 @@ var uid$2 = function (key) {
359
360
  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
360
361
  };
361
362
 
362
- var global$o = global$A;
363
+ var global$p = global$B;
363
364
  var shared$2 = shared$3.exports;
364
- var hasOwn$8 = hasOwnProperty_1;
365
+ var hasOwn$9 = hasOwnProperty_1;
365
366
  var uid$1 = uid$2;
366
367
  var NATIVE_SYMBOL = nativeSymbol;
367
368
  var USE_SYMBOL_AS_UID = useSymbolAsUid;
368
369
 
369
370
  var WellKnownSymbolsStore = shared$2('wks');
370
- var Symbol$1 = global$o.Symbol;
371
+ var Symbol$1 = global$p.Symbol;
371
372
  var symbolFor = Symbol$1 && Symbol$1['for'];
372
373
  var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
373
374
 
374
- var wellKnownSymbol$a = function (name) {
375
- if (!hasOwn$8(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
375
+ var wellKnownSymbol$e = function (name) {
376
+ if (!hasOwn$9(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
376
377
  var description = 'Symbol.' + name;
377
- if (NATIVE_SYMBOL && hasOwn$8(Symbol$1, name)) {
378
+ if (NATIVE_SYMBOL && hasOwn$9(Symbol$1, name)) {
378
379
  WellKnownSymbolsStore[name] = Symbol$1[name];
379
380
  } else if (USE_SYMBOL_AS_UID && symbolFor) {
380
381
  WellKnownSymbolsStore[name] = symbolFor(description);
@@ -384,16 +385,16 @@ var wellKnownSymbol$a = function (name) {
384
385
  } return WellKnownSymbolsStore[name];
385
386
  };
386
387
 
387
- var global$n = global$A;
388
- var call$7 = functionCall;
388
+ var global$o = global$B;
389
+ var call$8 = functionCall;
389
390
  var isObject$5 = isObject$7;
390
391
  var isSymbol$1 = isSymbol$2;
391
392
  var getMethod$2 = getMethod$3;
392
393
  var ordinaryToPrimitive = ordinaryToPrimitive$1;
393
- var wellKnownSymbol$9 = wellKnownSymbol$a;
394
+ var wellKnownSymbol$d = wellKnownSymbol$e;
394
395
 
395
- var TypeError$c = global$n.TypeError;
396
- var TO_PRIMITIVE = wellKnownSymbol$9('toPrimitive');
396
+ var TypeError$b = global$o.TypeError;
397
+ var TO_PRIMITIVE = wellKnownSymbol$d('toPrimitive');
397
398
 
398
399
  // `ToPrimitive` abstract operation
399
400
  // https://tc39.es/ecma262/#sec-toprimitive
@@ -403,9 +404,9 @@ var toPrimitive$1 = function (input, pref) {
403
404
  var result;
404
405
  if (exoticToPrim) {
405
406
  if (pref === undefined) pref = 'default';
406
- result = call$7(exoticToPrim, input, pref);
407
+ result = call$8(exoticToPrim, input, pref);
407
408
  if (!isObject$5(result) || isSymbol$1(result)) return result;
408
- throw TypeError$c("Can't convert object to primitive value");
409
+ throw TypeError$b("Can't convert object to primitive value");
409
410
  }
410
411
  if (pref === undefined) pref = 'number';
411
412
  return ordinaryToPrimitive(input, pref);
@@ -421,36 +422,36 @@ var toPropertyKey$2 = function (argument) {
421
422
  return isSymbol(key) ? key : key + '';
422
423
  };
423
424
 
424
- var global$m = global$A;
425
+ var global$n = global$B;
425
426
  var isObject$4 = isObject$7;
426
427
 
427
- var document$3 = global$m.document;
428
+ var document$3 = global$n.document;
428
429
  // typeof document.createElement is 'object' in old IE
429
430
  var EXISTS$1 = isObject$4(document$3) && isObject$4(document$3.createElement);
430
431
 
431
- var documentCreateElement = function (it) {
432
+ var documentCreateElement$2 = function (it) {
432
433
  return EXISTS$1 ? document$3.createElement(it) : {};
433
434
  };
434
435
 
435
- var DESCRIPTORS$7 = descriptors;
436
- var fails$6 = fails$b;
437
- var createElement$1 = documentCreateElement;
436
+ var DESCRIPTORS$9 = descriptors;
437
+ var fails$7 = fails$c;
438
+ var createElement$1 = documentCreateElement$2;
438
439
 
439
440
  // Thanks to IE8 for its funny defineProperty
440
- var ie8DomDefine = !DESCRIPTORS$7 && !fails$6(function () {
441
+ var ie8DomDefine = !DESCRIPTORS$9 && !fails$7(function () {
441
442
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
442
443
  return Object.defineProperty(createElement$1('div'), 'a', {
443
444
  get: function () { return 7; }
444
445
  }).a != 7;
445
446
  });
446
447
 
447
- var DESCRIPTORS$6 = descriptors;
448
- var call$6 = functionCall;
448
+ var DESCRIPTORS$8 = descriptors;
449
+ var call$7 = functionCall;
449
450
  var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
450
- var createPropertyDescriptor$1 = createPropertyDescriptor$2;
451
- var toIndexedObject$2 = toIndexedObject$3;
451
+ var createPropertyDescriptor$2 = createPropertyDescriptor$3;
452
+ var toIndexedObject$4 = toIndexedObject$5;
452
453
  var toPropertyKey$1 = toPropertyKey$2;
453
- var hasOwn$7 = hasOwnProperty_1;
454
+ var hasOwn$8 = hasOwnProperty_1;
454
455
  var IE8_DOM_DEFINE$1 = ie8DomDefine;
455
456
 
456
457
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -458,23 +459,23 @@ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
458
459
 
459
460
  // `Object.getOwnPropertyDescriptor` method
460
461
  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
461
- objectGetOwnPropertyDescriptor.f = DESCRIPTORS$6 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
462
- O = toIndexedObject$2(O);
462
+ objectGetOwnPropertyDescriptor.f = DESCRIPTORS$8 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
463
+ O = toIndexedObject$4(O);
463
464
  P = toPropertyKey$1(P);
464
465
  if (IE8_DOM_DEFINE$1) try {
465
466
  return $getOwnPropertyDescriptor$1(O, P);
466
467
  } catch (error) { /* empty */ }
467
- if (hasOwn$7(O, P)) return createPropertyDescriptor$1(!call$6(propertyIsEnumerableModule$1.f, O, P), O[P]);
468
+ if (hasOwn$8(O, P)) return createPropertyDescriptor$2(!call$7(propertyIsEnumerableModule$1.f, O, P), O[P]);
468
469
  };
469
470
 
470
471
  var objectDefineProperty = {};
471
472
 
472
- var DESCRIPTORS$5 = descriptors;
473
- var fails$5 = fails$b;
473
+ var DESCRIPTORS$7 = descriptors;
474
+ var fails$6 = fails$c;
474
475
 
475
476
  // V8 ~ Chrome 36-
476
477
  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
477
- var v8PrototypeDefineBug = DESCRIPTORS$5 && fails$5(function () {
478
+ var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$6(function () {
478
479
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
479
480
  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
480
481
  value: 42,
@@ -482,26 +483,26 @@ var v8PrototypeDefineBug = DESCRIPTORS$5 && fails$5(function () {
482
483
  }).prototype != 42;
483
484
  });
484
485
 
485
- var global$l = global$A;
486
+ var global$m = global$B;
486
487
  var isObject$3 = isObject$7;
487
488
 
488
- var String$3 = global$l.String;
489
- var TypeError$b = global$l.TypeError;
489
+ var String$3 = global$m.String;
490
+ var TypeError$a = global$m.TypeError;
490
491
 
491
492
  // `Assert: Type(argument) is Object`
492
- var anObject$8 = function (argument) {
493
+ var anObject$a = function (argument) {
493
494
  if (isObject$3(argument)) return argument;
494
- throw TypeError$b(String$3(argument) + ' is not an object');
495
+ throw TypeError$a(String$3(argument) + ' is not an object');
495
496
  };
496
497
 
497
- var global$k = global$A;
498
- var DESCRIPTORS$4 = descriptors;
498
+ var global$l = global$B;
499
+ var DESCRIPTORS$6 = descriptors;
499
500
  var IE8_DOM_DEFINE = ie8DomDefine;
500
- var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
501
- var anObject$7 = anObject$8;
501
+ var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
502
+ var anObject$9 = anObject$a;
502
503
  var toPropertyKey = toPropertyKey$2;
503
504
 
504
- var TypeError$a = global$k.TypeError;
505
+ var TypeError$9 = global$l.TypeError;
505
506
  // eslint-disable-next-line es/no-object-defineproperty -- safe
506
507
  var $defineProperty = Object.defineProperty;
507
508
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -512,10 +513,10 @@ var WRITABLE = 'writable';
512
513
 
513
514
  // `Object.defineProperty` method
514
515
  // https://tc39.es/ecma262/#sec-object.defineproperty
515
- objectDefineProperty.f = DESCRIPTORS$4 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
516
- anObject$7(O);
516
+ objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
517
+ anObject$9(O);
517
518
  P = toPropertyKey(P);
518
- anObject$7(Attributes);
519
+ anObject$9(Attributes);
519
520
  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
520
521
  var current = $getOwnPropertyDescriptor(O, P);
521
522
  if (current && current[WRITABLE]) {
@@ -528,38 +529,38 @@ objectDefineProperty.f = DESCRIPTORS$4 ? V8_PROTOTYPE_DEFINE_BUG ? function defi
528
529
  }
529
530
  } return $defineProperty(O, P, Attributes);
530
531
  } : $defineProperty : function defineProperty(O, P, Attributes) {
531
- anObject$7(O);
532
+ anObject$9(O);
532
533
  P = toPropertyKey(P);
533
- anObject$7(Attributes);
534
+ anObject$9(Attributes);
534
535
  if (IE8_DOM_DEFINE) try {
535
536
  return $defineProperty(O, P, Attributes);
536
537
  } catch (error) { /* empty */ }
537
- if ('get' in Attributes || 'set' in Attributes) throw TypeError$a('Accessors not supported');
538
+ if ('get' in Attributes || 'set' in Attributes) throw TypeError$9('Accessors not supported');
538
539
  if ('value' in Attributes) O[P] = Attributes.value;
539
540
  return O;
540
541
  };
541
542
 
542
- var DESCRIPTORS$3 = descriptors;
543
- var definePropertyModule$2 = objectDefineProperty;
544
- var createPropertyDescriptor = createPropertyDescriptor$2;
543
+ var DESCRIPTORS$5 = descriptors;
544
+ var definePropertyModule$4 = objectDefineProperty;
545
+ var createPropertyDescriptor$1 = createPropertyDescriptor$3;
545
546
 
546
- var createNonEnumerableProperty$3 = DESCRIPTORS$3 ? function (object, key, value) {
547
- return definePropertyModule$2.f(object, key, createPropertyDescriptor(1, value));
547
+ var createNonEnumerableProperty$5 = DESCRIPTORS$5 ? function (object, key, value) {
548
+ return definePropertyModule$4.f(object, key, createPropertyDescriptor$1(1, value));
548
549
  } : function (object, key, value) {
549
550
  object[key] = value;
550
551
  return object;
551
552
  };
552
553
 
553
- var redefine$3 = {exports: {}};
554
+ var redefine$5 = {exports: {}};
554
555
 
555
556
  var uncurryThis$8 = functionUncurryThis;
556
- var isCallable$8 = isCallable$e;
557
+ var isCallable$b = isCallable$h;
557
558
  var store$1 = sharedStore;
558
559
 
559
560
  var functionToString = uncurryThis$8(Function.toString);
560
561
 
561
562
  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
562
- if (!isCallable$8(store$1.inspectSource)) {
563
+ if (!isCallable$b(store$1.inspectSource)) {
563
564
  store$1.inspectSource = function (it) {
564
565
  return functionToString(it);
565
566
  };
@@ -567,38 +568,38 @@ if (!isCallable$8(store$1.inspectSource)) {
567
568
 
568
569
  var inspectSource$4 = store$1.inspectSource;
569
570
 
570
- var global$j = global$A;
571
- var isCallable$7 = isCallable$e;
571
+ var global$k = global$B;
572
+ var isCallable$a = isCallable$h;
572
573
  var inspectSource$3 = inspectSource$4;
573
574
 
574
- var WeakMap$1 = global$j.WeakMap;
575
+ var WeakMap$1 = global$k.WeakMap;
575
576
 
576
- var nativeWeakMap = isCallable$7(WeakMap$1) && /native code/.test(inspectSource$3(WeakMap$1));
577
+ var nativeWeakMap = isCallable$a(WeakMap$1) && /native code/.test(inspectSource$3(WeakMap$1));
577
578
 
578
579
  var shared$1 = shared$3.exports;
579
580
  var uid = uid$2;
580
581
 
581
582
  var keys = shared$1('keys');
582
583
 
583
- var sharedKey$1 = function (key) {
584
+ var sharedKey$3 = function (key) {
584
585
  return keys[key] || (keys[key] = uid(key));
585
586
  };
586
587
 
587
- var hiddenKeys$3 = {};
588
+ var hiddenKeys$4 = {};
588
589
 
589
590
  var NATIVE_WEAK_MAP = nativeWeakMap;
590
- var global$i = global$A;
591
+ var global$j = global$B;
591
592
  var uncurryThis$7 = functionUncurryThis;
592
593
  var isObject$2 = isObject$7;
593
- var createNonEnumerableProperty$2 = createNonEnumerableProperty$3;
594
- var hasOwn$6 = hasOwnProperty_1;
594
+ var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
595
+ var hasOwn$7 = hasOwnProperty_1;
595
596
  var shared = sharedStore;
596
- var sharedKey = sharedKey$1;
597
- var hiddenKeys$2 = hiddenKeys$3;
597
+ var sharedKey$2 = sharedKey$3;
598
+ var hiddenKeys$3 = hiddenKeys$4;
598
599
 
599
600
  var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
600
- var TypeError$9 = global$i.TypeError;
601
- var WeakMap = global$i.WeakMap;
601
+ var TypeError$8 = global$j.TypeError;
602
+ var WeakMap = global$j.WeakMap;
602
603
  var set$2, get$1, has;
603
604
 
604
605
  var enforce = function (it) {
@@ -609,7 +610,7 @@ var getterFor = function (TYPE) {
609
610
  return function (it) {
610
611
  var state;
611
612
  if (!isObject$2(it) || (state = get$1(it)).type !== TYPE) {
612
- throw TypeError$9('Incompatible receiver, ' + TYPE + ' required');
613
+ throw TypeError$8('Incompatible receiver, ' + TYPE + ' required');
613
614
  } return state;
614
615
  };
615
616
  };
@@ -620,7 +621,7 @@ if (NATIVE_WEAK_MAP || shared.state) {
620
621
  var wmhas = uncurryThis$7(store.has);
621
622
  var wmset = uncurryThis$7(store.set);
622
623
  set$2 = function (it, metadata) {
623
- if (wmhas(store, it)) throw new TypeError$9(OBJECT_ALREADY_INITIALIZED);
624
+ if (wmhas(store, it)) throw new TypeError$8(OBJECT_ALREADY_INITIALIZED);
624
625
  metadata.facade = it;
625
626
  wmset(store, it, metadata);
626
627
  return metadata;
@@ -632,19 +633,19 @@ if (NATIVE_WEAK_MAP || shared.state) {
632
633
  return wmhas(store, it);
633
634
  };
634
635
  } else {
635
- var STATE = sharedKey('state');
636
- hiddenKeys$2[STATE] = true;
636
+ var STATE = sharedKey$2('state');
637
+ hiddenKeys$3[STATE] = true;
637
638
  set$2 = function (it, metadata) {
638
- if (hasOwn$6(it, STATE)) throw new TypeError$9(OBJECT_ALREADY_INITIALIZED);
639
+ if (hasOwn$7(it, STATE)) throw new TypeError$8(OBJECT_ALREADY_INITIALIZED);
639
640
  metadata.facade = it;
640
- createNonEnumerableProperty$2(it, STATE, metadata);
641
+ createNonEnumerableProperty$4(it, STATE, metadata);
641
642
  return metadata;
642
643
  };
643
644
  get$1 = function (it) {
644
- return hasOwn$6(it, STATE) ? it[STATE] : {};
645
+ return hasOwn$7(it, STATE) ? it[STATE] : {};
645
646
  };
646
647
  has = function (it) {
647
- return hasOwn$6(it, STATE);
648
+ return hasOwn$7(it, STATE);
648
649
  };
649
650
  }
650
651
 
@@ -656,17 +657,17 @@ var internalState = {
656
657
  getterFor: getterFor
657
658
  };
658
659
 
659
- var DESCRIPTORS$2 = descriptors;
660
- var hasOwn$5 = hasOwnProperty_1;
660
+ var DESCRIPTORS$4 = descriptors;
661
+ var hasOwn$6 = hasOwnProperty_1;
661
662
 
662
663
  var FunctionPrototype$1 = Function.prototype;
663
664
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
664
- var getDescriptor = DESCRIPTORS$2 && Object.getOwnPropertyDescriptor;
665
+ var getDescriptor = DESCRIPTORS$4 && Object.getOwnPropertyDescriptor;
665
666
 
666
- var EXISTS = hasOwn$5(FunctionPrototype$1, 'name');
667
+ var EXISTS = hasOwn$6(FunctionPrototype$1, 'name');
667
668
  // additional protection from minified / mangled / dropped function names
668
669
  var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
669
- var CONFIGURABLE = EXISTS && (!DESCRIPTORS$2 || (DESCRIPTORS$2 && getDescriptor(FunctionPrototype$1, 'name').configurable));
670
+ var CONFIGURABLE = EXISTS && (!DESCRIPTORS$4 || (DESCRIPTORS$4 && getDescriptor(FunctionPrototype$1, 'name').configurable));
670
671
 
671
672
  var functionName = {
672
673
  EXISTS: EXISTS,
@@ -674,38 +675,38 @@ var functionName = {
674
675
  CONFIGURABLE: CONFIGURABLE
675
676
  };
676
677
 
677
- var global$h = global$A;
678
- var isCallable$6 = isCallable$e;
679
- var hasOwn$4 = hasOwnProperty_1;
680
- var createNonEnumerableProperty$1 = createNonEnumerableProperty$3;
678
+ var global$i = global$B;
679
+ var isCallable$9 = isCallable$h;
680
+ var hasOwn$5 = hasOwnProperty_1;
681
+ var createNonEnumerableProperty$3 = createNonEnumerableProperty$5;
681
682
  var setGlobal$1 = setGlobal$3;
682
683
  var inspectSource$2 = inspectSource$4;
683
- var InternalStateModule$1 = internalState;
684
- var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
684
+ var InternalStateModule$2 = internalState;
685
+ var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
685
686
 
686
- var getInternalState$1 = InternalStateModule$1.get;
687
- var enforceInternalState = InternalStateModule$1.enforce;
687
+ var getInternalState$2 = InternalStateModule$2.get;
688
+ var enforceInternalState = InternalStateModule$2.enforce;
688
689
  var TEMPLATE = String(String).split('String');
689
690
 
690
- (redefine$3.exports = function (O, key, value, options) {
691
+ (redefine$5.exports = function (O, key, value, options) {
691
692
  var unsafe = options ? !!options.unsafe : false;
692
693
  var simple = options ? !!options.enumerable : false;
693
694
  var noTargetGet = options ? !!options.noTargetGet : false;
694
695
  var name = options && options.name !== undefined ? options.name : key;
695
696
  var state;
696
- if (isCallable$6(value)) {
697
+ if (isCallable$9(value)) {
697
698
  if (String(name).slice(0, 7) === 'Symbol(') {
698
699
  name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
699
700
  }
700
- if (!hasOwn$4(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
701
- createNonEnumerableProperty$1(value, 'name', name);
701
+ if (!hasOwn$5(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
702
+ createNonEnumerableProperty$3(value, 'name', name);
702
703
  }
703
704
  state = enforceInternalState(value);
704
705
  if (!state.source) {
705
706
  state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
706
707
  }
707
708
  }
708
- if (O === global$h) {
709
+ if (O === global$i) {
709
710
  if (simple) O[key] = value;
710
711
  else setGlobal$1(key, value);
711
712
  return;
@@ -715,10 +716,10 @@ var TEMPLATE = String(String).split('String');
715
716
  simple = true;
716
717
  }
717
718
  if (simple) O[key] = value;
718
- else createNonEnumerableProperty$1(O, key, value);
719
+ else createNonEnumerableProperty$3(O, key, value);
719
720
  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
720
721
  })(Function.prototype, 'toString', function toString() {
721
- return isCallable$6(this) && getInternalState$1(this).source || inspectSource$2(this);
722
+ return isCallable$9(this) && getInternalState$2(this).source || inspectSource$2(this);
722
723
  });
723
724
 
724
725
  var objectGetOwnPropertyNames = {};
@@ -761,19 +762,19 @@ var toLength = toLength$1;
761
762
 
762
763
  // `LengthOfArrayLike` abstract operation
763
764
  // https://tc39.es/ecma262/#sec-lengthofarraylike
764
- var lengthOfArrayLike$3 = function (obj) {
765
+ var lengthOfArrayLike$2 = function (obj) {
765
766
  return toLength(obj.length);
766
767
  };
767
768
 
768
- var toIndexedObject$1 = toIndexedObject$3;
769
+ var toIndexedObject$3 = toIndexedObject$5;
769
770
  var toAbsoluteIndex = toAbsoluteIndex$1;
770
- var lengthOfArrayLike$2 = lengthOfArrayLike$3;
771
+ var lengthOfArrayLike$1 = lengthOfArrayLike$2;
771
772
 
772
773
  // `Array.prototype.{ indexOf, includes }` methods implementation
773
- var createMethod$1 = function (IS_INCLUDES) {
774
+ var createMethod = function (IS_INCLUDES) {
774
775
  return function ($this, el, fromIndex) {
775
- var O = toIndexedObject$1($this);
776
- var length = lengthOfArrayLike$2(O);
776
+ var O = toIndexedObject$3($this);
777
+ var length = lengthOfArrayLike$1(O);
777
778
  var index = toAbsoluteIndex(fromIndex, length);
778
779
  var value;
779
780
  // Array#includes uses SameValueZero equality algorithm
@@ -792,35 +793,35 @@ var createMethod$1 = function (IS_INCLUDES) {
792
793
  var arrayIncludes = {
793
794
  // `Array.prototype.includes` method
794
795
  // https://tc39.es/ecma262/#sec-array.prototype.includes
795
- includes: createMethod$1(true),
796
+ includes: createMethod(true),
796
797
  // `Array.prototype.indexOf` method
797
798
  // https://tc39.es/ecma262/#sec-array.prototype.indexof
798
- indexOf: createMethod$1(false)
799
+ indexOf: createMethod(false)
799
800
  };
800
801
 
801
802
  var uncurryThis$6 = functionUncurryThis;
802
- var hasOwn$3 = hasOwnProperty_1;
803
- var toIndexedObject = toIndexedObject$3;
803
+ var hasOwn$4 = hasOwnProperty_1;
804
+ var toIndexedObject$2 = toIndexedObject$5;
804
805
  var indexOf = arrayIncludes.indexOf;
805
- var hiddenKeys$1 = hiddenKeys$3;
806
+ var hiddenKeys$2 = hiddenKeys$4;
806
807
 
807
808
  var push = uncurryThis$6([].push);
808
809
 
809
810
  var objectKeysInternal = function (object, names) {
810
- var O = toIndexedObject(object);
811
+ var O = toIndexedObject$2(object);
811
812
  var i = 0;
812
813
  var result = [];
813
814
  var key;
814
- for (key in O) !hasOwn$3(hiddenKeys$1, key) && hasOwn$3(O, key) && push(result, key);
815
+ for (key in O) !hasOwn$4(hiddenKeys$2, key) && hasOwn$4(O, key) && push(result, key);
815
816
  // Don't enum bug & hidden keys
816
- while (names.length > i) if (hasOwn$3(O, key = names[i++])) {
817
+ while (names.length > i) if (hasOwn$4(O, key = names[i++])) {
817
818
  ~indexOf(result, key) || push(result, key);
818
819
  }
819
820
  return result;
820
821
  };
821
822
 
822
823
  // IE8- don't enum bug keys
823
- var enumBugKeys$2 = [
824
+ var enumBugKeys$3 = [
824
825
  'constructor',
825
826
  'hasOwnProperty',
826
827
  'isPrototypeOf',
@@ -831,15 +832,15 @@ var enumBugKeys$2 = [
831
832
  ];
832
833
 
833
834
  var internalObjectKeys$1 = objectKeysInternal;
834
- var enumBugKeys$1 = enumBugKeys$2;
835
+ var enumBugKeys$2 = enumBugKeys$3;
835
836
 
836
- var hiddenKeys = enumBugKeys$1.concat('length', 'prototype');
837
+ var hiddenKeys$1 = enumBugKeys$2.concat('length', 'prototype');
837
838
 
838
839
  // `Object.getOwnPropertyNames` method
839
840
  // https://tc39.es/ecma262/#sec-object.getownpropertynames
840
841
  // eslint-disable-next-line es/no-object-getownpropertynames -- safe
841
842
  objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
842
- return internalObjectKeys$1(O, hiddenKeys);
843
+ return internalObjectKeys$1(O, hiddenKeys$1);
843
844
  };
844
845
 
845
846
  var objectGetOwnPropertySymbols = {};
@@ -851,36 +852,36 @@ var getBuiltIn$4 = getBuiltIn$7;
851
852
  var uncurryThis$5 = functionUncurryThis;
852
853
  var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
853
854
  var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
854
- var anObject$6 = anObject$8;
855
+ var anObject$8 = anObject$a;
855
856
 
856
857
  var concat$1 = uncurryThis$5([].concat);
857
858
 
858
859
  // all object keys, includes non-enumerable and symbols
859
860
  var ownKeys$1 = getBuiltIn$4('Reflect', 'ownKeys') || function ownKeys(it) {
860
- var keys = getOwnPropertyNamesModule.f(anObject$6(it));
861
+ var keys = getOwnPropertyNamesModule.f(anObject$8(it));
861
862
  var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
862
863
  return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys;
863
864
  };
864
865
 
865
- var hasOwn$2 = hasOwnProperty_1;
866
+ var hasOwn$3 = hasOwnProperty_1;
866
867
  var ownKeys = ownKeys$1;
867
868
  var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
868
- var definePropertyModule$1 = objectDefineProperty;
869
+ var definePropertyModule$3 = objectDefineProperty;
869
870
 
870
871
  var copyConstructorProperties$1 = function (target, source, exceptions) {
871
872
  var keys = ownKeys(source);
872
- var defineProperty = definePropertyModule$1.f;
873
+ var defineProperty = definePropertyModule$3.f;
873
874
  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
874
875
  for (var i = 0; i < keys.length; i++) {
875
876
  var key = keys[i];
876
- if (!hasOwn$2(target, key) && !(exceptions && hasOwn$2(exceptions, key))) {
877
+ if (!hasOwn$3(target, key) && !(exceptions && hasOwn$3(exceptions, key))) {
877
878
  defineProperty(target, key, getOwnPropertyDescriptor(source, key));
878
879
  }
879
880
  }
880
881
  };
881
882
 
882
- var fails$4 = fails$b;
883
- var isCallable$5 = isCallable$e;
883
+ var fails$5 = fails$c;
884
+ var isCallable$8 = isCallable$h;
884
885
 
885
886
  var replacement = /#|\.prototype\./;
886
887
 
@@ -888,7 +889,7 @@ var isForced$2 = function (feature, detection) {
888
889
  var value = data[normalize(feature)];
889
890
  return value == POLYFILL ? true
890
891
  : value == NATIVE ? false
891
- : isCallable$5(detection) ? fails$4(detection)
892
+ : isCallable$8(detection) ? fails$5(detection)
892
893
  : !!detection;
893
894
  };
894
895
 
@@ -902,10 +903,10 @@ var POLYFILL = isForced$2.POLYFILL = 'P';
902
903
 
903
904
  var isForced_1 = isForced$2;
904
905
 
905
- var global$g = global$A;
906
+ var global$h = global$B;
906
907
  var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
907
- var createNonEnumerableProperty = createNonEnumerableProperty$3;
908
- var redefine$2 = redefine$3.exports;
908
+ var createNonEnumerableProperty$2 = createNonEnumerableProperty$5;
909
+ var redefine$4 = redefine$5.exports;
909
910
  var setGlobal = setGlobal$3;
910
911
  var copyConstructorProperties = copyConstructorProperties$1;
911
912
  var isForced$1 = isForced_1;
@@ -931,11 +932,11 @@ var _export = function (options, source) {
931
932
  var STATIC = options.stat;
932
933
  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
933
934
  if (GLOBAL) {
934
- target = global$g;
935
+ target = global$h;
935
936
  } else if (STATIC) {
936
- target = global$g[TARGET] || setGlobal(TARGET, {});
937
+ target = global$h[TARGET] || setGlobal(TARGET, {});
937
938
  } else {
938
- target = (global$g[TARGET] || {}).prototype;
939
+ target = (global$h[TARGET] || {}).prototype;
939
940
  }
940
941
  if (target) for (key in source) {
941
942
  sourceProperty = source[key];
@@ -951,39 +952,39 @@ var _export = function (options, source) {
951
952
  }
952
953
  // add a flag to not completely full polyfills
953
954
  if (options.sham || (targetProperty && targetProperty.sham)) {
954
- createNonEnumerableProperty(sourceProperty, 'sham', true);
955
+ createNonEnumerableProperty$2(sourceProperty, 'sham', true);
955
956
  }
956
957
  // extend global
957
- redefine$2(target, key, sourceProperty, options);
958
+ redefine$4(target, key, sourceProperty, options);
958
959
  }
959
960
  };
960
961
 
961
- var global$f = global$A;
962
+ var global$g = global$B;
962
963
 
963
- var nativePromiseConstructor = global$f.Promise;
964
+ var nativePromiseConstructor = global$g.Promise;
964
965
 
965
- var redefine$1 = redefine$3.exports;
966
+ var redefine$3 = redefine$5.exports;
966
967
 
967
968
  var redefineAll$1 = function (target, src, options) {
968
- for (var key in src) redefine$1(target, key, src[key], options);
969
+ for (var key in src) redefine$3(target, key, src[key], options);
969
970
  return target;
970
971
  };
971
972
 
972
- var global$e = global$A;
973
- var isCallable$4 = isCallable$e;
973
+ var global$f = global$B;
974
+ var isCallable$7 = isCallable$h;
974
975
 
975
- var String$2 = global$e.String;
976
- var TypeError$8 = global$e.TypeError;
976
+ var String$2 = global$f.String;
977
+ var TypeError$7 = global$f.TypeError;
977
978
 
978
979
  var aPossiblePrototype$1 = function (argument) {
979
- if (typeof argument == 'object' || isCallable$4(argument)) return argument;
980
- throw TypeError$8("Can't set " + String$2(argument) + ' as a prototype');
980
+ if (typeof argument == 'object' || isCallable$7(argument)) return argument;
981
+ throw TypeError$7("Can't set " + String$2(argument) + ' as a prototype');
981
982
  };
982
983
 
983
984
  /* eslint-disable no-proto -- safe */
984
985
 
985
986
  var uncurryThis$4 = functionUncurryThis;
986
- var anObject$5 = anObject$8;
987
+ var anObject$7 = anObject$a;
987
988
  var aPossiblePrototype = aPossiblePrototype$1;
988
989
 
989
990
  // `Object.setPrototypeOf` method
@@ -1001,7 +1002,7 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
1001
1002
  CORRECT_SETTER = test instanceof Array;
1002
1003
  } catch (error) { /* empty */ }
1003
1004
  return function setPrototypeOf(O, proto) {
1004
- anObject$5(O);
1005
+ anObject$7(O);
1005
1006
  aPossiblePrototype(proto);
1006
1007
  if (CORRECT_SETTER) setter(O, proto);
1007
1008
  else O.__proto__ = proto;
@@ -1009,31 +1010,31 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
1009
1010
  };
1010
1011
  }() : undefined);
1011
1012
 
1012
- var defineProperty$1 = objectDefineProperty.f;
1013
- var hasOwn$1 = hasOwnProperty_1;
1014
- var wellKnownSymbol$8 = wellKnownSymbol$a;
1013
+ var defineProperty$2 = objectDefineProperty.f;
1014
+ var hasOwn$2 = hasOwnProperty_1;
1015
+ var wellKnownSymbol$c = wellKnownSymbol$e;
1015
1016
 
1016
- var TO_STRING_TAG$2 = wellKnownSymbol$8('toStringTag');
1017
+ var TO_STRING_TAG$3 = wellKnownSymbol$c('toStringTag');
1017
1018
 
1018
- var setToStringTag$1 = function (target, TAG, STATIC) {
1019
+ var setToStringTag$3 = function (target, TAG, STATIC) {
1019
1020
  if (target && !STATIC) target = target.prototype;
1020
- if (target && !hasOwn$1(target, TO_STRING_TAG$2)) {
1021
- defineProperty$1(target, TO_STRING_TAG$2, { configurable: true, value: TAG });
1021
+ if (target && !hasOwn$2(target, TO_STRING_TAG$3)) {
1022
+ defineProperty$2(target, TO_STRING_TAG$3, { configurable: true, value: TAG });
1022
1023
  }
1023
1024
  };
1024
1025
 
1025
1026
  var getBuiltIn$3 = getBuiltIn$7;
1026
- var definePropertyModule = objectDefineProperty;
1027
- var wellKnownSymbol$7 = wellKnownSymbol$a;
1028
- var DESCRIPTORS$1 = descriptors;
1027
+ var definePropertyModule$2 = objectDefineProperty;
1028
+ var wellKnownSymbol$b = wellKnownSymbol$e;
1029
+ var DESCRIPTORS$3 = descriptors;
1029
1030
 
1030
- var SPECIES$2 = wellKnownSymbol$7('species');
1031
+ var SPECIES$2 = wellKnownSymbol$b('species');
1031
1032
 
1032
1033
  var setSpecies$1 = function (CONSTRUCTOR_NAME) {
1033
1034
  var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
1034
- var defineProperty = definePropertyModule.f;
1035
+ var defineProperty = definePropertyModule$2.f;
1035
1036
 
1036
- if (DESCRIPTORS$1 && Constructor && !Constructor[SPECIES$2]) {
1037
+ if (DESCRIPTORS$3 && Constructor && !Constructor[SPECIES$2]) {
1037
1038
  defineProperty(Constructor, SPECIES$2, {
1038
1039
  configurable: true,
1039
1040
  get: function () { return this; }
@@ -1041,25 +1042,25 @@ var setSpecies$1 = function (CONSTRUCTOR_NAME) {
1041
1042
  }
1042
1043
  };
1043
1044
 
1044
- var global$d = global$A;
1045
+ var global$e = global$B;
1045
1046
  var isPrototypeOf$1 = objectIsPrototypeOf;
1046
1047
 
1047
- var TypeError$7 = global$d.TypeError;
1048
+ var TypeError$6 = global$e.TypeError;
1048
1049
 
1049
1050
  var anInstance$1 = function (it, Prototype) {
1050
1051
  if (isPrototypeOf$1(Prototype, it)) return it;
1051
- throw TypeError$7('Incorrect invocation');
1052
+ throw TypeError$6('Incorrect invocation');
1052
1053
  };
1053
1054
 
1054
1055
  var uncurryThis$3 = functionUncurryThis;
1055
- var aCallable$4 = aCallable$6;
1056
+ var aCallable$3 = aCallable$5;
1056
1057
  var NATIVE_BIND$1 = functionBindNative;
1057
1058
 
1058
1059
  var bind$4 = uncurryThis$3(uncurryThis$3.bind);
1059
1060
 
1060
1061
  // optional / simple context binding
1061
1062
  var functionBindContext = function (fn, that) {
1062
- aCallable$4(fn);
1063
+ aCallable$3(fn);
1063
1064
  return that === undefined ? fn : NATIVE_BIND$1 ? bind$4(fn, that) : function (/* ...args */) {
1064
1065
  return fn.apply(that, arguments);
1065
1066
  };
@@ -1067,34 +1068,34 @@ var functionBindContext = function (fn, that) {
1067
1068
 
1068
1069
  var iterators = {};
1069
1070
 
1070
- var wellKnownSymbol$6 = wellKnownSymbol$a;
1071
- var Iterators$1 = iterators;
1071
+ var wellKnownSymbol$a = wellKnownSymbol$e;
1072
+ var Iterators$4 = iterators;
1072
1073
 
1073
- var ITERATOR$2 = wellKnownSymbol$6('iterator');
1074
- var ArrayPrototype = Array.prototype;
1074
+ var ITERATOR$5 = wellKnownSymbol$a('iterator');
1075
+ var ArrayPrototype$1 = Array.prototype;
1075
1076
 
1076
1077
  // check on default Array iterator
1077
1078
  var isArrayIteratorMethod$1 = function (it) {
1078
- return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it);
1079
+ return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it);
1079
1080
  };
1080
1081
 
1081
- var wellKnownSymbol$5 = wellKnownSymbol$a;
1082
+ var wellKnownSymbol$9 = wellKnownSymbol$e;
1082
1083
 
1083
- var TO_STRING_TAG$1 = wellKnownSymbol$5('toStringTag');
1084
+ var TO_STRING_TAG$2 = wellKnownSymbol$9('toStringTag');
1084
1085
  var test = {};
1085
1086
 
1086
- test[TO_STRING_TAG$1] = 'z';
1087
+ test[TO_STRING_TAG$2] = 'z';
1087
1088
 
1088
1089
  var toStringTagSupport = String(test) === '[object z]';
1089
1090
 
1090
- var global$c = global$A;
1091
+ var global$d = global$B;
1091
1092
  var TO_STRING_TAG_SUPPORT = toStringTagSupport;
1092
- var isCallable$3 = isCallable$e;
1093
+ var isCallable$6 = isCallable$h;
1093
1094
  var classofRaw = classofRaw$1;
1094
- var wellKnownSymbol$4 = wellKnownSymbol$a;
1095
+ var wellKnownSymbol$8 = wellKnownSymbol$e;
1095
1096
 
1096
- var TO_STRING_TAG = wellKnownSymbol$4('toStringTag');
1097
- var Object$1 = global$c.Object;
1097
+ var TO_STRING_TAG$1 = wellKnownSymbol$8('toStringTag');
1098
+ var Object$2 = global$d.Object;
1098
1099
 
1099
1100
  // ES3 wrong here
1100
1101
  var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
@@ -1111,78 +1112,78 @@ var classof$3 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
1111
1112
  var O, tag, result;
1112
1113
  return it === undefined ? 'Undefined' : it === null ? 'Null'
1113
1114
  // @@toStringTag case
1114
- : typeof (tag = tryGet(O = Object$1(it), TO_STRING_TAG)) == 'string' ? tag
1115
+ : typeof (tag = tryGet(O = Object$2(it), TO_STRING_TAG$1)) == 'string' ? tag
1115
1116
  // builtinTag case
1116
1117
  : CORRECT_ARGUMENTS ? classofRaw(O)
1117
1118
  // ES3 arguments fallback
1118
- : (result = classofRaw(O)) == 'Object' && isCallable$3(O.callee) ? 'Arguments' : result;
1119
+ : (result = classofRaw(O)) == 'Object' && isCallable$6(O.callee) ? 'Arguments' : result;
1119
1120
  };
1120
1121
 
1121
1122
  var classof$2 = classof$3;
1122
1123
  var getMethod$1 = getMethod$3;
1123
- var Iterators = iterators;
1124
- var wellKnownSymbol$3 = wellKnownSymbol$a;
1124
+ var Iterators$3 = iterators;
1125
+ var wellKnownSymbol$7 = wellKnownSymbol$e;
1125
1126
 
1126
- var ITERATOR$1 = wellKnownSymbol$3('iterator');
1127
+ var ITERATOR$4 = wellKnownSymbol$7('iterator');
1127
1128
 
1128
1129
  var getIteratorMethod$2 = function (it) {
1129
- if (it != undefined) return getMethod$1(it, ITERATOR$1)
1130
+ if (it != undefined) return getMethod$1(it, ITERATOR$4)
1130
1131
  || getMethod$1(it, '@@iterator')
1131
- || Iterators[classof$2(it)];
1132
+ || Iterators$3[classof$2(it)];
1132
1133
  };
1133
1134
 
1134
- var global$b = global$A;
1135
- var call$5 = functionCall;
1136
- var aCallable$3 = aCallable$6;
1137
- var anObject$4 = anObject$8;
1135
+ var global$c = global$B;
1136
+ var call$6 = functionCall;
1137
+ var aCallable$2 = aCallable$5;
1138
+ var anObject$6 = anObject$a;
1138
1139
  var tryToString$2 = tryToString$4;
1139
1140
  var getIteratorMethod$1 = getIteratorMethod$2;
1140
1141
 
1141
- var TypeError$6 = global$b.TypeError;
1142
+ var TypeError$5 = global$c.TypeError;
1142
1143
 
1143
1144
  var getIterator$1 = function (argument, usingIterator) {
1144
1145
  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
1145
- if (aCallable$3(iteratorMethod)) return anObject$4(call$5(iteratorMethod, argument));
1146
- throw TypeError$6(tryToString$2(argument) + ' is not iterable');
1146
+ if (aCallable$2(iteratorMethod)) return anObject$6(call$6(iteratorMethod, argument));
1147
+ throw TypeError$5(tryToString$2(argument) + ' is not iterable');
1147
1148
  };
1148
1149
 
1149
- var call$4 = functionCall;
1150
- var anObject$3 = anObject$8;
1150
+ var call$5 = functionCall;
1151
+ var anObject$5 = anObject$a;
1151
1152
  var getMethod = getMethod$3;
1152
1153
 
1153
1154
  var iteratorClose$1 = function (iterator, kind, value) {
1154
1155
  var innerResult, innerError;
1155
- anObject$3(iterator);
1156
+ anObject$5(iterator);
1156
1157
  try {
1157
1158
  innerResult = getMethod(iterator, 'return');
1158
1159
  if (!innerResult) {
1159
1160
  if (kind === 'throw') throw value;
1160
1161
  return value;
1161
1162
  }
1162
- innerResult = call$4(innerResult, iterator);
1163
+ innerResult = call$5(innerResult, iterator);
1163
1164
  } catch (error) {
1164
1165
  innerError = true;
1165
1166
  innerResult = error;
1166
1167
  }
1167
1168
  if (kind === 'throw') throw value;
1168
1169
  if (innerError) throw innerResult;
1169
- anObject$3(innerResult);
1170
+ anObject$5(innerResult);
1170
1171
  return value;
1171
1172
  };
1172
1173
 
1173
- var global$a = global$A;
1174
+ var global$b = global$B;
1174
1175
  var bind$3 = functionBindContext;
1175
- var call$3 = functionCall;
1176
- var anObject$2 = anObject$8;
1176
+ var call$4 = functionCall;
1177
+ var anObject$4 = anObject$a;
1177
1178
  var tryToString$1 = tryToString$4;
1178
1179
  var isArrayIteratorMethod = isArrayIteratorMethod$1;
1179
- var lengthOfArrayLike$1 = lengthOfArrayLike$3;
1180
+ var lengthOfArrayLike = lengthOfArrayLike$2;
1180
1181
  var isPrototypeOf = objectIsPrototypeOf;
1181
1182
  var getIterator = getIterator$1;
1182
1183
  var getIteratorMethod = getIteratorMethod$2;
1183
1184
  var iteratorClose = iteratorClose$1;
1184
1185
 
1185
- var TypeError$5 = global$a.TypeError;
1186
+ var TypeError$4 = global$b.TypeError;
1186
1187
 
1187
1188
  var Result = function (stopped, result) {
1188
1189
  this.stopped = stopped;
@@ -1206,7 +1207,7 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1206
1207
 
1207
1208
  var callFn = function (value) {
1208
1209
  if (AS_ENTRIES) {
1209
- anObject$2(value);
1210
+ anObject$4(value);
1210
1211
  return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
1211
1212
  } return INTERRUPTED ? fn(value, stop) : fn(value);
1212
1213
  };
@@ -1215,10 +1216,10 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1215
1216
  iterator = iterable;
1216
1217
  } else {
1217
1218
  iterFn = getIteratorMethod(iterable);
1218
- if (!iterFn) throw TypeError$5(tryToString$1(iterable) + ' is not iterable');
1219
+ if (!iterFn) throw TypeError$4(tryToString$1(iterable) + ' is not iterable');
1219
1220
  // optimisation for array iterators
1220
1221
  if (isArrayIteratorMethod(iterFn)) {
1221
- for (index = 0, length = lengthOfArrayLike$1(iterable); length > index; index++) {
1222
+ for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
1222
1223
  result = callFn(iterable[index]);
1223
1224
  if (result && isPrototypeOf(ResultPrototype, result)) return result;
1224
1225
  } return new Result(false);
@@ -1227,7 +1228,7 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1227
1228
  }
1228
1229
 
1229
1230
  next = iterator.next;
1230
- while (!(step = call$3(next, iterator)).done) {
1231
+ while (!(step = call$4(next, iterator)).done) {
1231
1232
  try {
1232
1233
  result = callFn(step.value);
1233
1234
  } catch (error) {
@@ -1237,9 +1238,9 @@ var iterate$1 = function (iterable, unboundFunction, options) {
1237
1238
  } return new Result(false);
1238
1239
  };
1239
1240
 
1240
- var wellKnownSymbol$2 = wellKnownSymbol$a;
1241
+ var wellKnownSymbol$6 = wellKnownSymbol$e;
1241
1242
 
1242
- var ITERATOR = wellKnownSymbol$2('iterator');
1243
+ var ITERATOR$3 = wellKnownSymbol$6('iterator');
1243
1244
  var SAFE_CLOSING = false;
1244
1245
 
1245
1246
  try {
@@ -1252,7 +1253,7 @@ try {
1252
1253
  SAFE_CLOSING = true;
1253
1254
  }
1254
1255
  };
1255
- iteratorWithReturn[ITERATOR] = function () {
1256
+ iteratorWithReturn[ITERATOR$3] = function () {
1256
1257
  return this;
1257
1258
  };
1258
1259
  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
@@ -1264,7 +1265,7 @@ var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
1264
1265
  var ITERATION_SUPPORT = false;
1265
1266
  try {
1266
1267
  var object = {};
1267
- object[ITERATOR] = function () {
1268
+ object[ITERATOR$3] = function () {
1268
1269
  return {
1269
1270
  next: function () {
1270
1271
  return { done: ITERATION_SUPPORT = true };
@@ -1277,8 +1278,8 @@ var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
1277
1278
  };
1278
1279
 
1279
1280
  var uncurryThis$2 = functionUncurryThis;
1280
- var fails$3 = fails$b;
1281
- var isCallable$2 = isCallable$e;
1281
+ var fails$4 = fails$c;
1282
+ var isCallable$5 = isCallable$h;
1282
1283
  var classof$1 = classof$3;
1283
1284
  var getBuiltIn$2 = getBuiltIn$7;
1284
1285
  var inspectSource$1 = inspectSource$4;
@@ -1291,7 +1292,7 @@ var exec = uncurryThis$2(constructorRegExp.exec);
1291
1292
  var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
1292
1293
 
1293
1294
  var isConstructorModern = function isConstructor(argument) {
1294
- if (!isCallable$2(argument)) return false;
1295
+ if (!isCallable$5(argument)) return false;
1295
1296
  try {
1296
1297
  construct(noop, empty, argument);
1297
1298
  return true;
@@ -1301,7 +1302,7 @@ var isConstructorModern = function isConstructor(argument) {
1301
1302
  };
1302
1303
 
1303
1304
  var isConstructorLegacy = function isConstructor(argument) {
1304
- if (!isCallable$2(argument)) return false;
1305
+ if (!isCallable$5(argument)) return false;
1305
1306
  switch (classof$1(argument)) {
1306
1307
  case 'AsyncFunction':
1307
1308
  case 'GeneratorFunction':
@@ -1321,7 +1322,7 @@ isConstructorLegacy.sham = true;
1321
1322
 
1322
1323
  // `IsConstructor` abstract operation
1323
1324
  // https://tc39.es/ecma262/#sec-isconstructor
1324
- var isConstructor$1 = !construct || fails$3(function () {
1325
+ var isConstructor$1 = !construct || fails$4(function () {
1325
1326
  var called;
1326
1327
  return isConstructorModern(isConstructorModern.call)
1327
1328
  || !isConstructorModern(Object)
@@ -1329,57 +1330,57 @@ var isConstructor$1 = !construct || fails$3(function () {
1329
1330
  || called;
1330
1331
  }) ? isConstructorLegacy : isConstructorModern;
1331
1332
 
1332
- var global$9 = global$A;
1333
+ var global$a = global$B;
1333
1334
  var isConstructor = isConstructor$1;
1334
1335
  var tryToString = tryToString$4;
1335
1336
 
1336
- var TypeError$4 = global$9.TypeError;
1337
+ var TypeError$3 = global$a.TypeError;
1337
1338
 
1338
1339
  // `Assert: IsConstructor(argument) is true`
1339
1340
  var aConstructor$1 = function (argument) {
1340
1341
  if (isConstructor(argument)) return argument;
1341
- throw TypeError$4(tryToString(argument) + ' is not a constructor');
1342
+ throw TypeError$3(tryToString(argument) + ' is not a constructor');
1342
1343
  };
1343
1344
 
1344
- var anObject$1 = anObject$8;
1345
+ var anObject$3 = anObject$a;
1345
1346
  var aConstructor = aConstructor$1;
1346
- var wellKnownSymbol$1 = wellKnownSymbol$a;
1347
+ var wellKnownSymbol$5 = wellKnownSymbol$e;
1347
1348
 
1348
- var SPECIES$1 = wellKnownSymbol$1('species');
1349
+ var SPECIES$1 = wellKnownSymbol$5('species');
1349
1350
 
1350
1351
  // `SpeciesConstructor` abstract operation
1351
1352
  // https://tc39.es/ecma262/#sec-speciesconstructor
1352
1353
  var speciesConstructor$1 = function (O, defaultConstructor) {
1353
- var C = anObject$1(O).constructor;
1354
+ var C = anObject$3(O).constructor;
1354
1355
  var S;
1355
- return C === undefined || (S = anObject$1(C)[SPECIES$1]) == undefined ? defaultConstructor : aConstructor(S);
1356
+ return C === undefined || (S = anObject$3(C)[SPECIES$1]) == undefined ? defaultConstructor : aConstructor(S);
1356
1357
  };
1357
1358
 
1358
1359
  var NATIVE_BIND = functionBindNative;
1359
1360
 
1360
1361
  var FunctionPrototype = Function.prototype;
1361
1362
  var apply$1 = FunctionPrototype.apply;
1362
- var call$2 = FunctionPrototype.call;
1363
+ var call$3 = FunctionPrototype.call;
1363
1364
 
1364
1365
  // eslint-disable-next-line es/no-reflect -- safe
1365
- var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$2.bind(apply$1) : function () {
1366
- return call$2.apply(apply$1, arguments);
1366
+ var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$3.bind(apply$1) : function () {
1367
+ return call$3.apply(apply$1, arguments);
1367
1368
  });
1368
1369
 
1369
1370
  var getBuiltIn$1 = getBuiltIn$7;
1370
1371
 
1371
- var html$1 = getBuiltIn$1('document', 'documentElement');
1372
+ var html$2 = getBuiltIn$1('document', 'documentElement');
1372
1373
 
1373
1374
  var uncurryThis$1 = functionUncurryThis;
1374
1375
 
1375
1376
  var arraySlice$1 = uncurryThis$1([].slice);
1376
1377
 
1377
- var global$8 = global$A;
1378
+ var global$9 = global$B;
1378
1379
 
1379
- var TypeError$3 = global$8.TypeError;
1380
+ var TypeError$2 = global$9.TypeError;
1380
1381
 
1381
1382
  var validateArgumentsLength$1 = function (passed, required) {
1382
- if (passed < required) throw TypeError$3('Not enough arguments');
1383
+ if (passed < required) throw TypeError$2('Not enough arguments');
1383
1384
  return passed;
1384
1385
  };
1385
1386
 
@@ -1388,30 +1389,30 @@ var userAgent$2 = engineUserAgent;
1388
1389
  var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
1389
1390
 
1390
1391
  var classof = classofRaw$1;
1391
- var global$7 = global$A;
1392
+ var global$8 = global$B;
1392
1393
 
1393
- var engineIsNode = classof(global$7.process) == 'process';
1394
+ var engineIsNode = classof(global$8.process) == 'process';
1394
1395
 
1395
- var global$6 = global$A;
1396
+ var global$7 = global$B;
1396
1397
  var apply = functionApply;
1397
1398
  var bind$2 = functionBindContext;
1398
- var isCallable$1 = isCallable$e;
1399
- var hasOwn = hasOwnProperty_1;
1400
- var fails$2 = fails$b;
1401
- var html = html$1;
1399
+ var isCallable$4 = isCallable$h;
1400
+ var hasOwn$1 = hasOwnProperty_1;
1401
+ var fails$3 = fails$c;
1402
+ var html$1 = html$2;
1402
1403
  var arraySlice = arraySlice$1;
1403
- var createElement = documentCreateElement;
1404
+ var createElement = documentCreateElement$2;
1404
1405
  var validateArgumentsLength = validateArgumentsLength$1;
1405
1406
  var IS_IOS$1 = engineIsIos;
1406
- var IS_NODE$3 = engineIsNode;
1407
-
1408
- var set$1 = global$6.setImmediate;
1409
- var clear = global$6.clearImmediate;
1410
- var process$3 = global$6.process;
1411
- var Dispatch = global$6.Dispatch;
1412
- var Function$1 = global$6.Function;
1413
- var MessageChannel = global$6.MessageChannel;
1414
- var String$1 = global$6.String;
1407
+ var IS_NODE$2 = engineIsNode;
1408
+
1409
+ var set$1 = global$7.setImmediate;
1410
+ var clear = global$7.clearImmediate;
1411
+ var process$3 = global$7.process;
1412
+ var Dispatch = global$7.Dispatch;
1413
+ var Function$1 = global$7.Function;
1414
+ var MessageChannel = global$7.MessageChannel;
1415
+ var String$1 = global$7.String;
1415
1416
  var counter = 0;
1416
1417
  var queue$1 = {};
1417
1418
  var ONREADYSTATECHANGE = 'onreadystatechange';
@@ -1419,11 +1420,11 @@ var location, defer, channel, port;
1419
1420
 
1420
1421
  try {
1421
1422
  // Deno throws a ReferenceError on `location` access without `--location` flag
1422
- location = global$6.location;
1423
+ location = global$7.location;
1423
1424
  } catch (error) { /* empty */ }
1424
1425
 
1425
1426
  var run = function (id) {
1426
- if (hasOwn(queue$1, id)) {
1427
+ if (hasOwn$1(queue$1, id)) {
1427
1428
  var fn = queue$1[id];
1428
1429
  delete queue$1[id];
1429
1430
  fn();
@@ -1442,14 +1443,14 @@ var listener = function (event) {
1442
1443
 
1443
1444
  var post = function (id) {
1444
1445
  // old engines have not location.origin
1445
- global$6.postMessage(String$1(id), location.protocol + '//' + location.host);
1446
+ global$7.postMessage(String$1(id), location.protocol + '//' + location.host);
1446
1447
  };
1447
1448
 
1448
1449
  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
1449
1450
  if (!set$1 || !clear) {
1450
1451
  set$1 = function setImmediate(handler) {
1451
1452
  validateArgumentsLength(arguments.length, 1);
1452
- var fn = isCallable$1(handler) ? handler : Function$1(handler);
1453
+ var fn = isCallable$4(handler) ? handler : Function$1(handler);
1453
1454
  var args = arraySlice(arguments, 1);
1454
1455
  queue$1[++counter] = function () {
1455
1456
  apply(fn, undefined, args);
@@ -1461,7 +1462,7 @@ if (!set$1 || !clear) {
1461
1462
  delete queue$1[id];
1462
1463
  };
1463
1464
  // Node.js 0.8-
1464
- if (IS_NODE$3) {
1465
+ if (IS_NODE$2) {
1465
1466
  defer = function (id) {
1466
1467
  process$3.nextTick(runner(id));
1467
1468
  };
@@ -1480,19 +1481,19 @@ if (!set$1 || !clear) {
1480
1481
  // Browsers with postMessage, skip WebWorkers
1481
1482
  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
1482
1483
  } else if (
1483
- global$6.addEventListener &&
1484
- isCallable$1(global$6.postMessage) &&
1485
- !global$6.importScripts &&
1484
+ global$7.addEventListener &&
1485
+ isCallable$4(global$7.postMessage) &&
1486
+ !global$7.importScripts &&
1486
1487
  location && location.protocol !== 'file:' &&
1487
- !fails$2(post)
1488
+ !fails$3(post)
1488
1489
  ) {
1489
1490
  defer = post;
1490
- global$6.addEventListener('message', listener, false);
1491
+ global$7.addEventListener('message', listener, false);
1491
1492
  // IE8-
1492
1493
  } else if (ONREADYSTATECHANGE in createElement('script')) {
1493
1494
  defer = function (id) {
1494
- html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
1495
- html.removeChild(this);
1495
+ html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
1496
+ html$1.removeChild(this);
1496
1497
  run(id);
1497
1498
  };
1498
1499
  };
@@ -1510,29 +1511,29 @@ var task$1 = {
1510
1511
  };
1511
1512
 
1512
1513
  var userAgent$1 = engineUserAgent;
1513
- var global$5 = global$A;
1514
+ var global$6 = global$B;
1514
1515
 
1515
- var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$5.Pebble !== undefined;
1516
+ var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$6.Pebble !== undefined;
1516
1517
 
1517
1518
  var userAgent = engineUserAgent;
1518
1519
 
1519
1520
  var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
1520
1521
 
1521
- var global$4 = global$A;
1522
+ var global$5 = global$B;
1522
1523
  var bind$1 = functionBindContext;
1523
1524
  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
1524
1525
  var macrotask = task$1.set;
1525
1526
  var IS_IOS = engineIsIos;
1526
1527
  var IS_IOS_PEBBLE = engineIsIosPebble;
1527
1528
  var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
1528
- var IS_NODE$2 = engineIsNode;
1529
+ var IS_NODE$1 = engineIsNode;
1529
1530
 
1530
- var MutationObserver = global$4.MutationObserver || global$4.WebKitMutationObserver;
1531
- var document$2 = global$4.document;
1532
- var process$2 = global$4.process;
1533
- var Promise$1 = global$4.Promise;
1531
+ var MutationObserver = global$5.MutationObserver || global$5.WebKitMutationObserver;
1532
+ var document$2 = global$5.document;
1533
+ var process$2 = global$5.process;
1534
+ var Promise$1 = global$5.Promise;
1534
1535
  // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
1535
- var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$4, 'queueMicrotask');
1536
+ var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$5, 'queueMicrotask');
1536
1537
  var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
1537
1538
 
1538
1539
  var flush, head, last, notify$1, toggle, node$1, promise, then;
@@ -1541,7 +1542,7 @@ var flush, head, last, notify$1, toggle, node$1, promise, then;
1541
1542
  if (!queueMicrotask) {
1542
1543
  flush = function () {
1543
1544
  var parent, fn;
1544
- if (IS_NODE$2 && (parent = process$2.domain)) parent.exit();
1545
+ if (IS_NODE$1 && (parent = process$2.domain)) parent.exit();
1545
1546
  while (head) {
1546
1547
  fn = head.fn;
1547
1548
  head = head.next;
@@ -1558,7 +1559,7 @@ if (!queueMicrotask) {
1558
1559
 
1559
1560
  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
1560
1561
  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
1561
- if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
1562
+ if (!IS_IOS && !IS_NODE$1 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
1562
1563
  toggle = true;
1563
1564
  node$1 = document$2.createTextNode('');
1564
1565
  new MutationObserver(flush).observe(node$1, { characterData: true });
@@ -1576,7 +1577,7 @@ if (!queueMicrotask) {
1576
1577
  then(flush);
1577
1578
  };
1578
1579
  // Node.js without promises
1579
- } else if (IS_NODE$2) {
1580
+ } else if (IS_NODE$1) {
1580
1581
  notify$1 = function () {
1581
1582
  process$2.nextTick(flush);
1582
1583
  };
@@ -1588,7 +1589,7 @@ if (!queueMicrotask) {
1588
1589
  // - setTimeout
1589
1590
  } else {
1590
1591
  // strange IE + webpack dev server bug - use .bind(global)
1591
- macrotask = bind$1(macrotask, global$4);
1592
+ macrotask = bind$1(macrotask, global$5);
1592
1593
  notify$1 = function () {
1593
1594
  macrotask(flush);
1594
1595
  };
@@ -1606,7 +1607,7 @@ var microtask$1 = queueMicrotask || function (fn) {
1606
1607
 
1607
1608
  var newPromiseCapability$2 = {};
1608
1609
 
1609
- var aCallable$2 = aCallable$6;
1610
+ var aCallable$1 = aCallable$5;
1610
1611
 
1611
1612
  var PromiseCapability = function (C) {
1612
1613
  var resolve, reject;
@@ -1615,8 +1616,8 @@ var PromiseCapability = function (C) {
1615
1616
  resolve = $$resolve;
1616
1617
  reject = $$reject;
1617
1618
  });
1618
- this.resolve = aCallable$2(resolve);
1619
- this.reject = aCallable$2(reject);
1619
+ this.resolve = aCallable$1(resolve);
1620
+ this.reject = aCallable$1(reject);
1620
1621
  };
1621
1622
 
1622
1623
  // `NewPromiseCapability` abstract operation
@@ -1625,12 +1626,12 @@ newPromiseCapability$2.f = function (C) {
1625
1626
  return new PromiseCapability(C);
1626
1627
  };
1627
1628
 
1628
- var anObject = anObject$8;
1629
+ var anObject$2 = anObject$a;
1629
1630
  var isObject$1 = isObject$7;
1630
1631
  var newPromiseCapability$1 = newPromiseCapability$2;
1631
1632
 
1632
1633
  var promiseResolve$1 = function (C, x) {
1633
- anObject(C);
1634
+ anObject$2(C);
1634
1635
  if (isObject$1(x) && x.constructor === C) return x;
1635
1636
  var promiseCapability = newPromiseCapability$1.f(C);
1636
1637
  var resolve = promiseCapability.resolve;
@@ -1638,10 +1639,10 @@ var promiseResolve$1 = function (C, x) {
1638
1639
  return promiseCapability.promise;
1639
1640
  };
1640
1641
 
1641
- var global$3 = global$A;
1642
+ var global$4 = global$B;
1642
1643
 
1643
1644
  var hostReportErrors$1 = function (a, b) {
1644
- var console = global$3.console;
1645
+ var console = global$4.console;
1645
1646
  if (console && console.error) {
1646
1647
  arguments.length == 1 ? console.error(a) : console.error(a, b);
1647
1648
  }
@@ -1682,17 +1683,17 @@ var queue = Queue$1;
1682
1683
  var engineIsBrowser = typeof window == 'object';
1683
1684
 
1684
1685
  var $$2 = _export;
1685
- var global$2 = global$A;
1686
+ var global$3 = global$B;
1686
1687
  var getBuiltIn = getBuiltIn$7;
1687
- var call$1 = functionCall;
1688
+ var call$2 = functionCall;
1688
1689
  var NativePromise = nativePromiseConstructor;
1689
- var redefine = redefine$3.exports;
1690
+ var redefine$2 = redefine$5.exports;
1690
1691
  var redefineAll = redefineAll$1;
1691
- var setPrototypeOf = objectSetPrototypeOf;
1692
- var setToStringTag = setToStringTag$1;
1692
+ var setPrototypeOf$1 = objectSetPrototypeOf;
1693
+ var setToStringTag$2 = setToStringTag$3;
1693
1694
  var setSpecies = setSpecies$1;
1694
- var aCallable$1 = aCallable$6;
1695
- var isCallable = isCallable$e;
1695
+ var aCallable = aCallable$5;
1696
+ var isCallable$3 = isCallable$h;
1696
1697
  var isObject = isObject$7;
1697
1698
  var anInstance = anInstance$1;
1698
1699
  var inspectSource = inspectSource$4;
@@ -1706,30 +1707,30 @@ var hostReportErrors = hostReportErrors$1;
1706
1707
  var newPromiseCapabilityModule = newPromiseCapability$2;
1707
1708
  var perform = perform$1;
1708
1709
  var Queue = queue;
1709
- var InternalStateModule = internalState;
1710
+ var InternalStateModule$1 = internalState;
1710
1711
  var isForced = isForced_1;
1711
- var wellKnownSymbol = wellKnownSymbol$a;
1712
+ var wellKnownSymbol$4 = wellKnownSymbol$e;
1712
1713
  var IS_BROWSER = engineIsBrowser;
1713
- var IS_NODE$1 = engineIsNode;
1714
+ var IS_NODE = engineIsNode;
1714
1715
  var V8_VERSION = engineV8Version;
1715
1716
 
1716
- var SPECIES = wellKnownSymbol('species');
1717
+ var SPECIES = wellKnownSymbol$4('species');
1717
1718
  var PROMISE = 'Promise';
1718
1719
 
1719
- var getInternalState = InternalStateModule.getterFor(PROMISE);
1720
- var setInternalState = InternalStateModule.set;
1721
- var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
1720
+ var getInternalState$1 = InternalStateModule$1.getterFor(PROMISE);
1721
+ var setInternalState$1 = InternalStateModule$1.set;
1722
+ var getInternalPromiseState = InternalStateModule$1.getterFor(PROMISE);
1722
1723
  var NativePromisePrototype = NativePromise && NativePromise.prototype;
1723
1724
  var PromiseConstructor = NativePromise;
1724
1725
  var PromisePrototype = NativePromisePrototype;
1725
- var TypeError$2 = global$2.TypeError;
1726
- var document$1 = global$2.document;
1727
- var process$1 = global$2.process;
1726
+ var TypeError$1 = global$3.TypeError;
1727
+ var document$1 = global$3.document;
1728
+ var process$1 = global$3.process;
1728
1729
  var newPromiseCapability = newPromiseCapabilityModule.f;
1729
1730
  var newGenericPromiseCapability = newPromiseCapability;
1730
1731
 
1731
- var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$2.dispatchEvent);
1732
- var NATIVE_REJECTION_EVENT = isCallable(global$2.PromiseRejectionEvent);
1732
+ var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$3.dispatchEvent);
1733
+ var NATIVE_REJECTION_EVENT = isCallable$3(global$3.PromiseRejectionEvent);
1733
1734
  var UNHANDLED_REJECTION = 'unhandledrejection';
1734
1735
  var REJECTION_HANDLED = 'rejectionhandled';
1735
1736
  var PENDING = 0;
@@ -1772,7 +1773,7 @@ var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (itera
1772
1773
  // helpers
1773
1774
  var isThenable = function (it) {
1774
1775
  var then;
1775
- return isObject(it) && isCallable(then = it.then) ? then : false;
1776
+ return isObject(it) && isCallable$3(then = it.then) ? then : false;
1776
1777
  };
1777
1778
 
1778
1779
  var callReaction = function (reaction, state) {
@@ -1799,9 +1800,9 @@ var callReaction = function (reaction, state) {
1799
1800
  }
1800
1801
  }
1801
1802
  if (result === reaction.promise) {
1802
- reject(TypeError$2('Promise-chain cycle'));
1803
+ reject(TypeError$1('Promise-chain cycle'));
1803
1804
  } else if (then = isThenable(result)) {
1804
- call$1(then, result, resolve, reject);
1805
+ call$2(then, result, resolve, reject);
1805
1806
  } else resolve(result);
1806
1807
  } else reject(value);
1807
1808
  } catch (error) {
@@ -1831,26 +1832,26 @@ var dispatchEvent = function (name, promise, reason) {
1831
1832
  event.promise = promise;
1832
1833
  event.reason = reason;
1833
1834
  event.initEvent(name, false, true);
1834
- global$2.dispatchEvent(event);
1835
+ global$3.dispatchEvent(event);
1835
1836
  } else event = { promise: promise, reason: reason };
1836
- if (!NATIVE_REJECTION_EVENT && (handler = global$2['on' + name])) handler(event);
1837
+ if (!NATIVE_REJECTION_EVENT && (handler = global$3['on' + name])) handler(event);
1837
1838
  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
1838
1839
  };
1839
1840
 
1840
1841
  var onUnhandled = function (state) {
1841
- call$1(task, global$2, function () {
1842
+ call$2(task, global$3, function () {
1842
1843
  var promise = state.facade;
1843
1844
  var value = state.value;
1844
1845
  var IS_UNHANDLED = isUnhandled(state);
1845
1846
  var result;
1846
1847
  if (IS_UNHANDLED) {
1847
1848
  result = perform(function () {
1848
- if (IS_NODE$1) {
1849
+ if (IS_NODE) {
1849
1850
  process$1.emit('unhandledRejection', value, promise);
1850
1851
  } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
1851
1852
  });
1852
1853
  // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
1853
- state.rejection = IS_NODE$1 || isUnhandled(state) ? UNHANDLED : HANDLED;
1854
+ state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
1854
1855
  if (result.error) throw result.value;
1855
1856
  }
1856
1857
  });
@@ -1861,9 +1862,9 @@ var isUnhandled = function (state) {
1861
1862
  };
1862
1863
 
1863
1864
  var onHandleUnhandled = function (state) {
1864
- call$1(task, global$2, function () {
1865
+ call$2(task, global$3, function () {
1865
1866
  var promise = state.facade;
1866
- if (IS_NODE$1) {
1867
+ if (IS_NODE) {
1867
1868
  process$1.emit('rejectionHandled', promise);
1868
1869
  } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
1869
1870
  });
@@ -1889,13 +1890,13 @@ var internalResolve = function (state, value, unwrap) {
1889
1890
  state.done = true;
1890
1891
  if (unwrap) state = unwrap;
1891
1892
  try {
1892
- if (state.facade === value) throw TypeError$2("Promise can't be resolved itself");
1893
+ if (state.facade === value) throw TypeError$1("Promise can't be resolved itself");
1893
1894
  var then = isThenable(value);
1894
1895
  if (then) {
1895
1896
  microtask(function () {
1896
1897
  var wrapper = { done: false };
1897
1898
  try {
1898
- call$1(then, value,
1899
+ call$2(then, value,
1899
1900
  bind(internalResolve, wrapper, state),
1900
1901
  bind(internalReject, wrapper, state)
1901
1902
  );
@@ -1918,9 +1919,9 @@ if (FORCED) {
1918
1919
  // 25.4.3.1 Promise(executor)
1919
1920
  PromiseConstructor = function Promise(executor) {
1920
1921
  anInstance(this, PromisePrototype);
1921
- aCallable$1(executor);
1922
- call$1(Internal, this);
1923
- var state = getInternalState(this);
1922
+ aCallable(executor);
1923
+ call$2(Internal, this);
1924
+ var state = getInternalState$1(this);
1924
1925
  try {
1925
1926
  executor(bind(internalResolve, state), bind(internalReject, state));
1926
1927
  } catch (error) {
@@ -1930,7 +1931,7 @@ if (FORCED) {
1930
1931
  PromisePrototype = PromiseConstructor.prototype;
1931
1932
  // eslint-disable-next-line no-unused-vars -- required for `.length`
1932
1933
  Internal = function Promise(executor) {
1933
- setInternalState(this, {
1934
+ setInternalState$1(this, {
1934
1935
  type: PROMISE,
1935
1936
  done: false,
1936
1937
  notified: false,
@@ -1949,9 +1950,9 @@ if (FORCED) {
1949
1950
  var state = getInternalPromiseState(this);
1950
1951
  var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
1951
1952
  state.parent = true;
1952
- reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;
1953
- reaction.fail = isCallable(onRejected) && onRejected;
1954
- reaction.domain = IS_NODE$1 ? process$1.domain : undefined;
1953
+ reaction.ok = isCallable$3(onFulfilled) ? onFulfilled : true;
1954
+ reaction.fail = isCallable$3(onRejected) && onRejected;
1955
+ reaction.domain = IS_NODE ? process$1.domain : undefined;
1955
1956
  if (state.state == PENDING) state.reactions.add(reaction);
1956
1957
  else microtask(function () {
1957
1958
  callReaction(reaction, state);
@@ -1966,7 +1967,7 @@ if (FORCED) {
1966
1967
  });
1967
1968
  OwnPromiseCapability = function () {
1968
1969
  var promise = new Internal();
1969
- var state = getInternalState(promise);
1970
+ var state = getInternalState$1(promise);
1970
1971
  this.promise = promise;
1971
1972
  this.resolve = bind(internalResolve, state);
1972
1973
  this.reject = bind(internalReject, state);
@@ -1977,21 +1978,21 @@ if (FORCED) {
1977
1978
  : newGenericPromiseCapability(C);
1978
1979
  };
1979
1980
 
1980
- if (isCallable(NativePromise) && NativePromisePrototype !== Object.prototype) {
1981
+ if (isCallable$3(NativePromise) && NativePromisePrototype !== Object.prototype) {
1981
1982
  nativeThen = NativePromisePrototype.then;
1982
1983
 
1983
1984
  if (!SUBCLASSING) {
1984
1985
  // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
1985
- redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
1986
+ redefine$2(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
1986
1987
  var that = this;
1987
1988
  return new PromiseConstructor(function (resolve, reject) {
1988
- call$1(nativeThen, that, resolve, reject);
1989
+ call$2(nativeThen, that, resolve, reject);
1989
1990
  }).then(onFulfilled, onRejected);
1990
1991
  // https://github.com/zloirock/core-js/issues/640
1991
1992
  }, { unsafe: true });
1992
1993
 
1993
1994
  // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
1994
- redefine(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });
1995
+ redefine$2(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });
1995
1996
  }
1996
1997
 
1997
1998
  // make `.constructor === Promise` work for native promise-based APIs
@@ -2000,8 +2001,8 @@ if (FORCED) {
2000
2001
  } catch (error) { /* empty */ }
2001
2002
 
2002
2003
  // make `instanceof Promise` work for native promise-based APIs
2003
- if (setPrototypeOf) {
2004
- setPrototypeOf(NativePromisePrototype, PromisePrototype);
2004
+ if (setPrototypeOf$1) {
2005
+ setPrototypeOf$1(NativePromisePrototype, PromisePrototype);
2005
2006
  }
2006
2007
  }
2007
2008
  }
@@ -2010,7 +2011,7 @@ $$2({ global: true, wrap: true, forced: FORCED }, {
2010
2011
  Promise: PromiseConstructor
2011
2012
  });
2012
2013
 
2013
- setToStringTag(PromiseConstructor, PROMISE, false);
2014
+ setToStringTag$2(PromiseConstructor, PROMISE, false);
2014
2015
  setSpecies(PROMISE);
2015
2016
 
2016
2017
  PromiseWrapper = getBuiltIn(PROMISE);
@@ -2021,7 +2022,7 @@ $$2({ target: PROMISE, stat: true, forced: FORCED }, {
2021
2022
  // https://tc39.es/ecma262/#sec-promise.reject
2022
2023
  reject: function reject(r) {
2023
2024
  var capability = newPromiseCapability(this);
2024
- call$1(capability.reject, undefined, r);
2025
+ call$2(capability.reject, undefined, r);
2025
2026
  return capability.promise;
2026
2027
  }
2027
2028
  });
@@ -2043,7 +2044,7 @@ $$2({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2043
2044
  var resolve = capability.resolve;
2044
2045
  var reject = capability.reject;
2045
2046
  var result = perform(function () {
2046
- var $promiseResolve = aCallable$1(C.resolve);
2047
+ var $promiseResolve = aCallable(C.resolve);
2047
2048
  var values = [];
2048
2049
  var counter = 0;
2049
2050
  var remaining = 1;
@@ -2051,7 +2052,7 @@ $$2({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2051
2052
  var index = counter++;
2052
2053
  var alreadyCalled = false;
2053
2054
  remaining++;
2054
- call$1($promiseResolve, C, promise).then(function (value) {
2055
+ call$2($promiseResolve, C, promise).then(function (value) {
2055
2056
  if (alreadyCalled) return;
2056
2057
  alreadyCalled = true;
2057
2058
  values[index] = value;
@@ -2070,9 +2071,9 @@ $$2({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2070
2071
  var capability = newPromiseCapability(C);
2071
2072
  var reject = capability.reject;
2072
2073
  var result = perform(function () {
2073
- var $promiseResolve = aCallable$1(C.resolve);
2074
+ var $promiseResolve = aCallable(C.resolve);
2074
2075
  iterate(iterable, function (promise) {
2075
- call$1($promiseResolve, C, promise).then(capability.resolve, reject);
2076
+ call$2($promiseResolve, C, promise).then(capability.resolve, reject);
2076
2077
  });
2077
2078
  });
2078
2079
  if (result.error) reject(result.value);
@@ -2081,39 +2082,39 @@ $$2({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
2081
2082
  });
2082
2083
 
2083
2084
  var internalObjectKeys = objectKeysInternal;
2084
- var enumBugKeys = enumBugKeys$2;
2085
+ var enumBugKeys$1 = enumBugKeys$3;
2085
2086
 
2086
2087
  // `Object.keys` method
2087
2088
  // https://tc39.es/ecma262/#sec-object.keys
2088
2089
  // eslint-disable-next-line es/no-object-keys -- safe
2089
- var objectKeys$1 = Object.keys || function keys(O) {
2090
- return internalObjectKeys(O, enumBugKeys);
2090
+ var objectKeys$2 = Object.keys || function keys(O) {
2091
+ return internalObjectKeys(O, enumBugKeys$1);
2091
2092
  };
2092
2093
 
2093
- var DESCRIPTORS = descriptors;
2094
+ var DESCRIPTORS$2 = descriptors;
2094
2095
  var uncurryThis = functionUncurryThis;
2095
- var call = functionCall;
2096
- var fails$1 = fails$b;
2097
- var objectKeys = objectKeys$1;
2096
+ var call$1 = functionCall;
2097
+ var fails$2 = fails$c;
2098
+ var objectKeys$1 = objectKeys$2;
2098
2099
  var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
2099
2100
  var propertyIsEnumerableModule = objectPropertyIsEnumerable;
2100
2101
  var toObject$1 = toObject$3;
2101
- var IndexedObject$1 = indexedObject;
2102
+ var IndexedObject = indexedObject;
2102
2103
 
2103
2104
  // eslint-disable-next-line es/no-object-assign -- safe
2104
2105
  var $assign = Object.assign;
2105
2106
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
2106
- var defineProperty = Object.defineProperty;
2107
+ var defineProperty$1 = Object.defineProperty;
2107
2108
  var concat = uncurryThis([].concat);
2108
2109
 
2109
2110
  // `Object.assign` method
2110
2111
  // https://tc39.es/ecma262/#sec-object.assign
2111
- var objectAssign = !$assign || fails$1(function () {
2112
+ var objectAssign = !$assign || fails$2(function () {
2112
2113
  // should have correct order of operations (Edge bug)
2113
- if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
2114
+ if (DESCRIPTORS$2 && $assign({ b: 1 }, $assign(defineProperty$1({}, 'a', {
2114
2115
  enumerable: true,
2115
2116
  get: function () {
2116
- defineProperty(this, 'b', {
2117
+ defineProperty$1(this, 'b', {
2117
2118
  value: 3,
2118
2119
  enumerable: false
2119
2120
  });
@@ -2127,7 +2128,7 @@ var objectAssign = !$assign || fails$1(function () {
2127
2128
  var alphabet = 'abcdefghijklmnopqrst';
2128
2129
  A[symbol] = 7;
2129
2130
  alphabet.split('').forEach(function (chr) { B[chr] = chr; });
2130
- return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;
2131
+ return $assign({}, A)[symbol] != 7 || objectKeys$1($assign({}, B)).join('') != alphabet;
2131
2132
  }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
2132
2133
  var T = toObject$1(target);
2133
2134
  var argumentsLength = arguments.length;
@@ -2135,14 +2136,14 @@ var objectAssign = !$assign || fails$1(function () {
2135
2136
  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
2136
2137
  var propertyIsEnumerable = propertyIsEnumerableModule.f;
2137
2138
  while (argumentsLength > index) {
2138
- var S = IndexedObject$1(arguments[index++]);
2139
- var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
2139
+ var S = IndexedObject(arguments[index++]);
2140
+ var keys = getOwnPropertySymbols ? concat(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S);
2140
2141
  var length = keys.length;
2141
2142
  var j = 0;
2142
2143
  var key;
2143
2144
  while (length > j) {
2144
2145
  key = keys[j++];
2145
- if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];
2146
+ if (!DESCRIPTORS$2 || call$1(propertyIsEnumerable, S, key)) T[key] = S[key];
2146
2147
  }
2147
2148
  } return T;
2148
2149
  } : $assign;
@@ -3442,11 +3443,13 @@ const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
3442
3443
  const ninetailedPlugin = ({
3443
3444
  clientId,
3444
3445
  environment,
3446
+ preview: _preview = false,
3445
3447
  url,
3446
3448
  profile,
3447
3449
  locale
3448
3450
  }) => {
3449
3451
  let isFirstEvent = true;
3452
+ let isInitialized = false;
3450
3453
  const apiClient = new NinetailedApiClient({
3451
3454
  clientId,
3452
3455
  environment,
@@ -3481,10 +3484,11 @@ const ninetailedPlugin = ({
3481
3484
  traits: get$2(cache, 'traits', {}),
3482
3485
  traitsUpdatedAt: get$2(cache, 'traitsUpdatedAt', new Date().toISOString()),
3483
3486
  localOnly,
3487
+ preview: _preview,
3484
3488
  options: {
3485
3489
  locale: locale || 'en'
3486
3490
  },
3487
- sessions: cache.sessions
3491
+ sessions: get$2(cache, 'sessions', [])
3488
3492
  });
3489
3493
  log('Profile from api: ', profile);
3490
3494
  const updatedCache = set({
@@ -3563,6 +3567,8 @@ const ninetailedPlugin = ({
3563
3567
  id: anonymousId
3564
3568
  }));
3565
3569
  }
3570
+
3571
+ isInitialized = true;
3566
3572
  },
3567
3573
  page: ({
3568
3574
  payload,
@@ -3615,7 +3621,7 @@ const ninetailedPlugin = ({
3615
3621
  }), instance);
3616
3622
  }),
3617
3623
  loaded: () => {
3618
- return true;
3624
+ return isInitialized;
3619
3625
  },
3620
3626
  methods: {
3621
3627
  reset: (...args) => __awaiter(void 0, void 0, void 0, function* () {
@@ -3650,79 +3656,465 @@ const ninetailedPlugin = ({
3650
3656
  };
3651
3657
  };
3652
3658
 
3653
- var global$1 = global$A;
3654
- var aCallable = aCallable$6;
3659
+ var objectDefineProperties = {};
3660
+
3661
+ var DESCRIPTORS$1 = descriptors;
3662
+ var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
3663
+ var definePropertyModule$1 = objectDefineProperty;
3664
+ var anObject$1 = anObject$a;
3665
+ var toIndexedObject$1 = toIndexedObject$5;
3666
+ var objectKeys = objectKeys$2;
3667
+
3668
+ // `Object.defineProperties` method
3669
+ // https://tc39.es/ecma262/#sec-object.defineproperties
3670
+ // eslint-disable-next-line es/no-object-defineproperties -- safe
3671
+ objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
3672
+ anObject$1(O);
3673
+ var props = toIndexedObject$1(Properties);
3674
+ var keys = objectKeys(Properties);
3675
+ var length = keys.length;
3676
+ var index = 0;
3677
+ var key;
3678
+ while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]);
3679
+ return O;
3680
+ };
3681
+
3682
+ /* global ActiveXObject -- old IE, WSH */
3683
+
3684
+ var anObject = anObject$a;
3685
+ var definePropertiesModule = objectDefineProperties;
3686
+ var enumBugKeys = enumBugKeys$3;
3687
+ var hiddenKeys = hiddenKeys$4;
3688
+ var html = html$2;
3689
+ var documentCreateElement$1 = documentCreateElement$2;
3690
+ var sharedKey$1 = sharedKey$3;
3691
+
3692
+ var GT = '>';
3693
+ var LT = '<';
3694
+ var PROTOTYPE = 'prototype';
3695
+ var SCRIPT = 'script';
3696
+ var IE_PROTO$1 = sharedKey$1('IE_PROTO');
3697
+
3698
+ var EmptyConstructor = function () { /* empty */ };
3699
+
3700
+ var scriptTag = function (content) {
3701
+ return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
3702
+ };
3703
+
3704
+ // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
3705
+ var NullProtoObjectViaActiveX = function (activeXDocument) {
3706
+ activeXDocument.write(scriptTag(''));
3707
+ activeXDocument.close();
3708
+ var temp = activeXDocument.parentWindow.Object;
3709
+ activeXDocument = null; // avoid memory leak
3710
+ return temp;
3711
+ };
3712
+
3713
+ // Create object with fake `null` prototype: use iframe Object with cleared prototype
3714
+ var NullProtoObjectViaIFrame = function () {
3715
+ // Thrash, waste and sodomy: IE GC bug
3716
+ var iframe = documentCreateElement$1('iframe');
3717
+ var JS = 'java' + SCRIPT + ':';
3718
+ var iframeDocument;
3719
+ iframe.style.display = 'none';
3720
+ html.appendChild(iframe);
3721
+ // https://github.com/zloirock/core-js/issues/475
3722
+ iframe.src = String(JS);
3723
+ iframeDocument = iframe.contentWindow.document;
3724
+ iframeDocument.open();
3725
+ iframeDocument.write(scriptTag('document.F=Object'));
3726
+ iframeDocument.close();
3727
+ return iframeDocument.F;
3728
+ };
3729
+
3730
+ // Check for document.domain and active x support
3731
+ // No need to use active x approach when document.domain is not set
3732
+ // see https://github.com/es-shims/es5-shim/issues/150
3733
+ // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
3734
+ // avoid IE GC bug
3735
+ var activeXDocument;
3736
+ var NullProtoObject = function () {
3737
+ try {
3738
+ activeXDocument = new ActiveXObject('htmlfile');
3739
+ } catch (error) { /* ignore */ }
3740
+ NullProtoObject = typeof document != 'undefined'
3741
+ ? document.domain && activeXDocument
3742
+ ? NullProtoObjectViaActiveX(activeXDocument) // old IE
3743
+ : NullProtoObjectViaIFrame()
3744
+ : NullProtoObjectViaActiveX(activeXDocument); // WSH
3745
+ var length = enumBugKeys.length;
3746
+ while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
3747
+ return NullProtoObject();
3748
+ };
3749
+
3750
+ hiddenKeys[IE_PROTO$1] = true;
3751
+
3752
+ // `Object.create` method
3753
+ // https://tc39.es/ecma262/#sec-object.create
3754
+ var objectCreate = Object.create || function create(O, Properties) {
3755
+ var result;
3756
+ if (O !== null) {
3757
+ EmptyConstructor[PROTOTYPE] = anObject(O);
3758
+ result = new EmptyConstructor();
3759
+ EmptyConstructor[PROTOTYPE] = null;
3760
+ // add "__proto__" for Object.getPrototypeOf polyfill
3761
+ result[IE_PROTO$1] = O;
3762
+ } else result = NullProtoObject();
3763
+ return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
3764
+ };
3765
+
3766
+ var wellKnownSymbol$3 = wellKnownSymbol$e;
3767
+ var create$1 = objectCreate;
3768
+ var definePropertyModule = objectDefineProperty;
3769
+
3770
+ var UNSCOPABLES = wellKnownSymbol$3('unscopables');
3771
+ var ArrayPrototype = Array.prototype;
3772
+
3773
+ // Array.prototype[@@unscopables]
3774
+ // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
3775
+ if (ArrayPrototype[UNSCOPABLES] == undefined) {
3776
+ definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
3777
+ configurable: true,
3778
+ value: create$1(null)
3779
+ });
3780
+ }
3781
+
3782
+ // add a key to Array.prototype[@@unscopables]
3783
+ var addToUnscopables$1 = function (key) {
3784
+ ArrayPrototype[UNSCOPABLES][key] = true;
3785
+ };
3786
+
3787
+ var fails$1 = fails$c;
3788
+
3789
+ var correctPrototypeGetter = !fails$1(function () {
3790
+ function F() { /* empty */ }
3791
+ F.prototype.constructor = null;
3792
+ // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
3793
+ return Object.getPrototypeOf(new F()) !== F.prototype;
3794
+ });
3795
+
3796
+ var global$2 = global$B;
3797
+ var hasOwn = hasOwnProperty_1;
3798
+ var isCallable$2 = isCallable$h;
3655
3799
  var toObject = toObject$3;
3656
- var IndexedObject = indexedObject;
3657
- var lengthOfArrayLike = lengthOfArrayLike$3;
3658
-
3659
- var TypeError$1 = global$1.TypeError;
3660
-
3661
- // `Array.prototype.{ reduce, reduceRight }` methods implementation
3662
- var createMethod = function (IS_RIGHT) {
3663
- return function (that, callbackfn, argumentsLength, memo) {
3664
- aCallable(callbackfn);
3665
- var O = toObject(that);
3666
- var self = IndexedObject(O);
3667
- var length = lengthOfArrayLike(O);
3668
- var index = IS_RIGHT ? length - 1 : 0;
3669
- var i = IS_RIGHT ? -1 : 1;
3670
- if (argumentsLength < 2) while (true) {
3671
- if (index in self) {
3672
- memo = self[index];
3673
- index += i;
3674
- break;
3675
- }
3676
- index += i;
3677
- if (IS_RIGHT ? index < 0 : length <= index) {
3678
- throw TypeError$1('Reduce of empty array with no initial value');
3800
+ var sharedKey = sharedKey$3;
3801
+ var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
3802
+
3803
+ var IE_PROTO = sharedKey('IE_PROTO');
3804
+ var Object$1 = global$2.Object;
3805
+ var ObjectPrototype = Object$1.prototype;
3806
+
3807
+ // `Object.getPrototypeOf` method
3808
+ // https://tc39.es/ecma262/#sec-object.getprototypeof
3809
+ var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object$1.getPrototypeOf : function (O) {
3810
+ var object = toObject(O);
3811
+ if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
3812
+ var constructor = object.constructor;
3813
+ if (isCallable$2(constructor) && object instanceof constructor) {
3814
+ return constructor.prototype;
3815
+ } return object instanceof Object$1 ? ObjectPrototype : null;
3816
+ };
3817
+
3818
+ var fails = fails$c;
3819
+ var isCallable$1 = isCallable$h;
3820
+ var getPrototypeOf$1 = objectGetPrototypeOf;
3821
+ var redefine$1 = redefine$5.exports;
3822
+ var wellKnownSymbol$2 = wellKnownSymbol$e;
3823
+
3824
+ var ITERATOR$2 = wellKnownSymbol$2('iterator');
3825
+ var BUGGY_SAFARI_ITERATORS$1 = false;
3826
+
3827
+ // `%IteratorPrototype%` object
3828
+ // https://tc39.es/ecma262/#sec-%iteratorprototype%-object
3829
+ var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator;
3830
+
3831
+ /* eslint-disable es/no-array-prototype-keys -- safe */
3832
+ if ([].keys) {
3833
+ arrayIterator = [].keys();
3834
+ // Safari 8 has buggy iterators w/o `next`
3835
+ if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true;
3836
+ else {
3837
+ PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator));
3838
+ if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype;
3839
+ }
3840
+ }
3841
+
3842
+ var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails(function () {
3843
+ var test = {};
3844
+ // FF44- legacy iterators case
3845
+ return IteratorPrototype$2[ITERATOR$2].call(test) !== test;
3846
+ });
3847
+
3848
+ if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
3849
+
3850
+ // `%IteratorPrototype%[@@iterator]()` method
3851
+ // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
3852
+ if (!isCallable$1(IteratorPrototype$2[ITERATOR$2])) {
3853
+ redefine$1(IteratorPrototype$2, ITERATOR$2, function () {
3854
+ return this;
3855
+ });
3856
+ }
3857
+
3858
+ var iteratorsCore = {
3859
+ IteratorPrototype: IteratorPrototype$2,
3860
+ BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1
3861
+ };
3862
+
3863
+ var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
3864
+ var create = objectCreate;
3865
+ var createPropertyDescriptor = createPropertyDescriptor$3;
3866
+ var setToStringTag$1 = setToStringTag$3;
3867
+ var Iterators$2 = iterators;
3868
+
3869
+ var returnThis$1 = function () { return this; };
3870
+
3871
+ var createIteratorConstructor$1 = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
3872
+ var TO_STRING_TAG = NAME + ' Iterator';
3873
+ IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
3874
+ setToStringTag$1(IteratorConstructor, TO_STRING_TAG, false);
3875
+ Iterators$2[TO_STRING_TAG] = returnThis$1;
3876
+ return IteratorConstructor;
3877
+ };
3878
+
3879
+ var $ = _export;
3880
+ var call = functionCall;
3881
+ var FunctionName = functionName;
3882
+ var isCallable = isCallable$h;
3883
+ var createIteratorConstructor = createIteratorConstructor$1;
3884
+ var getPrototypeOf = objectGetPrototypeOf;
3885
+ var setPrototypeOf = objectSetPrototypeOf;
3886
+ var setToStringTag = setToStringTag$3;
3887
+ var createNonEnumerableProperty$1 = createNonEnumerableProperty$5;
3888
+ var redefine = redefine$5.exports;
3889
+ var wellKnownSymbol$1 = wellKnownSymbol$e;
3890
+ var Iterators$1 = iterators;
3891
+ var IteratorsCore = iteratorsCore;
3892
+
3893
+ var PROPER_FUNCTION_NAME = FunctionName.PROPER;
3894
+ var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
3895
+ var IteratorPrototype = IteratorsCore.IteratorPrototype;
3896
+ var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
3897
+ var ITERATOR$1 = wellKnownSymbol$1('iterator');
3898
+ var KEYS = 'keys';
3899
+ var VALUES = 'values';
3900
+ var ENTRIES = 'entries';
3901
+
3902
+ var returnThis = function () { return this; };
3903
+
3904
+ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
3905
+ createIteratorConstructor(IteratorConstructor, NAME, next);
3906
+
3907
+ var getIterationMethod = function (KIND) {
3908
+ if (KIND === DEFAULT && defaultIterator) return defaultIterator;
3909
+ if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
3910
+ switch (KIND) {
3911
+ case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
3912
+ case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
3913
+ case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
3914
+ } return function () { return new IteratorConstructor(this); };
3915
+ };
3916
+
3917
+ var TO_STRING_TAG = NAME + ' Iterator';
3918
+ var INCORRECT_VALUES_NAME = false;
3919
+ var IterablePrototype = Iterable.prototype;
3920
+ var nativeIterator = IterablePrototype[ITERATOR$1]
3921
+ || IterablePrototype['@@iterator']
3922
+ || DEFAULT && IterablePrototype[DEFAULT];
3923
+ var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
3924
+ var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
3925
+ var CurrentIteratorPrototype, methods, KEY;
3926
+
3927
+ // fix native
3928
+ if (anyNativeIterator) {
3929
+ CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
3930
+ if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
3931
+ if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
3932
+ if (setPrototypeOf) {
3933
+ setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
3934
+ } else if (!isCallable(CurrentIteratorPrototype[ITERATOR$1])) {
3935
+ redefine(CurrentIteratorPrototype, ITERATOR$1, returnThis);
3936
+ }
3679
3937
  }
3938
+ // Set @@toStringTag to native iterators
3939
+ setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true);
3680
3940
  }
3681
- for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
3682
- memo = callbackfn(memo, self[index], index, O);
3941
+ }
3942
+
3943
+ // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
3944
+ if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
3945
+ if (CONFIGURABLE_FUNCTION_NAME) {
3946
+ createNonEnumerableProperty$1(IterablePrototype, 'name', VALUES);
3947
+ } else {
3948
+ INCORRECT_VALUES_NAME = true;
3949
+ defaultIterator = function values() { return call(nativeIterator, this); };
3683
3950
  }
3684
- return memo;
3685
- };
3686
- };
3951
+ }
3952
+
3953
+ // export additional methods
3954
+ if (DEFAULT) {
3955
+ methods = {
3956
+ values: getIterationMethod(VALUES),
3957
+ keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
3958
+ entries: getIterationMethod(ENTRIES)
3959
+ };
3960
+ if (FORCED) for (KEY in methods) {
3961
+ if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
3962
+ redefine(IterablePrototype, KEY, methods[KEY]);
3963
+ }
3964
+ } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
3965
+ }
3966
+
3967
+ // define iterator
3968
+ if (IterablePrototype[ITERATOR$1] !== defaultIterator) {
3969
+ redefine(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT });
3970
+ }
3971
+ Iterators$1[NAME] = defaultIterator;
3687
3972
 
3688
- var arrayReduce = {
3689
- // `Array.prototype.reduce` method
3690
- // https://tc39.es/ecma262/#sec-array.prototype.reduce
3691
- left: createMethod(false),
3692
- // `Array.prototype.reduceRight` method
3693
- // https://tc39.es/ecma262/#sec-array.prototype.reduceright
3694
- right: createMethod(true)
3973
+ return methods;
3695
3974
  };
3696
3975
 
3697
- var fails = fails$b;
3976
+ var toIndexedObject = toIndexedObject$5;
3977
+ var addToUnscopables = addToUnscopables$1;
3978
+ var Iterators = iterators;
3979
+ var InternalStateModule = internalState;
3980
+ var defineProperty = objectDefineProperty.f;
3981
+ var defineIterator = defineIterator$1;
3982
+ var DESCRIPTORS = descriptors;
3698
3983
 
3699
- var arrayMethodIsStrict$1 = function (METHOD_NAME, argument) {
3700
- var method = [][METHOD_NAME];
3701
- return !!method && fails(function () {
3702
- // eslint-disable-next-line no-useless-call -- required for testing
3703
- method.call(null, argument || function () { return 1; }, 1);
3984
+ var ARRAY_ITERATOR = 'Array Iterator';
3985
+ var setInternalState = InternalStateModule.set;
3986
+ var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
3987
+
3988
+ // `Array.prototype.entries` method
3989
+ // https://tc39.es/ecma262/#sec-array.prototype.entries
3990
+ // `Array.prototype.keys` method
3991
+ // https://tc39.es/ecma262/#sec-array.prototype.keys
3992
+ // `Array.prototype.values` method
3993
+ // https://tc39.es/ecma262/#sec-array.prototype.values
3994
+ // `Array.prototype[@@iterator]` method
3995
+ // https://tc39.es/ecma262/#sec-array.prototype-@@iterator
3996
+ // `CreateArrayIterator` internal method
3997
+ // https://tc39.es/ecma262/#sec-createarrayiterator
3998
+ var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
3999
+ setInternalState(this, {
4000
+ type: ARRAY_ITERATOR,
4001
+ target: toIndexedObject(iterated), // target
4002
+ index: 0, // next index
4003
+ kind: kind // kind
3704
4004
  });
4005
+ // `%ArrayIteratorPrototype%.next` method
4006
+ // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
4007
+ }, function () {
4008
+ var state = getInternalState(this);
4009
+ var target = state.target;
4010
+ var kind = state.kind;
4011
+ var index = state.index++;
4012
+ if (!target || index >= target.length) {
4013
+ state.target = undefined;
4014
+ return { value: undefined, done: true };
4015
+ }
4016
+ if (kind == 'keys') return { value: index, done: false };
4017
+ if (kind == 'values') return { value: target[index], done: false };
4018
+ return { value: [index, target[index]], done: false };
4019
+ }, 'values');
4020
+
4021
+ // argumentsList[@@iterator] is %ArrayProto_values%
4022
+ // https://tc39.es/ecma262/#sec-createunmappedargumentsobject
4023
+ // https://tc39.es/ecma262/#sec-createmappedargumentsobject
4024
+ var values = Iterators.Arguments = Iterators.Array;
4025
+
4026
+ // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
4027
+ addToUnscopables('keys');
4028
+ addToUnscopables('values');
4029
+ addToUnscopables('entries');
4030
+
4031
+ // V8 ~ Chrome 45- bug
4032
+ if (DESCRIPTORS && values.name !== 'values') try {
4033
+ defineProperty(values, 'name', { value: 'values' });
4034
+ } catch (error) { /* empty */ }
4035
+
4036
+ // iterable DOM collections
4037
+ // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
4038
+ var domIterables = {
4039
+ CSSRuleList: 0,
4040
+ CSSStyleDeclaration: 0,
4041
+ CSSValueList: 0,
4042
+ ClientRectList: 0,
4043
+ DOMRectList: 0,
4044
+ DOMStringList: 0,
4045
+ DOMTokenList: 1,
4046
+ DataTransferItemList: 0,
4047
+ FileList: 0,
4048
+ HTMLAllCollection: 0,
4049
+ HTMLCollection: 0,
4050
+ HTMLFormElement: 0,
4051
+ HTMLSelectElement: 0,
4052
+ MediaList: 0,
4053
+ MimeTypeArray: 0,
4054
+ NamedNodeMap: 0,
4055
+ NodeList: 1,
4056
+ PaintRequestList: 0,
4057
+ Plugin: 0,
4058
+ PluginArray: 0,
4059
+ SVGLengthList: 0,
4060
+ SVGNumberList: 0,
4061
+ SVGPathSegList: 0,
4062
+ SVGPointList: 0,
4063
+ SVGStringList: 0,
4064
+ SVGTransformList: 0,
4065
+ SourceBufferList: 0,
4066
+ StyleSheetList: 0,
4067
+ TextTrackCueList: 0,
4068
+ TextTrackList: 0,
4069
+ TouchList: 0
3705
4070
  };
3706
4071
 
3707
- var $ = _export;
3708
- var $reduce = arrayReduce.left;
3709
- var arrayMethodIsStrict = arrayMethodIsStrict$1;
3710
- var CHROME_VERSION = engineV8Version;
3711
- var IS_NODE = engineIsNode;
4072
+ // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
4073
+ var documentCreateElement = documentCreateElement$2;
3712
4074
 
3713
- var STRICT_METHOD = arrayMethodIsStrict('reduce');
3714
- // Chrome 80-82 has a critical bug
3715
- // https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
3716
- var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83;
3717
-
3718
- // `Array.prototype.reduce` method
3719
- // https://tc39.es/ecma262/#sec-array.prototype.reduce
3720
- $({ target: 'Array', proto: true, forced: !STRICT_METHOD || CHROME_BUG }, {
3721
- reduce: function reduce(callbackfn /* , initialValue */) {
3722
- var length = arguments.length;
3723
- return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : undefined);
4075
+ var classList = documentCreateElement('span').classList;
4076
+ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
4077
+
4078
+ var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
4079
+
4080
+ var global$1 = global$B;
4081
+ var DOMIterables = domIterables;
4082
+ var DOMTokenListPrototype = domTokenListPrototype;
4083
+ var ArrayIteratorMethods = es_array_iterator;
4084
+ var createNonEnumerableProperty = createNonEnumerableProperty$5;
4085
+ var wellKnownSymbol = wellKnownSymbol$e;
4086
+
4087
+ var ITERATOR = wellKnownSymbol('iterator');
4088
+ var TO_STRING_TAG = wellKnownSymbol('toStringTag');
4089
+ var ArrayValues = ArrayIteratorMethods.values;
4090
+
4091
+ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
4092
+ if (CollectionPrototype) {
4093
+ // some Chrome versions have non-configurable methods on DOMTokenList
4094
+ if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
4095
+ createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
4096
+ } catch (error) {
4097
+ CollectionPrototype[ITERATOR] = ArrayValues;
4098
+ }
4099
+ if (!CollectionPrototype[TO_STRING_TAG]) {
4100
+ createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
4101
+ }
4102
+ if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
4103
+ // some Chrome versions have non-configurable methods on DOMTokenList
4104
+ if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
4105
+ createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
4106
+ } catch (error) {
4107
+ CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
4108
+ }
4109
+ }
3724
4110
  }
3725
- });
4111
+ };
4112
+
4113
+ for (var COLLECTION_NAME in DOMIterables) {
4114
+ handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype, COLLECTION_NAME);
4115
+ }
4116
+
4117
+ handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
3726
4118
 
3727
4119
  class Ninetailed {
3728
4120
  constructor({
@@ -3742,6 +4134,15 @@ class Ninetailed {
3742
4134
  return this.instance.track(event, payload, this.buildOptions(options));
3743
4135
  };
3744
4136
 
4137
+ this.trackHasSeenComponent = payload => {
4138
+ return this.track('hasSeenComponent', payload, {
4139
+ plugins: {
4140
+ all: true,
4141
+ ninetailed: false
4142
+ }
4143
+ });
4144
+ };
4145
+
3745
4146
  this.identify = (uid, traits, options) => {
3746
4147
  return this.instance.identify(uid, traits, this.buildOptions(options));
3747
4148
  };
@@ -3766,7 +4167,7 @@ class Ninetailed {
3766
4167
  });
3767
4168
  };
3768
4169
 
3769
- this.plugins = plugins || [];
4170
+ this.plugins = flatten(plugins || []);
3770
4171
  this._profileState = {
3771
4172
  loading: !profile,
3772
4173
  profile,
@@ -3775,26 +4176,14 @@ class Ninetailed {
3775
4176
  };
3776
4177
  this.instance = Analytics({
3777
4178
  app: 'ninetailed',
3778
- plugins: [ninetailedPlugin({
4179
+ plugins: [...this.plugins, ninetailedPlugin({
3779
4180
  clientId,
3780
4181
  environment,
3781
4182
  url,
3782
4183
  profile,
3783
4184
  locale
3784
4185
  })]
3785
- }); // register plugins conditionally
3786
- // const additionalPlugins: AnalyticsPlugin[] = useMemo(() => {
3787
- // const importedPlugins = [];
3788
- // if (options.analyticsPlugins?.googleAnalytics) {
3789
- // importedPlugins.push(
3790
- // googleAnalytics({
3791
- // trackingId: options.analyticsPlugins.googleAnalytics.trackingId,
3792
- // })
3793
- // );
3794
- // }
3795
- // return importedPlugins;
3796
- // }, []);
3797
- // put in private method
4186
+ }); // put in private method
3798
4187
 
3799
4188
  this.onProfileChange(profileState => {
3800
4189
  this._profileState = profileState;
@@ -3807,14 +4196,7 @@ class Ninetailed {
3807
4196
  }
3808
4197
 
3809
4198
  buildOptions(options = {}) {
3810
- return Object.assign(Object.assign({}, options), {
3811
- plugins: Object.assign(Object.assign({
3812
- all: false,
3813
- ninetailed: true
3814
- }, this.plugins.map(plugin => plugin).filter(plugin => includes(plugin.name, 'ninetailed:')).reduce((acc, curr) => Object.assign(Object.assign({}, acc), {
3815
- [curr.name]: true
3816
- }), {})), get$2(options, 'plugins'))
3817
- });
4199
+ return Object.assign({}, options);
3818
4200
  }
3819
4201
 
3820
4202
  registerWindowHandlers() {
@@ -3822,6 +4204,7 @@ class Ninetailed {
3822
4204
  window.ninetailed = Object.assign({}, window.ninetailed, {
3823
4205
  page: this.page.bind(this),
3824
4206
  track: this.track.bind(this),
4207
+ trackHasSeenComponent: this.trackHasSeenComponent.bind(this),
3825
4208
  identify: this.identify.bind(this),
3826
4209
  reset: this.reset.bind(this),
3827
4210
  debug: this.debug.bind(this)
@@ -3841,7 +4224,12 @@ const selectVariant = (baseline, variants, {
3841
4224
  if (loading) {
3842
4225
  return {
3843
4226
  loading: true,
3844
- variant: baseline,
4227
+ variant: Object.assign({
4228
+ id: 'baseline',
4229
+ audience: {
4230
+ id: 'baseline'
4231
+ }
4232
+ }, baseline),
3845
4233
  audience: {
3846
4234
  id: 'baseline'
3847
4235
  },
@@ -3853,7 +4241,12 @@ const selectVariant = (baseline, variants, {
3853
4241
  if (error) {
3854
4242
  return {
3855
4243
  loading: false,
3856
- variant: baseline,
4244
+ variant: Object.assign({
4245
+ id: 'baseline',
4246
+ audience: {
4247
+ id: 'baseline'
4248
+ }
4249
+ }, baseline),
3857
4250
  audience: {
3858
4251
  id: 'baseline'
3859
4252
  },
@@ -3872,7 +4265,12 @@ const selectVariant = (baseline, variants, {
3872
4265
  if (options.holdout > profile.random) {
3873
4266
  return {
3874
4267
  loading: false,
3875
- variant: baseline,
4268
+ variant: Object.assign({
4269
+ id: 'baseline',
4270
+ audience: {
4271
+ id: 'baseline'
4272
+ }
4273
+ }, baseline),
3876
4274
  audience: {
3877
4275
  id: variant.audience.id
3878
4276
  },
@@ -3898,7 +4296,12 @@ const selectVariant = (baseline, variants, {
3898
4296
 
3899
4297
  return {
3900
4298
  loading: false,
3901
- variant: baseline,
4299
+ variant: Object.assign({
4300
+ id: 'baseline',
4301
+ audience: {
4302
+ id: 'baseline'
4303
+ }
4304
+ }, baseline),
3902
4305
  audience: {
3903
4306
  id: 'baseline'
3904
4307
  },