@vention/machine-logic-ui-sdk 0.1.0 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/index.esm.js +1320 -2446
  2. package/package.json +3 -2
package/index.esm.js CHANGED
@@ -7,21 +7,24 @@ import mqtt from 'mqtt';
7
7
  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
8
8
 
9
9
  var check = function (it) {
10
- return it && it.Math == Math && it;
10
+ return it && it.Math === Math && it;
11
11
  };
12
12
 
13
13
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
14
- var global$G =
14
+ var global$e =
15
15
  // eslint-disable-next-line es/no-global-this -- safe
16
16
  check(typeof globalThis == 'object' && globalThis) ||
17
17
  check(typeof window == 'object' && window) ||
18
18
  // eslint-disable-next-line no-restricted-globals -- safe
19
19
  check(typeof self == 'object' && self) ||
20
20
  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
21
+ check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
21
22
  // eslint-disable-next-line no-new-func -- fallback
22
23
  (function () { return this; })() || Function('return this')();
23
24
 
24
- var fails$i = function (exec) {
25
+ var objectGetOwnPropertyDescriptor = {};
26
+
27
+ var fails$h = function (exec) {
25
28
  try {
26
29
  return !!exec();
27
30
  } catch (error) {
@@ -29,168 +32,159 @@ var fails$i = function (exec) {
29
32
  }
30
33
  };
31
34
 
32
- var fails$h = fails$i;
35
+ var fails$g = fails$h;
36
+
37
+ // Detect IE8's incomplete defineProperty implementation
38
+ var descriptors = !fails$g(function () {
39
+ // eslint-disable-next-line es/no-object-defineproperty -- required for testing
40
+ return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
41
+ });
42
+
43
+ var fails$f = fails$h;
33
44
 
34
- var functionBindNative = !fails$h(function () {
45
+ var functionBindNative = !fails$f(function () {
46
+ // eslint-disable-next-line es/no-function-prototype-bind -- safe
35
47
  var test = (function () { /* empty */ }).bind();
36
48
  // eslint-disable-next-line no-prototype-builtins -- safe
37
49
  return typeof test != 'function' || test.hasOwnProperty('prototype');
38
50
  });
39
51
 
40
- var NATIVE_BIND$3 = functionBindNative;
52
+ var NATIVE_BIND$1 = functionBindNative;
53
+
54
+ var call$9 = Function.prototype.call;
55
+
56
+ var functionCall = NATIVE_BIND$1 ? call$9.bind(call$9) : function () {
57
+ return call$9.apply(call$9, arguments);
58
+ };
59
+
60
+ var objectPropertyIsEnumerable = {};
61
+
62
+ var $propertyIsEnumerable = {}.propertyIsEnumerable;
63
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
64
+ var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor;
65
+
66
+ // Nashorn ~ JDK8 bug
67
+ var NASHORN_BUG = getOwnPropertyDescriptor$3 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
68
+
69
+ // `Object.prototype.propertyIsEnumerable` method implementation
70
+ // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
71
+ objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
72
+ var descriptor = getOwnPropertyDescriptor$3(this, V);
73
+ return !!descriptor && descriptor.enumerable;
74
+ } : $propertyIsEnumerable;
75
+
76
+ var createPropertyDescriptor$3 = function (bitmap, value) {
77
+ return {
78
+ enumerable: !(bitmap & 1),
79
+ configurable: !(bitmap & 2),
80
+ writable: !(bitmap & 4),
81
+ value: value
82
+ };
83
+ };
84
+
85
+ var NATIVE_BIND = functionBindNative;
41
86
 
42
- var FunctionPrototype$2 = Function.prototype;
43
- var bind$5 = FunctionPrototype$2.bind;
44
- var call$e = FunctionPrototype$2.call;
45
- var uncurryThis$m = NATIVE_BIND$3 && bind$5.bind(call$e, call$e);
87
+ var FunctionPrototype$1 = Function.prototype;
88
+ var call$8 = FunctionPrototype$1.call;
89
+ var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype$1.bind.bind(call$8, call$8);
46
90
 
47
- var functionUncurryThis = NATIVE_BIND$3 ? function (fn) {
48
- return fn && uncurryThis$m(fn);
49
- } : function (fn) {
50
- return fn && function () {
51
- return call$e.apply(fn, arguments);
91
+ var functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
92
+ return function () {
93
+ return call$8.apply(fn, arguments);
52
94
  };
53
95
  };
54
96
 
55
- var uncurryThis$l = functionUncurryThis;
97
+ var uncurryThis$e = functionUncurryThis;
56
98
 
57
- var toString$7 = uncurryThis$l({}.toString);
58
- var stringSlice$5 = uncurryThis$l(''.slice);
99
+ var toString$6 = uncurryThis$e({}.toString);
100
+ var stringSlice$3 = uncurryThis$e(''.slice);
59
101
 
60
- var classofRaw$1 = function (it) {
61
- return stringSlice$5(toString$7(it), 8, -1);
102
+ var classofRaw$2 = function (it) {
103
+ return stringSlice$3(toString$6(it), 8, -1);
62
104
  };
63
105
 
64
- var global$F = global$G;
65
- var uncurryThis$k = functionUncurryThis;
66
- var fails$g = fails$i;
67
- var classof$7 = classofRaw$1;
106
+ var uncurryThis$d = functionUncurryThis;
107
+ var fails$e = fails$h;
108
+ var classof$4 = classofRaw$2;
68
109
 
69
- var Object$5 = global$F.Object;
70
- var split = uncurryThis$k(''.split);
110
+ var $Object$4 = Object;
111
+ var split = uncurryThis$d(''.split);
71
112
 
72
113
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
73
- var indexedObject = fails$g(function () {
114
+ var indexedObject = fails$e(function () {
74
115
  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
75
116
  // eslint-disable-next-line no-prototype-builtins -- safe
76
- return !Object$5('z').propertyIsEnumerable(0);
117
+ return !$Object$4('z').propertyIsEnumerable(0);
77
118
  }) ? function (it) {
78
- return classof$7(it) == 'String' ? split(it, '') : Object$5(it);
79
- } : Object$5;
119
+ return classof$4(it) === 'String' ? split(it, '') : $Object$4(it);
120
+ } : $Object$4;
121
+
122
+ // we can't use just `it == null` since of `document.all` special case
123
+ // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
124
+ var isNullOrUndefined$2 = function (it) {
125
+ return it === null || it === undefined;
126
+ };
80
127
 
81
- var global$E = global$G;
128
+ var isNullOrUndefined$1 = isNullOrUndefined$2;
82
129
 
83
- var TypeError$f = global$E.TypeError;
130
+ var $TypeError$9 = TypeError;
84
131
 
85
132
  // `RequireObjectCoercible` abstract operation
86
133
  // https://tc39.es/ecma262/#sec-requireobjectcoercible
87
- var requireObjectCoercible$6 = function (it) {
88
- if (it == undefined) throw TypeError$f("Can't call method on " + it);
134
+ var requireObjectCoercible$5 = function (it) {
135
+ if (isNullOrUndefined$1(it)) throw new $TypeError$9("Can't call method on " + it);
89
136
  return it;
90
137
  };
91
138
 
92
139
  // toObject with fallback for non-array-like ES3 strings
93
140
  var IndexedObject$1 = indexedObject;
94
- var requireObjectCoercible$5 = requireObjectCoercible$6;
141
+ var requireObjectCoercible$4 = requireObjectCoercible$5;
95
142
 
96
143
  var toIndexedObject$5 = function (it) {
97
- return IndexedObject$1(requireObjectCoercible$5(it));
98
- };
99
-
100
- var shared$4 = {exports: {}};
101
-
102
- var global$D = global$G;
103
-
104
- // eslint-disable-next-line es/no-object-defineproperty -- safe
105
- var defineProperty$3 = Object.defineProperty;
106
-
107
- var setGlobal$3 = function (key, value) {
108
- try {
109
- defineProperty$3(global$D, key, { value: value, configurable: true, writable: true });
110
- } catch (error) {
111
- global$D[key] = value;
112
- } return value;
113
- };
114
-
115
- var global$C = global$G;
116
- var setGlobal$2 = setGlobal$3;
117
-
118
- var SHARED = '__core-js_shared__';
119
- var store$3 = global$C[SHARED] || setGlobal$2(SHARED, {});
120
-
121
- var sharedStore = store$3;
122
-
123
- var store$2 = sharedStore;
124
-
125
- (shared$4.exports = function (key, value) {
126
- return store$2[key] || (store$2[key] = value !== undefined ? value : {});
127
- })('versions', []).push({
128
- version: '3.20.3',
129
- mode: 'global',
130
- copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
131
- license: 'https://github.com/zloirock/core-js/blob/v3.20.3/LICENSE',
132
- source: 'https://github.com/zloirock/core-js'
133
- });
134
-
135
- var global$B = global$G;
136
- var requireObjectCoercible$4 = requireObjectCoercible$6;
137
-
138
- var Object$4 = global$B.Object;
139
-
140
- // `ToObject` abstract operation
141
- // https://tc39.es/ecma262/#sec-toobject
142
- var toObject$4 = function (argument) {
143
- return Object$4(requireObjectCoercible$4(argument));
144
- };
145
-
146
- var uncurryThis$j = functionUncurryThis;
147
- var toObject$3 = toObject$4;
148
-
149
- var hasOwnProperty = uncurryThis$j({}.hasOwnProperty);
150
-
151
- // `HasOwnProperty` abstract operation
152
- // https://tc39.es/ecma262/#sec-hasownproperty
153
- var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
154
- return hasOwnProperty(toObject$3(it), key);
144
+ return IndexedObject$1(requireObjectCoercible$4(it));
155
145
  };
156
146
 
157
- var uncurryThis$i = functionUncurryThis;
158
-
159
- var id = 0;
160
- var postfix = Math.random();
161
- var toString$6 = uncurryThis$i(1.0.toString);
162
-
163
- var uid$2 = function (key) {
164
- return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$6(++id + postfix, 36);
165
- };
147
+ // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
148
+ var documentAll = typeof document == 'object' && document.all;
166
149
 
167
150
  // `IsCallable` abstract operation
168
151
  // https://tc39.es/ecma262/#sec-iscallable
169
- var isCallable$j = function (argument) {
152
+ // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
153
+ var isCallable$f = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
154
+ return typeof argument == 'function' || argument === documentAll;
155
+ } : function (argument) {
170
156
  return typeof argument == 'function';
171
157
  };
172
158
 
173
- var global$A = global$G;
174
- var isCallable$i = isCallable$j;
159
+ var isCallable$e = isCallable$f;
160
+
161
+ var isObject$9 = function (it) {
162
+ return typeof it == 'object' ? it !== null : isCallable$e(it);
163
+ };
164
+
165
+ var global$d = global$e;
166
+ var isCallable$d = isCallable$f;
175
167
 
176
168
  var aFunction = function (argument) {
177
- return isCallable$i(argument) ? argument : undefined;
169
+ return isCallable$d(argument) ? argument : undefined;
178
170
  };
179
171
 
180
- var getBuiltIn$7 = function (namespace, method) {
181
- return arguments.length < 2 ? aFunction(global$A[namespace]) : global$A[namespace] && global$A[namespace][method];
172
+ var getBuiltIn$3 = function (namespace, method) {
173
+ return arguments.length < 2 ? aFunction(global$d[namespace]) : global$d[namespace] && global$d[namespace][method];
182
174
  };
183
175
 
184
- var getBuiltIn$6 = getBuiltIn$7;
176
+ var uncurryThis$c = functionUncurryThis;
177
+
178
+ var objectIsPrototypeOf = uncurryThis$c({}.isPrototypeOf);
185
179
 
186
- var engineUserAgent = getBuiltIn$6('navigator', 'userAgent') || '';
180
+ var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
187
181
 
188
- var global$z = global$G;
189
- var userAgent$3 = engineUserAgent;
182
+ var global$c = global$e;
183
+ var userAgent = engineUserAgent;
190
184
 
191
- var process$3 = global$z.process;
192
- var Deno = global$z.Deno;
193
- var versions = process$3 && process$3.versions || Deno && Deno.version;
185
+ var process = global$c.process;
186
+ var Deno = global$c.Deno;
187
+ var versions = process && process.versions || Deno && Deno.version;
194
188
  var v8 = versions && versions.v8;
195
189
  var match, version;
196
190
 
@@ -203,10 +197,10 @@ if (v8) {
203
197
 
204
198
  // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
205
199
  // so check `userAgent` even if `.v8` exists, but 0
206
- if (!version && userAgent$3) {
207
- match = userAgent$3.match(/Edge\/(\d+)/);
200
+ if (!version && userAgent) {
201
+ match = userAgent.match(/Edge\/(\d+)/);
208
202
  if (!match || match[1] >= 74) {
209
- match = userAgent$3.match(/Chrome\/(\d+)/);
203
+ match = userAgent.match(/Chrome\/(\d+)/);
210
204
  if (match) version = +match[1];
211
205
  }
212
206
  }
@@ -214,218 +208,201 @@ if (!version && userAgent$3) {
214
208
  var engineV8Version = version;
215
209
 
216
210
  /* eslint-disable es/no-symbol -- required for testing */
211
+ var V8_VERSION = engineV8Version;
212
+ var fails$d = fails$h;
213
+ var global$b = global$e;
217
214
 
218
- var V8_VERSION$1 = engineV8Version;
219
- var fails$f = fails$i;
215
+ var $String$5 = global$b.String;
220
216
 
221
217
  // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
222
- var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$f(function () {
223
- var symbol = Symbol();
218
+ var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$d(function () {
219
+ var symbol = Symbol('symbol detection');
224
220
  // Chrome 38 Symbol has incorrect toString conversion
225
221
  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
226
- return !String(symbol) || !(Object(symbol) instanceof Symbol) ||
222
+ // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
223
+ // of course, fail.
224
+ return !$String$5(symbol) || !(Object(symbol) instanceof Symbol) ||
227
225
  // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
228
- !Symbol.sham && V8_VERSION$1 && V8_VERSION$1 < 41;
226
+ !Symbol.sham && V8_VERSION && V8_VERSION < 41;
229
227
  });
230
228
 
231
229
  /* eslint-disable es/no-symbol -- required for testing */
232
-
233
- var NATIVE_SYMBOL$1 = nativeSymbol;
230
+ var NATIVE_SYMBOL$1 = symbolConstructorDetection;
234
231
 
235
232
  var useSymbolAsUid = NATIVE_SYMBOL$1
236
233
  && !Symbol.sham
237
234
  && typeof Symbol.iterator == 'symbol';
238
235
 
239
- var global$y = global$G;
240
- var shared$3 = shared$4.exports;
241
- var hasOwn$9 = hasOwnProperty_1;
242
- var uid$1 = uid$2;
243
- var NATIVE_SYMBOL = nativeSymbol;
236
+ var getBuiltIn$2 = getBuiltIn$3;
237
+ var isCallable$c = isCallable$f;
238
+ var isPrototypeOf$1 = objectIsPrototypeOf;
244
239
  var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
245
240
 
246
- var WellKnownSymbolsStore = shared$3('wks');
247
- var Symbol$1 = global$y.Symbol;
248
- var symbolFor = Symbol$1 && Symbol$1['for'];
249
- var createWellKnownSymbol = USE_SYMBOL_AS_UID$1 ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
250
-
251
- var wellKnownSymbol$i = function (name) {
252
- if (!hasOwn$9(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
253
- var description = 'Symbol.' + name;
254
- if (NATIVE_SYMBOL && hasOwn$9(Symbol$1, name)) {
255
- WellKnownSymbolsStore[name] = Symbol$1[name];
256
- } else if (USE_SYMBOL_AS_UID$1 && symbolFor) {
257
- WellKnownSymbolsStore[name] = symbolFor(description);
258
- } else {
259
- WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
260
- }
261
- } return WellKnownSymbolsStore[name];
241
+ var $Object$3 = Object;
242
+
243
+ var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
244
+ return typeof it == 'symbol';
245
+ } : function (it) {
246
+ var $Symbol = getBuiltIn$2('Symbol');
247
+ return isCallable$c($Symbol) && isPrototypeOf$1($Symbol.prototype, $Object$3(it));
262
248
  };
263
249
 
264
- var isCallable$h = isCallable$j;
250
+ var $String$4 = String;
265
251
 
266
- var isObject$8 = function (it) {
267
- return typeof it == 'object' ? it !== null : isCallable$h(it);
252
+ var tryToString$1 = function (argument) {
253
+ try {
254
+ return $String$4(argument);
255
+ } catch (error) {
256
+ return 'Object';
257
+ }
268
258
  };
269
259
 
270
- var global$x = global$G;
271
- var isObject$7 = isObject$8;
260
+ var isCallable$b = isCallable$f;
261
+ var tryToString = tryToString$1;
272
262
 
273
- var String$5 = global$x.String;
274
- var TypeError$e = global$x.TypeError;
263
+ var $TypeError$8 = TypeError;
275
264
 
276
- // `Assert: Type(argument) is Object`
277
- var anObject$e = function (argument) {
278
- if (isObject$7(argument)) return argument;
279
- throw TypeError$e(String$5(argument) + ' is not an object');
265
+ // `Assert: IsCallable(argument) is true`
266
+ var aCallable$2 = function (argument) {
267
+ if (isCallable$b(argument)) return argument;
268
+ throw new $TypeError$8(tryToString(argument) + ' is not a function');
280
269
  };
281
270
 
282
- var objectDefineProperties = {};
271
+ var aCallable$1 = aCallable$2;
272
+ var isNullOrUndefined = isNullOrUndefined$2;
283
273
 
284
- var fails$e = fails$i;
274
+ // `GetMethod` abstract operation
275
+ // https://tc39.es/ecma262/#sec-getmethod
276
+ var getMethod$1 = function (V, P) {
277
+ var func = V[P];
278
+ return isNullOrUndefined(func) ? undefined : aCallable$1(func);
279
+ };
285
280
 
286
- // Detect IE8's incomplete defineProperty implementation
287
- var descriptors = !fails$e(function () {
288
- // eslint-disable-next-line es/no-object-defineproperty -- required for testing
289
- return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
290
- });
281
+ var call$7 = functionCall;
282
+ var isCallable$a = isCallable$f;
283
+ var isObject$8 = isObject$9;
291
284
 
292
- var DESCRIPTORS$9 = descriptors;
293
- var fails$d = fails$i;
285
+ var $TypeError$7 = TypeError;
294
286
 
295
- // V8 ~ Chrome 36-
296
- // https://bugs.chromium.org/p/v8/issues/detail?id=3334
297
- var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$d(function () {
298
- // eslint-disable-next-line es/no-object-defineproperty -- required for testing
299
- return Object.defineProperty(function () { /* empty */ }, 'prototype', {
300
- value: 42,
301
- writable: false
302
- }).prototype != 42;
303
- });
287
+ // `OrdinaryToPrimitive` abstract operation
288
+ // https://tc39.es/ecma262/#sec-ordinarytoprimitive
289
+ var ordinaryToPrimitive$1 = function (input, pref) {
290
+ var fn, val;
291
+ if (pref === 'string' && isCallable$a(fn = input.toString) && !isObject$8(val = call$7(fn, input))) return val;
292
+ if (isCallable$a(fn = input.valueOf) && !isObject$8(val = call$7(fn, input))) return val;
293
+ if (pref !== 'string' && isCallable$a(fn = input.toString) && !isObject$8(val = call$7(fn, input))) return val;
294
+ throw new $TypeError$7("Can't convert object to primitive value");
295
+ };
304
296
 
305
- var objectDefineProperty = {};
297
+ var sharedStore = {exports: {}};
306
298
 
307
- var global$w = global$G;
308
- var isObject$6 = isObject$8;
299
+ var global$a = global$e;
309
300
 
310
- var document$3 = global$w.document;
311
- // typeof document.createElement is 'object' in old IE
312
- var EXISTS$1 = isObject$6(document$3) && isObject$6(document$3.createElement);
301
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
302
+ var defineProperty$5 = Object.defineProperty;
313
303
 
314
- var documentCreateElement$2 = function (it) {
315
- return EXISTS$1 ? document$3.createElement(it) : {};
304
+ var defineGlobalProperty$3 = function (key, value) {
305
+ try {
306
+ defineProperty$5(global$a, key, { value: value, configurable: true, writable: true });
307
+ } catch (error) {
308
+ global$a[key] = value;
309
+ } return value;
316
310
  };
317
311
 
318
- var DESCRIPTORS$8 = descriptors;
319
- var fails$c = fails$i;
320
- var createElement$1 = documentCreateElement$2;
312
+ var globalThis$1 = global$e;
313
+ var defineGlobalProperty$2 = defineGlobalProperty$3;
321
314
 
322
- // Thanks to IE8 for its funny defineProperty
323
- var ie8DomDefine = !DESCRIPTORS$8 && !fails$c(function () {
324
- // eslint-disable-next-line es/no-object-defineproperty -- required for testing
325
- return Object.defineProperty(createElement$1('div'), 'a', {
326
- get: function () { return 7; }
327
- }).a != 7;
315
+ var SHARED = '__core-js_shared__';
316
+ var store$3 = sharedStore.exports = globalThis$1[SHARED] || defineGlobalProperty$2(SHARED, {});
317
+
318
+ (store$3.versions || (store$3.versions = [])).push({
319
+ version: '3.36.1',
320
+ mode: 'global',
321
+ copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
322
+ license: 'https://github.com/zloirock/core-js/blob/v3.36.1/LICENSE',
323
+ source: 'https://github.com/zloirock/core-js'
328
324
  });
329
325
 
330
- var NATIVE_BIND$2 = functionBindNative;
326
+ var sharedStoreExports = sharedStore.exports;
331
327
 
332
- var call$d = Function.prototype.call;
328
+ var store$2 = sharedStoreExports;
333
329
 
334
- var functionCall = NATIVE_BIND$2 ? call$d.bind(call$d) : function () {
335
- return call$d.apply(call$d, arguments);
330
+ var shared$4 = function (key, value) {
331
+ return store$2[key] || (store$2[key] = value || {});
336
332
  };
337
333
 
338
- var uncurryThis$h = functionUncurryThis;
339
-
340
- var objectIsPrototypeOf = uncurryThis$h({}.isPrototypeOf);
341
-
342
- var global$v = global$G;
343
- var getBuiltIn$5 = getBuiltIn$7;
344
- var isCallable$g = isCallable$j;
345
- var isPrototypeOf$3 = objectIsPrototypeOf;
346
- var USE_SYMBOL_AS_UID = useSymbolAsUid;
334
+ var requireObjectCoercible$3 = requireObjectCoercible$5;
347
335
 
348
- var Object$3 = global$v.Object;
336
+ var $Object$2 = Object;
349
337
 
350
- var isSymbol$2 = USE_SYMBOL_AS_UID ? function (it) {
351
- return typeof it == 'symbol';
352
- } : function (it) {
353
- var $Symbol = getBuiltIn$5('Symbol');
354
- return isCallable$g($Symbol) && isPrototypeOf$3($Symbol.prototype, Object$3(it));
338
+ // `ToObject` abstract operation
339
+ // https://tc39.es/ecma262/#sec-toobject
340
+ var toObject$4 = function (argument) {
341
+ return $Object$2(requireObjectCoercible$3(argument));
355
342
  };
356
343
 
357
- var global$u = global$G;
344
+ var uncurryThis$b = functionUncurryThis;
345
+ var toObject$3 = toObject$4;
358
346
 
359
- var String$4 = global$u.String;
347
+ var hasOwnProperty = uncurryThis$b({}.hasOwnProperty);
360
348
 
361
- var tryToString$4 = function (argument) {
362
- try {
363
- return String$4(argument);
364
- } catch (error) {
365
- return 'Object';
366
- }
349
+ // `HasOwnProperty` abstract operation
350
+ // https://tc39.es/ecma262/#sec-hasownproperty
351
+ // eslint-disable-next-line es/no-object-hasown -- safe
352
+ var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
353
+ return hasOwnProperty(toObject$3(it), key);
367
354
  };
368
355
 
369
- var global$t = global$G;
370
- var isCallable$f = isCallable$j;
371
- var tryToString$3 = tryToString$4;
372
-
373
- var TypeError$d = global$t.TypeError;
374
-
375
- // `Assert: IsCallable(argument) is true`
376
- var aCallable$5 = function (argument) {
377
- if (isCallable$f(argument)) return argument;
378
- throw TypeError$d(tryToString$3(argument) + ' is not a function');
379
- };
356
+ var uncurryThis$a = functionUncurryThis;
380
357
 
381
- var aCallable$4 = aCallable$5;
358
+ var id = 0;
359
+ var postfix = Math.random();
360
+ var toString$5 = uncurryThis$a(1.0.toString);
382
361
 
383
- // `GetMethod` abstract operation
384
- // https://tc39.es/ecma262/#sec-getmethod
385
- var getMethod$4 = function (V, P) {
386
- var func = V[P];
387
- return func == null ? undefined : aCallable$4(func);
362
+ var uid$2 = function (key) {
363
+ return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$5(++id + postfix, 36);
388
364
  };
389
365
 
390
- var global$s = global$G;
391
- var call$c = functionCall;
392
- var isCallable$e = isCallable$j;
393
- var isObject$5 = isObject$8;
366
+ var global$9 = global$e;
367
+ var shared$3 = shared$4;
368
+ var hasOwn$9 = hasOwnProperty_1;
369
+ var uid$1 = uid$2;
370
+ var NATIVE_SYMBOL = symbolConstructorDetection;
371
+ var USE_SYMBOL_AS_UID = useSymbolAsUid;
394
372
 
395
- var TypeError$c = global$s.TypeError;
373
+ var Symbol$1 = global$9.Symbol;
374
+ var WellKnownSymbolsStore = shared$3('wks');
375
+ var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
396
376
 
397
- // `OrdinaryToPrimitive` abstract operation
398
- // https://tc39.es/ecma262/#sec-ordinarytoprimitive
399
- var ordinaryToPrimitive$1 = function (input, pref) {
400
- var fn, val;
401
- if (pref === 'string' && isCallable$e(fn = input.toString) && !isObject$5(val = call$c(fn, input))) return val;
402
- if (isCallable$e(fn = input.valueOf) && !isObject$5(val = call$c(fn, input))) return val;
403
- if (pref !== 'string' && isCallable$e(fn = input.toString) && !isObject$5(val = call$c(fn, input))) return val;
404
- throw TypeError$c("Can't convert object to primitive value");
377
+ var wellKnownSymbol$a = function (name) {
378
+ if (!hasOwn$9(WellKnownSymbolsStore, name)) {
379
+ WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$9(Symbol$1, name)
380
+ ? Symbol$1[name]
381
+ : createWellKnownSymbol('Symbol.' + name);
382
+ } return WellKnownSymbolsStore[name];
405
383
  };
406
384
 
407
- var global$r = global$G;
408
- var call$b = functionCall;
409
- var isObject$4 = isObject$8;
385
+ var call$6 = functionCall;
386
+ var isObject$7 = isObject$9;
410
387
  var isSymbol$1 = isSymbol$2;
411
- var getMethod$3 = getMethod$4;
388
+ var getMethod = getMethod$1;
412
389
  var ordinaryToPrimitive = ordinaryToPrimitive$1;
413
- var wellKnownSymbol$h = wellKnownSymbol$i;
390
+ var wellKnownSymbol$9 = wellKnownSymbol$a;
414
391
 
415
- var TypeError$b = global$r.TypeError;
416
- var TO_PRIMITIVE = wellKnownSymbol$h('toPrimitive');
392
+ var $TypeError$6 = TypeError;
393
+ var TO_PRIMITIVE = wellKnownSymbol$9('toPrimitive');
417
394
 
418
395
  // `ToPrimitive` abstract operation
419
396
  // https://tc39.es/ecma262/#sec-toprimitive
420
397
  var toPrimitive$1 = function (input, pref) {
421
- if (!isObject$4(input) || isSymbol$1(input)) return input;
422
- var exoticToPrim = getMethod$3(input, TO_PRIMITIVE);
398
+ if (!isObject$7(input) || isSymbol$1(input)) return input;
399
+ var exoticToPrim = getMethod(input, TO_PRIMITIVE);
423
400
  var result;
424
401
  if (exoticToPrim) {
425
402
  if (pref === undefined) pref = 'default';
426
- result = call$b(exoticToPrim, input, pref);
427
- if (!isObject$4(result) || isSymbol$1(result)) return result;
428
- throw TypeError$b("Can't convert object to primitive value");
403
+ result = call$6(exoticToPrim, input, pref);
404
+ if (!isObject$7(result) || isSymbol$1(result)) return result;
405
+ throw new $TypeError$6("Can't convert object to primitive value");
429
406
  }
430
407
  if (pref === undefined) pref = 'number';
431
408
  return ordinaryToPrimitive(input, pref);
@@ -441,18 +418,89 @@ var toPropertyKey$2 = function (argument) {
441
418
  return isSymbol(key) ? key : key + '';
442
419
  };
443
420
 
444
- var global$q = global$G;
445
- var DESCRIPTORS$7 = descriptors;
421
+ var global$8 = global$e;
422
+ var isObject$6 = isObject$9;
423
+
424
+ var document$1 = global$8.document;
425
+ // typeof document.createElement is 'object' in old IE
426
+ var EXISTS$1 = isObject$6(document$1) && isObject$6(document$1.createElement);
427
+
428
+ var documentCreateElement$2 = function (it) {
429
+ return EXISTS$1 ? document$1.createElement(it) : {};
430
+ };
431
+
432
+ var DESCRIPTORS$a = descriptors;
433
+ var fails$c = fails$h;
434
+ var createElement = documentCreateElement$2;
435
+
436
+ // Thanks to IE8 for its funny defineProperty
437
+ var ie8DomDefine = !DESCRIPTORS$a && !fails$c(function () {
438
+ // eslint-disable-next-line es/no-object-defineproperty -- required for testing
439
+ return Object.defineProperty(createElement('div'), 'a', {
440
+ get: function () { return 7; }
441
+ }).a !== 7;
442
+ });
443
+
444
+ var DESCRIPTORS$9 = descriptors;
445
+ var call$5 = functionCall;
446
+ var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
447
+ var createPropertyDescriptor$2 = createPropertyDescriptor$3;
448
+ var toIndexedObject$4 = toIndexedObject$5;
449
+ var toPropertyKey$1 = toPropertyKey$2;
450
+ var hasOwn$8 = hasOwnProperty_1;
446
451
  var IE8_DOM_DEFINE$1 = ie8DomDefine;
452
+
453
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
454
+ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
455
+
456
+ // `Object.getOwnPropertyDescriptor` method
457
+ // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
458
+ objectGetOwnPropertyDescriptor.f = DESCRIPTORS$9 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
459
+ O = toIndexedObject$4(O);
460
+ P = toPropertyKey$1(P);
461
+ if (IE8_DOM_DEFINE$1) try {
462
+ return $getOwnPropertyDescriptor$1(O, P);
463
+ } catch (error) { /* empty */ }
464
+ if (hasOwn$8(O, P)) return createPropertyDescriptor$2(!call$5(propertyIsEnumerableModule$1.f, O, P), O[P]);
465
+ };
466
+
467
+ var objectDefineProperty = {};
468
+
469
+ var DESCRIPTORS$8 = descriptors;
470
+ var fails$b = fails$h;
471
+
472
+ // V8 ~ Chrome 36-
473
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3334
474
+ var v8PrototypeDefineBug = DESCRIPTORS$8 && fails$b(function () {
475
+ // eslint-disable-next-line es/no-object-defineproperty -- required for testing
476
+ return Object.defineProperty(function () { /* empty */ }, 'prototype', {
477
+ value: 42,
478
+ writable: false
479
+ }).prototype !== 42;
480
+ });
481
+
482
+ var isObject$5 = isObject$9;
483
+
484
+ var $String$3 = String;
485
+ var $TypeError$5 = TypeError;
486
+
487
+ // `Assert: Type(argument) is Object`
488
+ var anObject$7 = function (argument) {
489
+ if (isObject$5(argument)) return argument;
490
+ throw new $TypeError$5($String$3(argument) + ' is not an object');
491
+ };
492
+
493
+ var DESCRIPTORS$7 = descriptors;
494
+ var IE8_DOM_DEFINE = ie8DomDefine;
447
495
  var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
448
- var anObject$d = anObject$e;
449
- var toPropertyKey$1 = toPropertyKey$2;
496
+ var anObject$6 = anObject$7;
497
+ var toPropertyKey = toPropertyKey$2;
450
498
 
451
- var TypeError$a = global$q.TypeError;
499
+ var $TypeError$4 = TypeError;
452
500
  // eslint-disable-next-line es/no-object-defineproperty -- safe
453
501
  var $defineProperty = Object.defineProperty;
454
502
  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
455
- var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
503
+ var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
456
504
  var ENUMERABLE = 'enumerable';
457
505
  var CONFIGURABLE$1 = 'configurable';
458
506
  var WRITABLE = 'writable';
@@ -460,11 +508,11 @@ var WRITABLE = 'writable';
460
508
  // `Object.defineProperty` method
461
509
  // https://tc39.es/ecma262/#sec-object.defineproperty
462
510
  objectDefineProperty.f = DESCRIPTORS$7 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
463
- anObject$d(O);
464
- P = toPropertyKey$1(P);
465
- anObject$d(Attributes);
511
+ anObject$6(O);
512
+ P = toPropertyKey(P);
513
+ anObject$6(Attributes);
466
514
  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
467
- var current = $getOwnPropertyDescriptor$1(O, P);
515
+ var current = $getOwnPropertyDescriptor(O, P);
468
516
  if (current && current[WRITABLE]) {
469
517
  O[P] = Attributes.value;
470
518
  Attributes = {
@@ -475,76 +523,310 @@ objectDefineProperty.f = DESCRIPTORS$7 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
475
523
  }
476
524
  } return $defineProperty(O, P, Attributes);
477
525
  } : $defineProperty : function defineProperty(O, P, Attributes) {
478
- anObject$d(O);
479
- P = toPropertyKey$1(P);
480
- anObject$d(Attributes);
481
- if (IE8_DOM_DEFINE$1) try {
526
+ anObject$6(O);
527
+ P = toPropertyKey(P);
528
+ anObject$6(Attributes);
529
+ if (IE8_DOM_DEFINE) try {
482
530
  return $defineProperty(O, P, Attributes);
483
531
  } catch (error) { /* empty */ }
484
- if ('get' in Attributes || 'set' in Attributes) throw TypeError$a('Accessors not supported');
532
+ if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$4('Accessors not supported');
485
533
  if ('value' in Attributes) O[P] = Attributes.value;
486
534
  return O;
487
535
  };
488
536
 
489
- var ceil = Math.ceil;
490
- var floor$1 = Math.floor;
537
+ var DESCRIPTORS$6 = descriptors;
538
+ var definePropertyModule$3 = objectDefineProperty;
539
+ var createPropertyDescriptor$1 = createPropertyDescriptor$3;
491
540
 
492
- // `ToIntegerOrInfinity` abstract operation
493
- // https://tc39.es/ecma262/#sec-tointegerorinfinity
494
- var toIntegerOrInfinity$4 = function (argument) {
495
- var number = +argument;
496
- // eslint-disable-next-line no-self-compare -- safe
497
- return number !== number || number === 0 ? 0 : (number > 0 ? floor$1 : ceil)(number);
541
+ var createNonEnumerableProperty$4 = DESCRIPTORS$6 ? function (object, key, value) {
542
+ return definePropertyModule$3.f(object, key, createPropertyDescriptor$1(1, value));
543
+ } : function (object, key, value) {
544
+ object[key] = value;
545
+ return object;
498
546
  };
499
547
 
500
- var toIntegerOrInfinity$3 = toIntegerOrInfinity$4;
548
+ var makeBuiltIn$2 = {exports: {}};
501
549
 
502
- var max$1 = Math.max;
503
- var min$3 = Math.min;
550
+ var DESCRIPTORS$5 = descriptors;
551
+ var hasOwn$7 = hasOwnProperty_1;
552
+
553
+ var FunctionPrototype = Function.prototype;
554
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
555
+ var getDescriptor = DESCRIPTORS$5 && Object.getOwnPropertyDescriptor;
556
+
557
+ var EXISTS = hasOwn$7(FunctionPrototype, 'name');
558
+ // additional protection from minified / mangled / dropped function names
559
+ var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
560
+ var CONFIGURABLE = EXISTS && (!DESCRIPTORS$5 || (DESCRIPTORS$5 && getDescriptor(FunctionPrototype, 'name').configurable));
561
+
562
+ var functionName = {
563
+ EXISTS: EXISTS,
564
+ PROPER: PROPER,
565
+ CONFIGURABLE: CONFIGURABLE
566
+ };
567
+
568
+ var uncurryThis$9 = functionUncurryThis;
569
+ var isCallable$9 = isCallable$f;
570
+ var store$1 = sharedStoreExports;
571
+
572
+ var functionToString = uncurryThis$9(Function.toString);
573
+
574
+ // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
575
+ if (!isCallable$9(store$1.inspectSource)) {
576
+ store$1.inspectSource = function (it) {
577
+ return functionToString(it);
578
+ };
579
+ }
580
+
581
+ var inspectSource$1 = store$1.inspectSource;
582
+
583
+ var global$7 = global$e;
584
+ var isCallable$8 = isCallable$f;
585
+
586
+ var WeakMap$1 = global$7.WeakMap;
587
+
588
+ var weakMapBasicDetection = isCallable$8(WeakMap$1) && /native code/.test(String(WeakMap$1));
589
+
590
+ var shared$2 = shared$4;
591
+ var uid = uid$2;
592
+
593
+ var keys = shared$2('keys');
594
+
595
+ var sharedKey$3 = function (key) {
596
+ return keys[key] || (keys[key] = uid(key));
597
+ };
598
+
599
+ var hiddenKeys$4 = {};
600
+
601
+ var NATIVE_WEAK_MAP = weakMapBasicDetection;
602
+ var global$6 = global$e;
603
+ var isObject$4 = isObject$9;
604
+ var createNonEnumerableProperty$3 = createNonEnumerableProperty$4;
605
+ var hasOwn$6 = hasOwnProperty_1;
606
+ var shared$1 = sharedStoreExports;
607
+ var sharedKey$2 = sharedKey$3;
608
+ var hiddenKeys$3 = hiddenKeys$4;
609
+
610
+ var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
611
+ var TypeError$1 = global$6.TypeError;
612
+ var WeakMap = global$6.WeakMap;
613
+ var set, get, has;
614
+
615
+ var enforce = function (it) {
616
+ return has(it) ? get(it) : set(it, {});
617
+ };
618
+
619
+ var getterFor = function (TYPE) {
620
+ return function (it) {
621
+ var state;
622
+ if (!isObject$4(it) || (state = get(it)).type !== TYPE) {
623
+ throw new TypeError$1('Incompatible receiver, ' + TYPE + ' required');
624
+ } return state;
625
+ };
626
+ };
627
+
628
+ if (NATIVE_WEAK_MAP || shared$1.state) {
629
+ var store = shared$1.state || (shared$1.state = new WeakMap());
630
+ /* eslint-disable no-self-assign -- prototype methods protection */
631
+ store.get = store.get;
632
+ store.has = store.has;
633
+ store.set = store.set;
634
+ /* eslint-enable no-self-assign -- prototype methods protection */
635
+ set = function (it, metadata) {
636
+ if (store.has(it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
637
+ metadata.facade = it;
638
+ store.set(it, metadata);
639
+ return metadata;
640
+ };
641
+ get = function (it) {
642
+ return store.get(it) || {};
643
+ };
644
+ has = function (it) {
645
+ return store.has(it);
646
+ };
647
+ } else {
648
+ var STATE = sharedKey$2('state');
649
+ hiddenKeys$3[STATE] = true;
650
+ set = function (it, metadata) {
651
+ if (hasOwn$6(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
652
+ metadata.facade = it;
653
+ createNonEnumerableProperty$3(it, STATE, metadata);
654
+ return metadata;
655
+ };
656
+ get = function (it) {
657
+ return hasOwn$6(it, STATE) ? it[STATE] : {};
658
+ };
659
+ has = function (it) {
660
+ return hasOwn$6(it, STATE);
661
+ };
662
+ }
663
+
664
+ var internalState = {
665
+ set: set,
666
+ get: get,
667
+ has: has,
668
+ enforce: enforce,
669
+ getterFor: getterFor
670
+ };
671
+
672
+ var uncurryThis$8 = functionUncurryThis;
673
+ var fails$a = fails$h;
674
+ var isCallable$7 = isCallable$f;
675
+ var hasOwn$5 = hasOwnProperty_1;
676
+ var DESCRIPTORS$4 = descriptors;
677
+ var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
678
+ var inspectSource = inspectSource$1;
679
+ var InternalStateModule$1 = internalState;
680
+
681
+ var enforceInternalState = InternalStateModule$1.enforce;
682
+ var getInternalState$2 = InternalStateModule$1.get;
683
+ var $String$2 = String;
684
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
685
+ var defineProperty$4 = Object.defineProperty;
686
+ var stringSlice$2 = uncurryThis$8(''.slice);
687
+ var replace$1 = uncurryThis$8(''.replace);
688
+ var join = uncurryThis$8([].join);
689
+
690
+ var CONFIGURABLE_LENGTH = DESCRIPTORS$4 && !fails$a(function () {
691
+ return defineProperty$4(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
692
+ });
693
+
694
+ var TEMPLATE = String(String).split('String');
695
+
696
+ var makeBuiltIn$1 = makeBuiltIn$2.exports = function (value, name, options) {
697
+ if (stringSlice$2($String$2(name), 0, 7) === 'Symbol(') {
698
+ name = '[' + replace$1($String$2(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
699
+ }
700
+ if (options && options.getter) name = 'get ' + name;
701
+ if (options && options.setter) name = 'set ' + name;
702
+ if (!hasOwn$5(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
703
+ if (DESCRIPTORS$4) defineProperty$4(value, 'name', { value: name, configurable: true });
704
+ else value.name = name;
705
+ }
706
+ if (CONFIGURABLE_LENGTH && options && hasOwn$5(options, 'arity') && value.length !== options.arity) {
707
+ defineProperty$4(value, 'length', { value: options.arity });
708
+ }
709
+ try {
710
+ if (options && hasOwn$5(options, 'constructor') && options.constructor) {
711
+ if (DESCRIPTORS$4) defineProperty$4(value, 'prototype', { writable: false });
712
+ // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
713
+ } else if (value.prototype) value.prototype = undefined;
714
+ } catch (error) { /* empty */ }
715
+ var state = enforceInternalState(value);
716
+ if (!hasOwn$5(state, 'source')) {
717
+ state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
718
+ } return value;
719
+ };
720
+
721
+ // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
722
+ // eslint-disable-next-line no-extend-native -- required
723
+ Function.prototype.toString = makeBuiltIn$1(function toString() {
724
+ return isCallable$7(this) && getInternalState$2(this).source || inspectSource(this);
725
+ }, 'toString');
726
+
727
+ var makeBuiltInExports = makeBuiltIn$2.exports;
728
+
729
+ var isCallable$6 = isCallable$f;
730
+ var definePropertyModule$2 = objectDefineProperty;
731
+ var makeBuiltIn = makeBuiltInExports;
732
+ var defineGlobalProperty$1 = defineGlobalProperty$3;
733
+
734
+ var defineBuiltIn$4 = function (O, key, value, options) {
735
+ if (!options) options = {};
736
+ var simple = options.enumerable;
737
+ var name = options.name !== undefined ? options.name : key;
738
+ if (isCallable$6(value)) makeBuiltIn(value, name, options);
739
+ if (options.global) {
740
+ if (simple) O[key] = value;
741
+ else defineGlobalProperty$1(key, value);
742
+ } else {
743
+ try {
744
+ if (!options.unsafe) delete O[key];
745
+ else if (O[key]) simple = true;
746
+ } catch (error) { /* empty */ }
747
+ if (simple) O[key] = value;
748
+ else definePropertyModule$2.f(O, key, {
749
+ value: value,
750
+ enumerable: false,
751
+ configurable: !options.nonConfigurable,
752
+ writable: !options.nonWritable
753
+ });
754
+ } return O;
755
+ };
756
+
757
+ var objectGetOwnPropertyNames = {};
758
+
759
+ var ceil = Math.ceil;
760
+ var floor = Math.floor;
761
+
762
+ // `Math.trunc` method
763
+ // https://tc39.es/ecma262/#sec-math.trunc
764
+ // eslint-disable-next-line es/no-math-trunc -- safe
765
+ var mathTrunc = Math.trunc || function trunc(x) {
766
+ var n = +x;
767
+ return (n > 0 ? floor : ceil)(n);
768
+ };
769
+
770
+ var trunc = mathTrunc;
771
+
772
+ // `ToIntegerOrInfinity` abstract operation
773
+ // https://tc39.es/ecma262/#sec-tointegerorinfinity
774
+ var toIntegerOrInfinity$2 = function (argument) {
775
+ var number = +argument;
776
+ // eslint-disable-next-line no-self-compare -- NaN check
777
+ return number !== number || number === 0 ? 0 : trunc(number);
778
+ };
779
+
780
+ var toIntegerOrInfinity$1 = toIntegerOrInfinity$2;
781
+
782
+ var max = Math.max;
783
+ var min$2 = Math.min;
504
784
 
505
785
  // Helper for a popular repeating case of the spec:
506
786
  // Let integer be ? ToInteger(index).
507
787
  // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
508
788
  var toAbsoluteIndex$1 = function (index, length) {
509
- var integer = toIntegerOrInfinity$3(index);
510
- return integer < 0 ? max$1(integer + length, 0) : min$3(integer, length);
789
+ var integer = toIntegerOrInfinity$1(index);
790
+ return integer < 0 ? max(integer + length, 0) : min$2(integer, length);
511
791
  };
512
792
 
513
- var toIntegerOrInfinity$2 = toIntegerOrInfinity$4;
793
+ var toIntegerOrInfinity = toIntegerOrInfinity$2;
514
794
 
515
- var min$2 = Math.min;
795
+ var min$1 = Math.min;
516
796
 
517
797
  // `ToLength` abstract operation
518
798
  // https://tc39.es/ecma262/#sec-tolength
519
- var toLength$3 = function (argument) {
520
- return argument > 0 ? min$2(toIntegerOrInfinity$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
799
+ var toLength$2 = function (argument) {
800
+ var len = toIntegerOrInfinity(argument);
801
+ return len > 0 ? min$1(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
521
802
  };
522
803
 
523
- var toLength$2 = toLength$3;
804
+ var toLength$1 = toLength$2;
524
805
 
525
806
  // `LengthOfArrayLike` abstract operation
526
807
  // https://tc39.es/ecma262/#sec-lengthofarraylike
527
808
  var lengthOfArrayLike$2 = function (obj) {
528
- return toLength$2(obj.length);
809
+ return toLength$1(obj.length);
529
810
  };
530
811
 
531
- var toIndexedObject$4 = toIndexedObject$5;
812
+ var toIndexedObject$3 = toIndexedObject$5;
532
813
  var toAbsoluteIndex = toAbsoluteIndex$1;
533
814
  var lengthOfArrayLike$1 = lengthOfArrayLike$2;
534
815
 
535
816
  // `Array.prototype.{ indexOf, includes }` methods implementation
536
- var createMethod$1 = function (IS_INCLUDES) {
817
+ var createMethod = function (IS_INCLUDES) {
537
818
  return function ($this, el, fromIndex) {
538
- var O = toIndexedObject$4($this);
819
+ var O = toIndexedObject$3($this);
539
820
  var length = lengthOfArrayLike$1(O);
821
+ if (length === 0) return !IS_INCLUDES && -1;
540
822
  var index = toAbsoluteIndex(fromIndex, length);
541
823
  var value;
542
824
  // Array#includes uses SameValueZero equality algorithm
543
825
  // eslint-disable-next-line no-self-compare -- NaN check
544
- if (IS_INCLUDES && el != el) while (length > index) {
826
+ if (IS_INCLUDES && el !== el) while (length > index) {
545
827
  value = O[index++];
546
828
  // eslint-disable-next-line no-self-compare -- NaN check
547
- if (value != value) return true;
829
+ if (value !== value) return true;
548
830
  // Array#indexOf ignores holes, Array#includes - not
549
831
  } else for (;length > index; index++) {
550
832
  if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
@@ -555,31 +837,29 @@ var createMethod$1 = function (IS_INCLUDES) {
555
837
  var arrayIncludes = {
556
838
  // `Array.prototype.includes` method
557
839
  // https://tc39.es/ecma262/#sec-array.prototype.includes
558
- includes: createMethod$1(true),
840
+ includes: createMethod(true),
559
841
  // `Array.prototype.indexOf` method
560
842
  // https://tc39.es/ecma262/#sec-array.prototype.indexof
561
- indexOf: createMethod$1(false)
843
+ indexOf: createMethod(false)
562
844
  };
563
845
 
564
- var hiddenKeys$4 = {};
565
-
566
- var uncurryThis$g = functionUncurryThis;
567
- var hasOwn$8 = hasOwnProperty_1;
568
- var toIndexedObject$3 = toIndexedObject$5;
846
+ var uncurryThis$7 = functionUncurryThis;
847
+ var hasOwn$4 = hasOwnProperty_1;
848
+ var toIndexedObject$2 = toIndexedObject$5;
569
849
  var indexOf$1 = arrayIncludes.indexOf;
570
- var hiddenKeys$3 = hiddenKeys$4;
850
+ var hiddenKeys$2 = hiddenKeys$4;
571
851
 
572
- var push$1 = uncurryThis$g([].push);
852
+ var push = uncurryThis$7([].push);
573
853
 
574
854
  var objectKeysInternal = function (object, names) {
575
- var O = toIndexedObject$3(object);
855
+ var O = toIndexedObject$2(object);
576
856
  var i = 0;
577
857
  var result = [];
578
858
  var key;
579
- for (key in O) !hasOwn$8(hiddenKeys$3, key) && hasOwn$8(O, key) && push$1(result, key);
859
+ for (key in O) !hasOwn$4(hiddenKeys$2, key) && hasOwn$4(O, key) && push(result, key);
580
860
  // Don't enum bug & hidden keys
581
- while (names.length > i) if (hasOwn$8(O, key = names[i++])) {
582
- ~indexOf$1(result, key) || push$1(result, key);
861
+ while (names.length > i) if (hasOwn$4(O, key = names[i++])) {
862
+ ~indexOf$1(result, key) || push(result, key);
583
863
  }
584
864
  return result;
585
865
  };
@@ -598,62 +878,181 @@ var enumBugKeys$3 = [
598
878
  var internalObjectKeys$1 = objectKeysInternal;
599
879
  var enumBugKeys$2 = enumBugKeys$3;
600
880
 
881
+ var hiddenKeys$1 = enumBugKeys$2.concat('length', 'prototype');
882
+
883
+ // `Object.getOwnPropertyNames` method
884
+ // https://tc39.es/ecma262/#sec-object.getownpropertynames
885
+ // eslint-disable-next-line es/no-object-getownpropertynames -- safe
886
+ objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
887
+ return internalObjectKeys$1(O, hiddenKeys$1);
888
+ };
889
+
890
+ var objectGetOwnPropertySymbols = {};
891
+
892
+ // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
893
+ objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
894
+
895
+ var getBuiltIn$1 = getBuiltIn$3;
896
+ var uncurryThis$6 = functionUncurryThis;
897
+ var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
898
+ var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
899
+ var anObject$5 = anObject$7;
900
+
901
+ var concat$1 = uncurryThis$6([].concat);
902
+
903
+ // all object keys, includes non-enumerable and symbols
904
+ var ownKeys$1 = getBuiltIn$1('Reflect', 'ownKeys') || function ownKeys(it) {
905
+ var keys = getOwnPropertyNamesModule.f(anObject$5(it));
906
+ var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
907
+ return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys;
908
+ };
909
+
910
+ var hasOwn$3 = hasOwnProperty_1;
911
+ var ownKeys = ownKeys$1;
912
+ var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
913
+ var definePropertyModule$1 = objectDefineProperty;
914
+
915
+ var copyConstructorProperties$1 = function (target, source, exceptions) {
916
+ var keys = ownKeys(source);
917
+ var defineProperty = definePropertyModule$1.f;
918
+ var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
919
+ for (var i = 0; i < keys.length; i++) {
920
+ var key = keys[i];
921
+ if (!hasOwn$3(target, key) && !(exceptions && hasOwn$3(exceptions, key))) {
922
+ defineProperty(target, key, getOwnPropertyDescriptor(source, key));
923
+ }
924
+ }
925
+ };
926
+
927
+ var fails$9 = fails$h;
928
+ var isCallable$5 = isCallable$f;
929
+
930
+ var replacement = /#|\.prototype\./;
931
+
932
+ var isForced$1 = function (feature, detection) {
933
+ var value = data[normalize(feature)];
934
+ return value === POLYFILL ? true
935
+ : value === NATIVE ? false
936
+ : isCallable$5(detection) ? fails$9(detection)
937
+ : !!detection;
938
+ };
939
+
940
+ var normalize = isForced$1.normalize = function (string) {
941
+ return String(string).replace(replacement, '.').toLowerCase();
942
+ };
943
+
944
+ var data = isForced$1.data = {};
945
+ var NATIVE = isForced$1.NATIVE = 'N';
946
+ var POLYFILL = isForced$1.POLYFILL = 'P';
947
+
948
+ var isForced_1 = isForced$1;
949
+
950
+ var global$5 = global$e;
951
+ var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f;
952
+ var createNonEnumerableProperty$2 = createNonEnumerableProperty$4;
953
+ var defineBuiltIn$3 = defineBuiltIn$4;
954
+ var defineGlobalProperty = defineGlobalProperty$3;
955
+ var copyConstructorProperties = copyConstructorProperties$1;
956
+ var isForced = isForced_1;
957
+
958
+ /*
959
+ options.target - name of the target object
960
+ options.global - target is the global object
961
+ options.stat - export as static methods of target
962
+ options.proto - export as prototype methods of target
963
+ options.real - real prototype method for the `pure` version
964
+ options.forced - export even if the native feature is available
965
+ options.bind - bind methods to the target, required for the `pure` version
966
+ options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
967
+ options.unsafe - use the simple assignment of property instead of delete + defineProperty
968
+ options.sham - add a flag to not completely full polyfills
969
+ options.enumerable - export as enumerable property
970
+ options.dontCallGetSet - prevent calling a getter on target
971
+ options.name - the .name of the function if it does not match the key
972
+ */
973
+ var _export = function (options, source) {
974
+ var TARGET = options.target;
975
+ var GLOBAL = options.global;
976
+ var STATIC = options.stat;
977
+ var FORCED, target, key, targetProperty, sourceProperty, descriptor;
978
+ if (GLOBAL) {
979
+ target = global$5;
980
+ } else if (STATIC) {
981
+ target = global$5[TARGET] || defineGlobalProperty(TARGET, {});
982
+ } else {
983
+ target = global$5[TARGET] && global$5[TARGET].prototype;
984
+ }
985
+ if (target) for (key in source) {
986
+ sourceProperty = source[key];
987
+ if (options.dontCallGetSet) {
988
+ descriptor = getOwnPropertyDescriptor$2(target, key);
989
+ targetProperty = descriptor && descriptor.value;
990
+ } else targetProperty = target[key];
991
+ FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
992
+ // contained in target
993
+ if (!FORCED && targetProperty !== undefined) {
994
+ if (typeof sourceProperty == typeof targetProperty) continue;
995
+ copyConstructorProperties(sourceProperty, targetProperty);
996
+ }
997
+ // add a flag to not completely full polyfills
998
+ if (options.sham || (targetProperty && targetProperty.sham)) {
999
+ createNonEnumerableProperty$2(sourceProperty, 'sham', true);
1000
+ }
1001
+ defineBuiltIn$3(target, key, sourceProperty, options);
1002
+ }
1003
+ };
1004
+
1005
+ var objectDefineProperties = {};
1006
+
1007
+ var internalObjectKeys = objectKeysInternal;
1008
+ var enumBugKeys$1 = enumBugKeys$3;
1009
+
601
1010
  // `Object.keys` method
602
1011
  // https://tc39.es/ecma262/#sec-object.keys
603
1012
  // eslint-disable-next-line es/no-object-keys -- safe
604
1013
  var objectKeys$2 = Object.keys || function keys(O) {
605
- return internalObjectKeys$1(O, enumBugKeys$2);
1014
+ return internalObjectKeys(O, enumBugKeys$1);
606
1015
  };
607
1016
 
608
- var DESCRIPTORS$6 = descriptors;
1017
+ var DESCRIPTORS$3 = descriptors;
609
1018
  var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
610
- var definePropertyModule$4 = objectDefineProperty;
611
- var anObject$c = anObject$e;
612
- var toIndexedObject$2 = toIndexedObject$5;
1019
+ var definePropertyModule = objectDefineProperty;
1020
+ var anObject$4 = anObject$7;
1021
+ var toIndexedObject$1 = toIndexedObject$5;
613
1022
  var objectKeys$1 = objectKeys$2;
614
1023
 
615
1024
  // `Object.defineProperties` method
616
1025
  // https://tc39.es/ecma262/#sec-object.defineproperties
617
1026
  // eslint-disable-next-line es/no-object-defineproperties -- safe
618
- objectDefineProperties.f = DESCRIPTORS$6 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
619
- anObject$c(O);
620
- var props = toIndexedObject$2(Properties);
1027
+ objectDefineProperties.f = DESCRIPTORS$3 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
1028
+ anObject$4(O);
1029
+ var props = toIndexedObject$1(Properties);
621
1030
  var keys = objectKeys$1(Properties);
622
1031
  var length = keys.length;
623
1032
  var index = 0;
624
1033
  var key;
625
- while (length > index) definePropertyModule$4.f(O, key = keys[index++], props[key]);
1034
+ while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
626
1035
  return O;
627
1036
  };
628
1037
 
629
- var getBuiltIn$4 = getBuiltIn$7;
630
-
631
- var html$2 = getBuiltIn$4('document', 'documentElement');
632
-
633
- var shared$2 = shared$4.exports;
634
- var uid = uid$2;
635
-
636
- var keys = shared$2('keys');
1038
+ var getBuiltIn = getBuiltIn$3;
637
1039
 
638
- var sharedKey$3 = function (key) {
639
- return keys[key] || (keys[key] = uid(key));
640
- };
1040
+ var html$1 = getBuiltIn('document', 'documentElement');
641
1041
 
642
1042
  /* global ActiveXObject -- old IE, WSH */
643
-
644
- var anObject$b = anObject$e;
1043
+ var anObject$3 = anObject$7;
645
1044
  var definePropertiesModule = objectDefineProperties;
646
- var enumBugKeys$1 = enumBugKeys$3;
647
- var hiddenKeys$2 = hiddenKeys$4;
648
- var html$1 = html$2;
1045
+ var enumBugKeys = enumBugKeys$3;
1046
+ var hiddenKeys = hiddenKeys$4;
1047
+ var html = html$1;
649
1048
  var documentCreateElement$1 = documentCreateElement$2;
650
- var sharedKey$2 = sharedKey$3;
1049
+ var sharedKey$1 = sharedKey$3;
651
1050
 
652
1051
  var GT = '>';
653
1052
  var LT = '<';
654
1053
  var PROTOTYPE = 'prototype';
655
1054
  var SCRIPT = 'script';
656
- var IE_PROTO$1 = sharedKey$2('IE_PROTO');
1055
+ var IE_PROTO$1 = sharedKey$1('IE_PROTO');
657
1056
 
658
1057
  var EmptyConstructor = function () { /* empty */ };
659
1058
 
@@ -677,7 +1076,7 @@ var NullProtoObjectViaIFrame = function () {
677
1076
  var JS = 'java' + SCRIPT + ':';
678
1077
  var iframeDocument;
679
1078
  iframe.style.display = 'none';
680
- html$1.appendChild(iframe);
1079
+ html.appendChild(iframe);
681
1080
  // https://github.com/zloirock/core-js/issues/475
682
1081
  iframe.src = String(JS);
683
1082
  iframeDocument = iframe.contentWindow.document;
@@ -702,19 +1101,20 @@ var NullProtoObject = function () {
702
1101
  ? NullProtoObjectViaActiveX(activeXDocument) // old IE
703
1102
  : NullProtoObjectViaIFrame()
704
1103
  : NullProtoObjectViaActiveX(activeXDocument); // WSH
705
- var length = enumBugKeys$1.length;
706
- while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys$1[length]];
1104
+ var length = enumBugKeys.length;
1105
+ while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
707
1106
  return NullProtoObject();
708
1107
  };
709
1108
 
710
- hiddenKeys$2[IE_PROTO$1] = true;
1109
+ hiddenKeys[IE_PROTO$1] = true;
711
1110
 
712
1111
  // `Object.create` method
713
1112
  // https://tc39.es/ecma262/#sec-object.create
1113
+ // eslint-disable-next-line es/no-object-create -- safe
714
1114
  var objectCreate = Object.create || function create(O, Properties) {
715
1115
  var result;
716
1116
  if (O !== null) {
717
- EmptyConstructor[PROTOTYPE] = anObject$b(O);
1117
+ EmptyConstructor[PROTOTYPE] = anObject$3(O);
718
1118
  result = new EmptyConstructor();
719
1119
  EmptyConstructor[PROTOTYPE] = null;
720
1120
  // add "__proto__" for Object.getPrototypeOf polyfill
@@ -723,17 +1123,17 @@ var objectCreate = Object.create || function create(O, Properties) {
723
1123
  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
724
1124
  };
725
1125
 
726
- var wellKnownSymbol$g = wellKnownSymbol$i;
1126
+ var wellKnownSymbol$8 = wellKnownSymbol$a;
727
1127
  var create$2 = objectCreate;
728
- var definePropertyModule$3 = objectDefineProperty;
1128
+ var defineProperty$3 = objectDefineProperty.f;
729
1129
 
730
- var UNSCOPABLES = wellKnownSymbol$g('unscopables');
731
- var ArrayPrototype$1 = Array.prototype;
1130
+ var UNSCOPABLES = wellKnownSymbol$8('unscopables');
1131
+ var ArrayPrototype = Array.prototype;
732
1132
 
733
1133
  // Array.prototype[@@unscopables]
734
1134
  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
735
- if (ArrayPrototype$1[UNSCOPABLES] == undefined) {
736
- definePropertyModule$3.f(ArrayPrototype$1, UNSCOPABLES, {
1135
+ if (ArrayPrototype[UNSCOPABLES] === undefined) {
1136
+ defineProperty$3(ArrayPrototype, UNSCOPABLES, {
737
1137
  configurable: true,
738
1138
  value: create$2(null)
739
1139
  });
@@ -741,400 +1141,72 @@ if (ArrayPrototype$1[UNSCOPABLES] == undefined) {
741
1141
 
742
1142
  // add a key to Array.prototype[@@unscopables]
743
1143
  var addToUnscopables$2 = function (key) {
744
- ArrayPrototype$1[UNSCOPABLES][key] = true;
1144
+ ArrayPrototype[UNSCOPABLES][key] = true;
745
1145
  };
746
1146
 
747
- var iterators = {};
748
-
749
- var uncurryThis$f = functionUncurryThis;
750
- var isCallable$d = isCallable$j;
751
- var store$1 = sharedStore;
1147
+ var $$7 = _export;
1148
+ var $includes = arrayIncludes.includes;
1149
+ var fails$8 = fails$h;
1150
+ var addToUnscopables$1 = addToUnscopables$2;
752
1151
 
753
- var functionToString = uncurryThis$f(Function.toString);
1152
+ // FF99+ bug
1153
+ var BROKEN_ON_SPARSE = fails$8(function () {
1154
+ // eslint-disable-next-line es/no-array-prototype-includes -- detection
1155
+ return !Array(1).includes();
1156
+ });
754
1157
 
755
- // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
756
- if (!isCallable$d(store$1.inspectSource)) {
757
- store$1.inspectSource = function (it) {
758
- return functionToString(it);
759
- };
760
- }
761
-
762
- var inspectSource$4 = store$1.inspectSource;
763
-
764
- var global$p = global$G;
765
- var isCallable$c = isCallable$j;
766
- var inspectSource$3 = inspectSource$4;
767
-
768
- var WeakMap$1 = global$p.WeakMap;
769
-
770
- var nativeWeakMap = isCallable$c(WeakMap$1) && /native code/.test(inspectSource$3(WeakMap$1));
771
-
772
- var createPropertyDescriptor$3 = function (bitmap, value) {
773
- return {
774
- enumerable: !(bitmap & 1),
775
- configurable: !(bitmap & 2),
776
- writable: !(bitmap & 4),
777
- value: value
778
- };
779
- };
780
-
781
- var DESCRIPTORS$5 = descriptors;
782
- var definePropertyModule$2 = objectDefineProperty;
783
- var createPropertyDescriptor$2 = createPropertyDescriptor$3;
784
-
785
- var createNonEnumerableProperty$6 = DESCRIPTORS$5 ? function (object, key, value) {
786
- return definePropertyModule$2.f(object, key, createPropertyDescriptor$2(1, value));
787
- } : function (object, key, value) {
788
- object[key] = value;
789
- return object;
790
- };
791
-
792
- var NATIVE_WEAK_MAP = nativeWeakMap;
793
- var global$o = global$G;
794
- var uncurryThis$e = functionUncurryThis;
795
- var isObject$3 = isObject$8;
796
- var createNonEnumerableProperty$5 = createNonEnumerableProperty$6;
797
- var hasOwn$7 = hasOwnProperty_1;
798
- var shared$1 = sharedStore;
799
- var sharedKey$1 = sharedKey$3;
800
- var hiddenKeys$1 = hiddenKeys$4;
801
-
802
- var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
803
- var TypeError$9 = global$o.TypeError;
804
- var WeakMap = global$o.WeakMap;
805
- var set$1, get, has;
806
-
807
- var enforce = function (it) {
808
- return has(it) ? get(it) : set$1(it, {});
809
- };
810
-
811
- var getterFor = function (TYPE) {
812
- return function (it) {
813
- var state;
814
- if (!isObject$3(it) || (state = get(it)).type !== TYPE) {
815
- throw TypeError$9('Incompatible receiver, ' + TYPE + ' required');
816
- } return state;
817
- };
818
- };
819
-
820
- if (NATIVE_WEAK_MAP || shared$1.state) {
821
- var store = shared$1.state || (shared$1.state = new WeakMap());
822
- var wmget = uncurryThis$e(store.get);
823
- var wmhas = uncurryThis$e(store.has);
824
- var wmset = uncurryThis$e(store.set);
825
- set$1 = function (it, metadata) {
826
- if (wmhas(store, it)) throw new TypeError$9(OBJECT_ALREADY_INITIALIZED);
827
- metadata.facade = it;
828
- wmset(store, it, metadata);
829
- return metadata;
830
- };
831
- get = function (it) {
832
- return wmget(store, it) || {};
833
- };
834
- has = function (it) {
835
- return wmhas(store, it);
836
- };
837
- } else {
838
- var STATE = sharedKey$1('state');
839
- hiddenKeys$1[STATE] = true;
840
- set$1 = function (it, metadata) {
841
- if (hasOwn$7(it, STATE)) throw new TypeError$9(OBJECT_ALREADY_INITIALIZED);
842
- metadata.facade = it;
843
- createNonEnumerableProperty$5(it, STATE, metadata);
844
- return metadata;
845
- };
846
- get = function (it) {
847
- return hasOwn$7(it, STATE) ? it[STATE] : {};
848
- };
849
- has = function (it) {
850
- return hasOwn$7(it, STATE);
851
- };
852
- }
853
-
854
- var internalState = {
855
- set: set$1,
856
- get: get,
857
- has: has,
858
- enforce: enforce,
859
- getterFor: getterFor
860
- };
861
-
862
- var objectGetOwnPropertyDescriptor = {};
863
-
864
- var objectPropertyIsEnumerable = {};
865
-
866
- var $propertyIsEnumerable = {}.propertyIsEnumerable;
867
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
868
- var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor;
869
-
870
- // Nashorn ~ JDK8 bug
871
- var NASHORN_BUG = getOwnPropertyDescriptor$3 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
872
-
873
- // `Object.prototype.propertyIsEnumerable` method implementation
874
- // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
875
- objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
876
- var descriptor = getOwnPropertyDescriptor$3(this, V);
877
- return !!descriptor && descriptor.enumerable;
878
- } : $propertyIsEnumerable;
879
-
880
- var DESCRIPTORS$4 = descriptors;
881
- var call$a = functionCall;
882
- var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
883
- var createPropertyDescriptor$1 = createPropertyDescriptor$3;
884
- var toIndexedObject$1 = toIndexedObject$5;
885
- var toPropertyKey = toPropertyKey$2;
886
- var hasOwn$6 = hasOwnProperty_1;
887
- var IE8_DOM_DEFINE = ie8DomDefine;
888
-
889
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
890
- var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
891
-
892
- // `Object.getOwnPropertyDescriptor` method
893
- // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
894
- objectGetOwnPropertyDescriptor.f = DESCRIPTORS$4 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
895
- O = toIndexedObject$1(O);
896
- P = toPropertyKey(P);
897
- if (IE8_DOM_DEFINE) try {
898
- return $getOwnPropertyDescriptor(O, P);
899
- } catch (error) { /* empty */ }
900
- if (hasOwn$6(O, P)) return createPropertyDescriptor$1(!call$a(propertyIsEnumerableModule$1.f, O, P), O[P]);
901
- };
902
-
903
- var redefine$7 = {exports: {}};
904
-
905
- var DESCRIPTORS$3 = descriptors;
906
- var hasOwn$5 = hasOwnProperty_1;
907
-
908
- var FunctionPrototype$1 = Function.prototype;
909
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
910
- var getDescriptor = DESCRIPTORS$3 && Object.getOwnPropertyDescriptor;
911
-
912
- var EXISTS = hasOwn$5(FunctionPrototype$1, 'name');
913
- // additional protection from minified / mangled / dropped function names
914
- var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
915
- var CONFIGURABLE = EXISTS && (!DESCRIPTORS$3 || (DESCRIPTORS$3 && getDescriptor(FunctionPrototype$1, 'name').configurable));
916
-
917
- var functionName = {
918
- EXISTS: EXISTS,
919
- PROPER: PROPER,
920
- CONFIGURABLE: CONFIGURABLE
921
- };
922
-
923
- var global$n = global$G;
924
- var isCallable$b = isCallable$j;
925
- var hasOwn$4 = hasOwnProperty_1;
926
- var createNonEnumerableProperty$4 = createNonEnumerableProperty$6;
927
- var setGlobal$1 = setGlobal$3;
928
- var inspectSource$2 = inspectSource$4;
929
- var InternalStateModule$2 = internalState;
930
- var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
931
-
932
- var getInternalState$3 = InternalStateModule$2.get;
933
- var enforceInternalState = InternalStateModule$2.enforce;
934
- var TEMPLATE = String(String).split('String');
935
-
936
- (redefine$7.exports = function (O, key, value, options) {
937
- var unsafe = options ? !!options.unsafe : false;
938
- var simple = options ? !!options.enumerable : false;
939
- var noTargetGet = options ? !!options.noTargetGet : false;
940
- var name = options && options.name !== undefined ? options.name : key;
941
- var state;
942
- if (isCallable$b(value)) {
943
- if (String(name).slice(0, 7) === 'Symbol(') {
944
- name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
945
- }
946
- if (!hasOwn$4(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
947
- createNonEnumerableProperty$4(value, 'name', name);
948
- }
949
- state = enforceInternalState(value);
950
- if (!state.source) {
951
- state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
952
- }
953
- }
954
- if (O === global$n) {
955
- if (simple) O[key] = value;
956
- else setGlobal$1(key, value);
957
- return;
958
- } else if (!unsafe) {
959
- delete O[key];
960
- } else if (!noTargetGet && O[key]) {
961
- simple = true;
1158
+ // `Array.prototype.includes` method
1159
+ // https://tc39.es/ecma262/#sec-array.prototype.includes
1160
+ $$7({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
1161
+ includes: function includes(el /* , fromIndex = 0 */) {
1162
+ return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
962
1163
  }
963
- if (simple) O[key] = value;
964
- else createNonEnumerableProperty$4(O, key, value);
965
- // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
966
- })(Function.prototype, 'toString', function toString() {
967
- return isCallable$b(this) && getInternalState$3(this).source || inspectSource$2(this);
968
1164
  });
969
1165
 
970
- var objectGetOwnPropertyNames = {};
971
-
972
- var internalObjectKeys = objectKeysInternal;
973
- var enumBugKeys = enumBugKeys$3;
974
-
975
- var hiddenKeys = enumBugKeys.concat('length', 'prototype');
976
-
977
- // `Object.getOwnPropertyNames` method
978
- // https://tc39.es/ecma262/#sec-object.getownpropertynames
979
- // eslint-disable-next-line es/no-object-getownpropertynames -- safe
980
- objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
981
- return internalObjectKeys(O, hiddenKeys);
982
- };
983
-
984
- var objectGetOwnPropertySymbols = {};
985
-
986
- // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
987
- objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
988
-
989
- var getBuiltIn$3 = getBuiltIn$7;
990
- var uncurryThis$d = functionUncurryThis;
991
- var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
992
- var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
993
- var anObject$a = anObject$e;
994
-
995
- var concat$2 = uncurryThis$d([].concat);
996
-
997
- // all object keys, includes non-enumerable and symbols
998
- var ownKeys$1 = getBuiltIn$3('Reflect', 'ownKeys') || function ownKeys(it) {
999
- var keys = getOwnPropertyNamesModule.f(anObject$a(it));
1000
- var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
1001
- return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys;
1002
- };
1003
-
1004
- var hasOwn$3 = hasOwnProperty_1;
1005
- var ownKeys = ownKeys$1;
1006
- var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
1007
- var definePropertyModule$1 = objectDefineProperty;
1008
-
1009
- var copyConstructorProperties$1 = function (target, source, exceptions) {
1010
- var keys = ownKeys(source);
1011
- var defineProperty = definePropertyModule$1.f;
1012
- var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
1013
- for (var i = 0; i < keys.length; i++) {
1014
- var key = keys[i];
1015
- if (!hasOwn$3(target, key) && !(exceptions && hasOwn$3(exceptions, key))) {
1016
- defineProperty(target, key, getOwnPropertyDescriptor(source, key));
1017
- }
1018
- }
1019
- };
1020
-
1021
- var fails$b = fails$i;
1022
- var isCallable$a = isCallable$j;
1023
-
1024
- var replacement = /#|\.prototype\./;
1025
-
1026
- var isForced$2 = function (feature, detection) {
1027
- var value = data[normalize(feature)];
1028
- return value == POLYFILL ? true
1029
- : value == NATIVE ? false
1030
- : isCallable$a(detection) ? fails$b(detection)
1031
- : !!detection;
1032
- };
1033
-
1034
- var normalize = isForced$2.normalize = function (string) {
1035
- return String(string).replace(replacement, '.').toLowerCase();
1036
- };
1037
-
1038
- var data = isForced$2.data = {};
1039
- var NATIVE = isForced$2.NATIVE = 'N';
1040
- var POLYFILL = isForced$2.POLYFILL = 'P';
1041
-
1042
- var isForced_1 = isForced$2;
1043
-
1044
- var global$m = global$G;
1045
- var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f;
1046
- var createNonEnumerableProperty$3 = createNonEnumerableProperty$6;
1047
- var redefine$6 = redefine$7.exports;
1048
- var setGlobal = setGlobal$3;
1049
- var copyConstructorProperties = copyConstructorProperties$1;
1050
- var isForced$1 = isForced_1;
1166
+ // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1167
+ addToUnscopables$1('includes');
1051
1168
 
1052
- /*
1053
- options.target - name of the target object
1054
- options.global - target is the global object
1055
- options.stat - export as static methods of target
1056
- options.proto - export as prototype methods of target
1057
- options.real - real prototype method for the `pure` version
1058
- options.forced - export even if the native feature is available
1059
- options.bind - bind methods to the target, required for the `pure` version
1060
- options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
1061
- options.unsafe - use the simple assignment of property instead of delete + defineProperty
1062
- options.sham - add a flag to not completely full polyfills
1063
- options.enumerable - export as enumerable property
1064
- options.noTargetGet - prevent calling a getter on target
1065
- options.name - the .name of the function if it does not match the key
1066
- */
1067
- var _export = function (options, source) {
1068
- var TARGET = options.target;
1069
- var GLOBAL = options.global;
1070
- var STATIC = options.stat;
1071
- var FORCED, target, key, targetProperty, sourceProperty, descriptor;
1072
- if (GLOBAL) {
1073
- target = global$m;
1074
- } else if (STATIC) {
1075
- target = global$m[TARGET] || setGlobal(TARGET, {});
1076
- } else {
1077
- target = (global$m[TARGET] || {}).prototype;
1078
- }
1079
- if (target) for (key in source) {
1080
- sourceProperty = source[key];
1081
- if (options.noTargetGet) {
1082
- descriptor = getOwnPropertyDescriptor$2(target, key);
1083
- targetProperty = descriptor && descriptor.value;
1084
- } else targetProperty = target[key];
1085
- FORCED = isForced$1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
1086
- // contained in target
1087
- if (!FORCED && targetProperty !== undefined) {
1088
- if (typeof sourceProperty == typeof targetProperty) continue;
1089
- copyConstructorProperties(sourceProperty, targetProperty);
1090
- }
1091
- // add a flag to not completely full polyfills
1092
- if (options.sham || (targetProperty && targetProperty.sham)) {
1093
- createNonEnumerableProperty$3(sourceProperty, 'sham', true);
1094
- }
1095
- // extend global
1096
- redefine$6(target, key, sourceProperty, options);
1097
- }
1098
- };
1169
+ var iterators = {};
1099
1170
 
1100
- var fails$a = fails$i;
1171
+ var fails$7 = fails$h;
1101
1172
 
1102
- var correctPrototypeGetter = !fails$a(function () {
1173
+ var correctPrototypeGetter = !fails$7(function () {
1103
1174
  function F() { /* empty */ }
1104
1175
  F.prototype.constructor = null;
1105
1176
  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
1106
1177
  return Object.getPrototypeOf(new F()) !== F.prototype;
1107
1178
  });
1108
1179
 
1109
- var global$l = global$G;
1110
1180
  var hasOwn$2 = hasOwnProperty_1;
1111
- var isCallable$9 = isCallable$j;
1181
+ var isCallable$4 = isCallable$f;
1112
1182
  var toObject$2 = toObject$4;
1113
1183
  var sharedKey = sharedKey$3;
1114
1184
  var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
1115
1185
 
1116
1186
  var IE_PROTO = sharedKey('IE_PROTO');
1117
- var Object$2 = global$l.Object;
1118
- var ObjectPrototype = Object$2.prototype;
1187
+ var $Object$1 = Object;
1188
+ var ObjectPrototype = $Object$1.prototype;
1119
1189
 
1120
1190
  // `Object.getPrototypeOf` method
1121
1191
  // https://tc39.es/ecma262/#sec-object.getprototypeof
1122
- var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object$2.getPrototypeOf : function (O) {
1192
+ // eslint-disable-next-line es/no-object-getprototypeof -- safe
1193
+ var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object$1.getPrototypeOf : function (O) {
1123
1194
  var object = toObject$2(O);
1124
1195
  if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO];
1125
1196
  var constructor = object.constructor;
1126
- if (isCallable$9(constructor) && object instanceof constructor) {
1197
+ if (isCallable$4(constructor) && object instanceof constructor) {
1127
1198
  return constructor.prototype;
1128
- } return object instanceof Object$2 ? ObjectPrototype : null;
1199
+ } return object instanceof $Object$1 ? ObjectPrototype : null;
1129
1200
  };
1130
1201
 
1131
- var fails$9 = fails$i;
1132
- var isCallable$8 = isCallable$j;
1202
+ var fails$6 = fails$h;
1203
+ var isCallable$3 = isCallable$f;
1204
+ var isObject$3 = isObject$9;
1133
1205
  var getPrototypeOf$1 = objectGetPrototypeOf;
1134
- var redefine$5 = redefine$7.exports;
1135
- var wellKnownSymbol$f = wellKnownSymbol$i;
1206
+ var defineBuiltIn$2 = defineBuiltIn$4;
1207
+ var wellKnownSymbol$7 = wellKnownSymbol$a;
1136
1208
 
1137
- var ITERATOR$5 = wellKnownSymbol$f('iterator');
1209
+ var ITERATOR$2 = wellKnownSymbol$7('iterator');
1138
1210
  var BUGGY_SAFARI_ITERATORS$1 = false;
1139
1211
 
1140
1212
  // `%IteratorPrototype%` object
@@ -1152,18 +1224,18 @@ if ([].keys) {
1152
1224
  }
1153
1225
  }
1154
1226
 
1155
- var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$9(function () {
1227
+ var NEW_ITERATOR_PROTOTYPE = !isObject$3(IteratorPrototype$2) || fails$6(function () {
1156
1228
  var test = {};
1157
1229
  // FF44- legacy iterators case
1158
- return IteratorPrototype$2[ITERATOR$5].call(test) !== test;
1230
+ return IteratorPrototype$2[ITERATOR$2].call(test) !== test;
1159
1231
  });
1160
1232
 
1161
1233
  if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
1162
1234
 
1163
1235
  // `%IteratorPrototype%[@@iterator]()` method
1164
1236
  // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
1165
- if (!isCallable$8(IteratorPrototype$2[ITERATOR$5])) {
1166
- redefine$5(IteratorPrototype$2, ITERATOR$5, function () {
1237
+ if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) {
1238
+ defineBuiltIn$2(IteratorPrototype$2, ITERATOR$2, function () {
1167
1239
  return this;
1168
1240
  });
1169
1241
  }
@@ -1175,14 +1247,14 @@ var iteratorsCore = {
1175
1247
 
1176
1248
  var defineProperty$2 = objectDefineProperty.f;
1177
1249
  var hasOwn$1 = hasOwnProperty_1;
1178
- var wellKnownSymbol$e = wellKnownSymbol$i;
1250
+ var wellKnownSymbol$6 = wellKnownSymbol$a;
1179
1251
 
1180
- var TO_STRING_TAG$3 = wellKnownSymbol$e('toStringTag');
1252
+ var TO_STRING_TAG$2 = wellKnownSymbol$6('toStringTag');
1181
1253
 
1182
1254
  var setToStringTag$3 = function (target, TAG, STATIC) {
1183
1255
  if (target && !STATIC) target = target.prototype;
1184
- if (target && !hasOwn$1(target, TO_STRING_TAG$3)) {
1185
- defineProperty$2(target, TO_STRING_TAG$3, { configurable: true, value: TAG });
1256
+ if (target && !hasOwn$1(target, TO_STRING_TAG$2)) {
1257
+ defineProperty$2(target, TO_STRING_TAG$2, { configurable: true, value: TAG });
1186
1258
  }
1187
1259
  };
1188
1260
 
@@ -1190,33 +1262,48 @@ var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
1190
1262
  var create$1 = objectCreate;
1191
1263
  var createPropertyDescriptor = createPropertyDescriptor$3;
1192
1264
  var setToStringTag$2 = setToStringTag$3;
1193
- var Iterators$4 = iterators;
1265
+ var Iterators$2 = iterators;
1194
1266
 
1195
1267
  var returnThis$1 = function () { return this; };
1196
1268
 
1197
- var createIteratorConstructor$1 = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
1269
+ var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
1198
1270
  var TO_STRING_TAG = NAME + ' Iterator';
1199
1271
  IteratorConstructor.prototype = create$1(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
1200
1272
  setToStringTag$2(IteratorConstructor, TO_STRING_TAG, false);
1201
- Iterators$4[TO_STRING_TAG] = returnThis$1;
1273
+ Iterators$2[TO_STRING_TAG] = returnThis$1;
1202
1274
  return IteratorConstructor;
1203
1275
  };
1204
1276
 
1205
- var global$k = global$G;
1206
- var isCallable$7 = isCallable$j;
1277
+ var uncurryThis$5 = functionUncurryThis;
1278
+ var aCallable = aCallable$2;
1279
+
1280
+ var functionUncurryThisAccessor = function (object, key, method) {
1281
+ try {
1282
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1283
+ return uncurryThis$5(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
1284
+ } catch (error) { /* empty */ }
1285
+ };
1286
+
1287
+ var isObject$2 = isObject$9;
1207
1288
 
1208
- var String$3 = global$k.String;
1209
- var TypeError$8 = global$k.TypeError;
1289
+ var isPossiblePrototype$1 = function (argument) {
1290
+ return isObject$2(argument) || argument === null;
1291
+ };
1292
+
1293
+ var isPossiblePrototype = isPossiblePrototype$1;
1294
+
1295
+ var $String$1 = String;
1296
+ var $TypeError$3 = TypeError;
1210
1297
 
1211
1298
  var aPossiblePrototype$1 = function (argument) {
1212
- if (typeof argument == 'object' || isCallable$7(argument)) return argument;
1213
- throw TypeError$8("Can't set " + String$3(argument) + ' as a prototype');
1299
+ if (isPossiblePrototype(argument)) return argument;
1300
+ throw new $TypeError$3("Can't set " + $String$1(argument) + ' as a prototype');
1214
1301
  };
1215
1302
 
1216
1303
  /* eslint-disable no-proto -- safe */
1217
-
1218
- var uncurryThis$c = functionUncurryThis;
1219
- var anObject$9 = anObject$e;
1304
+ var uncurryThisAccessor = functionUncurryThisAccessor;
1305
+ var isObject$1 = isObject$9;
1306
+ var requireObjectCoercible$2 = requireObjectCoercible$5;
1220
1307
  var aPossiblePrototype = aPossiblePrototype$1;
1221
1308
 
1222
1309
  // `Object.setPrototypeOf` method
@@ -1228,14 +1315,14 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
1228
1315
  var test = {};
1229
1316
  var setter;
1230
1317
  try {
1231
- // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1232
- setter = uncurryThis$c(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
1318
+ setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
1233
1319
  setter(test, []);
1234
1320
  CORRECT_SETTER = test instanceof Array;
1235
1321
  } catch (error) { /* empty */ }
1236
1322
  return function setPrototypeOf(O, proto) {
1237
- anObject$9(O);
1323
+ requireObjectCoercible$2(O);
1238
1324
  aPossiblePrototype(proto);
1325
+ if (!isObject$1(O)) return O;
1239
1326
  if (CORRECT_SETTER) setter(O, proto);
1240
1327
  else O.__proto__ = proto;
1241
1328
  return O;
@@ -1243,51 +1330,54 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
1243
1330
  }() : undefined);
1244
1331
 
1245
1332
  var $$6 = _export;
1246
- var call$9 = functionCall;
1333
+ var call$4 = functionCall;
1247
1334
  var FunctionName = functionName;
1248
- var isCallable$6 = isCallable$j;
1249
- var createIteratorConstructor = createIteratorConstructor$1;
1335
+ var isCallable$2 = isCallable$f;
1336
+ var createIteratorConstructor = iteratorCreateConstructor;
1250
1337
  var getPrototypeOf = objectGetPrototypeOf;
1251
- var setPrototypeOf$1 = objectSetPrototypeOf;
1338
+ var setPrototypeOf = objectSetPrototypeOf;
1252
1339
  var setToStringTag$1 = setToStringTag$3;
1253
- var createNonEnumerableProperty$2 = createNonEnumerableProperty$6;
1254
- var redefine$4 = redefine$7.exports;
1255
- var wellKnownSymbol$d = wellKnownSymbol$i;
1256
- var Iterators$3 = iterators;
1340
+ var createNonEnumerableProperty$1 = createNonEnumerableProperty$4;
1341
+ var defineBuiltIn$1 = defineBuiltIn$4;
1342
+ var wellKnownSymbol$5 = wellKnownSymbol$a;
1343
+ var Iterators$1 = iterators;
1257
1344
  var IteratorsCore = iteratorsCore;
1258
1345
 
1259
1346
  var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER;
1260
1347
  var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
1261
1348
  var IteratorPrototype = IteratorsCore.IteratorPrototype;
1262
1349
  var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
1263
- var ITERATOR$4 = wellKnownSymbol$d('iterator');
1350
+ var ITERATOR$1 = wellKnownSymbol$5('iterator');
1264
1351
  var KEYS = 'keys';
1265
1352
  var VALUES = 'values';
1266
1353
  var ENTRIES = 'entries';
1267
1354
 
1268
1355
  var returnThis = function () { return this; };
1269
1356
 
1270
- var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
1357
+ var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
1271
1358
  createIteratorConstructor(IteratorConstructor, NAME, next);
1272
1359
 
1273
1360
  var getIterationMethod = function (KIND) {
1274
1361
  if (KIND === DEFAULT && defaultIterator) return defaultIterator;
1275
- if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
1362
+ if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];
1363
+
1276
1364
  switch (KIND) {
1277
1365
  case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
1278
1366
  case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
1279
1367
  case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
1280
- } return function () { return new IteratorConstructor(this); };
1368
+ }
1369
+
1370
+ return function () { return new IteratorConstructor(this); };
1281
1371
  };
1282
1372
 
1283
1373
  var TO_STRING_TAG = NAME + ' Iterator';
1284
1374
  var INCORRECT_VALUES_NAME = false;
1285
1375
  var IterablePrototype = Iterable.prototype;
1286
- var nativeIterator = IterablePrototype[ITERATOR$4]
1376
+ var nativeIterator = IterablePrototype[ITERATOR$1]
1287
1377
  || IterablePrototype['@@iterator']
1288
1378
  || DEFAULT && IterablePrototype[DEFAULT];
1289
1379
  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
1290
- var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
1380
+ var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
1291
1381
  var CurrentIteratorPrototype, methods, KEY;
1292
1382
 
1293
1383
  // fix native
@@ -1295,10 +1385,10 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
1295
1385
  CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
1296
1386
  if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
1297
1387
  if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
1298
- if (setPrototypeOf$1) {
1299
- setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype);
1300
- } else if (!isCallable$6(CurrentIteratorPrototype[ITERATOR$4])) {
1301
- redefine$4(CurrentIteratorPrototype, ITERATOR$4, returnThis);
1388
+ if (setPrototypeOf) {
1389
+ setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
1390
+ } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) {
1391
+ defineBuiltIn$1(CurrentIteratorPrototype, ITERATOR$1, returnThis);
1302
1392
  }
1303
1393
  }
1304
1394
  // Set @@toStringTag to native iterators
@@ -1307,12 +1397,12 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
1307
1397
  }
1308
1398
 
1309
1399
  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
1310
- if (PROPER_FUNCTION_NAME$1 && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
1400
+ if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
1311
1401
  if (CONFIGURABLE_FUNCTION_NAME) {
1312
- createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES);
1402
+ createNonEnumerableProperty$1(IterablePrototype, 'name', VALUES);
1313
1403
  } else {
1314
1404
  INCORRECT_VALUES_NAME = true;
1315
- defaultIterator = function values() { return call$9(nativeIterator, this); };
1405
+ defaultIterator = function values() { return call$4(nativeIterator, this); };
1316
1406
  }
1317
1407
  }
1318
1408
 
@@ -1325,31 +1415,38 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
1325
1415
  };
1326
1416
  if (FORCED) for (KEY in methods) {
1327
1417
  if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
1328
- redefine$4(IterablePrototype, KEY, methods[KEY]);
1418
+ defineBuiltIn$1(IterablePrototype, KEY, methods[KEY]);
1329
1419
  }
1330
1420
  } else $$6({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
1331
1421
  }
1332
1422
 
1333
1423
  // define iterator
1334
- if (IterablePrototype[ITERATOR$4] !== defaultIterator) {
1335
- redefine$4(IterablePrototype, ITERATOR$4, defaultIterator, { name: DEFAULT });
1424
+ if (IterablePrototype[ITERATOR$1] !== defaultIterator) {
1425
+ defineBuiltIn$1(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT });
1336
1426
  }
1337
- Iterators$3[NAME] = defaultIterator;
1427
+ Iterators$1[NAME] = defaultIterator;
1338
1428
 
1339
1429
  return methods;
1340
1430
  };
1341
1431
 
1432
+ // `CreateIterResultObject` abstract operation
1433
+ // https://tc39.es/ecma262/#sec-createiterresultobject
1434
+ var createIterResultObject$1 = function (value, done) {
1435
+ return { value: value, done: done };
1436
+ };
1437
+
1342
1438
  var toIndexedObject = toIndexedObject$5;
1343
- var addToUnscopables$1 = addToUnscopables$2;
1344
- var Iterators$2 = iterators;
1345
- var InternalStateModule$1 = internalState;
1439
+ var addToUnscopables = addToUnscopables$2;
1440
+ var Iterators = iterators;
1441
+ var InternalStateModule = internalState;
1346
1442
  var defineProperty$1 = objectDefineProperty.f;
1347
- var defineIterator = defineIterator$1;
1443
+ var defineIterator = iteratorDefine;
1444
+ var createIterResultObject = createIterResultObject$1;
1348
1445
  var DESCRIPTORS$2 = descriptors;
1349
1446
 
1350
1447
  var ARRAY_ITERATOR = 'Array Iterator';
1351
- var setInternalState$1 = InternalStateModule$1.set;
1352
- var getInternalState$2 = InternalStateModule$1.getterFor(ARRAY_ITERATOR);
1448
+ var setInternalState = InternalStateModule.set;
1449
+ var getInternalState$1 = InternalStateModule.getterFor(ARRAY_ITERATOR);
1353
1450
 
1354
1451
  // `Array.prototype.entries` method
1355
1452
  // https://tc39.es/ecma262/#sec-array.prototype.entries
@@ -1362,7 +1459,7 @@ var getInternalState$2 = InternalStateModule$1.getterFor(ARRAY_ITERATOR);
1362
1459
  // `CreateArrayIterator` internal method
1363
1460
  // https://tc39.es/ecma262/#sec-createarrayiterator
1364
1461
  var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
1365
- setInternalState$1(this, {
1462
+ setInternalState(this, {
1366
1463
  type: ARRAY_ITERATOR,
1367
1464
  target: toIndexedObject(iterated), // target
1368
1465
  index: 0, // next index
@@ -1371,176 +1468,120 @@ var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind)
1371
1468
  // `%ArrayIteratorPrototype%.next` method
1372
1469
  // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
1373
1470
  }, function () {
1374
- var state = getInternalState$2(this);
1471
+ var state = getInternalState$1(this);
1375
1472
  var target = state.target;
1376
- var kind = state.kind;
1377
1473
  var index = state.index++;
1378
1474
  if (!target || index >= target.length) {
1379
1475
  state.target = undefined;
1380
- return { value: undefined, done: true };
1476
+ return createIterResultObject(undefined, true);
1381
1477
  }
1382
- if (kind == 'keys') return { value: index, done: false };
1383
- if (kind == 'values') return { value: target[index], done: false };
1384
- return { value: [index, target[index]], done: false };
1478
+ switch (state.kind) {
1479
+ case 'keys': return createIterResultObject(index, false);
1480
+ case 'values': return createIterResultObject(target[index], false);
1481
+ } return createIterResultObject([index, target[index]], false);
1385
1482
  }, 'values');
1386
1483
 
1387
1484
  // argumentsList[@@iterator] is %ArrayProto_values%
1388
1485
  // https://tc39.es/ecma262/#sec-createunmappedargumentsobject
1389
1486
  // https://tc39.es/ecma262/#sec-createmappedargumentsobject
1390
- var values = Iterators$2.Arguments = Iterators$2.Array;
1487
+ var values = Iterators.Arguments = Iterators.Array;
1391
1488
 
1392
1489
  // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1393
- addToUnscopables$1('keys');
1394
- addToUnscopables$1('values');
1395
- addToUnscopables$1('entries');
1490
+ addToUnscopables('keys');
1491
+ addToUnscopables('values');
1492
+ addToUnscopables('entries');
1396
1493
 
1397
1494
  // V8 ~ Chrome 45- bug
1398
1495
  if (DESCRIPTORS$2 && values.name !== 'values') try {
1399
1496
  defineProperty$1(values, 'name', { value: 'values' });
1400
1497
  } catch (error) { /* empty */ }
1401
1498
 
1402
- // iterable DOM collections
1403
- // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
1404
- var domIterables = {
1405
- CSSRuleList: 0,
1406
- CSSStyleDeclaration: 0,
1407
- CSSValueList: 0,
1408
- ClientRectList: 0,
1409
- DOMRectList: 0,
1410
- DOMStringList: 0,
1411
- DOMTokenList: 1,
1412
- DataTransferItemList: 0,
1413
- FileList: 0,
1414
- HTMLAllCollection: 0,
1415
- HTMLCollection: 0,
1416
- HTMLFormElement: 0,
1417
- HTMLSelectElement: 0,
1418
- MediaList: 0,
1419
- MimeTypeArray: 0,
1420
- NamedNodeMap: 0,
1421
- NodeList: 1,
1422
- PaintRequestList: 0,
1423
- Plugin: 0,
1424
- PluginArray: 0,
1425
- SVGLengthList: 0,
1426
- SVGNumberList: 0,
1427
- SVGPathSegList: 0,
1428
- SVGPointList: 0,
1429
- SVGStringList: 0,
1430
- SVGTransformList: 0,
1431
- SourceBufferList: 0,
1432
- StyleSheetList: 0,
1433
- TextTrackCueList: 0,
1434
- TextTrackList: 0,
1435
- TouchList: 0
1436
- };
1437
-
1438
- // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
1439
- var documentCreateElement = documentCreateElement$2;
1440
-
1441
- var classList = documentCreateElement('span').classList;
1442
- var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
1443
-
1444
- var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
1445
-
1446
- var global$j = global$G;
1447
- var DOMIterables = domIterables;
1448
- var DOMTokenListPrototype = domTokenListPrototype;
1449
- var ArrayIteratorMethods = es_array_iterator;
1450
- var createNonEnumerableProperty$1 = createNonEnumerableProperty$6;
1451
- var wellKnownSymbol$c = wellKnownSymbol$i;
1499
+ var DESCRIPTORS$1 = descriptors;
1500
+ var uncurryThis$4 = functionUncurryThis;
1501
+ var call$3 = functionCall;
1502
+ var fails$5 = fails$h;
1503
+ var objectKeys = objectKeys$2;
1504
+ var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
1505
+ var propertyIsEnumerableModule = objectPropertyIsEnumerable;
1506
+ var toObject$1 = toObject$4;
1507
+ var IndexedObject = indexedObject;
1452
1508
 
1453
- var ITERATOR$3 = wellKnownSymbol$c('iterator');
1454
- var TO_STRING_TAG$2 = wellKnownSymbol$c('toStringTag');
1455
- var ArrayValues = ArrayIteratorMethods.values;
1509
+ // eslint-disable-next-line es/no-object-assign -- safe
1510
+ var $assign = Object.assign;
1511
+ // eslint-disable-next-line es/no-object-defineproperty -- required for testing
1512
+ var defineProperty = Object.defineProperty;
1513
+ var concat = uncurryThis$4([].concat);
1456
1514
 
1457
- var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
1458
- if (CollectionPrototype) {
1459
- // some Chrome versions have non-configurable methods on DOMTokenList
1460
- if (CollectionPrototype[ITERATOR$3] !== ArrayValues) try {
1461
- createNonEnumerableProperty$1(CollectionPrototype, ITERATOR$3, ArrayValues);
1462
- } catch (error) {
1463
- CollectionPrototype[ITERATOR$3] = ArrayValues;
1464
- }
1465
- if (!CollectionPrototype[TO_STRING_TAG$2]) {
1466
- createNonEnumerableProperty$1(CollectionPrototype, TO_STRING_TAG$2, COLLECTION_NAME);
1515
+ // `Object.assign` method
1516
+ // https://tc39.es/ecma262/#sec-object.assign
1517
+ var objectAssign = !$assign || fails$5(function () {
1518
+ // should have correct order of operations (Edge bug)
1519
+ if (DESCRIPTORS$1 && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
1520
+ enumerable: true,
1521
+ get: function () {
1522
+ defineProperty(this, 'b', {
1523
+ value: 3,
1524
+ enumerable: false
1525
+ });
1467
1526
  }
1468
- if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
1469
- // some Chrome versions have non-configurable methods on DOMTokenList
1470
- if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
1471
- createNonEnumerableProperty$1(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
1472
- } catch (error) {
1473
- CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
1474
- }
1527
+ }), { b: 2 })).b !== 1) return true;
1528
+ // should work with symbols and should have deterministic property order (V8 bug)
1529
+ var A = {};
1530
+ var B = {};
1531
+ // eslint-disable-next-line es/no-symbol -- safe
1532
+ var symbol = Symbol('assign detection');
1533
+ var alphabet = 'abcdefghijklmnopqrst';
1534
+ A[symbol] = 7;
1535
+ alphabet.split('').forEach(function (chr) { B[chr] = chr; });
1536
+ return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;
1537
+ }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
1538
+ var T = toObject$1(target);
1539
+ var argumentsLength = arguments.length;
1540
+ var index = 1;
1541
+ var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1542
+ var propertyIsEnumerable = propertyIsEnumerableModule.f;
1543
+ while (argumentsLength > index) {
1544
+ var S = IndexedObject(arguments[index++]);
1545
+ var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
1546
+ var length = keys.length;
1547
+ var j = 0;
1548
+ var key;
1549
+ while (length > j) {
1550
+ key = keys[j++];
1551
+ if (!DESCRIPTORS$1 || call$3(propertyIsEnumerable, S, key)) T[key] = S[key];
1475
1552
  }
1476
- }
1477
- };
1478
-
1479
- for (var COLLECTION_NAME in DOMIterables) {
1480
- handlePrototype(global$j[COLLECTION_NAME] && global$j[COLLECTION_NAME].prototype, COLLECTION_NAME);
1481
- }
1482
-
1483
- handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
1553
+ } return T;
1554
+ } : $assign;
1484
1555
 
1485
1556
  var $$5 = _export;
1486
- var $includes = arrayIncludes.includes;
1487
- var addToUnscopables = addToUnscopables$2;
1557
+ var assign = objectAssign;
1488
1558
 
1489
- // `Array.prototype.includes` method
1490
- // https://tc39.es/ecma262/#sec-array.prototype.includes
1491
- $$5({ target: 'Array', proto: true }, {
1492
- includes: function includes(el /* , fromIndex = 0 */) {
1493
- return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
1494
- }
1559
+ // `Object.assign` method
1560
+ // https://tc39.es/ecma262/#sec-object.assign
1561
+ // eslint-disable-next-line es/no-object-assign -- required for testing
1562
+ $$5({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
1563
+ assign: assign
1495
1564
  });
1496
1565
 
1497
- // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1498
- addToUnscopables('includes');
1499
-
1500
- var isObject$2 = isObject$8;
1501
- var classof$6 = classofRaw$1;
1502
- var wellKnownSymbol$b = wellKnownSymbol$i;
1503
-
1504
- var MATCH$1 = wellKnownSymbol$b('match');
1566
+ var wellKnownSymbol$4 = wellKnownSymbol$a;
1505
1567
 
1506
- // `IsRegExp` abstract operation
1507
- // https://tc39.es/ecma262/#sec-isregexp
1508
- var isRegexp = function (it) {
1509
- var isRegExp;
1510
- return isObject$2(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$6(it) == 'RegExp');
1511
- };
1512
-
1513
- var global$i = global$G;
1514
- var isRegExp = isRegexp;
1515
-
1516
- var TypeError$7 = global$i.TypeError;
1517
-
1518
- var notARegexp = function (it) {
1519
- if (isRegExp(it)) {
1520
- throw TypeError$7("The method doesn't accept regular expressions");
1521
- } return it;
1522
- };
1523
-
1524
- var wellKnownSymbol$a = wellKnownSymbol$i;
1525
-
1526
- var TO_STRING_TAG$1 = wellKnownSymbol$a('toStringTag');
1568
+ var TO_STRING_TAG$1 = wellKnownSymbol$4('toStringTag');
1527
1569
  var test = {};
1528
1570
 
1529
1571
  test[TO_STRING_TAG$1] = 'z';
1530
1572
 
1531
1573
  var toStringTagSupport = String(test) === '[object z]';
1532
1574
 
1533
- var global$h = global$G;
1534
1575
  var TO_STRING_TAG_SUPPORT = toStringTagSupport;
1535
- var isCallable$5 = isCallable$j;
1536
- var classofRaw = classofRaw$1;
1537
- var wellKnownSymbol$9 = wellKnownSymbol$i;
1576
+ var isCallable$1 = isCallable$f;
1577
+ var classofRaw$1 = classofRaw$2;
1578
+ var wellKnownSymbol$3 = wellKnownSymbol$a;
1538
1579
 
1539
- var TO_STRING_TAG = wellKnownSymbol$9('toStringTag');
1540
- var Object$1 = global$h.Object;
1580
+ var TO_STRING_TAG = wellKnownSymbol$3('toStringTag');
1581
+ var $Object = Object;
1541
1582
 
1542
1583
  // ES3 wrong here
1543
- var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
1584
+ var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments';
1544
1585
 
1545
1586
  // fallback for IE11 Script Access Denied error
1546
1587
  var tryGet = function (it, key) {
@@ -1550,30 +1591,109 @@ var tryGet = function (it, key) {
1550
1591
  };
1551
1592
 
1552
1593
  // getting tag from ES6+ `Object.prototype.toString`
1553
- var classof$5 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
1594
+ var classof$3 = TO_STRING_TAG_SUPPORT ? classofRaw$1 : function (it) {
1554
1595
  var O, tag, result;
1555
1596
  return it === undefined ? 'Undefined' : it === null ? 'Null'
1556
1597
  // @@toStringTag case
1557
- : typeof (tag = tryGet(O = Object$1(it), TO_STRING_TAG)) == 'string' ? tag
1598
+ : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
1558
1599
  // builtinTag case
1559
- : CORRECT_ARGUMENTS ? classofRaw(O)
1600
+ : CORRECT_ARGUMENTS ? classofRaw$1(O)
1560
1601
  // ES3 arguments fallback
1561
- : (result = classofRaw(O)) == 'Object' && isCallable$5(O.callee) ? 'Arguments' : result;
1602
+ : (result = classofRaw$1(O)) === 'Object' && isCallable$1(O.callee) ? 'Arguments' : result;
1603
+ };
1604
+
1605
+ var classof$2 = classof$3;
1606
+
1607
+ var $String = String;
1608
+
1609
+ var toString$4 = function (argument) {
1610
+ if (classof$2(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
1611
+ return $String(argument);
1612
+ };
1613
+
1614
+ var anObject$2 = anObject$7;
1615
+
1616
+ // `RegExp.prototype.flags` getter implementation
1617
+ // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
1618
+ var regexpFlags$1 = function () {
1619
+ var that = anObject$2(this);
1620
+ var result = '';
1621
+ if (that.hasIndices) result += 'd';
1622
+ if (that.global) result += 'g';
1623
+ if (that.ignoreCase) result += 'i';
1624
+ if (that.multiline) result += 'm';
1625
+ if (that.dotAll) result += 's';
1626
+ if (that.unicode) result += 'u';
1627
+ if (that.unicodeSets) result += 'v';
1628
+ if (that.sticky) result += 'y';
1629
+ return result;
1630
+ };
1631
+
1632
+ var call$2 = functionCall;
1633
+ var hasOwn = hasOwnProperty_1;
1634
+ var isPrototypeOf = objectIsPrototypeOf;
1635
+ var regExpFlags = regexpFlags$1;
1636
+
1637
+ var RegExpPrototype$1 = RegExp.prototype;
1638
+
1639
+ var regexpGetFlags = function (R) {
1640
+ var flags = R.flags;
1641
+ return flags === undefined && !('flags' in RegExpPrototype$1) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype$1, R)
1642
+ ? call$2(regExpFlags, R) : flags;
1643
+ };
1644
+
1645
+ var PROPER_FUNCTION_NAME = functionName.PROPER;
1646
+ var defineBuiltIn = defineBuiltIn$4;
1647
+ var anObject$1 = anObject$7;
1648
+ var $toString = toString$4;
1649
+ var fails$4 = fails$h;
1650
+ var getRegExpFlags = regexpGetFlags;
1651
+
1652
+ var TO_STRING = 'toString';
1653
+ var RegExpPrototype = RegExp.prototype;
1654
+ var nativeToString = RegExpPrototype[TO_STRING];
1655
+
1656
+ var NOT_GENERIC = fails$4(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
1657
+ // FF44- RegExp#toString has a wrong name
1658
+ var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING;
1659
+
1660
+ // `RegExp.prototype.toString` method
1661
+ // https://tc39.es/ecma262/#sec-regexp.prototype.tostring
1662
+ if (NOT_GENERIC || INCORRECT_NAME) {
1663
+ defineBuiltIn(RegExpPrototype, TO_STRING, function toString() {
1664
+ var R = anObject$1(this);
1665
+ var pattern = $toString(R.source);
1666
+ var flags = $toString(getRegExpFlags(R));
1667
+ return '/' + pattern + '/' + flags;
1668
+ }, { unsafe: true });
1669
+ }
1670
+
1671
+ var isObject = isObject$9;
1672
+ var classof$1 = classofRaw$2;
1673
+ var wellKnownSymbol$2 = wellKnownSymbol$a;
1674
+
1675
+ var MATCH$1 = wellKnownSymbol$2('match');
1676
+
1677
+ // `IsRegExp` abstract operation
1678
+ // https://tc39.es/ecma262/#sec-isregexp
1679
+ var isRegexp = function (it) {
1680
+ var isRegExp;
1681
+ return isObject(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$1(it) === 'RegExp');
1562
1682
  };
1563
1683
 
1564
- var global$g = global$G;
1565
- var classof$4 = classof$5;
1684
+ var isRegExp = isRegexp;
1566
1685
 
1567
- var String$2 = global$g.String;
1686
+ var $TypeError$2 = TypeError;
1568
1687
 
1569
- var toString$5 = function (argument) {
1570
- if (classof$4(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
1571
- return String$2(argument);
1688
+ var notARegexp = function (it) {
1689
+ if (isRegExp(it)) {
1690
+ throw new $TypeError$2("The method doesn't accept regular expressions");
1691
+ } return it;
1572
1692
  };
1573
1693
 
1574
- var wellKnownSymbol$8 = wellKnownSymbol$i;
1694
+ var wellKnownSymbol$1 = wellKnownSymbol$a;
1575
1695
 
1576
- var MATCH = wellKnownSymbol$8('match');
1696
+ var MATCH = wellKnownSymbol$1('match');
1577
1697
 
1578
1698
  var correctIsRegexpLogic = function (METHOD_NAME) {
1579
1699
  var regexp = /./;
@@ -1588,139 +1708,107 @@ var correctIsRegexpLogic = function (METHOD_NAME) {
1588
1708
  };
1589
1709
 
1590
1710
  var $$4 = _export;
1591
- var uncurryThis$b = functionUncurryThis;
1711
+ var uncurryThis$3 = functionUncurryThis;
1592
1712
  var notARegExp$1 = notARegexp;
1593
- var requireObjectCoercible$3 = requireObjectCoercible$6;
1594
- var toString$4 = toString$5;
1713
+ var requireObjectCoercible$1 = requireObjectCoercible$5;
1714
+ var toString$3 = toString$4;
1595
1715
  var correctIsRegExpLogic$1 = correctIsRegexpLogic;
1596
1716
 
1597
- var stringIndexOf$1 = uncurryThis$b(''.indexOf);
1717
+ var stringIndexOf = uncurryThis$3(''.indexOf);
1598
1718
 
1599
1719
  // `String.prototype.includes` method
1600
1720
  // https://tc39.es/ecma262/#sec-string.prototype.includes
1601
1721
  $$4({ target: 'String', proto: true, forced: !correctIsRegExpLogic$1('includes') }, {
1602
1722
  includes: function includes(searchString /* , position = 0 */) {
1603
- return !!~stringIndexOf$1(
1604
- toString$4(requireObjectCoercible$3(this)),
1605
- toString$4(notARegExp$1(searchString)),
1723
+ return !!~stringIndexOf(
1724
+ toString$3(requireObjectCoercible$1(this)),
1725
+ toString$3(notARegExp$1(searchString)),
1606
1726
  arguments.length > 1 ? arguments[1] : undefined
1607
1727
  );
1608
1728
  }
1609
1729
  });
1610
1730
 
1611
- var DESCRIPTORS$1 = descriptors;
1612
- var uncurryThis$a = functionUncurryThis;
1613
- var call$8 = functionCall;
1614
- var fails$8 = fails$i;
1615
- var objectKeys = objectKeys$2;
1616
- var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
1617
- var propertyIsEnumerableModule = objectPropertyIsEnumerable;
1618
- var toObject$1 = toObject$4;
1619
- var IndexedObject = indexedObject;
1620
-
1621
- // eslint-disable-next-line es/no-object-assign -- safe
1622
- var $assign = Object.assign;
1623
- // eslint-disable-next-line es/no-object-defineproperty -- required for testing
1624
- var defineProperty = Object.defineProperty;
1625
- var concat$1 = uncurryThis$a([].concat);
1626
-
1627
- // `Object.assign` method
1628
- // https://tc39.es/ecma262/#sec-object.assign
1629
- var objectAssign = !$assign || fails$8(function () {
1630
- // should have correct order of operations (Edge bug)
1631
- if (DESCRIPTORS$1 && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
1632
- enumerable: true,
1633
- get: function () {
1634
- defineProperty(this, 'b', {
1635
- value: 3,
1636
- enumerable: false
1637
- });
1638
- }
1639
- }), { b: 2 })).b !== 1) return true;
1640
- // should work with symbols and should have deterministic property order (V8 bug)
1641
- var A = {};
1642
- var B = {};
1643
- // eslint-disable-next-line es/no-symbol -- safe
1644
- var symbol = Symbol();
1645
- var alphabet = 'abcdefghijklmnopqrst';
1646
- A[symbol] = 7;
1647
- alphabet.split('').forEach(function (chr) { B[chr] = chr; });
1648
- return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;
1649
- }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
1650
- var T = toObject$1(target);
1651
- var argumentsLength = arguments.length;
1652
- var index = 1;
1653
- var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
1654
- var propertyIsEnumerable = propertyIsEnumerableModule.f;
1655
- while (argumentsLength > index) {
1656
- var S = IndexedObject(arguments[index++]);
1657
- var keys = getOwnPropertySymbols ? concat$1(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
1658
- var length = keys.length;
1659
- var j = 0;
1660
- var key;
1661
- while (length > j) {
1662
- key = keys[j++];
1663
- if (!DESCRIPTORS$1 || call$8(propertyIsEnumerable, S, key)) T[key] = S[key];
1664
- }
1665
- } return T;
1666
- } : $assign;
1667
-
1668
- var $$3 = _export;
1669
- var assign = objectAssign;
1670
-
1671
- // `Object.assign` method
1672
- // https://tc39.es/ecma262/#sec-object.assign
1673
- // eslint-disable-next-line es/no-object-assign -- required for testing
1674
- $$3({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
1675
- assign: assign
1676
- });
1731
+ // iterable DOM collections
1732
+ // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
1733
+ var domIterables = {
1734
+ CSSRuleList: 0,
1735
+ CSSStyleDeclaration: 0,
1736
+ CSSValueList: 0,
1737
+ ClientRectList: 0,
1738
+ DOMRectList: 0,
1739
+ DOMStringList: 0,
1740
+ DOMTokenList: 1,
1741
+ DataTransferItemList: 0,
1742
+ FileList: 0,
1743
+ HTMLAllCollection: 0,
1744
+ HTMLCollection: 0,
1745
+ HTMLFormElement: 0,
1746
+ HTMLSelectElement: 0,
1747
+ MediaList: 0,
1748
+ MimeTypeArray: 0,
1749
+ NamedNodeMap: 0,
1750
+ NodeList: 1,
1751
+ PaintRequestList: 0,
1752
+ Plugin: 0,
1753
+ PluginArray: 0,
1754
+ SVGLengthList: 0,
1755
+ SVGNumberList: 0,
1756
+ SVGPathSegList: 0,
1757
+ SVGPointList: 0,
1758
+ SVGStringList: 0,
1759
+ SVGTransformList: 0,
1760
+ SourceBufferList: 0,
1761
+ StyleSheetList: 0,
1762
+ TextTrackCueList: 0,
1763
+ TextTrackList: 0,
1764
+ TouchList: 0
1765
+ };
1677
1766
 
1678
- var anObject$8 = anObject$e;
1767
+ // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
1768
+ var documentCreateElement = documentCreateElement$2;
1679
1769
 
1680
- // `RegExp.prototype.flags` getter implementation
1681
- // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
1682
- var regexpFlags$1 = function () {
1683
- var that = anObject$8(this);
1684
- var result = '';
1685
- if (that.global) result += 'g';
1686
- if (that.ignoreCase) result += 'i';
1687
- if (that.multiline) result += 'm';
1688
- if (that.dotAll) result += 's';
1689
- if (that.unicode) result += 'u';
1690
- if (that.sticky) result += 'y';
1691
- return result;
1692
- };
1770
+ var classList = documentCreateElement('span').classList;
1771
+ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
1693
1772
 
1694
- var uncurryThis$9 = functionUncurryThis;
1695
- var PROPER_FUNCTION_NAME = functionName.PROPER;
1696
- var redefine$3 = redefine$7.exports;
1697
- var anObject$7 = anObject$e;
1698
- var isPrototypeOf$2 = objectIsPrototypeOf;
1699
- var $toString = toString$5;
1700
- var fails$7 = fails$i;
1701
- var regExpFlags = regexpFlags$1;
1773
+ var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
1702
1774
 
1703
- var TO_STRING = 'toString';
1704
- var RegExpPrototype$1 = RegExp.prototype;
1705
- var n$ToString = RegExpPrototype$1[TO_STRING];
1706
- var getFlags = uncurryThis$9(regExpFlags);
1775
+ var global$4 = global$e;
1776
+ var DOMIterables = domIterables;
1777
+ var DOMTokenListPrototype = domTokenListPrototype;
1778
+ var ArrayIteratorMethods = es_array_iterator;
1779
+ var createNonEnumerableProperty = createNonEnumerableProperty$4;
1780
+ var setToStringTag = setToStringTag$3;
1781
+ var wellKnownSymbol = wellKnownSymbol$a;
1707
1782
 
1708
- var NOT_GENERIC = fails$7(function () { return n$ToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
1709
- // FF44- RegExp#toString has a wrong name
1710
- var INCORRECT_NAME = PROPER_FUNCTION_NAME && n$ToString.name != TO_STRING;
1783
+ var ITERATOR = wellKnownSymbol('iterator');
1784
+ var ArrayValues = ArrayIteratorMethods.values;
1711
1785
 
1712
- // `RegExp.prototype.toString` method
1713
- // https://tc39.es/ecma262/#sec-regexp.prototype.tostring
1714
- if (NOT_GENERIC || INCORRECT_NAME) {
1715
- redefine$3(RegExp.prototype, TO_STRING, function toString() {
1716
- var R = anObject$7(this);
1717
- var p = $toString(R.source);
1718
- var rf = R.flags;
1719
- var f = $toString(rf === undefined && isPrototypeOf$2(RegExpPrototype$1, R) && !('flags' in RegExpPrototype$1) ? getFlags(R) : rf);
1720
- return '/' + p + '/' + f;
1721
- }, { unsafe: true });
1786
+ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
1787
+ if (CollectionPrototype) {
1788
+ // some Chrome versions have non-configurable methods on DOMTokenList
1789
+ if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
1790
+ createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
1791
+ } catch (error) {
1792
+ CollectionPrototype[ITERATOR] = ArrayValues;
1793
+ }
1794
+ setToStringTag(CollectionPrototype, COLLECTION_NAME, true);
1795
+ if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
1796
+ // some Chrome versions have non-configurable methods on DOMTokenList
1797
+ if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
1798
+ createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
1799
+ } catch (error) {
1800
+ CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
1801
+ }
1802
+ }
1803
+ }
1804
+ };
1805
+
1806
+ for (var COLLECTION_NAME in DOMIterables) {
1807
+ handlePrototype(global$4[COLLECTION_NAME] && global$4[COLLECTION_NAME].prototype, COLLECTION_NAME);
1722
1808
  }
1723
1809
 
1810
+ handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
1811
+
1724
1812
  var KeyboardLayoutName;
1725
1813
  (function (KeyboardLayoutName) {
1726
1814
  KeyboardLayoutName["DEFAULT"] = "default";
@@ -1986,1091 +2074,204 @@ function setInputValue(inputElement, inputValue, caretPosition) {
1986
2074
  // The input caret position doesn't stay in sync after setting the value programmatically, so we set it
1987
2075
  inputElement.setSelectionRange(caretPosition, caretPosition);
1988
2076
  inputElement.dispatchEvent(new Event("input")); // Some jQuery handlers use on("input", handler)
1989
- inputElement.dispatchEvent(new Event("input", {
1990
- bubbles: true
1991
- })); // Used by React onChange handlers
1992
- }
1993
- function toggleLayout(keyboardLayoutName) {
1994
- return keyboardLayoutName === KeyboardLayoutName.DEFAULT ? KeyboardLayoutName.SHIFT : KeyboardLayoutName.DEFAULT;
1995
- }
1996
- function isTextSelected(inputElement) {
1997
- if (typeof inputElement.selectionStart == "number") {
1998
- return inputElement.selectionStart === 0 && inputElement.selectionEnd === inputElement.value.length;
1999
- } else if (typeof window.getSelection != "undefined") {
2000
- const selection = window.getSelection();
2001
- return (selection === null || selection === void 0 ? void 0 : selection.toString()) === inputElement.value;
2002
- }
2003
- }
2004
-
2005
- var $$2 = _export;
2006
- var uncurryThis$8 = functionUncurryThis;
2007
- var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
2008
- var toLength$1 = toLength$3;
2009
- var toString$3 = toString$5;
2010
- var notARegExp = notARegexp;
2011
- var requireObjectCoercible$2 = requireObjectCoercible$6;
2012
- var correctIsRegExpLogic = correctIsRegexpLogic;
2013
-
2014
- // eslint-disable-next-line es/no-string-prototype-startswith -- safe
2015
- var un$StartsWith = uncurryThis$8(''.startsWith);
2016
- var stringSlice$4 = uncurryThis$8(''.slice);
2017
- var min$1 = Math.min;
2018
-
2019
- var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
2020
- // https://github.com/zloirock/core-js/pull/702
2021
- var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () {
2022
- var descriptor = getOwnPropertyDescriptor$1(String.prototype, 'startsWith');
2023
- return descriptor && !descriptor.writable;
2024
- }();
2025
-
2026
- // `String.prototype.startsWith` method
2027
- // https://tc39.es/ecma262/#sec-string.prototype.startswith
2028
- $$2({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
2029
- startsWith: function startsWith(searchString /* , position = 0 */) {
2030
- var that = toString$3(requireObjectCoercible$2(this));
2031
- notARegExp(searchString);
2032
- var index = toLength$1(min$1(arguments.length > 1 ? arguments[1] : undefined, that.length));
2033
- var search = toString$3(searchString);
2034
- return un$StartsWith
2035
- ? un$StartsWith(that, search, index)
2036
- : stringSlice$4(that, index, index + search.length) === search;
2037
- }
2038
- });
2039
-
2040
- var global$f = global$G;
2041
-
2042
- var nativePromiseConstructor = global$f.Promise;
2043
-
2044
- var redefine$2 = redefine$7.exports;
2045
-
2046
- var redefineAll$1 = function (target, src, options) {
2047
- for (var key in src) redefine$2(target, key, src[key], options);
2048
- return target;
2049
- };
2050
-
2051
- var getBuiltIn$2 = getBuiltIn$7;
2052
- var definePropertyModule = objectDefineProperty;
2053
- var wellKnownSymbol$7 = wellKnownSymbol$i;
2054
- var DESCRIPTORS = descriptors;
2055
-
2056
- var SPECIES$3 = wellKnownSymbol$7('species');
2057
-
2058
- var setSpecies$1 = function (CONSTRUCTOR_NAME) {
2059
- var Constructor = getBuiltIn$2(CONSTRUCTOR_NAME);
2060
- var defineProperty = definePropertyModule.f;
2061
-
2062
- if (DESCRIPTORS && Constructor && !Constructor[SPECIES$3]) {
2063
- defineProperty(Constructor, SPECIES$3, {
2064
- configurable: true,
2065
- get: function () { return this; }
2066
- });
2067
- }
2068
- };
2069
-
2070
- var global$e = global$G;
2071
- var isPrototypeOf$1 = objectIsPrototypeOf;
2072
-
2073
- var TypeError$6 = global$e.TypeError;
2074
-
2075
- var anInstance$1 = function (it, Prototype) {
2076
- if (isPrototypeOf$1(Prototype, it)) return it;
2077
- throw TypeError$6('Incorrect invocation');
2078
- };
2079
-
2080
- var uncurryThis$7 = functionUncurryThis;
2081
- var aCallable$3 = aCallable$5;
2082
- var NATIVE_BIND$1 = functionBindNative;
2083
-
2084
- var bind$4 = uncurryThis$7(uncurryThis$7.bind);
2085
-
2086
- // optional / simple context binding
2087
- var functionBindContext = function (fn, that) {
2088
- aCallable$3(fn);
2089
- return that === undefined ? fn : NATIVE_BIND$1 ? bind$4(fn, that) : function (/* ...args */) {
2090
- return fn.apply(that, arguments);
2091
- };
2092
- };
2093
-
2094
- var wellKnownSymbol$6 = wellKnownSymbol$i;
2095
- var Iterators$1 = iterators;
2096
-
2097
- var ITERATOR$2 = wellKnownSymbol$6('iterator');
2098
- var ArrayPrototype = Array.prototype;
2099
-
2100
- // check on default Array iterator
2101
- var isArrayIteratorMethod$1 = function (it) {
2102
- return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it);
2103
- };
2104
-
2105
- var classof$3 = classof$5;
2106
- var getMethod$2 = getMethod$4;
2107
- var Iterators = iterators;
2108
- var wellKnownSymbol$5 = wellKnownSymbol$i;
2109
-
2110
- var ITERATOR$1 = wellKnownSymbol$5('iterator');
2111
-
2112
- var getIteratorMethod$2 = function (it) {
2113
- if (it != undefined) return getMethod$2(it, ITERATOR$1)
2114
- || getMethod$2(it, '@@iterator')
2115
- || Iterators[classof$3(it)];
2116
- };
2117
-
2118
- var global$d = global$G;
2119
- var call$7 = functionCall;
2120
- var aCallable$2 = aCallable$5;
2121
- var anObject$6 = anObject$e;
2122
- var tryToString$2 = tryToString$4;
2123
- var getIteratorMethod$1 = getIteratorMethod$2;
2124
-
2125
- var TypeError$5 = global$d.TypeError;
2126
-
2127
- var getIterator$1 = function (argument, usingIterator) {
2128
- var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
2129
- if (aCallable$2(iteratorMethod)) return anObject$6(call$7(iteratorMethod, argument));
2130
- throw TypeError$5(tryToString$2(argument) + ' is not iterable');
2131
- };
2132
-
2133
- var call$6 = functionCall;
2134
- var anObject$5 = anObject$e;
2135
- var getMethod$1 = getMethod$4;
2136
-
2137
- var iteratorClose$1 = function (iterator, kind, value) {
2138
- var innerResult, innerError;
2139
- anObject$5(iterator);
2140
- try {
2141
- innerResult = getMethod$1(iterator, 'return');
2142
- if (!innerResult) {
2143
- if (kind === 'throw') throw value;
2144
- return value;
2145
- }
2146
- innerResult = call$6(innerResult, iterator);
2147
- } catch (error) {
2148
- innerError = true;
2149
- innerResult = error;
2150
- }
2151
- if (kind === 'throw') throw value;
2152
- if (innerError) throw innerResult;
2153
- anObject$5(innerResult);
2154
- return value;
2155
- };
2156
-
2157
- var global$c = global$G;
2158
- var bind$3 = functionBindContext;
2159
- var call$5 = functionCall;
2160
- var anObject$4 = anObject$e;
2161
- var tryToString$1 = tryToString$4;
2162
- var isArrayIteratorMethod = isArrayIteratorMethod$1;
2163
- var lengthOfArrayLike = lengthOfArrayLike$2;
2164
- var isPrototypeOf = objectIsPrototypeOf;
2165
- var getIterator = getIterator$1;
2166
- var getIteratorMethod = getIteratorMethod$2;
2167
- var iteratorClose = iteratorClose$1;
2168
-
2169
- var TypeError$4 = global$c.TypeError;
2170
-
2171
- var Result = function (stopped, result) {
2172
- this.stopped = stopped;
2173
- this.result = result;
2174
- };
2175
-
2176
- var ResultPrototype = Result.prototype;
2177
-
2178
- var iterate$1 = function (iterable, unboundFunction, options) {
2179
- var that = options && options.that;
2180
- var AS_ENTRIES = !!(options && options.AS_ENTRIES);
2181
- var IS_ITERATOR = !!(options && options.IS_ITERATOR);
2182
- var INTERRUPTED = !!(options && options.INTERRUPTED);
2183
- var fn = bind$3(unboundFunction, that);
2184
- var iterator, iterFn, index, length, result, next, step;
2185
-
2186
- var stop = function (condition) {
2187
- if (iterator) iteratorClose(iterator, 'normal', condition);
2188
- return new Result(true, condition);
2189
- };
2190
-
2191
- var callFn = function (value) {
2192
- if (AS_ENTRIES) {
2193
- anObject$4(value);
2194
- return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
2195
- } return INTERRUPTED ? fn(value, stop) : fn(value);
2196
- };
2197
-
2198
- if (IS_ITERATOR) {
2199
- iterator = iterable;
2200
- } else {
2201
- iterFn = getIteratorMethod(iterable);
2202
- if (!iterFn) throw TypeError$4(tryToString$1(iterable) + ' is not iterable');
2203
- // optimisation for array iterators
2204
- if (isArrayIteratorMethod(iterFn)) {
2205
- for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
2206
- result = callFn(iterable[index]);
2207
- if (result && isPrototypeOf(ResultPrototype, result)) return result;
2208
- } return new Result(false);
2209
- }
2210
- iterator = getIterator(iterable, iterFn);
2211
- }
2212
-
2213
- next = iterator.next;
2214
- while (!(step = call$5(next, iterator)).done) {
2215
- try {
2216
- result = callFn(step.value);
2217
- } catch (error) {
2218
- iteratorClose(iterator, 'throw', error);
2219
- }
2220
- if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
2221
- } return new Result(false);
2222
- };
2223
-
2224
- var wellKnownSymbol$4 = wellKnownSymbol$i;
2225
-
2226
- var ITERATOR = wellKnownSymbol$4('iterator');
2227
- var SAFE_CLOSING = false;
2228
-
2229
- try {
2230
- var called = 0;
2231
- var iteratorWithReturn = {
2232
- next: function () {
2233
- return { done: !!called++ };
2234
- },
2235
- 'return': function () {
2236
- SAFE_CLOSING = true;
2237
- }
2238
- };
2239
- iteratorWithReturn[ITERATOR] = function () {
2240
- return this;
2241
- };
2242
- // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
2243
- Array.from(iteratorWithReturn, function () { throw 2; });
2244
- } catch (error) { /* empty */ }
2245
-
2246
- var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
2247
- if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
2248
- var ITERATION_SUPPORT = false;
2249
- try {
2250
- var object = {};
2251
- object[ITERATOR] = function () {
2252
- return {
2253
- next: function () {
2254
- return { done: ITERATION_SUPPORT = true };
2255
- }
2256
- };
2257
- };
2258
- exec(object);
2259
- } catch (error) { /* empty */ }
2260
- return ITERATION_SUPPORT;
2261
- };
2262
-
2263
- var uncurryThis$6 = functionUncurryThis;
2264
- var fails$6 = fails$i;
2265
- var isCallable$4 = isCallable$j;
2266
- var classof$2 = classof$5;
2267
- var getBuiltIn$1 = getBuiltIn$7;
2268
- var inspectSource$1 = inspectSource$4;
2269
-
2270
- var noop = function () { /* empty */ };
2271
- var empty = [];
2272
- var construct = getBuiltIn$1('Reflect', 'construct');
2273
- var constructorRegExp = /^\s*(?:class|function)\b/;
2274
- var exec$1 = uncurryThis$6(constructorRegExp.exec);
2275
- var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
2276
-
2277
- var isConstructorModern = function isConstructor(argument) {
2278
- if (!isCallable$4(argument)) return false;
2279
- try {
2280
- construct(noop, empty, argument);
2281
- return true;
2282
- } catch (error) {
2283
- return false;
2284
- }
2285
- };
2286
-
2287
- var isConstructorLegacy = function isConstructor(argument) {
2288
- if (!isCallable$4(argument)) return false;
2289
- switch (classof$2(argument)) {
2290
- case 'AsyncFunction':
2291
- case 'GeneratorFunction':
2292
- case 'AsyncGeneratorFunction': return false;
2293
- }
2294
- try {
2295
- // we can't check .prototype since constructors produced by .bind haven't it
2296
- // `Function#toString` throws on some built-it function in some legacy engines
2297
- // (for example, `DOMQuad` and similar in FF41-)
2298
- return INCORRECT_TO_STRING || !!exec$1(constructorRegExp, inspectSource$1(argument));
2299
- } catch (error) {
2300
- return true;
2301
- }
2302
- };
2303
-
2304
- isConstructorLegacy.sham = true;
2305
-
2306
- // `IsConstructor` abstract operation
2307
- // https://tc39.es/ecma262/#sec-isconstructor
2308
- var isConstructor$1 = !construct || fails$6(function () {
2309
- var called;
2310
- return isConstructorModern(isConstructorModern.call)
2311
- || !isConstructorModern(Object)
2312
- || !isConstructorModern(function () { called = true; })
2313
- || called;
2314
- }) ? isConstructorLegacy : isConstructorModern;
2315
-
2316
- var global$b = global$G;
2317
- var isConstructor = isConstructor$1;
2318
- var tryToString = tryToString$4;
2319
-
2320
- var TypeError$3 = global$b.TypeError;
2321
-
2322
- // `Assert: IsConstructor(argument) is true`
2323
- var aConstructor$1 = function (argument) {
2324
- if (isConstructor(argument)) return argument;
2325
- throw TypeError$3(tryToString(argument) + ' is not a constructor');
2326
- };
2327
-
2328
- var anObject$3 = anObject$e;
2329
- var aConstructor = aConstructor$1;
2330
- var wellKnownSymbol$3 = wellKnownSymbol$i;
2331
-
2332
- var SPECIES$2 = wellKnownSymbol$3('species');
2333
-
2334
- // `SpeciesConstructor` abstract operation
2335
- // https://tc39.es/ecma262/#sec-speciesconstructor
2336
- var speciesConstructor$1 = function (O, defaultConstructor) {
2337
- var C = anObject$3(O).constructor;
2338
- var S;
2339
- return C === undefined || (S = anObject$3(C)[SPECIES$2]) == undefined ? defaultConstructor : aConstructor(S);
2340
- };
2341
-
2342
- var NATIVE_BIND = functionBindNative;
2343
-
2344
- var FunctionPrototype = Function.prototype;
2345
- var apply$2 = FunctionPrototype.apply;
2346
- var call$4 = FunctionPrototype.call;
2347
-
2348
- // eslint-disable-next-line es/no-reflect -- safe
2349
- var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$4.bind(apply$2) : function () {
2350
- return call$4.apply(apply$2, arguments);
2351
- });
2352
-
2353
- var uncurryThis$5 = functionUncurryThis;
2354
-
2355
- var arraySlice$1 = uncurryThis$5([].slice);
2356
-
2357
- var userAgent$2 = engineUserAgent;
2358
-
2359
- var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
2360
-
2361
- var classof$1 = classofRaw$1;
2362
- var global$a = global$G;
2363
-
2364
- var engineIsNode = classof$1(global$a.process) == 'process';
2365
-
2366
- var global$9 = global$G;
2367
- var apply$1 = functionApply;
2368
- var bind$2 = functionBindContext;
2369
- var isCallable$3 = isCallable$j;
2370
- var hasOwn = hasOwnProperty_1;
2371
- var fails$5 = fails$i;
2372
- var html = html$2;
2373
- var arraySlice = arraySlice$1;
2374
- var createElement = documentCreateElement$2;
2375
- var IS_IOS$1 = engineIsIos;
2376
- var IS_NODE$2 = engineIsNode;
2377
-
2378
- var set = global$9.setImmediate;
2379
- var clear = global$9.clearImmediate;
2380
- var process$2 = global$9.process;
2381
- var Dispatch = global$9.Dispatch;
2382
- var Function$1 = global$9.Function;
2383
- var MessageChannel = global$9.MessageChannel;
2384
- var String$1 = global$9.String;
2385
- var counter = 0;
2386
- var queue$1 = {};
2387
- var ONREADYSTATECHANGE = 'onreadystatechange';
2388
- var location, defer, channel, port;
2389
-
2390
- try {
2391
- // Deno throws a ReferenceError on `location` access without `--location` flag
2392
- location = global$9.location;
2393
- } catch (error) { /* empty */ }
2394
-
2395
- var run = function (id) {
2396
- if (hasOwn(queue$1, id)) {
2397
- var fn = queue$1[id];
2398
- delete queue$1[id];
2399
- fn();
2400
- }
2401
- };
2402
-
2403
- var runner = function (id) {
2404
- return function () {
2405
- run(id);
2406
- };
2407
- };
2408
-
2409
- var listener = function (event) {
2410
- run(event.data);
2411
- };
2412
-
2413
- var post = function (id) {
2414
- // old engines have not location.origin
2415
- global$9.postMessage(String$1(id), location.protocol + '//' + location.host);
2416
- };
2417
-
2418
- // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
2419
- if (!set || !clear) {
2420
- set = function setImmediate(fn) {
2421
- var args = arraySlice(arguments, 1);
2422
- queue$1[++counter] = function () {
2423
- apply$1(isCallable$3(fn) ? fn : Function$1(fn), undefined, args);
2424
- };
2425
- defer(counter);
2426
- return counter;
2427
- };
2428
- clear = function clearImmediate(id) {
2429
- delete queue$1[id];
2430
- };
2431
- // Node.js 0.8-
2432
- if (IS_NODE$2) {
2433
- defer = function (id) {
2434
- process$2.nextTick(runner(id));
2435
- };
2436
- // Sphere (JS game engine) Dispatch API
2437
- } else if (Dispatch && Dispatch.now) {
2438
- defer = function (id) {
2439
- Dispatch.now(runner(id));
2440
- };
2441
- // Browsers with MessageChannel, includes WebWorkers
2442
- // except iOS - https://github.com/zloirock/core-js/issues/624
2443
- } else if (MessageChannel && !IS_IOS$1) {
2444
- channel = new MessageChannel();
2445
- port = channel.port2;
2446
- channel.port1.onmessage = listener;
2447
- defer = bind$2(port.postMessage, port);
2448
- // Browsers with postMessage, skip WebWorkers
2449
- // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
2450
- } else if (
2451
- global$9.addEventListener &&
2452
- isCallable$3(global$9.postMessage) &&
2453
- !global$9.importScripts &&
2454
- location && location.protocol !== 'file:' &&
2455
- !fails$5(post)
2456
- ) {
2457
- defer = post;
2458
- global$9.addEventListener('message', listener, false);
2459
- // IE8-
2460
- } else if (ONREADYSTATECHANGE in createElement('script')) {
2461
- defer = function (id) {
2462
- html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
2463
- html.removeChild(this);
2464
- run(id);
2465
- };
2466
- };
2467
- // Rest old browsers
2468
- } else {
2469
- defer = function (id) {
2470
- setTimeout(runner(id), 0);
2471
- };
2472
- }
2473
- }
2474
-
2475
- var task$1 = {
2476
- set: set,
2477
- clear: clear
2478
- };
2479
-
2480
- var userAgent$1 = engineUserAgent;
2481
- var global$8 = global$G;
2482
-
2483
- var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$8.Pebble !== undefined;
2484
-
2485
- var userAgent = engineUserAgent;
2486
-
2487
- var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
2488
-
2489
- var global$7 = global$G;
2490
- var bind$1 = functionBindContext;
2491
- var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
2492
- var macrotask = task$1.set;
2493
- var IS_IOS = engineIsIos;
2494
- var IS_IOS_PEBBLE = engineIsIosPebble;
2495
- var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
2496
- var IS_NODE$1 = engineIsNode;
2497
-
2498
- var MutationObserver = global$7.MutationObserver || global$7.WebKitMutationObserver;
2499
- var document$2 = global$7.document;
2500
- var process$1 = global$7.process;
2501
- var Promise$1 = global$7.Promise;
2502
- // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
2503
- var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$7, 'queueMicrotask');
2504
- var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
2505
-
2506
- var flush, head, last, notify$1, toggle, node, promise, then;
2507
-
2508
- // modern engines have queueMicrotask method
2509
- if (!queueMicrotask) {
2510
- flush = function () {
2511
- var parent, fn;
2512
- if (IS_NODE$1 && (parent = process$1.domain)) parent.exit();
2513
- while (head) {
2514
- fn = head.fn;
2515
- head = head.next;
2516
- try {
2517
- fn();
2518
- } catch (error) {
2519
- if (head) notify$1();
2520
- else last = undefined;
2521
- throw error;
2522
- }
2523
- } last = undefined;
2524
- if (parent) parent.enter();
2525
- };
2526
-
2527
- // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
2528
- // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
2529
- if (!IS_IOS && !IS_NODE$1 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
2530
- toggle = true;
2531
- node = document$2.createTextNode('');
2532
- new MutationObserver(flush).observe(node, { characterData: true });
2533
- notify$1 = function () {
2534
- node.data = toggle = !toggle;
2535
- };
2536
- // environments with maybe non-completely correct, but existent Promise
2537
- } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) {
2538
- // Promise.resolve without an argument throws an error in LG WebOS 2
2539
- promise = Promise$1.resolve(undefined);
2540
- // workaround of WebKit ~ iOS Safari 10.1 bug
2541
- promise.constructor = Promise$1;
2542
- then = bind$1(promise.then, promise);
2543
- notify$1 = function () {
2544
- then(flush);
2545
- };
2546
- // Node.js without promises
2547
- } else if (IS_NODE$1) {
2548
- notify$1 = function () {
2549
- process$1.nextTick(flush);
2550
- };
2551
- // for other environments - macrotask based on:
2552
- // - setImmediate
2553
- // - MessageChannel
2554
- // - window.postMessag
2555
- // - onreadystatechange
2556
- // - setTimeout
2557
- } else {
2558
- // strange IE + webpack dev server bug - use .bind(global)
2559
- macrotask = bind$1(macrotask, global$7);
2560
- notify$1 = function () {
2561
- macrotask(flush);
2562
- };
2077
+ inputElement.dispatchEvent(new Event("input", {
2078
+ bubbles: true
2079
+ })); // Used by React onChange handlers
2080
+ }
2081
+ function toggleLayout(keyboardLayoutName) {
2082
+ return keyboardLayoutName === KeyboardLayoutName.DEFAULT ? KeyboardLayoutName.SHIFT : KeyboardLayoutName.DEFAULT;
2083
+ }
2084
+ function isTextSelected(inputElement) {
2085
+ if (typeof inputElement.selectionStart == "number") {
2086
+ return inputElement.selectionStart === 0 && inputElement.selectionEnd === inputElement.value.length;
2087
+ } else if (typeof window.getSelection != "undefined") {
2088
+ const selection = window.getSelection();
2089
+ return (selection === null || selection === void 0 ? void 0 : selection.toString()) === inputElement.value;
2563
2090
  }
2564
2091
  }
2565
2092
 
2566
- var microtask$1 = queueMicrotask || function (fn) {
2567
- var task = { fn: fn, next: undefined };
2568
- if (last) last.next = task;
2569
- if (!head) {
2570
- head = task;
2571
- notify$1();
2572
- } last = task;
2573
- };
2574
-
2575
- var newPromiseCapability$2 = {};
2576
-
2577
- var aCallable$1 = aCallable$5;
2578
-
2579
- var PromiseCapability = function (C) {
2580
- var resolve, reject;
2581
- this.promise = new C(function ($$resolve, $$reject) {
2582
- if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
2583
- resolve = $$resolve;
2584
- reject = $$reject;
2585
- });
2586
- this.resolve = aCallable$1(resolve);
2587
- this.reject = aCallable$1(reject);
2588
- };
2093
+ var classofRaw = classofRaw$2;
2094
+ var uncurryThis$2 = functionUncurryThis;
2589
2095
 
2590
- // `NewPromiseCapability` abstract operation
2591
- // https://tc39.es/ecma262/#sec-newpromisecapability
2592
- newPromiseCapability$2.f = function (C) {
2593
- return new PromiseCapability(C);
2096
+ var functionUncurryThisClause = function (fn) {
2097
+ // Nashorn bug:
2098
+ // https://github.com/zloirock/core-js/issues/1128
2099
+ // https://github.com/zloirock/core-js/issues/1130
2100
+ if (classofRaw(fn) === 'Function') return uncurryThis$2(fn);
2594
2101
  };
2595
2102
 
2596
- var anObject$2 = anObject$e;
2597
- var isObject$1 = isObject$8;
2598
- var newPromiseCapability$1 = newPromiseCapability$2;
2599
-
2600
- var promiseResolve$1 = function (C, x) {
2601
- anObject$2(C);
2602
- if (isObject$1(x) && x.constructor === C) return x;
2603
- var promiseCapability = newPromiseCapability$1.f(C);
2604
- var resolve = promiseCapability.resolve;
2605
- resolve(x);
2606
- return promiseCapability.promise;
2607
- };
2103
+ var $$3 = _export;
2104
+ var uncurryThis$1 = functionUncurryThisClause;
2105
+ var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
2106
+ var toLength = toLength$2;
2107
+ var toString$2 = toString$4;
2108
+ var notARegExp = notARegexp;
2109
+ var requireObjectCoercible = requireObjectCoercible$5;
2110
+ var correctIsRegExpLogic = correctIsRegexpLogic;
2608
2111
 
2609
- var global$6 = global$G;
2112
+ var stringSlice$1 = uncurryThis$1(''.slice);
2113
+ var min = Math.min;
2610
2114
 
2611
- var hostReportErrors$1 = function (a, b) {
2612
- var console = global$6.console;
2613
- if (console && console.error) {
2614
- arguments.length == 1 ? console.error(a) : console.error(a, b);
2615
- }
2616
- };
2115
+ var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
2116
+ // https://github.com/zloirock/core-js/pull/702
2117
+ var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () {
2118
+ var descriptor = getOwnPropertyDescriptor$1(String.prototype, 'startsWith');
2119
+ return descriptor && !descriptor.writable;
2120
+ }();
2617
2121
 
2618
- var perform$1 = function (exec) {
2619
- try {
2620
- return { error: false, value: exec() };
2621
- } catch (error) {
2622
- return { error: true, value: error };
2122
+ // `String.prototype.startsWith` method
2123
+ // https://tc39.es/ecma262/#sec-string.prototype.startswith
2124
+ $$3({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
2125
+ startsWith: function startsWith(searchString /* , position = 0 */) {
2126
+ var that = toString$2(requireObjectCoercible(this));
2127
+ notARegExp(searchString);
2128
+ var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));
2129
+ var search = toString$2(searchString);
2130
+ return stringSlice$1(that, index, index + search.length) === search;
2623
2131
  }
2624
- };
2132
+ });
2625
2133
 
2626
- var Queue$1 = function () {
2627
- this.head = null;
2628
- this.tail = null;
2629
- };
2630
-
2631
- Queue$1.prototype = {
2632
- add: function (item) {
2633
- var entry = { item: item, next: null };
2634
- if (this.head) this.tail.next = entry;
2635
- else this.head = entry;
2636
- this.tail = entry;
2637
- },
2638
- get: function () {
2639
- var entry = this.head;
2640
- if (entry) {
2641
- this.head = entry.next;
2642
- if (this.tail === entry) this.tail = null;
2643
- return entry.item;
2644
- }
2645
- }
2134
+ /******************************************************************************
2135
+ Copyright (c) Microsoft Corporation.
2136
+
2137
+ Permission to use, copy, modify, and/or distribute this software for any
2138
+ purpose with or without fee is hereby granted.
2139
+
2140
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
2141
+ REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
2142
+ AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
2143
+ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
2144
+ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
2145
+ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
2146
+ PERFORMANCE OF THIS SOFTWARE.
2147
+ ***************************************************************************** */
2148
+ /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
2149
+
2150
+
2151
+ function __awaiter(thisArg, _arguments, P, generator) {
2152
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
2153
+ return new (P || (P = Promise))(function (resolve, reject) {
2154
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
2155
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
2156
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
2157
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
2158
+ });
2159
+ }
2160
+
2161
+ typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
2162
+ var e = new Error(message);
2163
+ return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
2646
2164
  };
2647
2165
 
2648
- var queue = Queue$1;
2649
-
2650
- var engineIsBrowser = typeof window == 'object';
2651
-
2652
- var $$1 = _export;
2653
- var global$5 = global$G;
2654
- var getBuiltIn = getBuiltIn$7;
2655
- var call$3 = functionCall;
2656
- var NativePromise = nativePromiseConstructor;
2657
- var redefine$1 = redefine$7.exports;
2658
- var redefineAll = redefineAll$1;
2659
- var setPrototypeOf = objectSetPrototypeOf;
2660
- var setToStringTag = setToStringTag$3;
2661
- var setSpecies = setSpecies$1;
2662
- var aCallable = aCallable$5;
2663
- var isCallable$2 = isCallable$j;
2664
- var isObject = isObject$8;
2665
- var anInstance = anInstance$1;
2666
- var inspectSource = inspectSource$4;
2667
- var iterate = iterate$1;
2668
- var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
2669
- var speciesConstructor = speciesConstructor$1;
2670
- var task = task$1.set;
2671
- var microtask = microtask$1;
2672
- var promiseResolve = promiseResolve$1;
2673
- var hostReportErrors = hostReportErrors$1;
2674
- var newPromiseCapabilityModule = newPromiseCapability$2;
2675
- var perform = perform$1;
2676
- var Queue = queue;
2677
- var InternalStateModule = internalState;
2678
- var isForced = isForced_1;
2679
- var wellKnownSymbol$2 = wellKnownSymbol$i;
2680
- var IS_BROWSER = engineIsBrowser;
2681
- var IS_NODE = engineIsNode;
2682
- var V8_VERSION = engineV8Version;
2683
-
2684
- var SPECIES$1 = wellKnownSymbol$2('species');
2685
- var PROMISE = 'Promise';
2166
+ var classof = classofRaw$2;
2686
2167
 
2687
- var getInternalState$1 = InternalStateModule.getterFor(PROMISE);
2688
- var setInternalState = InternalStateModule.set;
2689
- var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
2690
- var NativePromisePrototype = NativePromise && NativePromise.prototype;
2691
- var PromiseConstructor = NativePromise;
2692
- var PromisePrototype = NativePromisePrototype;
2693
- var TypeError$2 = global$5.TypeError;
2694
- var document$1 = global$5.document;
2695
- var process = global$5.process;
2696
- var newPromiseCapability = newPromiseCapabilityModule.f;
2697
- var newGenericPromiseCapability = newPromiseCapability;
2698
-
2699
- var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$5.dispatchEvent);
2700
- var NATIVE_REJECTION_EVENT = isCallable$2(global$5.PromiseRejectionEvent);
2701
- var UNHANDLED_REJECTION = 'unhandledrejection';
2702
- var REJECTION_HANDLED = 'rejectionhandled';
2703
- var PENDING = 0;
2704
- var FULFILLED = 1;
2705
- var REJECTED = 2;
2706
- var HANDLED = 1;
2707
- var UNHANDLED = 2;
2708
- var SUBCLASSING = false;
2709
-
2710
- var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
2711
-
2712
- var FORCED = isForced(PROMISE, function () {
2713
- var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);
2714
- var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);
2715
- // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
2716
- // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
2717
- // We can't detect it synchronously, so just check versions
2718
- if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
2719
- // We can't use @@species feature detection in V8 since it causes
2720
- // deoptimization and performance degradation
2721
- // https://github.com/zloirock/core-js/issues/679
2722
- if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;
2723
- // Detect correctness of subclassing with @@species support
2724
- var promise = new PromiseConstructor(function (resolve) { resolve(1); });
2725
- var FakePromise = function (exec) {
2726
- exec(function () { /* empty */ }, function () { /* empty */ });
2727
- };
2728
- var constructor = promise.constructor = {};
2729
- constructor[SPECIES$1] = FakePromise;
2730
- SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
2731
- if (!SUBCLASSING) return true;
2732
- // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
2733
- return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;
2734
- });
2168
+ // `IsArray` abstract operation
2169
+ // https://tc39.es/ecma262/#sec-isarray
2170
+ // eslint-disable-next-line es/no-array-isarray -- safe
2171
+ var isArray$1 = Array.isArray || function isArray(argument) {
2172
+ return classof(argument) === 'Array';
2173
+ };
2735
2174
 
2736
- var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
2737
- PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
2738
- });
2175
+ var DESCRIPTORS = descriptors;
2176
+ var isArray = isArray$1;
2739
2177
 
2740
- // helpers
2741
- var isThenable = function (it) {
2742
- var then;
2743
- return isObject(it) && isCallable$2(then = it.then) ? then : false;
2744
- };
2178
+ var $TypeError$1 = TypeError;
2179
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
2180
+ var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2745
2181
 
2746
- var callReaction = function (reaction, state) {
2747
- var value = state.value;
2748
- var ok = state.state == FULFILLED;
2749
- var handler = ok ? reaction.ok : reaction.fail;
2750
- var resolve = reaction.resolve;
2751
- var reject = reaction.reject;
2752
- var domain = reaction.domain;
2753
- var result, then, exited;
2182
+ // Safari < 13 does not throw an error in this case
2183
+ var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
2184
+ // makes no sense without proper strict mode support
2185
+ if (this !== undefined) return true;
2754
2186
  try {
2755
- if (handler) {
2756
- if (!ok) {
2757
- if (state.rejection === UNHANDLED) onHandleUnhandled(state);
2758
- state.rejection = HANDLED;
2759
- }
2760
- if (handler === true) result = value;
2761
- else {
2762
- if (domain) domain.enter();
2763
- result = handler(value); // can throw
2764
- if (domain) {
2765
- domain.exit();
2766
- exited = true;
2767
- }
2768
- }
2769
- if (result === reaction.promise) {
2770
- reject(TypeError$2('Promise-chain cycle'));
2771
- } else if (then = isThenable(result)) {
2772
- call$3(then, result, resolve, reject);
2773
- } else resolve(result);
2774
- } else reject(value);
2187
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
2188
+ Object.defineProperty([], 'length', { writable: false }).length = 1;
2775
2189
  } catch (error) {
2776
- if (domain && !exited) domain.exit();
2777
- reject(error);
2190
+ return error instanceof TypeError;
2778
2191
  }
2779
- };
2780
-
2781
- var notify = function (state, isReject) {
2782
- if (state.notified) return;
2783
- state.notified = true;
2784
- microtask(function () {
2785
- var reactions = state.reactions;
2786
- var reaction;
2787
- while (reaction = reactions.get()) {
2788
- callReaction(reaction, state);
2789
- }
2790
- state.notified = false;
2791
- if (isReject && !state.rejection) onUnhandled(state);
2792
- });
2793
- };
2192
+ }();
2794
2193
 
2795
- var dispatchEvent = function (name, promise, reason) {
2796
- var event, handler;
2797
- if (DISPATCH_EVENT) {
2798
- event = document$1.createEvent('Event');
2799
- event.promise = promise;
2800
- event.reason = reason;
2801
- event.initEvent(name, false, true);
2802
- global$5.dispatchEvent(event);
2803
- } else event = { promise: promise, reason: reason };
2804
- if (!NATIVE_REJECTION_EVENT && (handler = global$5['on' + name])) handler(event);
2805
- else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
2806
- };
2807
-
2808
- var onUnhandled = function (state) {
2809
- call$3(task, global$5, function () {
2810
- var promise = state.facade;
2811
- var value = state.value;
2812
- var IS_UNHANDLED = isUnhandled(state);
2813
- var result;
2814
- if (IS_UNHANDLED) {
2815
- result = perform(function () {
2816
- if (IS_NODE) {
2817
- process.emit('unhandledRejection', value, promise);
2818
- } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
2819
- });
2820
- // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
2821
- state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
2822
- if (result.error) throw result.value;
2823
- }
2824
- });
2194
+ var arraySetLength = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
2195
+ if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
2196
+ throw new $TypeError$1('Cannot set read only .length');
2197
+ } return O.length = length;
2198
+ } : function (O, length) {
2199
+ return O.length = length;
2825
2200
  };
2826
2201
 
2827
- var isUnhandled = function (state) {
2828
- return state.rejection !== HANDLED && !state.parent;
2829
- };
2202
+ var $TypeError = TypeError;
2203
+ var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
2830
2204
 
2831
- var onHandleUnhandled = function (state) {
2832
- call$3(task, global$5, function () {
2833
- var promise = state.facade;
2834
- if (IS_NODE) {
2835
- process.emit('rejectionHandled', promise);
2836
- } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
2837
- });
2205
+ var doesNotExceedSafeInteger$1 = function (it) {
2206
+ if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
2207
+ return it;
2838
2208
  };
2839
2209
 
2840
- var bind = function (fn, state, unwrap) {
2841
- return function (value) {
2842
- fn(state, value, unwrap);
2843
- };
2844
- };
2210
+ var $$2 = _export;
2211
+ var toObject = toObject$4;
2212
+ var lengthOfArrayLike = lengthOfArrayLike$2;
2213
+ var setArrayLength = arraySetLength;
2214
+ var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1;
2215
+ var fails$3 = fails$h;
2845
2216
 
2846
- var internalReject = function (state, value, unwrap) {
2847
- if (state.done) return;
2848
- state.done = true;
2849
- if (unwrap) state = unwrap;
2850
- state.value = value;
2851
- state.state = REJECTED;
2852
- notify(state, true);
2853
- };
2217
+ var INCORRECT_TO_LENGTH = fails$3(function () {
2218
+ return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
2219
+ });
2854
2220
 
2855
- var internalResolve = function (state, value, unwrap) {
2856
- if (state.done) return;
2857
- state.done = true;
2858
- if (unwrap) state = unwrap;
2221
+ // V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError
2222
+ // https://bugs.chromium.org/p/v8/issues/detail?id=12681
2223
+ var properErrorOnNonWritableLength = function () {
2859
2224
  try {
2860
- if (state.facade === value) throw TypeError$2("Promise can't be resolved itself");
2861
- var then = isThenable(value);
2862
- if (then) {
2863
- microtask(function () {
2864
- var wrapper = { done: false };
2865
- try {
2866
- call$3(then, value,
2867
- bind(internalResolve, wrapper, state),
2868
- bind(internalReject, wrapper, state)
2869
- );
2870
- } catch (error) {
2871
- internalReject(wrapper, error, state);
2872
- }
2873
- });
2874
- } else {
2875
- state.value = value;
2876
- state.state = FULFILLED;
2877
- notify(state, false);
2878
- }
2225
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
2226
+ Object.defineProperty([], 'length', { writable: false }).push();
2879
2227
  } catch (error) {
2880
- internalReject({ done: false }, error, state);
2228
+ return error instanceof TypeError;
2881
2229
  }
2882
2230
  };
2883
2231
 
2884
- // constructor polyfill
2885
- if (FORCED) {
2886
- // 25.4.3.1 Promise(executor)
2887
- PromiseConstructor = function Promise(executor) {
2888
- anInstance(this, PromisePrototype);
2889
- aCallable(executor);
2890
- call$3(Internal, this);
2891
- var state = getInternalState$1(this);
2892
- try {
2893
- executor(bind(internalResolve, state), bind(internalReject, state));
2894
- } catch (error) {
2895
- internalReject(state, error);
2896
- }
2897
- };
2898
- PromisePrototype = PromiseConstructor.prototype;
2899
- // eslint-disable-next-line no-unused-vars -- required for `.length`
2900
- Internal = function Promise(executor) {
2901
- setInternalState(this, {
2902
- type: PROMISE,
2903
- done: false,
2904
- notified: false,
2905
- parent: false,
2906
- reactions: new Queue(),
2907
- rejection: false,
2908
- state: PENDING,
2909
- value: undefined
2910
- });
2911
- };
2912
- Internal.prototype = redefineAll(PromisePrototype, {
2913
- // `Promise.prototype.then` method
2914
- // https://tc39.es/ecma262/#sec-promise.prototype.then
2915
- // eslint-disable-next-line unicorn/no-thenable -- safe
2916
- then: function then(onFulfilled, onRejected) {
2917
- var state = getInternalPromiseState(this);
2918
- var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
2919
- state.parent = true;
2920
- reaction.ok = isCallable$2(onFulfilled) ? onFulfilled : true;
2921
- reaction.fail = isCallable$2(onRejected) && onRejected;
2922
- reaction.domain = IS_NODE ? process.domain : undefined;
2923
- if (state.state == PENDING) state.reactions.add(reaction);
2924
- else microtask(function () {
2925
- callReaction(reaction, state);
2926
- });
2927
- return reaction.promise;
2928
- },
2929
- // `Promise.prototype.catch` method
2930
- // https://tc39.es/ecma262/#sec-promise.prototype.catch
2931
- 'catch': function (onRejected) {
2932
- return this.then(undefined, onRejected);
2933
- }
2934
- });
2935
- OwnPromiseCapability = function () {
2936
- var promise = new Internal();
2937
- var state = getInternalState$1(promise);
2938
- this.promise = promise;
2939
- this.resolve = bind(internalResolve, state);
2940
- this.reject = bind(internalReject, state);
2941
- };
2942
- newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
2943
- return C === PromiseConstructor || C === PromiseWrapper
2944
- ? new OwnPromiseCapability(C)
2945
- : newGenericPromiseCapability(C);
2946
- };
2947
-
2948
- if (isCallable$2(NativePromise) && NativePromisePrototype !== Object.prototype) {
2949
- nativeThen = NativePromisePrototype.then;
2950
-
2951
- if (!SUBCLASSING) {
2952
- // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
2953
- redefine$1(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
2954
- var that = this;
2955
- return new PromiseConstructor(function (resolve, reject) {
2956
- call$3(nativeThen, that, resolve, reject);
2957
- }).then(onFulfilled, onRejected);
2958
- // https://github.com/zloirock/core-js/issues/640
2959
- }, { unsafe: true });
2960
-
2961
- // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
2962
- redefine$1(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });
2963
- }
2964
-
2965
- // make `.constructor === Promise` work for native promise-based APIs
2966
- try {
2967
- delete NativePromisePrototype.constructor;
2968
- } catch (error) { /* empty */ }
2232
+ var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();
2969
2233
 
2970
- // make `instanceof Promise` work for native promise-based APIs
2971
- if (setPrototypeOf) {
2972
- setPrototypeOf(NativePromisePrototype, PromisePrototype);
2234
+ // `Array.prototype.push` method
2235
+ // https://tc39.es/ecma262/#sec-array.prototype.push
2236
+ $$2({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
2237
+ // eslint-disable-next-line no-unused-vars -- required for `.length`
2238
+ push: function push(item) {
2239
+ var O = toObject(this);
2240
+ var len = lengthOfArrayLike(O);
2241
+ var argCount = arguments.length;
2242
+ doesNotExceedSafeInteger(len + argCount);
2243
+ for (var i = 0; i < argCount; i++) {
2244
+ O[len] = arguments[i];
2245
+ len++;
2973
2246
  }
2974
- }
2975
- }
2976
-
2977
- $$1({ global: true, wrap: true, forced: FORCED }, {
2978
- Promise: PromiseConstructor
2979
- });
2980
-
2981
- setToStringTag(PromiseConstructor, PROMISE, false);
2982
- setSpecies(PROMISE);
2983
-
2984
- PromiseWrapper = getBuiltIn(PROMISE);
2985
-
2986
- // statics
2987
- $$1({ target: PROMISE, stat: true, forced: FORCED }, {
2988
- // `Promise.reject` method
2989
- // https://tc39.es/ecma262/#sec-promise.reject
2990
- reject: function reject(r) {
2991
- var capability = newPromiseCapability(this);
2992
- call$3(capability.reject, undefined, r);
2993
- return capability.promise;
2994
- }
2995
- });
2996
-
2997
- $$1({ target: PROMISE, stat: true, forced: FORCED }, {
2998
- // `Promise.resolve` method
2999
- // https://tc39.es/ecma262/#sec-promise.resolve
3000
- resolve: function resolve(x) {
3001
- return promiseResolve(this, x);
3002
- }
3003
- });
3004
-
3005
- $$1({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
3006
- // `Promise.all` method
3007
- // https://tc39.es/ecma262/#sec-promise.all
3008
- all: function all(iterable) {
3009
- var C = this;
3010
- var capability = newPromiseCapability(C);
3011
- var resolve = capability.resolve;
3012
- var reject = capability.reject;
3013
- var result = perform(function () {
3014
- var $promiseResolve = aCallable(C.resolve);
3015
- var values = [];
3016
- var counter = 0;
3017
- var remaining = 1;
3018
- iterate(iterable, function (promise) {
3019
- var index = counter++;
3020
- var alreadyCalled = false;
3021
- remaining++;
3022
- call$3($promiseResolve, C, promise).then(function (value) {
3023
- if (alreadyCalled) return;
3024
- alreadyCalled = true;
3025
- values[index] = value;
3026
- --remaining || resolve(values);
3027
- }, reject);
3028
- });
3029
- --remaining || resolve(values);
3030
- });
3031
- if (result.error) reject(result.value);
3032
- return capability.promise;
3033
- },
3034
- // `Promise.race` method
3035
- // https://tc39.es/ecma262/#sec-promise.race
3036
- race: function race(iterable) {
3037
- var C = this;
3038
- var capability = newPromiseCapability(C);
3039
- var reject = capability.reject;
3040
- var result = perform(function () {
3041
- var $promiseResolve = aCallable(C.resolve);
3042
- iterate(iterable, function (promise) {
3043
- call$3($promiseResolve, C, promise).then(capability.resolve, reject);
3044
- });
3045
- });
3046
- if (result.error) reject(result.value);
3047
- return capability.promise;
2247
+ setArrayLength(O, len);
2248
+ return len;
3048
2249
  }
3049
2250
  });
3050
2251
 
3051
- var fails$4 = fails$i;
3052
- var global$4 = global$G;
2252
+ var fails$2 = fails$h;
2253
+ var global$3 = global$e;
3053
2254
 
3054
2255
  // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
3055
- var $RegExp$2 = global$4.RegExp;
2256
+ var $RegExp$2 = global$3.RegExp;
3056
2257
 
3057
- var UNSUPPORTED_Y$1 = fails$4(function () {
2258
+ var UNSUPPORTED_Y$1 = fails$2(function () {
3058
2259
  var re = $RegExp$2('a', 'y');
3059
2260
  re.lastIndex = 2;
3060
- return re.exec('abcd') != null;
2261
+ return re.exec('abcd') !== null;
3061
2262
  });
3062
2263
 
3063
2264
  // UC Browser bug
3064
2265
  // https://github.com/zloirock/core-js/issues/1008
3065
- var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$4(function () {
2266
+ var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$2(function () {
3066
2267
  return !$RegExp$2('a', 'y').sticky;
3067
2268
  });
3068
2269
 
3069
- var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () {
2270
+ var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$2(function () {
3070
2271
  // https://bugzilla.mozilla.org/show_bug.cgi?id=773687
3071
2272
  var re = $RegExp$2('^r', 'gy');
3072
2273
  re.lastIndex = 2;
3073
- return re.exec('str') != null;
2274
+ return re.exec('str') !== null;
3074
2275
  });
3075
2276
 
3076
2277
  var regexpStickyHelpers = {
@@ -3079,24 +2280,24 @@ var regexpStickyHelpers = {
3079
2280
  UNSUPPORTED_Y: UNSUPPORTED_Y$1
3080
2281
  };
3081
2282
 
3082
- var fails$3 = fails$i;
3083
- var global$3 = global$G;
2283
+ var fails$1 = fails$h;
2284
+ var global$2 = global$e;
3084
2285
 
3085
2286
  // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
3086
- var $RegExp$1 = global$3.RegExp;
2287
+ var $RegExp$1 = global$2.RegExp;
3087
2288
 
3088
- var regexpUnsupportedDotAll = fails$3(function () {
2289
+ var regexpUnsupportedDotAll = fails$1(function () {
3089
2290
  var re = $RegExp$1('.', 's');
3090
- return !(re.dotAll && re.exec('\n') && re.flags === 's');
2291
+ return !(re.dotAll && re.test('\n') && re.flags === 's');
3091
2292
  });
3092
2293
 
3093
- var fails$2 = fails$i;
3094
- var global$2 = global$G;
2294
+ var fails = fails$h;
2295
+ var global$1 = global$e;
3095
2296
 
3096
2297
  // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
3097
- var $RegExp = global$2.RegExp;
2298
+ var $RegExp = global$1.RegExp;
3098
2299
 
3099
- var regexpUnsupportedNcg = fails$2(function () {
2300
+ var regexpUnsupportedNcg = fails(function () {
3100
2301
  var re = $RegExp('(?<a>b)', 'g');
3101
2302
  return re.exec('b').groups.a !== 'b' ||
3102
2303
  'b'.replace(re, '$<a>c') !== 'bc';
@@ -3104,12 +2305,12 @@ var regexpUnsupportedNcg = fails$2(function () {
3104
2305
 
3105
2306
  /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
3106
2307
  /* eslint-disable regexp/no-useless-quantifier -- testing */
3107
- var call$2 = functionCall;
3108
- var uncurryThis$4 = functionUncurryThis;
3109
- var toString$2 = toString$5;
2308
+ var call$1 = functionCall;
2309
+ var uncurryThis = functionUncurryThis;
2310
+ var toString$1 = toString$4;
3110
2311
  var regexpFlags = regexpFlags$1;
3111
2312
  var stickyHelpers = regexpStickyHelpers;
3112
- var shared = shared$4.exports;
2313
+ var shared = shared$4;
3113
2314
  var create = objectCreate;
3114
2315
  var getInternalState = internalState.get;
3115
2316
  var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
@@ -3118,16 +2319,16 @@ var UNSUPPORTED_NCG = regexpUnsupportedNcg;
3118
2319
  var nativeReplace = shared('native-string-replace', String.prototype.replace);
3119
2320
  var nativeExec = RegExp.prototype.exec;
3120
2321
  var patchedExec = nativeExec;
3121
- var charAt$3 = uncurryThis$4(''.charAt);
3122
- var indexOf = uncurryThis$4(''.indexOf);
3123
- var replace$1 = uncurryThis$4(''.replace);
3124
- var stringSlice$3 = uncurryThis$4(''.slice);
2322
+ var charAt = uncurryThis(''.charAt);
2323
+ var indexOf = uncurryThis(''.indexOf);
2324
+ var replace = uncurryThis(''.replace);
2325
+ var stringSlice = uncurryThis(''.slice);
3125
2326
 
3126
2327
  var UPDATES_LAST_INDEX_WRONG = (function () {
3127
2328
  var re1 = /a/;
3128
2329
  var re2 = /b*/g;
3129
- call$2(nativeExec, re1, 'a');
3130
- call$2(nativeExec, re2, 'a');
2330
+ call$1(nativeExec, re1, 'a');
2331
+ call$1(nativeExec, re2, 'a');
3131
2332
  return re1.lastIndex !== 0 || re2.lastIndex !== 0;
3132
2333
  })();
3133
2334
 
@@ -3142,33 +2343,33 @@ if (PATCH) {
3142
2343
  patchedExec = function exec(string) {
3143
2344
  var re = this;
3144
2345
  var state = getInternalState(re);
3145
- var str = toString$2(string);
2346
+ var str = toString$1(string);
3146
2347
  var raw = state.raw;
3147
2348
  var result, reCopy, lastIndex, match, i, object, group;
3148
2349
 
3149
2350
  if (raw) {
3150
2351
  raw.lastIndex = re.lastIndex;
3151
- result = call$2(patchedExec, raw, str);
2352
+ result = call$1(patchedExec, raw, str);
3152
2353
  re.lastIndex = raw.lastIndex;
3153
2354
  return result;
3154
2355
  }
3155
2356
 
3156
2357
  var groups = state.groups;
3157
2358
  var sticky = UNSUPPORTED_Y && re.sticky;
3158
- var flags = call$2(regexpFlags, re);
2359
+ var flags = call$1(regexpFlags, re);
3159
2360
  var source = re.source;
3160
2361
  var charsAdded = 0;
3161
2362
  var strCopy = str;
3162
2363
 
3163
2364
  if (sticky) {
3164
- flags = replace$1(flags, 'y', '');
2365
+ flags = replace(flags, 'y', '');
3165
2366
  if (indexOf(flags, 'g') === -1) {
3166
2367
  flags += 'g';
3167
2368
  }
3168
2369
 
3169
- strCopy = stringSlice$3(str, re.lastIndex);
2370
+ strCopy = stringSlice(str, re.lastIndex);
3170
2371
  // Support anchored sticky behavior.
3171
- if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$3(str, re.lastIndex - 1) !== '\n')) {
2372
+ if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt(str, re.lastIndex - 1) !== '\n')) {
3172
2373
  source = '(?: ' + source + ')';
3173
2374
  strCopy = ' ' + strCopy;
3174
2375
  charsAdded++;
@@ -3183,12 +2384,12 @@ if (PATCH) {
3183
2384
  }
3184
2385
  if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
3185
2386
 
3186
- match = call$2(nativeExec, sticky ? reCopy : re, strCopy);
2387
+ match = call$1(nativeExec, sticky ? reCopy : re, strCopy);
3187
2388
 
3188
2389
  if (sticky) {
3189
2390
  if (match) {
3190
- match.input = stringSlice$3(match.input, charsAdded);
3191
- match[0] = stringSlice$3(match[0], charsAdded);
2391
+ match.input = stringSlice(match.input, charsAdded);
2392
+ match[0] = stringSlice(match[0], charsAdded);
3192
2393
  match.index = re.lastIndex;
3193
2394
  re.lastIndex += match[0].length;
3194
2395
  } else re.lastIndex = 0;
@@ -3197,8 +2398,8 @@ if (PATCH) {
3197
2398
  }
3198
2399
  if (NPCG_INCLUDED && match && match.length > 1) {
3199
2400
  // Fix browsers whose `exec` methods don't consistently return `undefined`
3200
- // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
3201
- call$2(nativeReplace, match[0], reCopy, function () {
2401
+ // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
2402
+ call$1(nativeReplace, match[0], reCopy, function () {
3202
2403
  for (i = 1; i < arguments.length - 2; i++) {
3203
2404
  if (arguments[i] === undefined) match[i] = undefined;
3204
2405
  }
@@ -3217,363 +2418,51 @@ if (PATCH) {
3217
2418
  };
3218
2419
  }
3219
2420
 
3220
- var regexpExec$2 = patchedExec;
2421
+ var regexpExec = patchedExec;
3221
2422
 
3222
- var $ = _export;
3223
- var exec = regexpExec$2;
2423
+ var $$1 = _export;
2424
+ var exec = regexpExec;
3224
2425
 
3225
2426
  // `RegExp.prototype.exec` method
3226
2427
  // https://tc39.es/ecma262/#sec-regexp.prototype.exec
3227
- $({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
2428
+ $$1({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
3228
2429
  exec: exec
3229
2430
  });
3230
2431
 
3231
2432
  // TODO: Remove from `core-js@4` since it's moved to entry points
3232
2433
 
3233
- var uncurryThis$3 = functionUncurryThis;
3234
- var redefine = redefine$7.exports;
3235
- var regexpExec$1 = regexpExec$2;
3236
- var fails$1 = fails$i;
3237
- var wellKnownSymbol$1 = wellKnownSymbol$i;
3238
- var createNonEnumerableProperty = createNonEnumerableProperty$6;
3239
-
3240
- var SPECIES = wellKnownSymbol$1('species');
3241
- var RegExpPrototype = RegExp.prototype;
3242
-
3243
- var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
3244
- var SYMBOL = wellKnownSymbol$1(KEY);
3245
-
3246
- var DELEGATES_TO_SYMBOL = !fails$1(function () {
3247
- // String methods call symbol-named RegEp methods
3248
- var O = {};
3249
- O[SYMBOL] = function () { return 7; };
3250
- return ''[KEY](O) != 7;
3251
- });
3252
-
3253
- var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$1(function () {
3254
- // Symbol-named RegExp methods call .exec
3255
- var execCalled = false;
3256
- var re = /a/;
3257
-
3258
- if (KEY === 'split') {
3259
- // We can't use real regex here since it causes deoptimization
3260
- // and serious performance degradation in V8
3261
- // https://github.com/zloirock/core-js/issues/306
3262
- re = {};
3263
- // RegExp[@@split] doesn't call the regex's exec method, but first creates
3264
- // a new one. We need to return the patched regex when creating the new one.
3265
- re.constructor = {};
3266
- re.constructor[SPECIES] = function () { return re; };
3267
- re.flags = '';
3268
- re[SYMBOL] = /./[SYMBOL];
3269
- }
3270
-
3271
- re.exec = function () { execCalled = true; return null; };
3272
-
3273
- re[SYMBOL]('');
3274
- return !execCalled;
3275
- });
3276
-
3277
- if (
3278
- !DELEGATES_TO_SYMBOL ||
3279
- !DELEGATES_TO_EXEC ||
3280
- FORCED
3281
- ) {
3282
- var uncurriedNativeRegExpMethod = uncurryThis$3(/./[SYMBOL]);
3283
- var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
3284
- var uncurriedNativeMethod = uncurryThis$3(nativeMethod);
3285
- var $exec = regexp.exec;
3286
- if ($exec === regexpExec$1 || $exec === RegExpPrototype.exec) {
3287
- if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
3288
- // The native String method already delegates to @@method (this
3289
- // polyfilled function), leasing to infinite recursion.
3290
- // We avoid it by directly calling the native @@method method.
3291
- return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };
3292
- }
3293
- return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };
3294
- }
3295
- return { done: false };
3296
- });
3297
-
3298
- redefine(String.prototype, KEY, methods[0]);
3299
- redefine(RegExpPrototype, SYMBOL, methods[1]);
3300
- }
3301
-
3302
- if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
3303
- };
3304
-
3305
- var uncurryThis$2 = functionUncurryThis;
3306
- var toIntegerOrInfinity$1 = toIntegerOrInfinity$4;
3307
- var toString$1 = toString$5;
3308
- var requireObjectCoercible$1 = requireObjectCoercible$6;
3309
-
3310
- var charAt$2 = uncurryThis$2(''.charAt);
3311
- var charCodeAt = uncurryThis$2(''.charCodeAt);
3312
- var stringSlice$2 = uncurryThis$2(''.slice);
3313
-
3314
- var createMethod = function (CONVERT_TO_STRING) {
3315
- return function ($this, pos) {
3316
- var S = toString$1(requireObjectCoercible$1($this));
3317
- var position = toIntegerOrInfinity$1(pos);
3318
- var size = S.length;
3319
- var first, second;
3320
- if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
3321
- first = charCodeAt(S, position);
3322
- return first < 0xD800 || first > 0xDBFF || position + 1 === size
3323
- || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
3324
- ? CONVERT_TO_STRING
3325
- ? charAt$2(S, position)
3326
- : first
3327
- : CONVERT_TO_STRING
3328
- ? stringSlice$2(S, position, position + 2)
3329
- : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
3330
- };
3331
- };
3332
-
3333
- var stringMultibyte = {
3334
- // `String.prototype.codePointAt` method
3335
- // https://tc39.es/ecma262/#sec-string.prototype.codepointat
3336
- codeAt: createMethod(false),
3337
- // `String.prototype.at` method
3338
- // https://github.com/mathiasbynens/String.prototype.at
3339
- charAt: createMethod(true)
3340
- };
3341
-
3342
- var charAt$1 = stringMultibyte.charAt;
3343
-
3344
- // `AdvanceStringIndex` abstract operation
3345
- // https://tc39.es/ecma262/#sec-advancestringindex
3346
- var advanceStringIndex$1 = function (S, index, unicode) {
3347
- return index + (unicode ? charAt$1(S, index).length : 1);
3348
- };
3349
-
3350
- var uncurryThis$1 = functionUncurryThis;
3351
- var toObject = toObject$4;
3352
-
3353
- var floor = Math.floor;
3354
- var charAt = uncurryThis$1(''.charAt);
3355
- var replace = uncurryThis$1(''.replace);
3356
- var stringSlice$1 = uncurryThis$1(''.slice);
3357
- var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
3358
- var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
3359
-
3360
- // `GetSubstitution` abstract operation
3361
- // https://tc39.es/ecma262/#sec-getsubstitution
3362
- var getSubstitution$1 = function (matched, str, position, captures, namedCaptures, replacement) {
3363
- var tailPos = position + matched.length;
3364
- var m = captures.length;
3365
- var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
3366
- if (namedCaptures !== undefined) {
3367
- namedCaptures = toObject(namedCaptures);
3368
- symbols = SUBSTITUTION_SYMBOLS;
3369
- }
3370
- return replace(replacement, symbols, function (match, ch) {
3371
- var capture;
3372
- switch (charAt(ch, 0)) {
3373
- case '$': return '$';
3374
- case '&': return matched;
3375
- case '`': return stringSlice$1(str, 0, position);
3376
- case "'": return stringSlice$1(str, tailPos);
3377
- case '<':
3378
- capture = namedCaptures[stringSlice$1(ch, 1, -1)];
3379
- break;
3380
- default: // \d\d?
3381
- var n = +ch;
3382
- if (n === 0) return match;
3383
- if (n > m) {
3384
- var f = floor(n / 10);
3385
- if (f === 0) return match;
3386
- if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);
3387
- return match;
3388
- }
3389
- capture = captures[n - 1];
3390
- }
3391
- return capture === undefined ? '' : capture;
3392
- });
3393
- };
3394
-
3395
- var global$1 = global$G;
3396
- var call$1 = functionCall;
3397
- var anObject$1 = anObject$e;
3398
- var isCallable$1 = isCallable$j;
3399
- var classof = classofRaw$1;
3400
- var regexpExec = regexpExec$2;
3401
-
3402
- var TypeError$1 = global$1.TypeError;
3403
-
3404
- // `RegExpExec` abstract operation
3405
- // https://tc39.es/ecma262/#sec-regexpexec
3406
- var regexpExecAbstract = function (R, S) {
3407
- var exec = R.exec;
3408
- if (isCallable$1(exec)) {
3409
- var result = call$1(exec, R, S);
3410
- if (result !== null) anObject$1(result);
3411
- return result;
3412
- }
3413
- if (classof(R) === 'RegExp') return call$1(regexpExec, R, S);
3414
- throw TypeError$1('RegExp#exec called on incompatible receiver');
3415
- };
3416
-
3417
- var apply = functionApply;
2434
+ var $ = _export;
3418
2435
  var call = functionCall;
3419
- var uncurryThis = functionUncurryThis;
3420
- var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
3421
- var fails = fails$i;
3422
- var anObject = anObject$e;
3423
- var isCallable = isCallable$j;
3424
- var toIntegerOrInfinity = toIntegerOrInfinity$4;
3425
- var toLength = toLength$3;
3426
- var toString = toString$5;
3427
- var requireObjectCoercible = requireObjectCoercible$6;
3428
- var advanceStringIndex = advanceStringIndex$1;
3429
- var getMethod = getMethod$4;
3430
- var getSubstitution = getSubstitution$1;
3431
- var regExpExec = regexpExecAbstract;
3432
- var wellKnownSymbol = wellKnownSymbol$i;
3433
-
3434
- var REPLACE = wellKnownSymbol('replace');
3435
- var max = Math.max;
3436
- var min = Math.min;
3437
- var concat = uncurryThis([].concat);
3438
- var push = uncurryThis([].push);
3439
- var stringIndexOf = uncurryThis(''.indexOf);
3440
- var stringSlice = uncurryThis(''.slice);
3441
-
3442
- var maybeToString = function (it) {
3443
- return it === undefined ? it : String(it);
3444
- };
2436
+ var isCallable = isCallable$f;
2437
+ var anObject = anObject$7;
2438
+ var toString = toString$4;
3445
2439
 
3446
- // IE <= 11 replaces $0 with the whole match, as if it was $&
3447
- // https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
3448
- var REPLACE_KEEPS_$0 = (function () {
3449
- // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
3450
- return 'a'.replace(/./, '$0') === '$0';
3451
- })();
3452
-
3453
- // Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
3454
- var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
3455
- if (/./[REPLACE]) {
3456
- return /./[REPLACE]('a', '$0') === '';
3457
- }
3458
- return false;
3459
- })();
3460
-
3461
- var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
3462
- var re = /./;
2440
+ var DELEGATES_TO_EXEC = function () {
2441
+ var execCalled = false;
2442
+ var re = /[ac]/;
3463
2443
  re.exec = function () {
3464
- var result = [];
3465
- result.groups = { a: '7' };
3466
- return result;
2444
+ execCalled = true;
2445
+ return /./.exec.apply(this, arguments);
3467
2446
  };
3468
- // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive
3469
- return ''.replace(re, '$<a>') !== '7';
3470
- });
3471
-
3472
- // @@replace logic
3473
- fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
3474
- var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
3475
-
3476
- return [
3477
- // `String.prototype.replace` method
3478
- // https://tc39.es/ecma262/#sec-string.prototype.replace
3479
- function replace(searchValue, replaceValue) {
3480
- var O = requireObjectCoercible(this);
3481
- var replacer = searchValue == undefined ? undefined : getMethod(searchValue, REPLACE);
3482
- return replacer
3483
- ? call(replacer, searchValue, O, replaceValue)
3484
- : call(nativeReplace, toString(O), searchValue, replaceValue);
3485
- },
3486
- // `RegExp.prototype[@@replace]` method
3487
- // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
3488
- function (string, replaceValue) {
3489
- var rx = anObject(this);
3490
- var S = toString(string);
3491
-
3492
- if (
3493
- typeof replaceValue == 'string' &&
3494
- stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 &&
3495
- stringIndexOf(replaceValue, '$<') === -1
3496
- ) {
3497
- var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
3498
- if (res.done) return res.value;
3499
- }
3500
-
3501
- var functionalReplace = isCallable(replaceValue);
3502
- if (!functionalReplace) replaceValue = toString(replaceValue);
3503
-
3504
- var global = rx.global;
3505
- if (global) {
3506
- var fullUnicode = rx.unicode;
3507
- rx.lastIndex = 0;
3508
- }
3509
- var results = [];
3510
- while (true) {
3511
- var result = regExpExec(rx, S);
3512
- if (result === null) break;
3513
-
3514
- push(results, result);
3515
- if (!global) break;
3516
-
3517
- var matchStr = toString(result[0]);
3518
- if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
3519
- }
3520
-
3521
- var accumulatedResult = '';
3522
- var nextSourcePosition = 0;
3523
- for (var i = 0; i < results.length; i++) {
3524
- result = results[i];
3525
-
3526
- var matched = toString(result[0]);
3527
- var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
3528
- var captures = [];
3529
- // NOTE: This is equivalent to
3530
- // captures = result.slice(1).map(maybeToString)
3531
- // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
3532
- // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
3533
- // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
3534
- for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
3535
- var namedCaptures = result.groups;
3536
- if (functionalReplace) {
3537
- var replacerArgs = concat([matched], captures, position, S);
3538
- if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
3539
- var replacement = toString(apply(replaceValue, undefined, replacerArgs));
3540
- } else {
3541
- replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
3542
- }
3543
- if (position >= nextSourcePosition) {
3544
- accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
3545
- nextSourcePosition = position + matched.length;
3546
- }
3547
- }
3548
- return accumulatedResult + stringSlice(S, nextSourcePosition);
3549
- }
3550
- ];
3551
- }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
2447
+ return re.test('abc') === true && execCalled;
2448
+ }();
3552
2449
 
3553
- /******************************************************************************
3554
- Copyright (c) Microsoft Corporation.
3555
-
3556
- Permission to use, copy, modify, and/or distribute this software for any
3557
- purpose with or without fee is hereby granted.
3558
-
3559
- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
3560
- REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
3561
- AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
3562
- INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
3563
- LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
3564
- OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
3565
- PERFORMANCE OF THIS SOFTWARE.
3566
- ***************************************************************************** */
3567
-
3568
- function __awaiter(thisArg, _arguments, P, generator) {
3569
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
3570
- return new (P || (P = Promise))(function (resolve, reject) {
3571
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
3572
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
3573
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
3574
- step((generator = generator.apply(thisArg, _arguments || [])).next());
3575
- });
3576
- }
2450
+ var nativeTest = /./.test;
2451
+
2452
+ // `RegExp.prototype.test` method
2453
+ // https://tc39.es/ecma262/#sec-regexp.prototype.test
2454
+ $({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, {
2455
+ test: function (S) {
2456
+ var R = anObject(this);
2457
+ var string = toString(S);
2458
+ var exec = R.exec;
2459
+ if (!isCallable(exec)) return call(nativeTest, R, string);
2460
+ var result = call(exec, R, string);
2461
+ if (result === null) return false;
2462
+ anObject(result);
2463
+ return true;
2464
+ }
2465
+ });
3577
2466
 
3578
2467
  const MQTT_TIMEOUT_SECONDS = 3;
3579
2468
  const MQTT_TIMEOUT_MS = MQTT_TIMEOUT_SECONDS * 1000;
@@ -3653,25 +2542,10 @@ const isOnEdge = () => {
3653
2542
  return window.location.hostname.startsWith("192.168") || window.location.hostname.startsWith("localhost");
3654
2543
  };
3655
2544
  const getExecutionEngineHttpUrl = () => {
3656
- const url = window.location.hostname;
3657
- const executionEngineUrl = isOnEdge() ? `http://${url}:3100` : `${window.location.origin}/digital-twin/execution-engine`;
3658
- return executionEngineUrl;
2545
+ return isOnEdge() ? `http://${window.location.hostname}:3100` : `${window.location.origin}/digital-twin/execution-engine`;
3659
2546
  };
3660
2547
  const getMqttWsUrl = () => __awaiter(void 0, void 0, void 0, function* () {
3661
- if (isOnEdge()) {
3662
- return `ws://${window.location.hostname}:9001`;
3663
- }
3664
- /**
3665
- * We are not trying to allocate a new Machine Motion here. By the time a custom UI can be opened in the CAD (assembler),
3666
- * we would have already been allocated a Virtual Machine Motion, and a repeated request to the
3667
- * alloc endpoint will just re-return the connection details of the Virtual Machine Motion that
3668
- * has already been allocated.
3669
- */
3670
- const response = yield fetch(`${window.location.origin}/orchestrator/allocator/vmm_connection_details`);
3671
- const data = yield response.json();
3672
- const url = `${data.message.host}/${data.message.token}/mqtt`;
3673
- const websocketUrl = url.replace("https", "wss");
3674
- return websocketUrl;
2548
+ return isOnEdge() ? `ws://${window.location.hostname}:9001` : `wss://${window.location.hostname}/digital-twin/mqtt`;
3675
2549
  });
3676
2550
  const connectToMqttAndGetClient = () => __awaiter(void 0, void 0, void 0, function* () {
3677
2551
  const websocketUrl = yield getMqttWsUrl();