@bcrumbs.net/bc-api 0.0.23 → 0.0.25

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.cjs.js CHANGED
@@ -3600,7 +3600,7 @@ var check = function (it) {
3600
3600
  };
3601
3601
 
3602
3602
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
3603
- var global$m =
3603
+ var global$n =
3604
3604
  // eslint-disable-next-line es/no-global-this -- safe
3605
3605
  check(typeof globalThis == 'object' && globalThis) ||
3606
3606
  check(typeof window == 'object' && window) ||
@@ -3613,7 +3613,7 @@ var global$m =
3613
3613
 
3614
3614
  var objectGetOwnPropertyDescriptor = {};
3615
3615
 
3616
- var fails$l = function (exec) {
3616
+ var fails$m = function (exec) {
3617
3617
  try {
3618
3618
  return !!exec();
3619
3619
  } catch (error) {
@@ -3621,17 +3621,17 @@ var fails$l = function (exec) {
3621
3621
  }
3622
3622
  };
3623
3623
 
3624
- var fails$k = fails$l;
3624
+ var fails$l = fails$m;
3625
3625
 
3626
3626
  // Detect IE8's incomplete defineProperty implementation
3627
- var descriptors = !fails$k(function () {
3627
+ var descriptors = !fails$l(function () {
3628
3628
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
3629
3629
  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
3630
3630
  });
3631
3631
 
3632
- var fails$j = fails$l;
3632
+ var fails$k = fails$m;
3633
3633
 
3634
- var functionBindNative = !fails$j(function () {
3634
+ var functionBindNative = !fails$k(function () {
3635
3635
  // eslint-disable-next-line es/no-function-prototype-bind -- safe
3636
3636
  var test = (function () { /* empty */ }).bind();
3637
3637
  // eslint-disable-next-line no-prototype-builtins -- safe
@@ -3662,7 +3662,7 @@ objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
3662
3662
  return !!descriptor && descriptor.enumerable;
3663
3663
  } : $propertyIsEnumerable;
3664
3664
 
3665
- var createPropertyDescriptor$3 = function (bitmap, value) {
3665
+ var createPropertyDescriptor$4 = function (bitmap, value) {
3666
3666
  return {
3667
3667
  enumerable: !(bitmap & 1),
3668
3668
  configurable: !(bitmap & 2),
@@ -3683,24 +3683,24 @@ var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function (fn) {
3683
3683
  };
3684
3684
  };
3685
3685
 
3686
- var uncurryThis$n = functionUncurryThis;
3686
+ var uncurryThis$o = functionUncurryThis;
3687
3687
 
3688
- var toString$a = uncurryThis$n({}.toString);
3689
- var stringSlice$5 = uncurryThis$n(''.slice);
3688
+ var toString$b = uncurryThis$o({}.toString);
3689
+ var stringSlice$5 = uncurryThis$o(''.slice);
3690
3690
 
3691
3691
  var classofRaw$2 = function (it) {
3692
- return stringSlice$5(toString$a(it), 8, -1);
3692
+ return stringSlice$5(toString$b(it), 8, -1);
3693
3693
  };
3694
3694
 
3695
- var uncurryThis$m = functionUncurryThis;
3696
- var fails$i = fails$l;
3695
+ var uncurryThis$n = functionUncurryThis;
3696
+ var fails$j = fails$m;
3697
3697
  var classof$9 = classofRaw$2;
3698
3698
 
3699
3699
  var $Object$4 = Object;
3700
- var split = uncurryThis$m(''.split);
3700
+ var split = uncurryThis$n(''.split);
3701
3701
 
3702
3702
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
3703
- var indexedObject = fails$i(function () {
3703
+ var indexedObject = fails$j(function () {
3704
3704
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
3705
3705
  // eslint-disable-next-line no-prototype-builtins -- safe
3706
3706
  return !$Object$4('z').propertyIsEnumerable(0);
@@ -3739,40 +3739,40 @@ var documentAll = typeof document == 'object' && document.all;
3739
3739
  // `IsCallable` abstract operation
3740
3740
  // https://tc39.es/ecma262/#sec-iscallable
3741
3741
  // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
3742
- var isCallable$n = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
3742
+ var isCallable$o = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
3743
3743
  return typeof argument == 'function' || argument === documentAll;
3744
3744
  } : function (argument) {
3745
3745
  return typeof argument == 'function';
3746
3746
  };
3747
3747
 
3748
- var isCallable$m = isCallable$n;
3748
+ var isCallable$n = isCallable$o;
3749
3749
 
3750
- var isObject$b = function (it) {
3751
- return typeof it == 'object' ? it !== null : isCallable$m(it);
3750
+ var isObject$d = function (it) {
3751
+ return typeof it == 'object' ? it !== null : isCallable$n(it);
3752
3752
  };
3753
3753
 
3754
- var global$l = global$m;
3755
- var isCallable$l = isCallable$n;
3754
+ var global$m = global$n;
3755
+ var isCallable$m = isCallable$o;
3756
3756
 
3757
3757
  var aFunction = function (argument) {
3758
- return isCallable$l(argument) ? argument : undefined;
3758
+ return isCallable$m(argument) ? argument : undefined;
3759
3759
  };
3760
3760
 
3761
- var getBuiltIn$8 = function (namespace, method) {
3762
- return arguments.length < 2 ? aFunction(global$l[namespace]) : global$l[namespace] && global$l[namespace][method];
3761
+ var getBuiltIn$9 = function (namespace, method) {
3762
+ return arguments.length < 2 ? aFunction(global$m[namespace]) : global$m[namespace] && global$m[namespace][method];
3763
3763
  };
3764
3764
 
3765
- var uncurryThis$l = functionUncurryThis;
3765
+ var uncurryThis$m = functionUncurryThis;
3766
3766
 
3767
- var objectIsPrototypeOf = uncurryThis$l({}.isPrototypeOf);
3767
+ var objectIsPrototypeOf = uncurryThis$m({}.isPrototypeOf);
3768
3768
 
3769
3769
  var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
3770
3770
 
3771
- var global$k = global$m;
3771
+ var global$l = global$n;
3772
3772
  var userAgent$3 = engineUserAgent;
3773
3773
 
3774
- var process$4 = global$k.process;
3775
- var Deno$1 = global$k.Deno;
3774
+ var process$4 = global$l.process;
3775
+ var Deno$1 = global$l.Deno;
3776
3776
  var versions = process$4 && process$4.versions || Deno$1 && Deno$1.version;
3777
3777
  var v8 = versions && versions.v8;
3778
3778
  var match, version;
@@ -3798,13 +3798,13 @@ var engineV8Version = version;
3798
3798
 
3799
3799
  /* eslint-disable es/no-symbol -- required for testing */
3800
3800
  var V8_VERSION$1 = engineV8Version;
3801
- var fails$h = fails$l;
3802
- var global$j = global$m;
3801
+ var fails$i = fails$m;
3802
+ var global$k = global$n;
3803
3803
 
3804
- var $String$6 = global$j.String;
3804
+ var $String$6 = global$k.String;
3805
3805
 
3806
3806
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
3807
- var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$h(function () {
3807
+ var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$i(function () {
3808
3808
  var symbol = Symbol('symbol detection');
3809
3809
  // Chrome 38 Symbol has incorrect toString conversion
3810
3810
  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
@@ -3822,9 +3822,9 @@ var useSymbolAsUid = NATIVE_SYMBOL$2
3822
3822
  && !Symbol.sham
3823
3823
  && typeof Symbol.iterator == 'symbol';
3824
3824
 
3825
- var getBuiltIn$7 = getBuiltIn$8;
3826
- var isCallable$k = isCallable$n;
3827
- var isPrototypeOf$2 = objectIsPrototypeOf;
3825
+ var getBuiltIn$8 = getBuiltIn$9;
3826
+ var isCallable$l = isCallable$o;
3827
+ var isPrototypeOf$3 = objectIsPrototypeOf;
3828
3828
  var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
3829
3829
 
3830
3830
  var $Object$3 = Object;
@@ -3832,8 +3832,8 @@ var $Object$3 = Object;
3832
3832
  var isSymbol$3 = USE_SYMBOL_AS_UID$1 ? function (it) {
3833
3833
  return typeof it == 'symbol';
3834
3834
  } : function (it) {
3835
- var $Symbol = getBuiltIn$7('Symbol');
3836
- return isCallable$k($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it));
3835
+ var $Symbol = getBuiltIn$8('Symbol');
3836
+ return isCallable$l($Symbol) && isPrototypeOf$3($Symbol.prototype, $Object$3(it));
3837
3837
  };
3838
3838
 
3839
3839
  var $String$5 = String;
@@ -3846,14 +3846,14 @@ var tryToString$4 = function (argument) {
3846
3846
  }
3847
3847
  };
3848
3848
 
3849
- var isCallable$j = isCallable$n;
3849
+ var isCallable$k = isCallable$o;
3850
3850
  var tryToString$3 = tryToString$4;
3851
3851
 
3852
3852
  var $TypeError$d = TypeError;
3853
3853
 
3854
3854
  // `Assert: IsCallable(argument) is true`
3855
3855
  var aCallable$8 = function (argument) {
3856
- if (isCallable$j(argument)) return argument;
3856
+ if (isCallable$k(argument)) return argument;
3857
3857
  throw new $TypeError$d(tryToString$3(argument) + ' is not a function');
3858
3858
  };
3859
3859
 
@@ -3868,8 +3868,8 @@ var getMethod$5 = function (V, P) {
3868
3868
  };
3869
3869
 
3870
3870
  var call$h = functionCall;
3871
- var isCallable$i = isCallable$n;
3872
- var isObject$a = isObject$b;
3871
+ var isCallable$j = isCallable$o;
3872
+ var isObject$c = isObject$d;
3873
3873
 
3874
3874
  var $TypeError$c = TypeError;
3875
3875
 
@@ -3877,28 +3877,28 @@ var $TypeError$c = TypeError;
3877
3877
  // https://tc39.es/ecma262/#sec-ordinarytoprimitive
3878
3878
  var ordinaryToPrimitive$1 = function (input, pref) {
3879
3879
  var fn, val;
3880
- if (pref === 'string' && isCallable$i(fn = input.toString) && !isObject$a(val = call$h(fn, input))) return val;
3881
- if (isCallable$i(fn = input.valueOf) && !isObject$a(val = call$h(fn, input))) return val;
3882
- if (pref !== 'string' && isCallable$i(fn = input.toString) && !isObject$a(val = call$h(fn, input))) return val;
3880
+ if (pref === 'string' && isCallable$j(fn = input.toString) && !isObject$c(val = call$h(fn, input))) return val;
3881
+ if (isCallable$j(fn = input.valueOf) && !isObject$c(val = call$h(fn, input))) return val;
3882
+ if (pref !== 'string' && isCallable$j(fn = input.toString) && !isObject$c(val = call$h(fn, input))) return val;
3883
3883
  throw new $TypeError$c("Can't convert object to primitive value");
3884
3884
  };
3885
3885
 
3886
3886
  var sharedStore = {exports: {}};
3887
3887
 
3888
- var global$i = global$m;
3888
+ var global$j = global$n;
3889
3889
 
3890
3890
  // eslint-disable-next-line es/no-object-defineproperty -- safe
3891
- var defineProperty$6 = Object.defineProperty;
3891
+ var defineProperty$7 = Object.defineProperty;
3892
3892
 
3893
3893
  var defineGlobalProperty$3 = function (key, value) {
3894
3894
  try {
3895
- defineProperty$6(global$i, key, { value: value, configurable: true, writable: true });
3895
+ defineProperty$7(global$j, key, { value: value, configurable: true, writable: true });
3896
3896
  } catch (error) {
3897
- global$i[key] = value;
3897
+ global$j[key] = value;
3898
3898
  } return value;
3899
3899
  };
3900
3900
 
3901
- var globalThis$1 = global$m;
3901
+ var globalThis$1 = global$n;
3902
3902
  var defineGlobalProperty$2 = defineGlobalProperty$3;
3903
3903
 
3904
3904
  var SHARED = '__core-js_shared__';
@@ -3930,10 +3930,10 @@ var toObject$4 = function (argument) {
3930
3930
  return $Object$2(requireObjectCoercible$6(argument));
3931
3931
  };
3932
3932
 
3933
- var uncurryThis$k = functionUncurryThis;
3933
+ var uncurryThis$l = functionUncurryThis;
3934
3934
  var toObject$3 = toObject$4;
3935
3935
 
3936
- var hasOwnProperty = uncurryThis$k({}.hasOwnProperty);
3936
+ var hasOwnProperty = uncurryThis$l({}.hasOwnProperty);
3937
3937
 
3938
3938
  // `HasOwnProperty` abstract operation
3939
3939
  // https://tc39.es/ecma262/#sec-hasownproperty
@@ -3942,37 +3942,37 @@ var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
3942
3942
  return hasOwnProperty(toObject$3(it), key);
3943
3943
  };
3944
3944
 
3945
- var uncurryThis$j = functionUncurryThis;
3945
+ var uncurryThis$k = functionUncurryThis;
3946
3946
 
3947
3947
  var id = 0;
3948
3948
  var postfix = Math.random();
3949
- var toString$9 = uncurryThis$j(1.0.toString);
3949
+ var toString$a = uncurryThis$k(1.0.toString);
3950
3950
 
3951
3951
  var uid$2 = function (key) {
3952
- return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$9(++id + postfix, 36);
3952
+ return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$a(++id + postfix, 36);
3953
3953
  };
3954
3954
 
3955
- var global$h = global$m;
3955
+ var global$i = global$n;
3956
3956
  var shared$3 = shared$4;
3957
- var hasOwn$9 = hasOwnProperty_1;
3957
+ var hasOwn$a = hasOwnProperty_1;
3958
3958
  var uid$1 = uid$2;
3959
3959
  var NATIVE_SYMBOL$1 = symbolConstructorDetection;
3960
3960
  var USE_SYMBOL_AS_UID = useSymbolAsUid;
3961
3961
 
3962
- var Symbol$2 = global$h.Symbol;
3962
+ var Symbol$2 = global$i.Symbol;
3963
3963
  var WellKnownSymbolsStore = shared$3('wks');
3964
3964
  var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$2['for'] || Symbol$2 : Symbol$2 && Symbol$2.withoutSetter || uid$1;
3965
3965
 
3966
3966
  var wellKnownSymbol$i = function (name) {
3967
- if (!hasOwn$9(WellKnownSymbolsStore, name)) {
3968
- WellKnownSymbolsStore[name] = NATIVE_SYMBOL$1 && hasOwn$9(Symbol$2, name)
3967
+ if (!hasOwn$a(WellKnownSymbolsStore, name)) {
3968
+ WellKnownSymbolsStore[name] = NATIVE_SYMBOL$1 && hasOwn$a(Symbol$2, name)
3969
3969
  ? Symbol$2[name]
3970
3970
  : createWellKnownSymbol('Symbol.' + name);
3971
3971
  } return WellKnownSymbolsStore[name];
3972
3972
  };
3973
3973
 
3974
3974
  var call$g = functionCall;
3975
- var isObject$9 = isObject$b;
3975
+ var isObject$b = isObject$d;
3976
3976
  var isSymbol$2 = isSymbol$3;
3977
3977
  var getMethod$4 = getMethod$5;
3978
3978
  var ordinaryToPrimitive = ordinaryToPrimitive$1;
@@ -3984,13 +3984,13 @@ var TO_PRIMITIVE = wellKnownSymbol$h('toPrimitive');
3984
3984
  // `ToPrimitive` abstract operation
3985
3985
  // https://tc39.es/ecma262/#sec-toprimitive
3986
3986
  var toPrimitive$1 = function (input, pref) {
3987
- if (!isObject$9(input) || isSymbol$2(input)) return input;
3987
+ if (!isObject$b(input) || isSymbol$2(input)) return input;
3988
3988
  var exoticToPrim = getMethod$4(input, TO_PRIMITIVE);
3989
3989
  var result;
3990
3990
  if (exoticToPrim) {
3991
3991
  if (pref === undefined) pref = 'default';
3992
3992
  result = call$g(exoticToPrim, input, pref);
3993
- if (!isObject$9(result) || isSymbol$2(result)) return result;
3993
+ if (!isObject$b(result) || isSymbol$2(result)) return result;
3994
3994
  throw new $TypeError$b("Can't convert object to primitive value");
3995
3995
  }
3996
3996
  if (pref === undefined) pref = 'number';
@@ -4007,36 +4007,36 @@ var toPropertyKey$2 = function (argument) {
4007
4007
  return isSymbol$1(key) ? key : key + '';
4008
4008
  };
4009
4009
 
4010
- var global$g = global$m;
4011
- var isObject$8 = isObject$b;
4010
+ var global$h = global$n;
4011
+ var isObject$a = isObject$d;
4012
4012
 
4013
- var document$3 = global$g.document;
4013
+ var document$3 = global$h.document;
4014
4014
  // typeof document.createElement is 'object' in old IE
4015
- var EXISTS$1 = isObject$8(document$3) && isObject$8(document$3.createElement);
4015
+ var EXISTS$1 = isObject$a(document$3) && isObject$a(document$3.createElement);
4016
4016
 
4017
4017
  var documentCreateElement$2 = function (it) {
4018
4018
  return EXISTS$1 ? document$3.createElement(it) : {};
4019
4019
  };
4020
4020
 
4021
- var DESCRIPTORS$b = descriptors;
4022
- var fails$g = fails$l;
4021
+ var DESCRIPTORS$c = descriptors;
4022
+ var fails$h = fails$m;
4023
4023
  var createElement$1 = documentCreateElement$2;
4024
4024
 
4025
4025
  // Thanks to IE8 for its funny defineProperty
4026
- var ie8DomDefine = !DESCRIPTORS$b && !fails$g(function () {
4026
+ var ie8DomDefine = !DESCRIPTORS$c && !fails$h(function () {
4027
4027
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
4028
4028
  return Object.defineProperty(createElement$1('div'), 'a', {
4029
4029
  get: function () { return 7; }
4030
4030
  }).a !== 7;
4031
4031
  });
4032
4032
 
4033
- var DESCRIPTORS$a = descriptors;
4033
+ var DESCRIPTORS$b = descriptors;
4034
4034
  var call$f = functionCall;
4035
4035
  var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
4036
- var createPropertyDescriptor$2 = createPropertyDescriptor$3;
4036
+ var createPropertyDescriptor$3 = createPropertyDescriptor$4;
4037
4037
  var toIndexedObject$4 = toIndexedObject$5;
4038
4038
  var toPropertyKey$1 = toPropertyKey$2;
4039
- var hasOwn$8 = hasOwnProperty_1;
4039
+ var hasOwn$9 = hasOwnProperty_1;
4040
4040
  var IE8_DOM_DEFINE$1 = ie8DomDefine;
4041
4041
 
4042
4042
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
@@ -4044,23 +4044,23 @@ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
4044
4044
 
4045
4045
  // `Object.getOwnPropertyDescriptor` method
4046
4046
  // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
4047
- objectGetOwnPropertyDescriptor.f = DESCRIPTORS$a ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
4047
+ objectGetOwnPropertyDescriptor.f = DESCRIPTORS$b ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
4048
4048
  O = toIndexedObject$4(O);
4049
4049
  P = toPropertyKey$1(P);
4050
4050
  if (IE8_DOM_DEFINE$1) try {
4051
4051
  return $getOwnPropertyDescriptor$1(O, P);
4052
4052
  } catch (error) { /* empty */ }
4053
- if (hasOwn$8(O, P)) return createPropertyDescriptor$2(!call$f(propertyIsEnumerableModule$1.f, O, P), O[P]);
4053
+ if (hasOwn$9(O, P)) return createPropertyDescriptor$3(!call$f(propertyIsEnumerableModule$1.f, O, P), O[P]);
4054
4054
  };
4055
4055
 
4056
4056
  var objectDefineProperty = {};
4057
4057
 
4058
- var DESCRIPTORS$9 = descriptors;
4059
- var fails$f = fails$l;
4058
+ var DESCRIPTORS$a = descriptors;
4059
+ var fails$g = fails$m;
4060
4060
 
4061
4061
  // V8 ~ Chrome 36-
4062
4062
  // https://bugs.chromium.org/p/v8/issues/detail?id=3334
4063
- var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$f(function () {
4063
+ var v8PrototypeDefineBug = DESCRIPTORS$a && fails$g(function () {
4064
4064
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
4065
4065
  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
4066
4066
  value: 42,
@@ -4068,18 +4068,18 @@ var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$f(function () {
4068
4068
  }).prototype !== 42;
4069
4069
  });
4070
4070
 
4071
- var isObject$7 = isObject$b;
4071
+ var isObject$9 = isObject$d;
4072
4072
 
4073
4073
  var $String$4 = String;
4074
4074
  var $TypeError$a = TypeError;
4075
4075
 
4076
4076
  // `Assert: Type(argument) is Object`
4077
4077
  var anObject$d = function (argument) {
4078
- if (isObject$7(argument)) return argument;
4078
+ if (isObject$9(argument)) return argument;
4079
4079
  throw new $TypeError$a($String$4(argument) + ' is not an object');
4080
4080
  };
4081
4081
 
4082
- var DESCRIPTORS$8 = descriptors;
4082
+ var DESCRIPTORS$9 = descriptors;
4083
4083
  var IE8_DOM_DEFINE = ie8DomDefine;
4084
4084
  var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
4085
4085
  var anObject$c = anObject$d;
@@ -4096,7 +4096,7 @@ var WRITABLE = 'writable';
4096
4096
 
4097
4097
  // `Object.defineProperty` method
4098
4098
  // https://tc39.es/ecma262/#sec-object.defineproperty
4099
- objectDefineProperty.f = DESCRIPTORS$8 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
4099
+ objectDefineProperty.f = DESCRIPTORS$9 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
4100
4100
  anObject$c(O);
4101
4101
  P = toPropertyKey(P);
4102
4102
  anObject$c(Attributes);
@@ -4123,12 +4123,12 @@ objectDefineProperty.f = DESCRIPTORS$8 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
4123
4123
  return O;
4124
4124
  };
4125
4125
 
4126
- var DESCRIPTORS$7 = descriptors;
4126
+ var DESCRIPTORS$8 = descriptors;
4127
4127
  var definePropertyModule$3 = objectDefineProperty;
4128
- var createPropertyDescriptor$1 = createPropertyDescriptor$3;
4128
+ var createPropertyDescriptor$2 = createPropertyDescriptor$4;
4129
4129
 
4130
- var createNonEnumerableProperty$5 = DESCRIPTORS$7 ? function (object, key, value) {
4131
- return definePropertyModule$3.f(object, key, createPropertyDescriptor$1(1, value));
4130
+ var createNonEnumerableProperty$8 = DESCRIPTORS$8 ? function (object, key, value) {
4131
+ return definePropertyModule$3.f(object, key, createPropertyDescriptor$2(1, value));
4132
4132
  } : function (object, key, value) {
4133
4133
  object[key] = value;
4134
4134
  return object;
@@ -4136,17 +4136,17 @@ var createNonEnumerableProperty$5 = DESCRIPTORS$7 ? function (object, key, value
4136
4136
 
4137
4137
  var makeBuiltIn$3 = {exports: {}};
4138
4138
 
4139
- var DESCRIPTORS$6 = descriptors;
4140
- var hasOwn$7 = hasOwnProperty_1;
4139
+ var DESCRIPTORS$7 = descriptors;
4140
+ var hasOwn$8 = hasOwnProperty_1;
4141
4141
 
4142
4142
  var FunctionPrototype$1 = Function.prototype;
4143
4143
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
4144
- var getDescriptor = DESCRIPTORS$6 && Object.getOwnPropertyDescriptor;
4144
+ var getDescriptor = DESCRIPTORS$7 && Object.getOwnPropertyDescriptor;
4145
4145
 
4146
- var EXISTS = hasOwn$7(FunctionPrototype$1, 'name');
4146
+ var EXISTS = hasOwn$8(FunctionPrototype$1, 'name');
4147
4147
  // additional protection from minified / mangled / dropped function names
4148
4148
  var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
4149
- var CONFIGURABLE = EXISTS && (!DESCRIPTORS$6 || (DESCRIPTORS$6 && getDescriptor(FunctionPrototype$1, 'name').configurable));
4149
+ var CONFIGURABLE = EXISTS && (!DESCRIPTORS$7 || (DESCRIPTORS$7 && getDescriptor(FunctionPrototype$1, 'name').configurable));
4150
4150
 
4151
4151
  var functionName = {
4152
4152
  EXISTS: EXISTS,
@@ -4154,14 +4154,14 @@ var functionName = {
4154
4154
  CONFIGURABLE: CONFIGURABLE
4155
4155
  };
4156
4156
 
4157
- var uncurryThis$i = functionUncurryThis;
4158
- var isCallable$h = isCallable$n;
4157
+ var uncurryThis$j = functionUncurryThis;
4158
+ var isCallable$i = isCallable$o;
4159
4159
  var store$1 = sharedStoreExports;
4160
4160
 
4161
- var functionToString = uncurryThis$i(Function.toString);
4161
+ var functionToString = uncurryThis$j(Function.toString);
4162
4162
 
4163
4163
  // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
4164
- if (!isCallable$h(store$1.inspectSource)) {
4164
+ if (!isCallable$i(store$1.inspectSource)) {
4165
4165
  store$1.inspectSource = function (it) {
4166
4166
  return functionToString(it);
4167
4167
  };
@@ -4169,12 +4169,12 @@ if (!isCallable$h(store$1.inspectSource)) {
4169
4169
 
4170
4170
  var inspectSource$3 = store$1.inspectSource;
4171
4171
 
4172
- var global$f = global$m;
4173
- var isCallable$g = isCallable$n;
4172
+ var global$g = global$n;
4173
+ var isCallable$h = isCallable$o;
4174
4174
 
4175
- var WeakMap$1 = global$f.WeakMap;
4175
+ var WeakMap$1 = global$g.WeakMap;
4176
4176
 
4177
- var weakMapBasicDetection = isCallable$g(WeakMap$1) && /native code/.test(String(WeakMap$1));
4177
+ var weakMapBasicDetection = isCallable$h(WeakMap$1) && /native code/.test(String(WeakMap$1));
4178
4178
 
4179
4179
  var shared$2 = shared$4;
4180
4180
  var uid = uid$2;
@@ -4188,17 +4188,17 @@ var sharedKey$3 = function (key) {
4188
4188
  var hiddenKeys$4 = {};
4189
4189
 
4190
4190
  var NATIVE_WEAK_MAP = weakMapBasicDetection;
4191
- var global$e = global$m;
4192
- var isObject$6 = isObject$b;
4193
- var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
4194
- var hasOwn$6 = hasOwnProperty_1;
4191
+ var global$f = global$n;
4192
+ var isObject$8 = isObject$d;
4193
+ var createNonEnumerableProperty$7 = createNonEnumerableProperty$8;
4194
+ var hasOwn$7 = hasOwnProperty_1;
4195
4195
  var shared$1 = sharedStoreExports;
4196
4196
  var sharedKey$2 = sharedKey$3;
4197
4197
  var hiddenKeys$3 = hiddenKeys$4;
4198
4198
 
4199
4199
  var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
4200
- var TypeError$2 = global$e.TypeError;
4201
- var WeakMap = global$e.WeakMap;
4200
+ var TypeError$2 = global$f.TypeError;
4201
+ var WeakMap = global$f.WeakMap;
4202
4202
  var set$1, get, has;
4203
4203
 
4204
4204
  var enforce = function (it) {
@@ -4208,7 +4208,7 @@ var enforce = function (it) {
4208
4208
  var getterFor = function (TYPE) {
4209
4209
  return function (it) {
4210
4210
  var state;
4211
- if (!isObject$6(it) || (state = get(it)).type !== TYPE) {
4211
+ if (!isObject$8(it) || (state = get(it)).type !== TYPE) {
4212
4212
  throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required');
4213
4213
  } return state;
4214
4214
  };
@@ -4237,16 +4237,16 @@ if (NATIVE_WEAK_MAP || shared$1.state) {
4237
4237
  var STATE = sharedKey$2('state');
4238
4238
  hiddenKeys$3[STATE] = true;
4239
4239
  set$1 = function (it, metadata) {
4240
- if (hasOwn$6(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED);
4240
+ if (hasOwn$7(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED);
4241
4241
  metadata.facade = it;
4242
- createNonEnumerableProperty$4(it, STATE, metadata);
4242
+ createNonEnumerableProperty$7(it, STATE, metadata);
4243
4243
  return metadata;
4244
4244
  };
4245
4245
  get = function (it) {
4246
- return hasOwn$6(it, STATE) ? it[STATE] : {};
4246
+ return hasOwn$7(it, STATE) ? it[STATE] : {};
4247
4247
  };
4248
4248
  has = function (it) {
4249
- return hasOwn$6(it, STATE);
4249
+ return hasOwn$7(it, STATE);
4250
4250
  };
4251
4251
  }
4252
4252
 
@@ -4258,11 +4258,11 @@ var internalState = {
4258
4258
  getterFor: getterFor
4259
4259
  };
4260
4260
 
4261
- var uncurryThis$h = functionUncurryThis;
4262
- var fails$e = fails$l;
4263
- var isCallable$f = isCallable$n;
4264
- var hasOwn$5 = hasOwnProperty_1;
4265
- var DESCRIPTORS$5 = descriptors;
4261
+ var uncurryThis$i = functionUncurryThis;
4262
+ var fails$f = fails$m;
4263
+ var isCallable$g = isCallable$o;
4264
+ var hasOwn$6 = hasOwnProperty_1;
4265
+ var DESCRIPTORS$6 = descriptors;
4266
4266
  var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
4267
4267
  var inspectSource$2 = inspectSource$3;
4268
4268
  var InternalStateModule$2 = internalState;
@@ -4271,38 +4271,38 @@ var enforceInternalState = InternalStateModule$2.enforce;
4271
4271
  var getInternalState$2 = InternalStateModule$2.get;
4272
4272
  var $String$3 = String;
4273
4273
  // eslint-disable-next-line es/no-object-defineproperty -- safe
4274
- var defineProperty$5 = Object.defineProperty;
4275
- var stringSlice$4 = uncurryThis$h(''.slice);
4276
- var replace$4 = uncurryThis$h(''.replace);
4277
- var join = uncurryThis$h([].join);
4274
+ var defineProperty$6 = Object.defineProperty;
4275
+ var stringSlice$4 = uncurryThis$i(''.slice);
4276
+ var replace$5 = uncurryThis$i(''.replace);
4277
+ var join = uncurryThis$i([].join);
4278
4278
 
4279
- var CONFIGURABLE_LENGTH = DESCRIPTORS$5 && !fails$e(function () {
4280
- return defineProperty$5(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
4279
+ var CONFIGURABLE_LENGTH = DESCRIPTORS$6 && !fails$f(function () {
4280
+ return defineProperty$6(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
4281
4281
  });
4282
4282
 
4283
4283
  var TEMPLATE = String(String).split('String');
4284
4284
 
4285
4285
  var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
4286
4286
  if (stringSlice$4($String$3(name), 0, 7) === 'Symbol(') {
4287
- name = '[' + replace$4($String$3(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
4287
+ name = '[' + replace$5($String$3(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
4288
4288
  }
4289
4289
  if (options && options.getter) name = 'get ' + name;
4290
4290
  if (options && options.setter) name = 'set ' + name;
4291
- if (!hasOwn$5(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
4292
- if (DESCRIPTORS$5) defineProperty$5(value, 'name', { value: name, configurable: true });
4291
+ if (!hasOwn$6(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
4292
+ if (DESCRIPTORS$6) defineProperty$6(value, 'name', { value: name, configurable: true });
4293
4293
  else value.name = name;
4294
4294
  }
4295
- if (CONFIGURABLE_LENGTH && options && hasOwn$5(options, 'arity') && value.length !== options.arity) {
4296
- defineProperty$5(value, 'length', { value: options.arity });
4295
+ if (CONFIGURABLE_LENGTH && options && hasOwn$6(options, 'arity') && value.length !== options.arity) {
4296
+ defineProperty$6(value, 'length', { value: options.arity });
4297
4297
  }
4298
4298
  try {
4299
- if (options && hasOwn$5(options, 'constructor') && options.constructor) {
4300
- if (DESCRIPTORS$5) defineProperty$5(value, 'prototype', { writable: false });
4299
+ if (options && hasOwn$6(options, 'constructor') && options.constructor) {
4300
+ if (DESCRIPTORS$6) defineProperty$6(value, 'prototype', { writable: false });
4301
4301
  // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
4302
4302
  } else if (value.prototype) value.prototype = undefined;
4303
4303
  } catch (error) { /* empty */ }
4304
4304
  var state = enforceInternalState(value);
4305
- if (!hasOwn$5(state, 'source')) {
4305
+ if (!hasOwn$6(state, 'source')) {
4306
4306
  state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
4307
4307
  } return value;
4308
4308
  };
@@ -4310,12 +4310,12 @@ var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
4310
4310
  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
4311
4311
  // eslint-disable-next-line no-extend-native -- required
4312
4312
  Function.prototype.toString = makeBuiltIn$2(function toString() {
4313
- return isCallable$f(this) && getInternalState$2(this).source || inspectSource$2(this);
4313
+ return isCallable$g(this) && getInternalState$2(this).source || inspectSource$2(this);
4314
4314
  }, 'toString');
4315
4315
 
4316
4316
  var makeBuiltInExports = makeBuiltIn$3.exports;
4317
4317
 
4318
- var isCallable$e = isCallable$n;
4318
+ var isCallable$f = isCallable$o;
4319
4319
  var definePropertyModule$2 = objectDefineProperty;
4320
4320
  var makeBuiltIn$1 = makeBuiltInExports;
4321
4321
  var defineGlobalProperty$1 = defineGlobalProperty$3;
@@ -4324,7 +4324,7 @@ var defineBuiltIn$6 = function (O, key, value, options) {
4324
4324
  if (!options) options = {};
4325
4325
  var simple = options.enumerable;
4326
4326
  var name = options.name !== undefined ? options.name : key;
4327
- if (isCallable$e(value)) makeBuiltIn$1(value, name, options);
4327
+ if (isCallable$f(value)) makeBuiltIn$1(value, name, options);
4328
4328
  if (options.global) {
4329
4329
  if (simple) O[key] = value;
4330
4330
  else defineGlobalProperty$1(key, value);
@@ -4432,22 +4432,22 @@ var arrayIncludes = {
4432
4432
  indexOf: createMethod$2(false)
4433
4433
  };
4434
4434
 
4435
- var uncurryThis$g = functionUncurryThis;
4436
- var hasOwn$4 = hasOwnProperty_1;
4435
+ var uncurryThis$h = functionUncurryThis;
4436
+ var hasOwn$5 = hasOwnProperty_1;
4437
4437
  var toIndexedObject$2 = toIndexedObject$5;
4438
4438
  var indexOf$1 = arrayIncludes.indexOf;
4439
4439
  var hiddenKeys$2 = hiddenKeys$4;
4440
4440
 
4441
- var push$2 = uncurryThis$g([].push);
4441
+ var push$2 = uncurryThis$h([].push);
4442
4442
 
4443
4443
  var objectKeysInternal = function (object, names) {
4444
4444
  var O = toIndexedObject$2(object);
4445
4445
  var i = 0;
4446
4446
  var result = [];
4447
4447
  var key;
4448
- for (key in O) !hasOwn$4(hiddenKeys$2, key) && hasOwn$4(O, key) && push$2(result, key);
4448
+ for (key in O) !hasOwn$5(hiddenKeys$2, key) && hasOwn$5(O, key) && push$2(result, key);
4449
4449
  // Don't enum bug & hidden keys
4450
- while (names.length > i) if (hasOwn$4(O, key = names[i++])) {
4450
+ while (names.length > i) if (hasOwn$5(O, key = names[i++])) {
4451
4451
  ~indexOf$1(result, key) || push$2(result, key);
4452
4452
  }
4453
4453
  return result;
@@ -4481,40 +4481,40 @@ var objectGetOwnPropertySymbols = {};
4481
4481
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
4482
4482
  objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
4483
4483
 
4484
- var getBuiltIn$6 = getBuiltIn$8;
4485
- var uncurryThis$f = functionUncurryThis;
4484
+ var getBuiltIn$7 = getBuiltIn$9;
4485
+ var uncurryThis$g = functionUncurryThis;
4486
4486
  var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
4487
4487
  var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
4488
4488
  var anObject$b = anObject$d;
4489
4489
 
4490
- var concat$2 = uncurryThis$f([].concat);
4490
+ var concat$2 = uncurryThis$g([].concat);
4491
4491
 
4492
4492
  // all object keys, includes non-enumerable and symbols
4493
- var ownKeys$1 = getBuiltIn$6('Reflect', 'ownKeys') || function ownKeys(it) {
4493
+ var ownKeys$1 = getBuiltIn$7('Reflect', 'ownKeys') || function ownKeys(it) {
4494
4494
  var keys = getOwnPropertyNamesModule.f(anObject$b(it));
4495
4495
  var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
4496
4496
  return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys;
4497
4497
  };
4498
4498
 
4499
- var hasOwn$3 = hasOwnProperty_1;
4499
+ var hasOwn$4 = hasOwnProperty_1;
4500
4500
  var ownKeys = ownKeys$1;
4501
4501
  var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
4502
4502
  var definePropertyModule$1 = objectDefineProperty;
4503
4503
 
4504
- var copyConstructorProperties$1 = function (target, source, exceptions) {
4504
+ var copyConstructorProperties$2 = function (target, source, exceptions) {
4505
4505
  var keys = ownKeys(source);
4506
4506
  var defineProperty = definePropertyModule$1.f;
4507
4507
  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
4508
4508
  for (var i = 0; i < keys.length; i++) {
4509
4509
  var key = keys[i];
4510
- if (!hasOwn$3(target, key) && !(exceptions && hasOwn$3(exceptions, key))) {
4510
+ if (!hasOwn$4(target, key) && !(exceptions && hasOwn$4(exceptions, key))) {
4511
4511
  defineProperty(target, key, getOwnPropertyDescriptor(source, key));
4512
4512
  }
4513
4513
  }
4514
4514
  };
4515
4515
 
4516
- var fails$d = fails$l;
4517
- var isCallable$d = isCallable$n;
4516
+ var fails$e = fails$m;
4517
+ var isCallable$e = isCallable$o;
4518
4518
 
4519
4519
  var replacement = /#|\.prototype\./;
4520
4520
 
@@ -4522,7 +4522,7 @@ var isForced$2 = function (feature, detection) {
4522
4522
  var value = data[normalize$1(feature)];
4523
4523
  return value === POLYFILL ? true
4524
4524
  : value === NATIVE ? false
4525
- : isCallable$d(detection) ? fails$d(detection)
4525
+ : isCallable$e(detection) ? fails$e(detection)
4526
4526
  : !!detection;
4527
4527
  };
4528
4528
 
@@ -4536,12 +4536,12 @@ var POLYFILL = isForced$2.POLYFILL = 'P';
4536
4536
 
4537
4537
  var isForced_1 = isForced$2;
4538
4538
 
4539
- var global$d = global$m;
4539
+ var global$e = global$n;
4540
4540
  var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
4541
- var createNonEnumerableProperty$3 = createNonEnumerableProperty$5;
4541
+ var createNonEnumerableProperty$6 = createNonEnumerableProperty$8;
4542
4542
  var defineBuiltIn$5 = defineBuiltIn$6;
4543
4543
  var defineGlobalProperty = defineGlobalProperty$3;
4544
- var copyConstructorProperties = copyConstructorProperties$1;
4544
+ var copyConstructorProperties$1 = copyConstructorProperties$2;
4545
4545
  var isForced$1 = isForced_1;
4546
4546
 
4547
4547
  /*
@@ -4565,11 +4565,11 @@ var _export = function (options, source) {
4565
4565
  var STATIC = options.stat;
4566
4566
  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
4567
4567
  if (GLOBAL) {
4568
- target = global$d;
4568
+ target = global$e;
4569
4569
  } else if (STATIC) {
4570
- target = global$d[TARGET] || defineGlobalProperty(TARGET, {});
4570
+ target = global$e[TARGET] || defineGlobalProperty(TARGET, {});
4571
4571
  } else {
4572
- target = global$d[TARGET] && global$d[TARGET].prototype;
4572
+ target = global$e[TARGET] && global$e[TARGET].prototype;
4573
4573
  }
4574
4574
  if (target) for (key in source) {
4575
4575
  sourceProperty = source[key];
@@ -4581,11 +4581,11 @@ var _export = function (options, source) {
4581
4581
  // contained in target
4582
4582
  if (!FORCED && targetProperty !== undefined) {
4583
4583
  if (typeof sourceProperty == typeof targetProperty) continue;
4584
- copyConstructorProperties(sourceProperty, targetProperty);
4584
+ copyConstructorProperties$1(sourceProperty, targetProperty);
4585
4585
  }
4586
4586
  // add a flag to not completely full polyfills
4587
4587
  if (options.sham || (targetProperty && targetProperty.sham)) {
4588
- createNonEnumerableProperty$3(sourceProperty, 'sham', true);
4588
+ createNonEnumerableProperty$6(sourceProperty, 'sham', true);
4589
4589
  }
4590
4590
  defineBuiltIn$5(target, key, sourceProperty, options);
4591
4591
  }
@@ -4601,10 +4601,10 @@ var objectKeys$2 = Object.keys || function keys(O) {
4601
4601
  return internalObjectKeys(O, enumBugKeys$1);
4602
4602
  };
4603
4603
 
4604
- var DESCRIPTORS$4 = descriptors;
4605
- var uncurryThis$e = functionUncurryThis;
4604
+ var DESCRIPTORS$5 = descriptors;
4605
+ var uncurryThis$f = functionUncurryThis;
4606
4606
  var call$e = functionCall;
4607
- var fails$c = fails$l;
4607
+ var fails$d = fails$m;
4608
4608
  var objectKeys$1 = objectKeys$2;
4609
4609
  var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
4610
4610
  var propertyIsEnumerableModule = objectPropertyIsEnumerable;
@@ -4614,17 +4614,17 @@ var IndexedObject = indexedObject;
4614
4614
  // eslint-disable-next-line es/no-object-assign -- safe
4615
4615
  var $assign = Object.assign;
4616
4616
  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
4617
- var defineProperty$4 = Object.defineProperty;
4618
- var concat$1 = uncurryThis$e([].concat);
4617
+ var defineProperty$5 = Object.defineProperty;
4618
+ var concat$1 = uncurryThis$f([].concat);
4619
4619
 
4620
4620
  // `Object.assign` method
4621
4621
  // https://tc39.es/ecma262/#sec-object.assign
4622
- var objectAssign = !$assign || fails$c(function () {
4622
+ var objectAssign = !$assign || fails$d(function () {
4623
4623
  // should have correct order of operations (Edge bug)
4624
- if (DESCRIPTORS$4 && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', {
4624
+ if (DESCRIPTORS$5 && $assign({ b: 1 }, $assign(defineProperty$5({}, 'a', {
4625
4625
  enumerable: true,
4626
4626
  get: function () {
4627
- defineProperty$4(this, 'b', {
4627
+ defineProperty$5(this, 'b', {
4628
4628
  value: 3,
4629
4629
  enumerable: false
4630
4630
  });
@@ -4653,40 +4653,40 @@ var objectAssign = !$assign || fails$c(function () {
4653
4653
  var key;
4654
4654
  while (length > j) {
4655
4655
  key = keys[j++];
4656
- if (!DESCRIPTORS$4 || call$e(propertyIsEnumerable, S, key)) T[key] = S[key];
4656
+ if (!DESCRIPTORS$5 || call$e(propertyIsEnumerable, S, key)) T[key] = S[key];
4657
4657
  }
4658
4658
  } return T;
4659
4659
  } : $assign;
4660
4660
 
4661
- var $$c = _export;
4661
+ var $$d = _export;
4662
4662
  var assign = objectAssign;
4663
4663
 
4664
4664
  // `Object.assign` method
4665
4665
  // https://tc39.es/ecma262/#sec-object.assign
4666
4666
  // eslint-disable-next-line es/no-object-assign -- required for testing
4667
- $$c({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
4667
+ $$d({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
4668
4668
  assign: assign
4669
4669
  });
4670
4670
 
4671
- var global$c = global$m;
4671
+ var global$d = global$n;
4672
4672
  var classof$8 = classofRaw$2;
4673
4673
 
4674
- var engineIsNode = classof$8(global$c.process) === 'process';
4674
+ var engineIsNode = classof$8(global$d.process) === 'process';
4675
4675
 
4676
- var uncurryThis$d = functionUncurryThis;
4676
+ var uncurryThis$e = functionUncurryThis;
4677
4677
  var aCallable$6 = aCallable$8;
4678
4678
 
4679
4679
  var functionUncurryThisAccessor = function (object, key, method) {
4680
4680
  try {
4681
4681
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
4682
- return uncurryThis$d(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method]));
4682
+ return uncurryThis$e(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method]));
4683
4683
  } catch (error) { /* empty */ }
4684
4684
  };
4685
4685
 
4686
- var isObject$5 = isObject$b;
4686
+ var isObject$7 = isObject$d;
4687
4687
 
4688
4688
  var isPossiblePrototype$1 = function (argument) {
4689
- return isObject$5(argument) || argument === null;
4689
+ return isObject$7(argument) || argument === null;
4690
4690
  };
4691
4691
 
4692
4692
  var isPossiblePrototype = isPossiblePrototype$1;
@@ -4701,7 +4701,7 @@ var aPossiblePrototype$1 = function (argument) {
4701
4701
 
4702
4702
  /* eslint-disable no-proto -- safe */
4703
4703
  var uncurryThisAccessor = functionUncurryThisAccessor;
4704
- var isObject$4 = isObject$b;
4704
+ var isObject$6 = isObject$d;
4705
4705
  var requireObjectCoercible$5 = requireObjectCoercible$8;
4706
4706
  var aPossiblePrototype = aPossiblePrototype$1;
4707
4707
 
@@ -4721,46 +4721,46 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
4721
4721
  return function setPrototypeOf(O, proto) {
4722
4722
  requireObjectCoercible$5(O);
4723
4723
  aPossiblePrototype(proto);
4724
- if (!isObject$4(O)) return O;
4724
+ if (!isObject$6(O)) return O;
4725
4725
  if (CORRECT_SETTER) setter(O, proto);
4726
4726
  else O.__proto__ = proto;
4727
4727
  return O;
4728
4728
  };
4729
4729
  }() : undefined);
4730
4730
 
4731
- var defineProperty$3 = objectDefineProperty.f;
4732
- var hasOwn$2 = hasOwnProperty_1;
4731
+ var defineProperty$4 = objectDefineProperty.f;
4732
+ var hasOwn$3 = hasOwnProperty_1;
4733
4733
  var wellKnownSymbol$g = wellKnownSymbol$i;
4734
4734
 
4735
4735
  var TO_STRING_TAG$2 = wellKnownSymbol$g('toStringTag');
4736
4736
 
4737
4737
  var setToStringTag$4 = function (target, TAG, STATIC) {
4738
4738
  if (target && !STATIC) target = target.prototype;
4739
- if (target && !hasOwn$2(target, TO_STRING_TAG$2)) {
4740
- defineProperty$3(target, TO_STRING_TAG$2, { configurable: true, value: TAG });
4739
+ if (target && !hasOwn$3(target, TO_STRING_TAG$2)) {
4740
+ defineProperty$4(target, TO_STRING_TAG$2, { configurable: true, value: TAG });
4741
4741
  }
4742
4742
  };
4743
4743
 
4744
4744
  var makeBuiltIn = makeBuiltInExports;
4745
- var defineProperty$2 = objectDefineProperty;
4745
+ var defineProperty$3 = objectDefineProperty;
4746
4746
 
4747
4747
  var defineBuiltInAccessor$1 = function (target, name, descriptor) {
4748
4748
  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
4749
4749
  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
4750
- return defineProperty$2.f(target, name, descriptor);
4750
+ return defineProperty$3.f(target, name, descriptor);
4751
4751
  };
4752
4752
 
4753
- var getBuiltIn$5 = getBuiltIn$8;
4753
+ var getBuiltIn$6 = getBuiltIn$9;
4754
4754
  var defineBuiltInAccessor = defineBuiltInAccessor$1;
4755
4755
  var wellKnownSymbol$f = wellKnownSymbol$i;
4756
- var DESCRIPTORS$3 = descriptors;
4756
+ var DESCRIPTORS$4 = descriptors;
4757
4757
 
4758
4758
  var SPECIES$3 = wellKnownSymbol$f('species');
4759
4759
 
4760
4760
  var setSpecies$1 = function (CONSTRUCTOR_NAME) {
4761
- var Constructor = getBuiltIn$5(CONSTRUCTOR_NAME);
4761
+ var Constructor = getBuiltIn$6(CONSTRUCTOR_NAME);
4762
4762
 
4763
- if (DESCRIPTORS$3 && Constructor && !Constructor[SPECIES$3]) {
4763
+ if (DESCRIPTORS$4 && Constructor && !Constructor[SPECIES$3]) {
4764
4764
  defineBuiltInAccessor(Constructor, SPECIES$3, {
4765
4765
  configurable: true,
4766
4766
  get: function () { return this; }
@@ -4768,12 +4768,12 @@ var setSpecies$1 = function (CONSTRUCTOR_NAME) {
4768
4768
  }
4769
4769
  };
4770
4770
 
4771
- var isPrototypeOf$1 = objectIsPrototypeOf;
4771
+ var isPrototypeOf$2 = objectIsPrototypeOf;
4772
4772
 
4773
4773
  var $TypeError$7 = TypeError;
4774
4774
 
4775
4775
  var anInstance$1 = function (it, Prototype) {
4776
- if (isPrototypeOf$1(Prototype, it)) return it;
4776
+ if (isPrototypeOf$2(Prototype, it)) return it;
4777
4777
  throw new $TypeError$7('Incorrect invocation');
4778
4778
  };
4779
4779
 
@@ -4787,7 +4787,7 @@ test[TO_STRING_TAG$1] = 'z';
4787
4787
  var toStringTagSupport = String(test) === '[object z]';
4788
4788
 
4789
4789
  var TO_STRING_TAG_SUPPORT = toStringTagSupport;
4790
- var isCallable$c = isCallable$n;
4790
+ var isCallable$d = isCallable$o;
4791
4791
  var classofRaw$1 = classofRaw$2;
4792
4792
  var wellKnownSymbol$d = wellKnownSymbol$i;
4793
4793
 
@@ -4813,24 +4813,24 @@ var classof$7 = TO_STRING_TAG_SUPPORT ? classofRaw$1 : function (it) {
4813
4813
  // builtinTag case
4814
4814
  : CORRECT_ARGUMENTS ? classofRaw$1(O)
4815
4815
  // ES3 arguments fallback
4816
- : (result = classofRaw$1(O)) === 'Object' && isCallable$c(O.callee) ? 'Arguments' : result;
4816
+ : (result = classofRaw$1(O)) === 'Object' && isCallable$d(O.callee) ? 'Arguments' : result;
4817
4817
  };
4818
4818
 
4819
- var uncurryThis$c = functionUncurryThis;
4820
- var fails$b = fails$l;
4821
- var isCallable$b = isCallable$n;
4819
+ var uncurryThis$d = functionUncurryThis;
4820
+ var fails$c = fails$m;
4821
+ var isCallable$c = isCallable$o;
4822
4822
  var classof$6 = classof$7;
4823
- var getBuiltIn$4 = getBuiltIn$8;
4823
+ var getBuiltIn$5 = getBuiltIn$9;
4824
4824
  var inspectSource$1 = inspectSource$3;
4825
4825
 
4826
4826
  var noop = function () { /* empty */ };
4827
- var construct = getBuiltIn$4('Reflect', 'construct');
4827
+ var construct = getBuiltIn$5('Reflect', 'construct');
4828
4828
  var constructorRegExp = /^\s*(?:class|function)\b/;
4829
- var exec$3 = uncurryThis$c(constructorRegExp.exec);
4829
+ var exec$3 = uncurryThis$d(constructorRegExp.exec);
4830
4830
  var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
4831
4831
 
4832
4832
  var isConstructorModern = function isConstructor(argument) {
4833
- if (!isCallable$b(argument)) return false;
4833
+ if (!isCallable$c(argument)) return false;
4834
4834
  try {
4835
4835
  construct(noop, [], argument);
4836
4836
  return true;
@@ -4840,7 +4840,7 @@ var isConstructorModern = function isConstructor(argument) {
4840
4840
  };
4841
4841
 
4842
4842
  var isConstructorLegacy = function isConstructor(argument) {
4843
- if (!isCallable$b(argument)) return false;
4843
+ if (!isCallable$c(argument)) return false;
4844
4844
  switch (classof$6(argument)) {
4845
4845
  case 'AsyncFunction':
4846
4846
  case 'GeneratorFunction':
@@ -4860,7 +4860,7 @@ isConstructorLegacy.sham = true;
4860
4860
 
4861
4861
  // `IsConstructor` abstract operation
4862
4862
  // https://tc39.es/ecma262/#sec-isconstructor
4863
- var isConstructor$1 = !construct || fails$b(function () {
4863
+ var isConstructor$1 = !construct || fails$c(function () {
4864
4864
  var called;
4865
4865
  return isConstructorModern(isConstructorModern.call)
4866
4866
  || !isConstructorModern(Object)
@@ -4897,29 +4897,29 @@ var speciesConstructor$1 = function (O, defaultConstructor) {
4897
4897
  var NATIVE_BIND$1 = functionBindNative;
4898
4898
 
4899
4899
  var FunctionPrototype = Function.prototype;
4900
- var apply$3 = FunctionPrototype.apply;
4900
+ var apply$4 = FunctionPrototype.apply;
4901
4901
  var call$d = FunctionPrototype.call;
4902
4902
 
4903
4903
  // eslint-disable-next-line es/no-reflect -- safe
4904
- var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$d.bind(apply$3) : function () {
4905
- return call$d.apply(apply$3, arguments);
4904
+ var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$d.bind(apply$4) : function () {
4905
+ return call$d.apply(apply$4, arguments);
4906
4906
  });
4907
4907
 
4908
4908
  var classofRaw = classofRaw$2;
4909
- var uncurryThis$b = functionUncurryThis;
4909
+ var uncurryThis$c = functionUncurryThis;
4910
4910
 
4911
4911
  var functionUncurryThisClause = function (fn) {
4912
4912
  // Nashorn bug:
4913
4913
  // https://github.com/zloirock/core-js/issues/1128
4914
4914
  // https://github.com/zloirock/core-js/issues/1130
4915
- if (classofRaw(fn) === 'Function') return uncurryThis$b(fn);
4915
+ if (classofRaw(fn) === 'Function') return uncurryThis$c(fn);
4916
4916
  };
4917
4917
 
4918
- var uncurryThis$a = functionUncurryThisClause;
4918
+ var uncurryThis$b = functionUncurryThisClause;
4919
4919
  var aCallable$5 = aCallable$8;
4920
4920
  var NATIVE_BIND = functionBindNative;
4921
4921
 
4922
- var bind$4 = uncurryThis$a(uncurryThis$a.bind);
4922
+ var bind$4 = uncurryThis$b(uncurryThis$b.bind);
4923
4923
 
4924
4924
  // optional / simple context binding
4925
4925
  var functionBindContext = function (fn, that) {
@@ -4929,13 +4929,13 @@ var functionBindContext = function (fn, that) {
4929
4929
  };
4930
4930
  };
4931
4931
 
4932
- var getBuiltIn$3 = getBuiltIn$8;
4932
+ var getBuiltIn$4 = getBuiltIn$9;
4933
4933
 
4934
- var html$2 = getBuiltIn$3('document', 'documentElement');
4934
+ var html$2 = getBuiltIn$4('document', 'documentElement');
4935
4935
 
4936
- var uncurryThis$9 = functionUncurryThis;
4936
+ var uncurryThis$a = functionUncurryThis;
4937
4937
 
4938
- var arraySlice$2 = uncurryThis$9([].slice);
4938
+ var arraySlice$2 = uncurryThis$a([].slice);
4939
4939
 
4940
4940
  var $TypeError$5 = TypeError;
4941
4941
 
@@ -4949,12 +4949,12 @@ var userAgent$2 = engineUserAgent;
4949
4949
  // eslint-disable-next-line redos/no-vulnerable -- safe
4950
4950
  var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
4951
4951
 
4952
- var global$b = global$m;
4953
- var apply$2 = functionApply;
4952
+ var global$c = global$n;
4953
+ var apply$3 = functionApply;
4954
4954
  var bind$3 = functionBindContext;
4955
- var isCallable$a = isCallable$n;
4956
- var hasOwn$1 = hasOwnProperty_1;
4957
- var fails$a = fails$l;
4955
+ var isCallable$b = isCallable$o;
4956
+ var hasOwn$2 = hasOwnProperty_1;
4957
+ var fails$b = fails$m;
4958
4958
  var html$1 = html$2;
4959
4959
  var arraySlice$1 = arraySlice$2;
4960
4960
  var createElement = documentCreateElement$2;
@@ -4962,25 +4962,25 @@ var validateArgumentsLength = validateArgumentsLength$1;
4962
4962
  var IS_IOS$1 = engineIsIos;
4963
4963
  var IS_NODE$3 = engineIsNode;
4964
4964
 
4965
- var set = global$b.setImmediate;
4966
- var clear = global$b.clearImmediate;
4967
- var process$3 = global$b.process;
4968
- var Dispatch = global$b.Dispatch;
4969
- var Function$1 = global$b.Function;
4970
- var MessageChannel = global$b.MessageChannel;
4971
- var String$1 = global$b.String;
4965
+ var set = global$c.setImmediate;
4966
+ var clear = global$c.clearImmediate;
4967
+ var process$3 = global$c.process;
4968
+ var Dispatch = global$c.Dispatch;
4969
+ var Function$1 = global$c.Function;
4970
+ var MessageChannel = global$c.MessageChannel;
4971
+ var String$1 = global$c.String;
4972
4972
  var counter = 0;
4973
4973
  var queue$2 = {};
4974
4974
  var ONREADYSTATECHANGE = 'onreadystatechange';
4975
4975
  var $location, defer, channel, port;
4976
4976
 
4977
- fails$a(function () {
4977
+ fails$b(function () {
4978
4978
  // Deno throws a ReferenceError on `location` access without `--location` flag
4979
- $location = global$b.location;
4979
+ $location = global$c.location;
4980
4980
  });
4981
4981
 
4982
4982
  var run = function (id) {
4983
- if (hasOwn$1(queue$2, id)) {
4983
+ if (hasOwn$2(queue$2, id)) {
4984
4984
  var fn = queue$2[id];
4985
4985
  delete queue$2[id];
4986
4986
  fn();
@@ -4999,17 +4999,17 @@ var eventListener = function (event) {
4999
4999
 
5000
5000
  var globalPostMessageDefer = function (id) {
5001
5001
  // old engines have not location.origin
5002
- global$b.postMessage(String$1(id), $location.protocol + '//' + $location.host);
5002
+ global$c.postMessage(String$1(id), $location.protocol + '//' + $location.host);
5003
5003
  };
5004
5004
 
5005
5005
  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
5006
5006
  if (!set || !clear) {
5007
5007
  set = function setImmediate(handler) {
5008
5008
  validateArgumentsLength(arguments.length, 1);
5009
- var fn = isCallable$a(handler) ? handler : Function$1(handler);
5009
+ var fn = isCallable$b(handler) ? handler : Function$1(handler);
5010
5010
  var args = arraySlice$1(arguments, 1);
5011
5011
  queue$2[++counter] = function () {
5012
- apply$2(fn, undefined, args);
5012
+ apply$3(fn, undefined, args);
5013
5013
  };
5014
5014
  defer(counter);
5015
5015
  return counter;
@@ -5037,14 +5037,14 @@ if (!set || !clear) {
5037
5037
  // Browsers with postMessage, skip WebWorkers
5038
5038
  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
5039
5039
  } else if (
5040
- global$b.addEventListener &&
5041
- isCallable$a(global$b.postMessage) &&
5042
- !global$b.importScripts &&
5040
+ global$c.addEventListener &&
5041
+ isCallable$b(global$c.postMessage) &&
5042
+ !global$c.importScripts &&
5043
5043
  $location && $location.protocol !== 'file:' &&
5044
- !fails$a(globalPostMessageDefer)
5044
+ !fails$b(globalPostMessageDefer)
5045
5045
  ) {
5046
5046
  defer = globalPostMessageDefer;
5047
- global$b.addEventListener('message', eventListener, false);
5047
+ global$c.addEventListener('message', eventListener, false);
5048
5048
  // IE8-
5049
5049
  } else if (ONREADYSTATECHANGE in createElement('script')) {
5050
5050
  defer = function (id) {
@@ -5066,16 +5066,16 @@ var task$1 = {
5066
5066
  clear: clear
5067
5067
  };
5068
5068
 
5069
- var global$a = global$m;
5070
- var DESCRIPTORS$2 = descriptors;
5069
+ var global$b = global$n;
5070
+ var DESCRIPTORS$3 = descriptors;
5071
5071
 
5072
5072
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
5073
5073
  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
5074
5074
 
5075
5075
  // Avoid NodeJS experimental warning
5076
5076
  var safeGetBuiltIn$1 = function (name) {
5077
- if (!DESCRIPTORS$2) return global$a[name];
5078
- var descriptor = getOwnPropertyDescriptor(global$a, name);
5077
+ if (!DESCRIPTORS$3) return global$b[name];
5078
+ var descriptor = getOwnPropertyDescriptor(global$b, name);
5079
5079
  return descriptor && descriptor.value;
5080
5080
  };
5081
5081
 
@@ -5112,7 +5112,7 @@ var userAgent = engineUserAgent;
5112
5112
 
5113
5113
  var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
5114
5114
 
5115
- var global$9 = global$m;
5115
+ var global$a = global$n;
5116
5116
  var safeGetBuiltIn = safeGetBuiltIn$1;
5117
5117
  var bind$2 = functionBindContext;
5118
5118
  var macrotask = task$1.set;
@@ -5122,10 +5122,10 @@ var IS_IOS_PEBBLE = engineIsIosPebble;
5122
5122
  var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
5123
5123
  var IS_NODE$2 = engineIsNode;
5124
5124
 
5125
- var MutationObserver = global$9.MutationObserver || global$9.WebKitMutationObserver;
5126
- var document$2 = global$9.document;
5127
- var process$2 = global$9.process;
5128
- var Promise$1 = global$9.Promise;
5125
+ var MutationObserver = global$a.MutationObserver || global$a.WebKitMutationObserver;
5126
+ var document$2 = global$a.document;
5127
+ var process$2 = global$a.process;
5128
+ var Promise$1 = global$a.Promise;
5129
5129
  var microtask$1 = safeGetBuiltIn('queueMicrotask');
5130
5130
  var notify$1, toggle, node, promise, then;
5131
5131
 
@@ -5177,7 +5177,7 @@ if (!microtask$1) {
5177
5177
  // - setTimeout
5178
5178
  } else {
5179
5179
  // `webpack` dev server bug on IE global methods - use bind(fn, global)
5180
- macrotask = bind$2(macrotask, global$9);
5180
+ macrotask = bind$2(macrotask, global$a);
5181
5181
  notify$1 = function () {
5182
5182
  macrotask(flush);
5183
5183
  };
@@ -5206,9 +5206,9 @@ var perform$3 = function (exec) {
5206
5206
  }
5207
5207
  };
5208
5208
 
5209
- var global$8 = global$m;
5209
+ var global$9 = global$n;
5210
5210
 
5211
- var promiseNativeConstructor = global$8.Promise;
5211
+ var promiseNativeConstructor = global$9.Promise;
5212
5212
 
5213
5213
  /* global Deno -- Deno case */
5214
5214
  var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
@@ -5220,9 +5220,9 @@ var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1
5220
5220
  && typeof window == 'object'
5221
5221
  && typeof document == 'object';
5222
5222
 
5223
- var global$7 = global$m;
5223
+ var global$8 = global$n;
5224
5224
  var NativePromiseConstructor$3 = promiseNativeConstructor;
5225
- var isCallable$9 = isCallable$n;
5225
+ var isCallable$a = isCallable$o;
5226
5226
  var isForced = isForced_1;
5227
5227
  var inspectSource = inspectSource$3;
5228
5228
  var wellKnownSymbol$b = wellKnownSymbol$i;
@@ -5233,7 +5233,7 @@ var V8_VERSION = engineV8Version;
5233
5233
  NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype;
5234
5234
  var SPECIES$1 = wellKnownSymbol$b('species');
5235
5235
  var SUBCLASSING = false;
5236
- var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$9(global$7.PromiseRejectionEvent);
5236
+ var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$a(global$8.PromiseRejectionEvent);
5237
5237
 
5238
5238
  var FORCED_PROMISE_CONSTRUCTOR$5 = isForced('Promise', function () {
5239
5239
  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3);
@@ -5288,17 +5288,17 @@ newPromiseCapability$2.f = function (C) {
5288
5288
  return new PromiseCapability(C);
5289
5289
  };
5290
5290
 
5291
- var $$b = _export;
5291
+ var $$c = _export;
5292
5292
  var IS_NODE = engineIsNode;
5293
- var global$6 = global$m;
5293
+ var global$7 = global$n;
5294
5294
  var call$c = functionCall;
5295
5295
  var defineBuiltIn$4 = defineBuiltIn$6;
5296
- var setPrototypeOf$1 = objectSetPrototypeOf;
5296
+ var setPrototypeOf$3 = objectSetPrototypeOf;
5297
5297
  var setToStringTag$3 = setToStringTag$4;
5298
5298
  var setSpecies = setSpecies$1;
5299
5299
  var aCallable$3 = aCallable$8;
5300
- var isCallable$8 = isCallable$n;
5301
- var isObject$3 = isObject$b;
5300
+ var isCallable$9 = isCallable$o;
5301
+ var isObject$5 = isObject$d;
5302
5302
  var anInstance = anInstance$1;
5303
5303
  var speciesConstructor = speciesConstructor$1;
5304
5304
  var task = task$1.set;
@@ -5320,13 +5320,13 @@ var setInternalState$1 = InternalStateModule$1.set;
5320
5320
  var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype;
5321
5321
  var PromiseConstructor = NativePromiseConstructor$2;
5322
5322
  var PromisePrototype = NativePromisePrototype$1;
5323
- var TypeError$1 = global$6.TypeError;
5324
- var document$1 = global$6.document;
5325
- var process$1 = global$6.process;
5323
+ var TypeError$1 = global$7.TypeError;
5324
+ var document$1 = global$7.document;
5325
+ var process$1 = global$7.process;
5326
5326
  var newPromiseCapability$1 = newPromiseCapabilityModule$3.f;
5327
5327
  var newGenericPromiseCapability = newPromiseCapability$1;
5328
5328
 
5329
- var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$6.dispatchEvent);
5329
+ var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$7.dispatchEvent);
5330
5330
  var UNHANDLED_REJECTION = 'unhandledrejection';
5331
5331
  var REJECTION_HANDLED = 'rejectionhandled';
5332
5332
  var PENDING = 0;
@@ -5340,7 +5340,7 @@ var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
5340
5340
  // helpers
5341
5341
  var isThenable = function (it) {
5342
5342
  var then;
5343
- return isObject$3(it) && isCallable$8(then = it.then) ? then : false;
5343
+ return isObject$5(it) && isCallable$9(then = it.then) ? then : false;
5344
5344
  };
5345
5345
 
5346
5346
  var callReaction = function (reaction, state) {
@@ -5399,14 +5399,14 @@ var dispatchEvent = function (name, promise, reason) {
5399
5399
  event.promise = promise;
5400
5400
  event.reason = reason;
5401
5401
  event.initEvent(name, false, true);
5402
- global$6.dispatchEvent(event);
5402
+ global$7.dispatchEvent(event);
5403
5403
  } else event = { promise: promise, reason: reason };
5404
- if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$6['on' + name])) handler(event);
5404
+ if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$7['on' + name])) handler(event);
5405
5405
  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
5406
5406
  };
5407
5407
 
5408
5408
  var onUnhandled = function (state) {
5409
- call$c(task, global$6, function () {
5409
+ call$c(task, global$7, function () {
5410
5410
  var promise = state.facade;
5411
5411
  var value = state.value;
5412
5412
  var IS_UNHANDLED = isUnhandled(state);
@@ -5429,7 +5429,7 @@ var isUnhandled = function (state) {
5429
5429
  };
5430
5430
 
5431
5431
  var onHandleUnhandled = function (state) {
5432
- call$c(task, global$6, function () {
5432
+ call$c(task, global$7, function () {
5433
5433
  var promise = state.facade;
5434
5434
  if (IS_NODE) {
5435
5435
  process$1.emit('rejectionHandled', promise);
@@ -5518,8 +5518,8 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
5518
5518
  var state = getInternalPromiseState(this);
5519
5519
  var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor));
5520
5520
  state.parent = true;
5521
- reaction.ok = isCallable$8(onFulfilled) ? onFulfilled : true;
5522
- reaction.fail = isCallable$8(onRejected) && onRejected;
5521
+ reaction.ok = isCallable$9(onFulfilled) ? onFulfilled : true;
5522
+ reaction.fail = isCallable$9(onRejected) && onRejected;
5523
5523
  reaction.domain = IS_NODE ? process$1.domain : undefined;
5524
5524
  if (state.state === PENDING) state.reactions.add(reaction);
5525
5525
  else microtask(function () {
@@ -5542,7 +5542,7 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
5542
5542
  : newGenericPromiseCapability(C);
5543
5543
  };
5544
5544
 
5545
- if (isCallable$8(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) {
5545
+ if (isCallable$9(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) {
5546
5546
  nativeThen = NativePromisePrototype$1.then;
5547
5547
 
5548
5548
  if (!NATIVE_PROMISE_SUBCLASSING) {
@@ -5562,13 +5562,13 @@ if (FORCED_PROMISE_CONSTRUCTOR$4) {
5562
5562
  } catch (error) { /* empty */ }
5563
5563
 
5564
5564
  // make `instanceof Promise` work for native promise-based APIs
5565
- if (setPrototypeOf$1) {
5566
- setPrototypeOf$1(NativePromisePrototype$1, PromisePrototype);
5565
+ if (setPrototypeOf$3) {
5566
+ setPrototypeOf$3(NativePromisePrototype$1, PromisePrototype);
5567
5567
  }
5568
5568
  }
5569
5569
  }
5570
5570
 
5571
- $$b({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
5571
+ $$c({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
5572
5572
  Promise: PromiseConstructor
5573
5573
  });
5574
5574
 
@@ -5646,7 +5646,7 @@ var anObject$7 = anObject$d;
5646
5646
  var tryToString = tryToString$4;
5647
5647
  var isArrayIteratorMethod = isArrayIteratorMethod$1;
5648
5648
  var lengthOfArrayLike = lengthOfArrayLike$2;
5649
- var isPrototypeOf = objectIsPrototypeOf;
5649
+ var isPrototypeOf$1 = objectIsPrototypeOf;
5650
5650
  var getIterator = getIterator$1;
5651
5651
  var getIteratorMethod = getIteratorMethod$2;
5652
5652
  var iteratorClose = iteratorClose$1;
@@ -5692,7 +5692,7 @@ var iterate$2 = function (iterable, unboundFunction, options) {
5692
5692
  if (isArrayIteratorMethod(iterFn)) {
5693
5693
  for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
5694
5694
  result = callFn(iterable[index]);
5695
- if (result && isPrototypeOf(ResultPrototype, result)) return result;
5695
+ if (result && isPrototypeOf$1(ResultPrototype, result)) return result;
5696
5696
  } return new Result(false);
5697
5697
  }
5698
5698
  iterator = getIterator(iterable, iterFn);
@@ -5705,7 +5705,7 @@ var iterate$2 = function (iterable, unboundFunction, options) {
5705
5705
  } catch (error) {
5706
5706
  iteratorClose(iterator, 'throw', error);
5707
5707
  }
5708
- if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
5708
+ if (typeof result == 'object' && result && isPrototypeOf$1(ResultPrototype, result)) return result;
5709
5709
  } return new Result(false);
5710
5710
  };
5711
5711
 
@@ -5758,7 +5758,7 @@ var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCor
5758
5758
  NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ });
5759
5759
  });
5760
5760
 
5761
- var $$a = _export;
5761
+ var $$b = _export;
5762
5762
  var call$8 = functionCall;
5763
5763
  var aCallable$1 = aCallable$8;
5764
5764
  var newPromiseCapabilityModule$2 = newPromiseCapability$2;
@@ -5768,7 +5768,7 @@ var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration;
5768
5768
 
5769
5769
  // `Promise.all` method
5770
5770
  // https://tc39.es/ecma262/#sec-promise.all
5771
- $$a({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
5771
+ $$b({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
5772
5772
  all: function all(iterable) {
5773
5773
  var C = this;
5774
5774
  var capability = newPromiseCapabilityModule$2.f(C);
@@ -5797,32 +5797,32 @@ $$a({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
5797
5797
  }
5798
5798
  });
5799
5799
 
5800
- var $$9 = _export;
5800
+ var $$a = _export;
5801
5801
  var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
5802
5802
  var NativePromiseConstructor = promiseNativeConstructor;
5803
- var getBuiltIn$2 = getBuiltIn$8;
5804
- var isCallable$7 = isCallable$n;
5803
+ var getBuiltIn$3 = getBuiltIn$9;
5804
+ var isCallable$8 = isCallable$o;
5805
5805
  var defineBuiltIn$3 = defineBuiltIn$6;
5806
5806
 
5807
5807
  var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
5808
5808
 
5809
5809
  // `Promise.prototype.catch` method
5810
5810
  // https://tc39.es/ecma262/#sec-promise.prototype.catch
5811
- $$9({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
5811
+ $$a({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
5812
5812
  'catch': function (onRejected) {
5813
5813
  return this.then(undefined, onRejected);
5814
5814
  }
5815
5815
  });
5816
5816
 
5817
5817
  // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
5818
- if (isCallable$7(NativePromiseConstructor)) {
5819
- var method = getBuiltIn$2('Promise').prototype['catch'];
5818
+ if (isCallable$8(NativePromiseConstructor)) {
5819
+ var method = getBuiltIn$3('Promise').prototype['catch'];
5820
5820
  if (NativePromisePrototype['catch'] !== method) {
5821
5821
  defineBuiltIn$3(NativePromisePrototype, 'catch', method, { unsafe: true });
5822
5822
  }
5823
5823
  }
5824
5824
 
5825
- var $$8 = _export;
5825
+ var $$9 = _export;
5826
5826
  var call$7 = functionCall;
5827
5827
  var aCallable = aCallable$8;
5828
5828
  var newPromiseCapabilityModule$1 = newPromiseCapability$2;
@@ -5832,7 +5832,7 @@ var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration;
5832
5832
 
5833
5833
  // `Promise.race` method
5834
5834
  // https://tc39.es/ecma262/#sec-promise.race
5835
- $$8({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
5835
+ $$9({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
5836
5836
  race: function race(iterable) {
5837
5837
  var C = this;
5838
5838
  var capability = newPromiseCapabilityModule$1.f(C);
@@ -5848,13 +5848,13 @@ $$8({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION
5848
5848
  }
5849
5849
  });
5850
5850
 
5851
- var $$7 = _export;
5851
+ var $$8 = _export;
5852
5852
  var newPromiseCapabilityModule = newPromiseCapability$2;
5853
5853
  var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
5854
5854
 
5855
5855
  // `Promise.reject` method
5856
5856
  // https://tc39.es/ecma262/#sec-promise.reject
5857
- $$7({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
5857
+ $$8({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
5858
5858
  reject: function reject(r) {
5859
5859
  var capability = newPromiseCapabilityModule.f(this);
5860
5860
  var capabilityReject = capability.reject;
@@ -5864,28 +5864,28 @@ $$7({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
5864
5864
  });
5865
5865
 
5866
5866
  var anObject$6 = anObject$d;
5867
- var isObject$2 = isObject$b;
5867
+ var isObject$4 = isObject$d;
5868
5868
  var newPromiseCapability = newPromiseCapability$2;
5869
5869
 
5870
5870
  var promiseResolve$1 = function (C, x) {
5871
5871
  anObject$6(C);
5872
- if (isObject$2(x) && x.constructor === C) return x;
5872
+ if (isObject$4(x) && x.constructor === C) return x;
5873
5873
  var promiseCapability = newPromiseCapability.f(C);
5874
5874
  var resolve = promiseCapability.resolve;
5875
5875
  resolve(x);
5876
5876
  return promiseCapability.promise;
5877
5877
  };
5878
5878
 
5879
- var $$6 = _export;
5880
- var getBuiltIn$1 = getBuiltIn$8;
5879
+ var $$7 = _export;
5880
+ var getBuiltIn$2 = getBuiltIn$9;
5881
5881
  var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR;
5882
5882
  var promiseResolve = promiseResolve$1;
5883
5883
 
5884
- getBuiltIn$1('Promise');
5884
+ getBuiltIn$2('Promise');
5885
5885
 
5886
5886
  // `Promise.resolve` method
5887
5887
  // https://tc39.es/ecma262/#sec-promise.resolve
5888
- $$6({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
5888
+ $$7({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
5889
5889
  resolve: function resolve(x) {
5890
5890
  return promiseResolve(this, x);
5891
5891
  }
@@ -5895,7 +5895,7 @@ var classof$4 = classof$7;
5895
5895
 
5896
5896
  var $String$1 = String;
5897
5897
 
5898
- var toString$8 = function (argument) {
5898
+ var toString$9 = function (argument) {
5899
5899
  if (classof$4(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
5900
5900
  return $String$1(argument);
5901
5901
  };
@@ -5918,13 +5918,13 @@ var regexpFlags$1 = function () {
5918
5918
  return result;
5919
5919
  };
5920
5920
 
5921
- var fails$9 = fails$l;
5922
- var global$5 = global$m;
5921
+ var fails$a = fails$m;
5922
+ var global$6 = global$n;
5923
5923
 
5924
5924
  // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
5925
- var $RegExp$2 = global$5.RegExp;
5925
+ var $RegExp$2 = global$6.RegExp;
5926
5926
 
5927
- var UNSUPPORTED_Y$1 = fails$9(function () {
5927
+ var UNSUPPORTED_Y$1 = fails$a(function () {
5928
5928
  var re = $RegExp$2('a', 'y');
5929
5929
  re.lastIndex = 2;
5930
5930
  return re.exec('abcd') !== null;
@@ -5932,11 +5932,11 @@ var UNSUPPORTED_Y$1 = fails$9(function () {
5932
5932
 
5933
5933
  // UC Browser bug
5934
5934
  // https://github.com/zloirock/core-js/issues/1008
5935
- var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$9(function () {
5935
+ var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$a(function () {
5936
5936
  return !$RegExp$2('a', 'y').sticky;
5937
5937
  });
5938
5938
 
5939
- var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$9(function () {
5939
+ var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$a(function () {
5940
5940
  // https://bugzilla.mozilla.org/show_bug.cgi?id=773687
5941
5941
  var re = $RegExp$2('^r', 'gy');
5942
5942
  re.lastIndex = 2;
@@ -5951,7 +5951,7 @@ var regexpStickyHelpers = {
5951
5951
 
5952
5952
  var objectDefineProperties = {};
5953
5953
 
5954
- var DESCRIPTORS$1 = descriptors;
5954
+ var DESCRIPTORS$2 = descriptors;
5955
5955
  var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
5956
5956
  var definePropertyModule = objectDefineProperty;
5957
5957
  var anObject$4 = anObject$d;
@@ -5961,7 +5961,7 @@ var objectKeys = objectKeys$2;
5961
5961
  // `Object.defineProperties` method
5962
5962
  // https://tc39.es/ecma262/#sec-object.defineproperties
5963
5963
  // eslint-disable-next-line es/no-object-defineproperties -- safe
5964
- objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
5964
+ objectDefineProperties.f = DESCRIPTORS$2 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
5965
5965
  anObject$4(O);
5966
5966
  var props = toIndexedObject$1(Properties);
5967
5967
  var keys = objectKeys(Properties);
@@ -6056,24 +6056,24 @@ var objectCreate = Object.create || function create(O, Properties) {
6056
6056
  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
6057
6057
  };
6058
6058
 
6059
- var fails$8 = fails$l;
6060
- var global$4 = global$m;
6059
+ var fails$9 = fails$m;
6060
+ var global$5 = global$n;
6061
6061
 
6062
6062
  // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
6063
- var $RegExp$1 = global$4.RegExp;
6063
+ var $RegExp$1 = global$5.RegExp;
6064
6064
 
6065
- var regexpUnsupportedDotAll = fails$8(function () {
6065
+ var regexpUnsupportedDotAll = fails$9(function () {
6066
6066
  var re = $RegExp$1('.', 's');
6067
6067
  return !(re.dotAll && re.test('\n') && re.flags === 's');
6068
6068
  });
6069
6069
 
6070
- var fails$7 = fails$l;
6071
- var global$3 = global$m;
6070
+ var fails$8 = fails$m;
6071
+ var global$4 = global$n;
6072
6072
 
6073
6073
  // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
6074
- var $RegExp = global$3.RegExp;
6074
+ var $RegExp = global$4.RegExp;
6075
6075
 
6076
- var regexpUnsupportedNcg = fails$7(function () {
6076
+ var regexpUnsupportedNcg = fails$8(function () {
6077
6077
  var re = $RegExp('(?<a>b)', 'g');
6078
6078
  return re.exec('b').groups.a !== 'b' ||
6079
6079
  'b'.replace(re, '$<a>c') !== 'bc';
@@ -6082,8 +6082,8 @@ var regexpUnsupportedNcg = fails$7(function () {
6082
6082
  /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
6083
6083
  /* eslint-disable regexp/no-useless-quantifier -- testing */
6084
6084
  var call$6 = functionCall;
6085
- var uncurryThis$8 = functionUncurryThis;
6086
- var toString$7 = toString$8;
6085
+ var uncurryThis$9 = functionUncurryThis;
6086
+ var toString$8 = toString$9;
6087
6087
  var regexpFlags = regexpFlags$1;
6088
6088
  var stickyHelpers = regexpStickyHelpers;
6089
6089
  var shared = shared$4;
@@ -6095,10 +6095,10 @@ var UNSUPPORTED_NCG = regexpUnsupportedNcg;
6095
6095
  var nativeReplace = shared('native-string-replace', String.prototype.replace);
6096
6096
  var nativeExec = RegExp.prototype.exec;
6097
6097
  var patchedExec = nativeExec;
6098
- var charAt$4 = uncurryThis$8(''.charAt);
6099
- var indexOf = uncurryThis$8(''.indexOf);
6100
- var replace$3 = uncurryThis$8(''.replace);
6101
- var stringSlice$3 = uncurryThis$8(''.slice);
6098
+ var charAt$4 = uncurryThis$9(''.charAt);
6099
+ var indexOf = uncurryThis$9(''.indexOf);
6100
+ var replace$4 = uncurryThis$9(''.replace);
6101
+ var stringSlice$3 = uncurryThis$9(''.slice);
6102
6102
 
6103
6103
  var UPDATES_LAST_INDEX_WRONG = (function () {
6104
6104
  var re1 = /a/;
@@ -6119,7 +6119,7 @@ if (PATCH) {
6119
6119
  patchedExec = function exec(string) {
6120
6120
  var re = this;
6121
6121
  var state = getInternalState$1(re);
6122
- var str = toString$7(string);
6122
+ var str = toString$8(string);
6123
6123
  var raw = state.raw;
6124
6124
  var result, reCopy, lastIndex, match, i, object, group;
6125
6125
 
@@ -6138,7 +6138,7 @@ if (PATCH) {
6138
6138
  var strCopy = str;
6139
6139
 
6140
6140
  if (sticky) {
6141
- flags = replace$3(flags, 'y', '');
6141
+ flags = replace$4(flags, 'y', '');
6142
6142
  if (indexOf(flags, 'g') === -1) {
6143
6143
  flags += 'g';
6144
6144
  }
@@ -6196,12 +6196,12 @@ if (PATCH) {
6196
6196
 
6197
6197
  var regexpExec$2 = patchedExec;
6198
6198
 
6199
- var $$5 = _export;
6199
+ var $$6 = _export;
6200
6200
  var exec$2 = regexpExec$2;
6201
6201
 
6202
6202
  // `RegExp.prototype.exec` method
6203
6203
  // https://tc39.es/ecma262/#sec-regexp.prototype.exec
6204
- $$5({ target: 'RegExp', proto: true, forced: /./.exec !== exec$2 }, {
6204
+ $$6({ target: 'RegExp', proto: true, forced: /./.exec !== exec$2 }, {
6205
6205
  exec: exec$2
6206
6206
  });
6207
6207
 
@@ -6210,9 +6210,9 @@ $$5({ target: 'RegExp', proto: true, forced: /./.exec !== exec$2 }, {
6210
6210
  var call$5 = functionCall;
6211
6211
  var defineBuiltIn$2 = defineBuiltIn$6;
6212
6212
  var regexpExec$1 = regexpExec$2;
6213
- var fails$6 = fails$l;
6213
+ var fails$7 = fails$m;
6214
6214
  var wellKnownSymbol$7 = wellKnownSymbol$i;
6215
- var createNonEnumerableProperty$2 = createNonEnumerableProperty$5;
6215
+ var createNonEnumerableProperty$5 = createNonEnumerableProperty$8;
6216
6216
 
6217
6217
  var SPECIES = wellKnownSymbol$7('species');
6218
6218
  var RegExpPrototype = RegExp.prototype;
@@ -6220,14 +6220,14 @@ var RegExpPrototype = RegExp.prototype;
6220
6220
  var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
6221
6221
  var SYMBOL = wellKnownSymbol$7(KEY);
6222
6222
 
6223
- var DELEGATES_TO_SYMBOL = !fails$6(function () {
6223
+ var DELEGATES_TO_SYMBOL = !fails$7(function () {
6224
6224
  // String methods call symbol-named RegExp methods
6225
6225
  var O = {};
6226
6226
  O[SYMBOL] = function () { return 7; };
6227
6227
  return ''[KEY](O) !== 7;
6228
6228
  });
6229
6229
 
6230
- var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$6(function () {
6230
+ var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$7(function () {
6231
6231
  // Symbol-named RegExp methods call .exec
6232
6232
  var execCalled = false;
6233
6233
  var re = /a/;
@@ -6278,21 +6278,21 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
6278
6278
  defineBuiltIn$2(RegExpPrototype, SYMBOL, methods[1]);
6279
6279
  }
6280
6280
 
6281
- if (SHAM) createNonEnumerableProperty$2(RegExpPrototype[SYMBOL], 'sham', true);
6281
+ if (SHAM) createNonEnumerableProperty$5(RegExpPrototype[SYMBOL], 'sham', true);
6282
6282
  };
6283
6283
 
6284
- var uncurryThis$7 = functionUncurryThis;
6284
+ var uncurryThis$8 = functionUncurryThis;
6285
6285
  var toIntegerOrInfinity$1 = toIntegerOrInfinity$4;
6286
- var toString$6 = toString$8;
6286
+ var toString$7 = toString$9;
6287
6287
  var requireObjectCoercible$4 = requireObjectCoercible$8;
6288
6288
 
6289
- var charAt$3 = uncurryThis$7(''.charAt);
6290
- var charCodeAt$1 = uncurryThis$7(''.charCodeAt);
6291
- var stringSlice$2 = uncurryThis$7(''.slice);
6289
+ var charAt$3 = uncurryThis$8(''.charAt);
6290
+ var charCodeAt$1 = uncurryThis$8(''.charCodeAt);
6291
+ var stringSlice$2 = uncurryThis$8(''.slice);
6292
6292
 
6293
6293
  var createMethod$1 = function (CONVERT_TO_STRING) {
6294
6294
  return function ($this, pos) {
6295
- var S = toString$6(requireObjectCoercible$4($this));
6295
+ var S = toString$7(requireObjectCoercible$4($this));
6296
6296
  var position = toIntegerOrInfinity$1(pos);
6297
6297
  var size = S.length;
6298
6298
  var first, second;
@@ -6326,13 +6326,13 @@ var advanceStringIndex$1 = function (S, index, unicode) {
6326
6326
  return index + (unicode ? charAt$2(S, index).length : 1);
6327
6327
  };
6328
6328
 
6329
- var uncurryThis$6 = functionUncurryThis;
6329
+ var uncurryThis$7 = functionUncurryThis;
6330
6330
  var toObject$1 = toObject$4;
6331
6331
 
6332
6332
  var floor = Math.floor;
6333
- var charAt$1 = uncurryThis$6(''.charAt);
6334
- var replace$2 = uncurryThis$6(''.replace);
6335
- var stringSlice$1 = uncurryThis$6(''.slice);
6333
+ var charAt$1 = uncurryThis$7(''.charAt);
6334
+ var replace$3 = uncurryThis$7(''.replace);
6335
+ var stringSlice$1 = uncurryThis$7(''.slice);
6336
6336
  // eslint-disable-next-line redos/no-vulnerable -- safe
6337
6337
  var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
6338
6338
  var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
@@ -6347,7 +6347,7 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
6347
6347
  namedCaptures = toObject$1(namedCaptures);
6348
6348
  symbols = SUBSTITUTION_SYMBOLS;
6349
6349
  }
6350
- return replace$2(replacement, symbols, function (match, ch) {
6350
+ return replace$3(replacement, symbols, function (match, ch) {
6351
6351
  var capture;
6352
6352
  switch (charAt$1(ch, 0)) {
6353
6353
  case '$': return '$';
@@ -6374,7 +6374,7 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
6374
6374
 
6375
6375
  var call$4 = functionCall;
6376
6376
  var anObject$2 = anObject$d;
6377
- var isCallable$6 = isCallable$n;
6377
+ var isCallable$7 = isCallable$o;
6378
6378
  var classof$3 = classofRaw$2;
6379
6379
  var regexpExec = regexpExec$2;
6380
6380
 
@@ -6384,7 +6384,7 @@ var $TypeError$1 = TypeError;
6384
6384
  // https://tc39.es/ecma262/#sec-regexpexec
6385
6385
  var regexpExecAbstract = function (R, S) {
6386
6386
  var exec = R.exec;
6387
- if (isCallable$6(exec)) {
6387
+ if (isCallable$7(exec)) {
6388
6388
  var result = call$4(exec, R, S);
6389
6389
  if (result !== null) anObject$2(result);
6390
6390
  return result;
@@ -6393,17 +6393,17 @@ var regexpExecAbstract = function (R, S) {
6393
6393
  throw new $TypeError$1('RegExp#exec called on incompatible receiver');
6394
6394
  };
6395
6395
 
6396
- var apply$1 = functionApply;
6396
+ var apply$2 = functionApply;
6397
6397
  var call$3 = functionCall;
6398
- var uncurryThis$5 = functionUncurryThis;
6398
+ var uncurryThis$6 = functionUncurryThis;
6399
6399
  var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic;
6400
- var fails$5 = fails$l;
6400
+ var fails$6 = fails$m;
6401
6401
  var anObject$1 = anObject$d;
6402
- var isCallable$5 = isCallable$n;
6402
+ var isCallable$6 = isCallable$o;
6403
6403
  var isNullOrUndefined$1 = isNullOrUndefined$6;
6404
6404
  var toIntegerOrInfinity = toIntegerOrInfinity$4;
6405
6405
  var toLength = toLength$2;
6406
- var toString$5 = toString$8;
6406
+ var toString$6 = toString$9;
6407
6407
  var requireObjectCoercible$3 = requireObjectCoercible$8;
6408
6408
  var advanceStringIndex = advanceStringIndex$1;
6409
6409
  var getMethod$1 = getMethod$5;
@@ -6414,10 +6414,10 @@ var wellKnownSymbol$6 = wellKnownSymbol$i;
6414
6414
  var REPLACE = wellKnownSymbol$6('replace');
6415
6415
  var max = Math.max;
6416
6416
  var min = Math.min;
6417
- var concat = uncurryThis$5([].concat);
6418
- var push$1 = uncurryThis$5([].push);
6419
- var stringIndexOf$1 = uncurryThis$5(''.indexOf);
6420
- var stringSlice = uncurryThis$5(''.slice);
6417
+ var concat = uncurryThis$6([].concat);
6418
+ var push$1 = uncurryThis$6([].push);
6419
+ var stringIndexOf$1 = uncurryThis$6(''.indexOf);
6420
+ var stringSlice = uncurryThis$6(''.slice);
6421
6421
 
6422
6422
  var maybeToString = function (it) {
6423
6423
  return it === undefined ? it : String(it);
@@ -6438,7 +6438,7 @@ var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
6438
6438
  return false;
6439
6439
  })();
6440
6440
 
6441
- var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$5(function () {
6441
+ var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$6(function () {
6442
6442
  var re = /./;
6443
6443
  re.exec = function () {
6444
6444
  var result = [];
@@ -6461,13 +6461,13 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
6461
6461
  var replacer = isNullOrUndefined$1(searchValue) ? undefined : getMethod$1(searchValue, REPLACE);
6462
6462
  return replacer
6463
6463
  ? call$3(replacer, searchValue, O, replaceValue)
6464
- : call$3(nativeReplace, toString$5(O), searchValue, replaceValue);
6464
+ : call$3(nativeReplace, toString$6(O), searchValue, replaceValue);
6465
6465
  },
6466
6466
  // `RegExp.prototype[@@replace]` method
6467
6467
  // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
6468
6468
  function (string, replaceValue) {
6469
6469
  var rx = anObject$1(this);
6470
- var S = toString$5(string);
6470
+ var S = toString$6(string);
6471
6471
 
6472
6472
  if (
6473
6473
  typeof replaceValue == 'string' &&
@@ -6478,8 +6478,8 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
6478
6478
  if (res.done) return res.value;
6479
6479
  }
6480
6480
 
6481
- var functionalReplace = isCallable$5(replaceValue);
6482
- if (!functionalReplace) replaceValue = toString$5(replaceValue);
6481
+ var functionalReplace = isCallable$6(replaceValue);
6482
+ if (!functionalReplace) replaceValue = toString$6(replaceValue);
6483
6483
 
6484
6484
  var global = rx.global;
6485
6485
  var fullUnicode;
@@ -6497,7 +6497,7 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
6497
6497
  push$1(results, result);
6498
6498
  if (!global) break;
6499
6499
 
6500
- var matchStr = toString$5(result[0]);
6500
+ var matchStr = toString$6(result[0]);
6501
6501
  if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
6502
6502
  }
6503
6503
 
@@ -6506,7 +6506,7 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
6506
6506
  for (var i = 0; i < results.length; i++) {
6507
6507
  result = results[i];
6508
6508
 
6509
- var matched = toString$5(result[0]);
6509
+ var matched = toString$6(result[0]);
6510
6510
  var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
6511
6511
  var captures = [];
6512
6512
  var replacement;
@@ -6520,7 +6520,7 @@ fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCall
6520
6520
  if (functionalReplace) {
6521
6521
  var replacerArgs = concat([matched], captures, position, S);
6522
6522
  if (namedCaptures !== undefined) push$1(replacerArgs, namedCaptures);
6523
- replacement = toString$5(apply$1(replaceValue, undefined, replacerArgs));
6523
+ replacement = toString$6(apply$2(replaceValue, undefined, replacerArgs));
6524
6524
  } else {
6525
6525
  replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
6526
6526
  }
@@ -6549,7 +6549,7 @@ var anObject = anObject$d;
6549
6549
  var isNullOrUndefined = isNullOrUndefined$6;
6550
6550
  var requireObjectCoercible$2 = requireObjectCoercible$8;
6551
6551
  var sameValue = sameValue$1;
6552
- var toString$4 = toString$8;
6552
+ var toString$5 = toString$9;
6553
6553
  var getMethod = getMethod$5;
6554
6554
  var regExpExec = regexpExecAbstract;
6555
6555
 
@@ -6561,13 +6561,13 @@ fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCal
6561
6561
  function search(regexp) {
6562
6562
  var O = requireObjectCoercible$2(this);
6563
6563
  var searcher = isNullOrUndefined(regexp) ? undefined : getMethod(regexp, SEARCH);
6564
- return searcher ? call$2(searcher, regexp, O) : new RegExp(regexp)[SEARCH](toString$4(O));
6564
+ return searcher ? call$2(searcher, regexp, O) : new RegExp(regexp)[SEARCH](toString$5(O));
6565
6565
  },
6566
6566
  // `RegExp.prototype[@@search]` method
6567
6567
  // https://tc39.es/ecma262/#sec-regexp.prototype-@@search
6568
6568
  function (string) {
6569
6569
  var rx = anObject(this);
6570
- var S = toString$4(string);
6570
+ var S = toString$5(string);
6571
6571
  var res = maybeCallNative(nativeSearch, rx, S);
6572
6572
 
6573
6573
  if (res.done) return res.value;
@@ -6582,75 +6582,74 @@ fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCal
6582
6582
  });
6583
6583
 
6584
6584
  function loadParams() {
6585
- const list = window && window.location.search.substring(1).split('&');
6586
- const m = {};
6587
- for (let i = 0; i < list.length; i++) {
6588
- const indexOf = list[i].indexOf('=');
6589
- if (indexOf >= 0) {
6590
- m[list[i].substring(0, indexOf)] = decodeURIComponent(list[i].substring(indexOf + 1));
6585
+ if (typeof window !== 'undefined') {
6586
+ const list = window.location.search.substring(1).split('&');
6587
+ const m = {};
6588
+ for (let i = 0; i < list.length; i++) {
6589
+ const indexOf = list[i].indexOf('=');
6590
+ if (indexOf >= 0) {
6591
+ m[list[i].substring(0, indexOf)] = decodeURIComponent(list[i].substring(indexOf + 1));
6592
+ }
6591
6593
  }
6594
+ return m;
6592
6595
  }
6593
- return m;
6596
+ return {};
6594
6597
  }
6595
6598
  function initBackendsLocations() {
6596
- if (typeof window !== "undefined") {
6597
- params = loadParams();
6598
- api = params['api'];
6599
- if (window && window.location) {
6600
- currentUrl = window.location.href;
6601
- }
6602
- switch (api) {
6603
- case 'prod':
6599
+ params = loadParams();
6600
+ api = params['api'];
6601
+ if (typeof window !== 'undefined' && window.location) {
6602
+ currentUrl = window.location.href;
6603
+ }
6604
+ switch (api) {
6605
+ case 'prod':
6606
+ dBackend = 'https://query.bcrumbs.net';
6607
+ exports.frontend = 'https://app.bcrumbs.net';
6608
+ exports.apiBackend = 'https://api.bcrumbs.net';
6609
+ exports.apiV2Backend = 'https://apiv2.bcrumbs.net';
6610
+ showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6611
+ break;
6612
+ case 'test':
6613
+ dBackend = 'https://query.bcrumbs.net';
6614
+ exports.frontend = 'https://dev.bcrumbs.net';
6615
+ exports.apiBackend = 'https://api.bcrumbs.net';
6616
+ exports.apiV2Backend = 'apiv2-dev.bcrumbs.net';
6617
+ showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6618
+ break;
6619
+ case 'local':
6620
+ dBackend = 'https://localhost:44322';
6621
+ exports.frontend = 'http://localhost:4200';
6622
+ exports.apiBackend = 'http://localhost:6085';
6623
+ exports.apiV2Backend = 'https://apiv2-dev.bcrumbs.net';
6624
+ showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6625
+ break;
6626
+ default:
6627
+ if (currentUrl && currentUrl.indexOf('localhost') > -1) {
6628
+ dBackend = 'https://query.bcrumbs.net';
6629
+ exports.frontend = 'http://localhost:4200';
6630
+ exports.apiBackend = 'https://api.bcrumbs.net';
6631
+ exports.apiV2Backend = 'https://apiv2-dev.bcrumbs.net';
6632
+ showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6633
+ } else if (currentUrl && currentUrl.indexOf('dconfig.com') > -1) {
6604
6634
  dBackend = 'https://query.bcrumbs.net';
6605
6635
  exports.frontend = 'https://app.bcrumbs.net';
6606
6636
  exports.apiBackend = 'https://api.bcrumbs.net';
6607
6637
  exports.apiV2Backend = 'https://apiv2.bcrumbs.net';
6608
6638
  showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6609
- break;
6610
- case 'test':
6639
+ } else if (currentUrl && currentUrl.indexOf('dev.bcrumbs.net') > -1) {
6611
6640
  dBackend = 'https://query.bcrumbs.net';
6612
6641
  exports.frontend = 'https://dev.bcrumbs.net';
6613
6642
  exports.apiBackend = 'https://api.bcrumbs.net';
6614
- exports.apiV2Backend = 'apiv2-dev.bcrumbs.net';
6643
+ exports.apiV2Backend = 'https://apiv2.bcrumbs.net';
6615
6644
  showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6616
- break;
6617
- case 'local':
6618
- dBackend = 'https://localhost:44322';
6619
- exports.frontend = 'http://localhost:4200';
6620
- exports.apiBackend = 'http://localhost:6085';
6621
- exports.apiV2Backend = 'https://apiv2-dev.bcrumbs.net';
6645
+ } else {
6646
+ dBackend = 'https://query.bcrumbs.net';
6647
+ exports.frontend = 'https://app.bcrumbs.net';
6648
+ exports.apiBackend = 'https://api.bcrumbs.net';
6649
+ exports.apiV2Backend = 'https://apiv2.bcrumbs.net';
6622
6650
  showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6623
- break;
6624
- default:
6625
- if (currentUrl) {
6626
- if (currentUrl.indexOf('localhost') > -1) {
6627
- dBackend = 'https://query.bcrumbs.net';
6628
- exports.frontend = 'http://localhost:4200';
6629
- exports.apiBackend = 'https://api.bcrumbs.net';
6630
- exports.apiV2Backend = 'https://apiv2-dev.bcrumbs.net';
6631
- showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6632
- } else if (currentUrl.indexOf('dconfig.com') > -1) {
6633
- dBackend = 'https://query.bcrumbs.net';
6634
- exports.frontend = 'https://app.bcrumbs.net';
6635
- exports.apiBackend = 'https://api.bcrumbs.net';
6636
- exports.apiV2Backend = 'https://apiv2.bcrumbs.net';
6637
- showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6638
- } else if (currentUrl.indexOf('dev.bcrumbs.net') > -1) {
6639
- dBackend = 'https://query.bcrumbs.net';
6640
- exports.frontend = 'https://dev.bcrumbs.net';
6641
- exports.apiBackend = 'https://api.bcrumbs.net';
6642
- exports.apiV2Backend = 'https://apiv2.bcrumbs.net';
6643
- showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6644
- } else {
6645
- dBackend = 'https://query.bcrumbs.net';
6646
- exports.frontend = 'https://app.bcrumbs.net';
6647
- exports.apiBackend = 'https://api.bcrumbs.net';
6648
- exports.apiV2Backend = 'https://apiv2.bcrumbs.net';
6649
- showcaseRenderer = 'https://test-showcase.bcrumbs.net';
6650
- }
6651
- }
6652
- break;
6653
- }
6651
+ }
6652
+ break;
6654
6653
  }
6655
6654
  }
6656
6655
  let params;
@@ -6687,16 +6686,22 @@ const {
6687
6686
  function getUserToken() {
6688
6687
  return __awaiter(this, void 0, void 0, function* () {
6689
6688
  return new Promise(resolve => {
6690
- const storedToken = window && window.localStorage.getItem('token');
6691
- resolve(storedToken);
6689
+ if (typeof window !== 'undefined') {
6690
+ const storedToken = window.localStorage.getItem('token');
6691
+ resolve(storedToken);
6692
+ }
6693
+ resolve(undefined);
6692
6694
  });
6693
6695
  });
6694
6696
  }
6695
6697
  function getUserContext() {
6696
6698
  return __awaiter(this, void 0, void 0, function* () {
6697
6699
  return new Promise(resolve => {
6698
- const storedContext = window && window.localStorage.getItem('ContextId');
6699
- resolve(storedContext);
6700
+ if (typeof window !== 'undefined') {
6701
+ const storedContext = window.localStorage.getItem('ContextId');
6702
+ resolve(storedContext);
6703
+ }
6704
+ resolve(undefined);
6700
6705
  });
6701
6706
  });
6702
6707
  }
@@ -6730,11 +6735,17 @@ const errorLink$1 = error.onError(({
6730
6735
  }) => {
6731
6736
  if (networkError && networkError.statusCode === 401) {
6732
6737
  // redirect to login page
6733
- return window && window.location.replace('/account/login');
6738
+ if (typeof window !== 'undefined') {
6739
+ return window.location.replace('/account/login');
6740
+ }
6734
6741
  } else if (networkError && networkError.statusCode > 500 && networkError.statusCode !== 503) {
6735
- return window && window.location.replace('/account/error?message=' + networkError.message);
6742
+ if (typeof window !== 'undefined') {
6743
+ return window.location.replace('/account/error?message=' + networkError.message);
6744
+ }
6736
6745
  } else {
6737
- return window && window.location.replace('/account/error?message=Cannot connect to the server, please make sure you have an active internet connection');
6746
+ if (typeof window !== 'undefined') {
6747
+ return window.location.replace('/account/error?message=Cannot connect to the server, please make sure you have an active internet connection');
6748
+ }
6738
6749
  }
6739
6750
  });
6740
6751
  /* eslint-disable no-process-env */
@@ -6892,9 +6903,13 @@ const errorLink = error.onError(({
6892
6903
  }) => {
6893
6904
  if (networkError && networkError.statusCode === 401) {
6894
6905
  // redirect to login page
6895
- return window && window.location.replace('/account/login');
6906
+ if (typeof window !== 'undefined') {
6907
+ return window.location.replace('/account/login');
6908
+ }
6896
6909
  } else if (networkError && networkError.statusCode > 500 && networkError.statusCode !== 503) {
6897
- return window && window.location.replace('/error?message=' + networkError.message);
6910
+ if (typeof window !== 'undefined') {
6911
+ return window.location.replace('/error?message=' + networkError.message);
6912
+ }
6898
6913
  }
6899
6914
  });
6900
6915
  /* eslint-disable no-process-env */
@@ -6912,7 +6927,7 @@ const dqueryClient = new client.ApolloClient({
6912
6927
  connectToDevTools: isDevEnv$1,
6913
6928
  queryDeduplication: true
6914
6929
  });
6915
- const withDQueryClient = withApollo(({
6930
+ const withDQueryClient = withApollo.withApollo(({
6916
6931
  initialState
6917
6932
  }) =>
6918
6933
  // @ts-expect-error TypeScript is complaining
@@ -6923,6 +6938,215 @@ new client.ApolloClient({
6923
6938
  .restore(initialState || {})
6924
6939
  }));
6925
6940
 
6941
+ var defineProperty$2 = objectDefineProperty.f;
6942
+
6943
+ var proxyAccessor$1 = function (Target, Source, key) {
6944
+ key in Target || defineProperty$2(Target, key, {
6945
+ configurable: true,
6946
+ get: function () { return Source[key]; },
6947
+ set: function (it) { Source[key] = it; }
6948
+ });
6949
+ };
6950
+
6951
+ var isCallable$5 = isCallable$o;
6952
+ var isObject$3 = isObject$d;
6953
+ var setPrototypeOf$2 = objectSetPrototypeOf;
6954
+
6955
+ // makes subclassing work correct for wrapped built-ins
6956
+ var inheritIfRequired$1 = function ($this, dummy, Wrapper) {
6957
+ var NewTarget, NewTargetPrototype;
6958
+ if (
6959
+ // it can work only with native `setPrototypeOf`
6960
+ setPrototypeOf$2 &&
6961
+ // we haven't completely correct pre-ES6 way for getting `new.target`, so use this
6962
+ isCallable$5(NewTarget = dummy.constructor) &&
6963
+ NewTarget !== Wrapper &&
6964
+ isObject$3(NewTargetPrototype = NewTarget.prototype) &&
6965
+ NewTargetPrototype !== Wrapper.prototype
6966
+ ) setPrototypeOf$2($this, NewTargetPrototype);
6967
+ return $this;
6968
+ };
6969
+
6970
+ var toString$4 = toString$9;
6971
+
6972
+ var normalizeStringArgument$1 = function (argument, $default) {
6973
+ return argument === undefined ? arguments.length < 2 ? '' : $default : toString$4(argument);
6974
+ };
6975
+
6976
+ var isObject$2 = isObject$d;
6977
+ var createNonEnumerableProperty$4 = createNonEnumerableProperty$8;
6978
+
6979
+ // `InstallErrorCause` abstract operation
6980
+ // https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause
6981
+ var installErrorCause$1 = function (O, options) {
6982
+ if (isObject$2(options) && 'cause' in options) {
6983
+ createNonEnumerableProperty$4(O, 'cause', options.cause);
6984
+ }
6985
+ };
6986
+
6987
+ var uncurryThis$5 = functionUncurryThis;
6988
+
6989
+ var $Error = Error;
6990
+ var replace$2 = uncurryThis$5(''.replace);
6991
+
6992
+ var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
6993
+ // eslint-disable-next-line redos/no-vulnerable -- safe
6994
+ var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
6995
+ var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
6996
+
6997
+ var errorStackClear = function (stack, dropEntries) {
6998
+ if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
6999
+ while (dropEntries--) stack = replace$2(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
7000
+ } return stack;
7001
+ };
7002
+
7003
+ var fails$5 = fails$m;
7004
+ var createPropertyDescriptor$1 = createPropertyDescriptor$4;
7005
+
7006
+ var errorStackInstallable = !fails$5(function () {
7007
+ var error = new Error('a');
7008
+ if (!('stack' in error)) return true;
7009
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
7010
+ Object.defineProperty(error, 'stack', createPropertyDescriptor$1(1, 7));
7011
+ return error.stack !== 7;
7012
+ });
7013
+
7014
+ var createNonEnumerableProperty$3 = createNonEnumerableProperty$8;
7015
+ var clearErrorStack = errorStackClear;
7016
+ var ERROR_STACK_INSTALLABLE = errorStackInstallable;
7017
+
7018
+ // non-standard V8
7019
+ var captureStackTrace = Error.captureStackTrace;
7020
+
7021
+ var errorStackInstall = function (error, C, stack, dropEntries) {
7022
+ if (ERROR_STACK_INSTALLABLE) {
7023
+ if (captureStackTrace) captureStackTrace(error, C);
7024
+ else createNonEnumerableProperty$3(error, 'stack', clearErrorStack(stack, dropEntries));
7025
+ }
7026
+ };
7027
+
7028
+ var getBuiltIn$1 = getBuiltIn$9;
7029
+ var hasOwn$1 = hasOwnProperty_1;
7030
+ var createNonEnumerableProperty$2 = createNonEnumerableProperty$8;
7031
+ var isPrototypeOf = objectIsPrototypeOf;
7032
+ var setPrototypeOf$1 = objectSetPrototypeOf;
7033
+ var copyConstructorProperties = copyConstructorProperties$2;
7034
+ var proxyAccessor = proxyAccessor$1;
7035
+ var inheritIfRequired = inheritIfRequired$1;
7036
+ var normalizeStringArgument = normalizeStringArgument$1;
7037
+ var installErrorCause = installErrorCause$1;
7038
+ var installErrorStack = errorStackInstall;
7039
+ var DESCRIPTORS$1 = descriptors;
7040
+
7041
+ var wrapErrorConstructorWithCause$1 = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) {
7042
+ var STACK_TRACE_LIMIT = 'stackTraceLimit';
7043
+ var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1;
7044
+ var path = FULL_NAME.split('.');
7045
+ var ERROR_NAME = path[path.length - 1];
7046
+ var OriginalError = getBuiltIn$1.apply(null, path);
7047
+
7048
+ if (!OriginalError) return;
7049
+
7050
+ var OriginalErrorPrototype = OriginalError.prototype;
7051
+
7052
+ // V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006
7053
+ if (hasOwn$1(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause;
7054
+
7055
+ if (!FORCED) return OriginalError;
7056
+
7057
+ var BaseError = getBuiltIn$1('Error');
7058
+
7059
+ var WrappedError = wrapper(function (a, b) {
7060
+ var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined);
7061
+ var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError();
7062
+ if (message !== undefined) createNonEnumerableProperty$2(result, 'message', message);
7063
+ installErrorStack(result, WrappedError, result.stack, 2);
7064
+ if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError);
7065
+ if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]);
7066
+ return result;
7067
+ });
7068
+
7069
+ WrappedError.prototype = OriginalErrorPrototype;
7070
+
7071
+ if (ERROR_NAME !== 'Error') {
7072
+ if (setPrototypeOf$1) setPrototypeOf$1(WrappedError, BaseError);
7073
+ else copyConstructorProperties(WrappedError, BaseError, { name: true });
7074
+ } else if (DESCRIPTORS$1 && STACK_TRACE_LIMIT in OriginalError) {
7075
+ proxyAccessor(WrappedError, OriginalError, STACK_TRACE_LIMIT);
7076
+ proxyAccessor(WrappedError, OriginalError, 'prepareStackTrace');
7077
+ }
7078
+
7079
+ copyConstructorProperties(WrappedError, OriginalError);
7080
+
7081
+ try {
7082
+ // Safari 13- bug: WebAssembly errors does not have a proper `.name`
7083
+ if (OriginalErrorPrototype.name !== ERROR_NAME) {
7084
+ createNonEnumerableProperty$2(OriginalErrorPrototype, 'name', ERROR_NAME);
7085
+ }
7086
+ OriginalErrorPrototype.constructor = WrappedError;
7087
+ } catch (error) { /* empty */ }
7088
+
7089
+ return WrappedError;
7090
+ };
7091
+
7092
+ /* eslint-disable no-unused-vars -- required for functions `.length` */
7093
+ var $$5 = _export;
7094
+ var global$3 = global$n;
7095
+ var apply$1 = functionApply;
7096
+ var wrapErrorConstructorWithCause = wrapErrorConstructorWithCause$1;
7097
+
7098
+ var WEB_ASSEMBLY = 'WebAssembly';
7099
+ var WebAssembly = global$3[WEB_ASSEMBLY];
7100
+
7101
+ // eslint-disable-next-line es/no-error-cause -- feature detection
7102
+ var FORCED$1 = new Error('e', { cause: 7 }).cause !== 7;
7103
+
7104
+ var exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) {
7105
+ var O = {};
7106
+ O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED$1);
7107
+ $$5({ global: true, constructor: true, arity: 1, forced: FORCED$1 }, O);
7108
+ };
7109
+
7110
+ var exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) {
7111
+ if (WebAssembly && WebAssembly[ERROR_NAME]) {
7112
+ var O = {};
7113
+ O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED$1);
7114
+ $$5({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED$1 }, O);
7115
+ }
7116
+ };
7117
+
7118
+ // https://tc39.es/ecma262/#sec-nativeerror
7119
+ exportGlobalErrorCauseWrapper('Error', function (init) {
7120
+ return function Error(message) { return apply$1(init, this, arguments); };
7121
+ });
7122
+ exportGlobalErrorCauseWrapper('EvalError', function (init) {
7123
+ return function EvalError(message) { return apply$1(init, this, arguments); };
7124
+ });
7125
+ exportGlobalErrorCauseWrapper('RangeError', function (init) {
7126
+ return function RangeError(message) { return apply$1(init, this, arguments); };
7127
+ });
7128
+ exportGlobalErrorCauseWrapper('ReferenceError', function (init) {
7129
+ return function ReferenceError(message) { return apply$1(init, this, arguments); };
7130
+ });
7131
+ exportGlobalErrorCauseWrapper('SyntaxError', function (init) {
7132
+ return function SyntaxError(message) { return apply$1(init, this, arguments); };
7133
+ });
7134
+ exportGlobalErrorCauseWrapper('TypeError', function (init) {
7135
+ return function TypeError(message) { return apply$1(init, this, arguments); };
7136
+ });
7137
+ exportGlobalErrorCauseWrapper('URIError', function (init) {
7138
+ return function URIError(message) { return apply$1(init, this, arguments); };
7139
+ });
7140
+ exportWebAssemblyErrorCauseWrapper('CompileError', function (init) {
7141
+ return function CompileError(message) { return apply$1(init, this, arguments); };
7142
+ });
7143
+ exportWebAssemblyErrorCauseWrapper('LinkError', function (init) {
7144
+ return function LinkError(message) { return apply$1(init, this, arguments); };
7145
+ });
7146
+ exportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) {
7147
+ return function RuntimeError(message) { return apply$1(init, this, arguments); };
7148
+ });
7149
+
6926
7150
  var classof$2 = classofRaw$2;
6927
7151
 
6928
7152
  // `IsArray` abstract operation
@@ -6934,9 +7158,9 @@ var isArray$1 = Array.isArray || function isArray(argument) {
6934
7158
 
6935
7159
  var uncurryThis$4 = functionUncurryThis;
6936
7160
  var isArray = isArray$1;
6937
- var isCallable$4 = isCallable$n;
7161
+ var isCallable$4 = isCallable$o;
6938
7162
  var classof$1 = classofRaw$2;
6939
- var toString$3 = toString$8;
7163
+ var toString$3 = toString$9;
6940
7164
 
6941
7165
  var push = uncurryThis$4([].push);
6942
7166
 
@@ -6963,12 +7187,12 @@ var getJsonReplacerFunction = function (replacer) {
6963
7187
  };
6964
7188
 
6965
7189
  var $$4 = _export;
6966
- var getBuiltIn = getBuiltIn$8;
7190
+ var getBuiltIn = getBuiltIn$9;
6967
7191
  var apply = functionApply;
6968
7192
  var call$1 = functionCall;
6969
7193
  var uncurryThis$3 = functionUncurryThis;
6970
- var fails$4 = fails$l;
6971
- var isCallable$3 = isCallable$n;
7194
+ var fails$4 = fails$m;
7195
+ var isCallable$3 = isCallable$o;
6972
7196
  var isSymbol = isSymbol$3;
6973
7197
  var arraySlice = arraySlice$2;
6974
7198
  var getReplacerFunction = getJsonReplacerFunction;
@@ -7041,7 +7265,7 @@ var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u200
7041
7265
 
7042
7266
  var uncurryThis$2 = functionUncurryThis;
7043
7267
  var requireObjectCoercible$1 = requireObjectCoercible$8;
7044
- var toString$2 = toString$8;
7268
+ var toString$2 = toString$9;
7045
7269
  var whitespaces$1 = whitespaces$2;
7046
7270
 
7047
7271
  var replace = uncurryThis$2(''.replace);
@@ -7070,10 +7294,10 @@ var stringTrim = {
7070
7294
  trim: createMethod(3)
7071
7295
  };
7072
7296
 
7073
- var global$2 = global$m;
7074
- var fails$3 = fails$l;
7297
+ var global$2 = global$n;
7298
+ var fails$3 = fails$m;
7075
7299
  var uncurryThis$1 = functionUncurryThis;
7076
- var toString$1 = toString$8;
7300
+ var toString$1 = toString$9;
7077
7301
  var trim = stringTrim.trim;
7078
7302
  var whitespaces = whitespaces$2;
7079
7303
 
@@ -7126,13 +7350,16 @@ const auth = {
7126
7350
  * @returns {string} token value
7127
7351
  */
7128
7352
  getToken(fromStorage = APP_PERSIST_STORES_TYPES[0], tokenKey = TOKEN_KEY) {
7353
+ if (typeof window === 'undefined') {
7354
+ return null;
7355
+ }
7129
7356
  // localStorage:
7130
7357
  if (fromStorage === APP_PERSIST_STORES_TYPES[0]) {
7131
- return window && window.localStorage && window.localStorage.getItem(tokenKey) || null;
7358
+ return window.localStorage && window.localStorage.getItem(tokenKey) || null;
7132
7359
  }
7133
7360
  // sessionStorage:
7134
7361
  if (fromStorage === APP_PERSIST_STORES_TYPES[1]) {
7135
- return window && window.sessionStorage && window.sessionStorage.getItem(tokenKey) || null;
7362
+ return window.sessionStorage && window.sessionStorage.getItem(tokenKey) || null;
7136
7363
  }
7137
7364
  // default:
7138
7365
  return null;
@@ -7146,18 +7373,21 @@ const auth = {
7146
7373
  * @returns {boolean} success/failure flag
7147
7374
  */
7148
7375
  setToken(value = '', toStorage = APP_PERSIST_STORES_TYPES[0], tokenKey = TOKEN_KEY) {
7376
+ if (typeof window === 'undefined') {
7377
+ throw Error('Token should not be set from backend side.');
7378
+ }
7149
7379
  if (!value || value.length <= 0) {
7150
7380
  return;
7151
7381
  }
7152
7382
  // localStorage:
7153
7383
  if (toStorage === APP_PERSIST_STORES_TYPES[0]) {
7154
- if (window && window.localStorage) {
7384
+ if (window.localStorage) {
7155
7385
  window.localStorage.setItem(tokenKey, value);
7156
7386
  }
7157
7387
  }
7158
7388
  // sessionStorage:
7159
7389
  if (toStorage === APP_PERSIST_STORES_TYPES[1]) {
7160
- if (window && window.sessionStorage) {
7390
+ if (window.sessionStorage) {
7161
7391
  window.sessionStorage.setItem(tokenKey, value);
7162
7392
  }
7163
7393
  }
@@ -7184,9 +7414,12 @@ const auth = {
7184
7414
  * @returns {bool} is authenticed response
7185
7415
  */
7186
7416
  isAuthenticated(fromStorage = APP_PERSIST_STORES_TYPES[0], tokenKey = TOKEN_KEY) {
7417
+ if (typeof window === 'undefined') {
7418
+ return false;
7419
+ }
7187
7420
  // localStorage:
7188
7421
  if (fromStorage === APP_PERSIST_STORES_TYPES[0]) {
7189
- if (window && window.localStorage && window.localStorage.getItem(tokenKey)) {
7422
+ if (window.localStorage && window.localStorage.getItem(tokenKey)) {
7190
7423
  return true;
7191
7424
  } else {
7192
7425
  return false;
@@ -7194,7 +7427,7 @@ const auth = {
7194
7427
  }
7195
7428
  // sessionStorage:
7196
7429
  if (fromStorage === APP_PERSIST_STORES_TYPES[1]) {
7197
- if (window && window.sessionStorage && window.sessionStorage.getItem(tokenKey)) {
7430
+ if (window.sessionStorage && window.sessionStorage.getItem(tokenKey)) {
7198
7431
  return true;
7199
7432
  } else {
7200
7433
  return false;
@@ -7210,13 +7443,16 @@ const auth = {
7210
7443
  * @returns {bool} success/failure flag
7211
7444
  */
7212
7445
  clearToken(storage = APP_PERSIST_STORES_TYPES[0], tokenKey = TOKEN_KEY) {
7446
+ if (typeof window === 'undefined') {
7447
+ return false;
7448
+ }
7213
7449
  // localStorage:
7214
- if (window && window.localStorage && window.localStorage[tokenKey]) {
7450
+ if (window.localStorage && window.localStorage[tokenKey]) {
7215
7451
  window.localStorage.removeItem(tokenKey);
7216
7452
  return true;
7217
7453
  }
7218
7454
  // sessionStorage:
7219
- if (window && window.sessionStorage && window.sessionStorage[tokenKey]) {
7455
+ if (window.sessionStorage && window.sessionStorage[tokenKey]) {
7220
7456
  window.sessionStorage.removeItem(tokenKey);
7221
7457
  return true;
7222
7458
  }
@@ -7230,6 +7466,9 @@ const auth = {
7230
7466
  * @returns {date | null} returns expiration date or null id expired props not found in decoded token
7231
7467
  */
7232
7468
  getTokenExpirationDate(encodedToken) {
7469
+ if (typeof window === 'undefined') {
7470
+ return new Date(0);
7471
+ }
7233
7472
  if (!encodedToken) {
7234
7473
  return new Date(0); // is expired
7235
7474
  }
@@ -7265,8 +7504,8 @@ const auth = {
7265
7504
  * @returns {string} token value
7266
7505
  */
7267
7506
  getUserInfo(fromStorage = APP_PERSIST_STORES_TYPES[0], userInfoKey = USER_INFO) {
7268
- if (!window) {
7269
- return '';
7507
+ if (typeof window === 'undefined') {
7508
+ return undefined;
7270
7509
  }
7271
7510
  // localStorage:
7272
7511
  if (fromStorage === APP_PERSIST_STORES_TYPES[0]) {
@@ -7290,18 +7529,21 @@ const auth = {
7290
7529
  * @returns {boolean} success/failure flag
7291
7530
  */
7292
7531
  setUserInfo(value, toStorage = APP_PERSIST_STORES_TYPES[0], userInfoKey = USER_INFO) {
7532
+ if (typeof window === 'undefined') {
7533
+ throw Error('User info should not be set from backend side.');
7534
+ }
7293
7535
  if (!value) {
7294
7536
  return;
7295
7537
  }
7296
7538
  // localStorage:
7297
7539
  if (toStorage === APP_PERSIST_STORES_TYPES[0]) {
7298
- if (window && window.localStorage) {
7540
+ if (window.localStorage) {
7299
7541
  window.localStorage.setItem(userInfoKey, stringify(value));
7300
7542
  }
7301
7543
  }
7302
7544
  // sessionStorage:
7303
7545
  if (toStorage === APP_PERSIST_STORES_TYPES[1]) {
7304
- if (window && window.sessionStorage) {
7546
+ if (window.sessionStorage) {
7305
7547
  window.sessionStorage.setItem(userInfoKey, stringify(value));
7306
7548
  }
7307
7549
  }
@@ -7319,12 +7561,15 @@ const auth = {
7319
7561
  * @returns {bool} success/failure flag
7320
7562
  */
7321
7563
  clearUserInfo(userInfoKey = USER_INFO) {
7564
+ if (typeof window === 'undefined') {
7565
+ throw Error('User info should not be cleared from backend side.');
7566
+ }
7322
7567
  // localStorage:
7323
- if (window && window.localStorage && window.localStorage[userInfoKey]) {
7568
+ if (window.localStorage && window.localStorage[userInfoKey]) {
7324
7569
  window.localStorage.removeItem(userInfoKey);
7325
7570
  }
7326
7571
  // sessionStorage:
7327
- if (window && window.sessionStorage && window.sessionStorage[userInfoKey]) {
7572
+ if (window.sessionStorage && window.sessionStorage[userInfoKey]) {
7328
7573
  window.sessionStorage.removeItem(userInfoKey);
7329
7574
  }
7330
7575
  },
@@ -7336,10 +7581,13 @@ const auth = {
7336
7581
  * @returns {bool} success/failure flag
7337
7582
  */
7338
7583
  clearAllAppStorage() {
7339
- if (window && window.localStorage) {
7584
+ if (typeof window === 'undefined') {
7585
+ throw Error('App storage should not be cleared from backend side.');
7586
+ }
7587
+ if (window.localStorage) {
7340
7588
  window.localStorage.clear();
7341
7589
  }
7342
- if (window && window.sessionStorage) {
7590
+ if (window.sessionStorage) {
7343
7591
  window.sessionStorage.clear();
7344
7592
  }
7345
7593
  dconfigClient.clearStore();
@@ -7356,18 +7604,21 @@ const auth = {
7356
7604
  * @returns {boolean} success/failure flag
7357
7605
  */
7358
7606
  setContext(value = '', toStorage = APP_PERSIST_STORES_TYPES[0], contextKey = CONTEXT_KEY) {
7607
+ if (typeof window === 'undefined') {
7608
+ throw Error('Context should not be set from backend side.');
7609
+ }
7359
7610
  if (!value || value.length <= 0) {
7360
7611
  return;
7361
7612
  }
7362
7613
  // localStorage:
7363
7614
  if (toStorage === APP_PERSIST_STORES_TYPES[0]) {
7364
- if (window && window.localStorage) {
7615
+ if (window.localStorage) {
7365
7616
  window.localStorage.setItem(contextKey, value);
7366
7617
  }
7367
7618
  }
7368
7619
  // sessionStorage:
7369
7620
  if (toStorage === APP_PERSIST_STORES_TYPES[1]) {
7370
- if (window && window.sessionStorage) {
7621
+ if (window.sessionStorage) {
7371
7622
  window.sessionStorage.setItem(contextKey, value);
7372
7623
  }
7373
7624
  }
@@ -7380,13 +7631,16 @@ const auth = {
7380
7631
  * @returns {number} token value
7381
7632
  */
7382
7633
  getContext(fromStorage = APP_PERSIST_STORES_TYPES[0], contextKey = CONTEXT_KEY) {
7634
+ if (typeof window === 'undefined') {
7635
+ return undefined;
7636
+ }
7383
7637
  // localStorage:
7384
7638
  if (fromStorage === APP_PERSIST_STORES_TYPES[0]) {
7385
- return parseInt(window && window.localStorage && window.localStorage.getItem(contextKey) || '');
7639
+ return parseInt(window.localStorage && window.localStorage.getItem(contextKey) || '');
7386
7640
  }
7387
7641
  // sessionStorage:
7388
7642
  if (fromStorage === APP_PERSIST_STORES_TYPES[1]) {
7389
- return parseInt(window && window.sessionStorage && window.sessionStorage.getItem(contextKey) || '');
7643
+ return parseInt(window.sessionStorage && window.sessionStorage.getItem(contextKey) || '');
7390
7644
  }
7391
7645
  // default:
7392
7646
  return null;
@@ -90746,7 +91000,7 @@ var addToUnscopables$2 = function (key) {
90746
91000
  ArrayPrototype[UNSCOPABLES][key] = true;
90747
91001
  };
90748
91002
 
90749
- var fails$2 = fails$l;
91003
+ var fails$2 = fails$m;
90750
91004
 
90751
91005
  var correctPrototypeGetter = !fails$2(function () {
90752
91006
  function F() { /* empty */ }
@@ -90756,7 +91010,7 @@ var correctPrototypeGetter = !fails$2(function () {
90756
91010
  });
90757
91011
 
90758
91012
  var hasOwn = hasOwnProperty_1;
90759
- var isCallable$2 = isCallable$n;
91013
+ var isCallable$2 = isCallable$o;
90760
91014
  var toObject = toObject$4;
90761
91015
  var sharedKey = sharedKey$3;
90762
91016
  var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
@@ -90777,9 +91031,9 @@ var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : f
90777
91031
  } return object instanceof $Object ? ObjectPrototype : null;
90778
91032
  };
90779
91033
 
90780
- var fails$1 = fails$l;
90781
- var isCallable$1 = isCallable$n;
90782
- var isObject$1 = isObject$b;
91034
+ var fails$1 = fails$m;
91035
+ var isCallable$1 = isCallable$o;
91036
+ var isObject$1 = isObject$d;
90783
91037
  var getPrototypeOf$1 = objectGetPrototypeOf;
90784
91038
  var defineBuiltIn$1 = defineBuiltIn$6;
90785
91039
  var wellKnownSymbol$4 = wellKnownSymbol$i;
@@ -90825,7 +91079,7 @@ var iteratorsCore = {
90825
91079
 
90826
91080
  var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
90827
91081
  var create = objectCreate;
90828
- var createPropertyDescriptor = createPropertyDescriptor$3;
91082
+ var createPropertyDescriptor = createPropertyDescriptor$4;
90829
91083
  var setToStringTag$2 = setToStringTag$4;
90830
91084
  var Iterators$2 = iterators;
90831
91085
 
@@ -90842,12 +91096,12 @@ var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUME
90842
91096
  var $$2 = _export;
90843
91097
  var call = functionCall;
90844
91098
  var FunctionName = functionName;
90845
- var isCallable = isCallable$n;
91099
+ var isCallable = isCallable$o;
90846
91100
  var createIteratorConstructor = iteratorCreateConstructor;
90847
91101
  var getPrototypeOf = objectGetPrototypeOf;
90848
91102
  var setPrototypeOf = objectSetPrototypeOf;
90849
91103
  var setToStringTag$1 = setToStringTag$4;
90850
- var createNonEnumerableProperty$1 = createNonEnumerableProperty$5;
91104
+ var createNonEnumerableProperty$1 = createNonEnumerableProperty$8;
90851
91105
  var defineBuiltIn = defineBuiltIn$6;
90852
91106
  var wellKnownSymbol$3 = wellKnownSymbol$i;
90853
91107
  var Iterators$1 = iterators;
@@ -91050,11 +91304,11 @@ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.co
91050
91304
 
91051
91305
  var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
91052
91306
 
91053
- var global$1 = global$m;
91307
+ var global$1 = global$n;
91054
91308
  var DOMIterables = domIterables;
91055
91309
  var DOMTokenListPrototype = domTokenListPrototype;
91056
91310
  var ArrayIteratorMethods = es_array_iterator;
91057
- var createNonEnumerableProperty = createNonEnumerableProperty$5;
91311
+ var createNonEnumerableProperty = createNonEnumerableProperty$8;
91058
91312
  var setToStringTag = setToStringTag$4;
91059
91313
  var wellKnownSymbol$2 = wellKnownSymbol$i;
91060
91314
 
@@ -91505,7 +91759,7 @@ const HttpStatusCodeName = {
91505
91759
 
91506
91760
  var $$1 = _export;
91507
91761
  var $includes = arrayIncludes.includes;
91508
- var fails = fails$l;
91762
+ var fails = fails$m;
91509
91763
  var addToUnscopables = addToUnscopables$2;
91510
91764
 
91511
91765
  // FF99+ bug
@@ -91525,7 +91779,7 @@ $$1({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
91525
91779
  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
91526
91780
  addToUnscopables('includes');
91527
91781
 
91528
- var isObject = isObject$b;
91782
+ var isObject = isObject$d;
91529
91783
  var classof = classofRaw$2;
91530
91784
  var wellKnownSymbol$1 = wellKnownSymbol$i;
91531
91785
 
@@ -91568,7 +91822,7 @@ var $ = _export;
91568
91822
  var uncurryThis = functionUncurryThis;
91569
91823
  var notARegExp = notARegexp;
91570
91824
  var requireObjectCoercible = requireObjectCoercible$8;
91571
- var toString = toString$8;
91825
+ var toString = toString$9;
91572
91826
  var correctIsRegExpLogic = correctIsRegexpLogic;
91573
91827
 
91574
91828
  var stringIndexOf = uncurryThis(''.indexOf);
@@ -91640,11 +91894,6 @@ class StringsUtils {
91640
91894
  }
91641
91895
  }
91642
91896
 
91643
- // Add global to window, assigning the value of window itself.
91644
- if (typeof window !== 'undefined') {
91645
- window.global = window;
91646
- }
91647
-
91648
91897
  exports.CreateCheckoutSessionUri = CreateCheckoutSessionUri;
91649
91898
  exports.CreatePortalSessionUri = CreatePortalSessionUri;
91650
91899
  exports.HttpStatusCodeName = HttpStatusCodeName;