@vention/machine-logic-ui-sdk 0.0.8 → 0.0.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/index.esm.js +2050 -1731
- 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
|
|
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$
|
|
14
|
+
var global$l =
|
|
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
|
|
25
|
+
var objectGetOwnPropertyDescriptor = {};
|
|
26
|
+
|
|
27
|
+
var fails$l = function (exec) {
|
|
25
28
|
try {
|
|
26
29
|
return !!exec();
|
|
27
30
|
} catch (error) {
|
|
@@ -29,9 +32,18 @@ var fails$i = function (exec) {
|
|
|
29
32
|
}
|
|
30
33
|
};
|
|
31
34
|
|
|
32
|
-
var fails$
|
|
35
|
+
var fails$k = fails$l;
|
|
36
|
+
|
|
37
|
+
// Detect IE8's incomplete defineProperty implementation
|
|
38
|
+
var descriptors = !fails$k(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$j = fails$l;
|
|
33
44
|
|
|
34
|
-
var functionBindNative = !fails$
|
|
45
|
+
var functionBindNative = !fails$j(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');
|
|
@@ -39,158 +51,140 @@ var functionBindNative = !fails$h(function () {
|
|
|
39
51
|
|
|
40
52
|
var NATIVE_BIND$3 = functionBindNative;
|
|
41
53
|
|
|
42
|
-
var
|
|
43
|
-
|
|
44
|
-
var
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
54
|
+
var call$j = Function.prototype.call;
|
|
55
|
+
|
|
56
|
+
var functionCall = NATIVE_BIND$3 ? call$j.bind(call$j) : function () {
|
|
57
|
+
return call$j.apply(call$j, arguments);
|
|
58
|
+
};
|
|
59
|
+
|
|
60
|
+
var objectPropertyIsEnumerable = {};
|
|
61
|
+
|
|
62
|
+
var $propertyIsEnumerable = {}.propertyIsEnumerable;
|
|
63
|
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
64
|
+
var getOwnPropertyDescriptor$4 = Object.getOwnPropertyDescriptor;
|
|
65
|
+
|
|
66
|
+
// Nashorn ~ JDK8 bug
|
|
67
|
+
var NASHORN_BUG = getOwnPropertyDescriptor$4 && !$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$4(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
|
|
52
82
|
};
|
|
53
83
|
};
|
|
54
84
|
|
|
55
|
-
var
|
|
85
|
+
var NATIVE_BIND$2 = functionBindNative;
|
|
56
86
|
|
|
57
|
-
var
|
|
58
|
-
var
|
|
87
|
+
var FunctionPrototype$2 = Function.prototype;
|
|
88
|
+
var call$i = FunctionPrototype$2.call;
|
|
89
|
+
var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$2.bind.bind(call$i, call$i);
|
|
59
90
|
|
|
60
|
-
var
|
|
61
|
-
return
|
|
91
|
+
var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function (fn) {
|
|
92
|
+
return function () {
|
|
93
|
+
return call$i.apply(fn, arguments);
|
|
94
|
+
};
|
|
62
95
|
};
|
|
63
96
|
|
|
64
|
-
var global$F = global$G;
|
|
65
97
|
var uncurryThis$k = functionUncurryThis;
|
|
66
|
-
var fails$g = fails$i;
|
|
67
|
-
var classof$7 = classofRaw$1;
|
|
68
98
|
|
|
69
|
-
var
|
|
70
|
-
var
|
|
99
|
+
var toString$8 = uncurryThis$k({}.toString);
|
|
100
|
+
var stringSlice$6 = uncurryThis$k(''.slice);
|
|
101
|
+
|
|
102
|
+
var classofRaw$2 = function (it) {
|
|
103
|
+
return stringSlice$6(toString$8(it), 8, -1);
|
|
104
|
+
};
|
|
105
|
+
|
|
106
|
+
var uncurryThis$j = functionUncurryThis;
|
|
107
|
+
var fails$i = fails$l;
|
|
108
|
+
var classof$8 = classofRaw$2;
|
|
109
|
+
|
|
110
|
+
var $Object$4 = Object;
|
|
111
|
+
var split = uncurryThis$j(''.split);
|
|
71
112
|
|
|
72
113
|
// fallback for non-array-like ES3 and non-enumerable old V8 strings
|
|
73
|
-
var indexedObject = fails$
|
|
114
|
+
var indexedObject = fails$i(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
|
|
117
|
+
return !$Object$4('z').propertyIsEnumerable(0);
|
|
77
118
|
}) ? function (it) {
|
|
78
|
-
return classof$
|
|
79
|
-
} : Object$
|
|
119
|
+
return classof$8(it) === 'String' ? split(it, '') : $Object$4(it);
|
|
120
|
+
} : $Object$4;
|
|
80
121
|
|
|
81
|
-
|
|
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$5 = function (it) {
|
|
125
|
+
return it === null || it === undefined;
|
|
126
|
+
};
|
|
127
|
+
|
|
128
|
+
var isNullOrUndefined$4 = isNullOrUndefined$5;
|
|
82
129
|
|
|
83
|
-
var TypeError$
|
|
130
|
+
var $TypeError$g = TypeError;
|
|
84
131
|
|
|
85
132
|
// `RequireObjectCoercible` abstract operation
|
|
86
133
|
// https://tc39.es/ecma262/#sec-requireobjectcoercible
|
|
87
|
-
var requireObjectCoercible$
|
|
88
|
-
if (it
|
|
134
|
+
var requireObjectCoercible$7 = function (it) {
|
|
135
|
+
if (isNullOrUndefined$4(it)) throw new $TypeError$g("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$
|
|
141
|
+
var requireObjectCoercible$6 = requireObjectCoercible$7;
|
|
95
142
|
|
|
96
143
|
var toIndexedObject$5 = function (it) {
|
|
97
|
-
return IndexedObject$1(requireObjectCoercible$
|
|
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$6(it));
|
|
155
145
|
};
|
|
156
146
|
|
|
157
|
-
|
|
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
|
-
|
|
152
|
+
// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
|
|
153
|
+
var isCallable$m = 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
|
|
174
|
-
|
|
159
|
+
var isCallable$l = isCallable$m;
|
|
160
|
+
|
|
161
|
+
var isObject$b = function (it) {
|
|
162
|
+
return typeof it == 'object' ? it !== null : isCallable$l(it);
|
|
163
|
+
};
|
|
164
|
+
|
|
165
|
+
var global$k = global$l;
|
|
166
|
+
var isCallable$k = isCallable$m;
|
|
175
167
|
|
|
176
168
|
var aFunction = function (argument) {
|
|
177
|
-
return isCallable$
|
|
169
|
+
return isCallable$k(argument) ? argument : undefined;
|
|
178
170
|
};
|
|
179
171
|
|
|
180
172
|
var getBuiltIn$7 = function (namespace, method) {
|
|
181
|
-
return arguments.length < 2 ? aFunction(global$
|
|
173
|
+
return arguments.length < 2 ? aFunction(global$k[namespace]) : global$k[namespace] && global$k[namespace][method];
|
|
182
174
|
};
|
|
183
175
|
|
|
184
|
-
var
|
|
176
|
+
var uncurryThis$i = functionUncurryThis;
|
|
185
177
|
|
|
186
|
-
var
|
|
178
|
+
var objectIsPrototypeOf = uncurryThis$i({}.isPrototypeOf);
|
|
187
179
|
|
|
188
|
-
var
|
|
180
|
+
var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
|
|
181
|
+
|
|
182
|
+
var global$j = global$l;
|
|
189
183
|
var userAgent$3 = engineUserAgent;
|
|
190
184
|
|
|
191
|
-
var process$3 = global$
|
|
192
|
-
var Deno = global$
|
|
193
|
-
var versions = process$3 && process$3.versions || Deno && Deno.version;
|
|
185
|
+
var process$3 = global$j.process;
|
|
186
|
+
var Deno$1 = global$j.Deno;
|
|
187
|
+
var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version;
|
|
194
188
|
var v8 = versions && versions.v8;
|
|
195
189
|
var match, version;
|
|
196
190
|
|
|
@@ -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 */
|
|
217
|
-
|
|
218
211
|
var V8_VERSION$1 = engineV8Version;
|
|
219
|
-
var fails$
|
|
212
|
+
var fails$h = fails$l;
|
|
213
|
+
var global$i = global$l;
|
|
214
|
+
|
|
215
|
+
var $String$5 = global$i.String;
|
|
220
216
|
|
|
221
217
|
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
|
|
222
|
-
var
|
|
223
|
-
var symbol = Symbol();
|
|
218
|
+
var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$h(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
|
-
|
|
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
226
|
!Symbol.sham && V8_VERSION$1 && V8_VERSION$1 < 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
|
|
240
|
-
var
|
|
241
|
-
var
|
|
242
|
-
var uid$1 = uid$2;
|
|
243
|
-
var NATIVE_SYMBOL = nativeSymbol;
|
|
236
|
+
var getBuiltIn$6 = getBuiltIn$7;
|
|
237
|
+
var isCallable$j = isCallable$m;
|
|
238
|
+
var isPrototypeOf$3 = objectIsPrototypeOf;
|
|
244
239
|
var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
|
|
245
240
|
|
|
246
|
-
var
|
|
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;
|
|
241
|
+
var $Object$3 = Object;
|
|
250
242
|
|
|
251
|
-
var
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
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];
|
|
243
|
+
var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
|
|
244
|
+
return typeof it == 'symbol';
|
|
245
|
+
} : function (it) {
|
|
246
|
+
var $Symbol = getBuiltIn$6('Symbol');
|
|
247
|
+
return isCallable$j($Symbol) && isPrototypeOf$3($Symbol.prototype, $Object$3(it));
|
|
262
248
|
};
|
|
263
249
|
|
|
264
|
-
var
|
|
250
|
+
var $String$4 = String;
|
|
265
251
|
|
|
266
|
-
var
|
|
267
|
-
|
|
252
|
+
var tryToString$4 = function (argument) {
|
|
253
|
+
try {
|
|
254
|
+
return $String$4(argument);
|
|
255
|
+
} catch (error) {
|
|
256
|
+
return 'Object';
|
|
257
|
+
}
|
|
268
258
|
};
|
|
269
259
|
|
|
270
|
-
var
|
|
271
|
-
var
|
|
260
|
+
var isCallable$i = isCallable$m;
|
|
261
|
+
var tryToString$3 = tryToString$4;
|
|
272
262
|
|
|
273
|
-
var
|
|
274
|
-
var TypeError$e = global$x.TypeError;
|
|
263
|
+
var $TypeError$f = TypeError;
|
|
275
264
|
|
|
276
|
-
// `Assert:
|
|
277
|
-
var
|
|
278
|
-
if (
|
|
279
|
-
throw TypeError$
|
|
265
|
+
// `Assert: IsCallable(argument) is true`
|
|
266
|
+
var aCallable$8 = function (argument) {
|
|
267
|
+
if (isCallable$i(argument)) return argument;
|
|
268
|
+
throw new $TypeError$f(tryToString$3(argument) + ' is not a function');
|
|
280
269
|
};
|
|
281
270
|
|
|
282
|
-
var
|
|
271
|
+
var aCallable$7 = aCallable$8;
|
|
272
|
+
var isNullOrUndefined$3 = isNullOrUndefined$5;
|
|
283
273
|
|
|
284
|
-
|
|
274
|
+
// `GetMethod` abstract operation
|
|
275
|
+
// https://tc39.es/ecma262/#sec-getmethod
|
|
276
|
+
var getMethod$4 = function (V, P) {
|
|
277
|
+
var func = V[P];
|
|
278
|
+
return isNullOrUndefined$3(func) ? undefined : aCallable$7(func);
|
|
279
|
+
};
|
|
285
280
|
|
|
286
|
-
|
|
287
|
-
var
|
|
288
|
-
|
|
289
|
-
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
|
|
290
|
-
});
|
|
281
|
+
var call$h = functionCall;
|
|
282
|
+
var isCallable$h = isCallable$m;
|
|
283
|
+
var isObject$a = isObject$b;
|
|
291
284
|
|
|
292
|
-
var
|
|
293
|
-
var fails$d = fails$i;
|
|
285
|
+
var $TypeError$e = TypeError;
|
|
294
286
|
|
|
295
|
-
//
|
|
296
|
-
// https://
|
|
297
|
-
var
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
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$h(fn = input.toString) && !isObject$a(val = call$h(fn, input))) return val;
|
|
292
|
+
if (isCallable$h(fn = input.valueOf) && !isObject$a(val = call$h(fn, input))) return val;
|
|
293
|
+
if (pref !== 'string' && isCallable$h(fn = input.toString) && !isObject$a(val = call$h(fn, input))) return val;
|
|
294
|
+
throw new $TypeError$e("Can't convert object to primitive value");
|
|
295
|
+
};
|
|
304
296
|
|
|
305
|
-
var
|
|
297
|
+
var sharedStore = {exports: {}};
|
|
306
298
|
|
|
307
|
-
var global$
|
|
308
|
-
var isObject$6 = isObject$8;
|
|
299
|
+
var global$h = global$l;
|
|
309
300
|
|
|
310
|
-
|
|
311
|
-
|
|
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$6 = Object.defineProperty;
|
|
313
303
|
|
|
314
|
-
var
|
|
315
|
-
|
|
304
|
+
var defineGlobalProperty$3 = function (key, value) {
|
|
305
|
+
try {
|
|
306
|
+
defineProperty$6(global$h, key, { value: value, configurable: true, writable: true });
|
|
307
|
+
} catch (error) {
|
|
308
|
+
global$h[key] = value;
|
|
309
|
+
} return value;
|
|
316
310
|
};
|
|
317
311
|
|
|
318
|
-
var
|
|
319
|
-
var
|
|
320
|
-
var createElement$1 = documentCreateElement$2;
|
|
312
|
+
var globalThis$1 = global$l;
|
|
313
|
+
var defineGlobalProperty$2 = defineGlobalProperty$3;
|
|
321
314
|
|
|
322
|
-
|
|
323
|
-
var
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
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
|
|
326
|
+
var sharedStoreExports = sharedStore.exports;
|
|
331
327
|
|
|
332
|
-
var
|
|
328
|
+
var store$2 = sharedStoreExports;
|
|
333
329
|
|
|
334
|
-
var
|
|
335
|
-
return
|
|
330
|
+
var shared$4 = function (key, value) {
|
|
331
|
+
return store$2[key] || (store$2[key] = value || {});
|
|
336
332
|
};
|
|
337
333
|
|
|
338
|
-
var
|
|
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$5 = requireObjectCoercible$7;
|
|
347
335
|
|
|
348
|
-
var Object$
|
|
336
|
+
var $Object$2 = Object;
|
|
349
337
|
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
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$5 = function (argument) {
|
|
341
|
+
return $Object$2(requireObjectCoercible$5(argument));
|
|
355
342
|
};
|
|
356
343
|
|
|
357
|
-
var
|
|
344
|
+
var uncurryThis$h = functionUncurryThis;
|
|
345
|
+
var toObject$4 = toObject$5;
|
|
358
346
|
|
|
359
|
-
var
|
|
347
|
+
var hasOwnProperty = uncurryThis$h({}.hasOwnProperty);
|
|
360
348
|
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
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$4(it), key);
|
|
367
354
|
};
|
|
368
355
|
|
|
369
|
-
var
|
|
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$g = functionUncurryThis;
|
|
380
357
|
|
|
381
|
-
var
|
|
358
|
+
var id = 0;
|
|
359
|
+
var postfix = Math.random();
|
|
360
|
+
var toString$7 = uncurryThis$g(1.0.toString);
|
|
382
361
|
|
|
383
|
-
|
|
384
|
-
|
|
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$7(++id + postfix, 36);
|
|
388
364
|
};
|
|
389
365
|
|
|
390
|
-
var global$
|
|
391
|
-
var
|
|
392
|
-
var
|
|
393
|
-
var
|
|
366
|
+
var global$g = global$l;
|
|
367
|
+
var shared$3 = shared$4;
|
|
368
|
+
var hasOwn$a = hasOwnProperty_1;
|
|
369
|
+
var uid$1 = uid$2;
|
|
370
|
+
var NATIVE_SYMBOL = symbolConstructorDetection;
|
|
371
|
+
var USE_SYMBOL_AS_UID = useSymbolAsUid;
|
|
394
372
|
|
|
395
|
-
var
|
|
373
|
+
var Symbol$1 = global$g.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
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
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$i = function (name) {
|
|
378
|
+
if (!hasOwn$a(WellKnownSymbolsStore, name)) {
|
|
379
|
+
WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$a(Symbol$1, name)
|
|
380
|
+
? Symbol$1[name]
|
|
381
|
+
: createWellKnownSymbol('Symbol.' + name);
|
|
382
|
+
} return WellKnownSymbolsStore[name];
|
|
405
383
|
};
|
|
406
384
|
|
|
407
|
-
var
|
|
408
|
-
var
|
|
409
|
-
var isObject$4 = isObject$8;
|
|
385
|
+
var call$g = functionCall;
|
|
386
|
+
var isObject$9 = isObject$b;
|
|
410
387
|
var isSymbol$1 = isSymbol$2;
|
|
411
388
|
var getMethod$3 = getMethod$4;
|
|
412
389
|
var ordinaryToPrimitive = ordinaryToPrimitive$1;
|
|
413
390
|
var wellKnownSymbol$h = wellKnownSymbol$i;
|
|
414
391
|
|
|
415
|
-
var TypeError$
|
|
392
|
+
var $TypeError$d = TypeError;
|
|
416
393
|
var TO_PRIMITIVE = wellKnownSymbol$h('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$
|
|
398
|
+
if (!isObject$9(input) || isSymbol$1(input)) return input;
|
|
422
399
|
var exoticToPrim = getMethod$3(input, TO_PRIMITIVE);
|
|
423
400
|
var result;
|
|
424
401
|
if (exoticToPrim) {
|
|
425
402
|
if (pref === undefined) pref = 'default';
|
|
426
|
-
result = call$
|
|
427
|
-
if (!isObject$
|
|
428
|
-
throw TypeError$
|
|
403
|
+
result = call$g(exoticToPrim, input, pref);
|
|
404
|
+
if (!isObject$9(result) || isSymbol$1(result)) return result;
|
|
405
|
+
throw new $TypeError$d("Can't convert object to primitive value");
|
|
429
406
|
}
|
|
430
407
|
if (pref === undefined) pref = 'number';
|
|
431
408
|
return ordinaryToPrimitive(input, pref);
|
|
@@ -441,30 +418,101 @@ var toPropertyKey$2 = function (argument) {
|
|
|
441
418
|
return isSymbol(key) ? key : key + '';
|
|
442
419
|
};
|
|
443
420
|
|
|
444
|
-
var global$
|
|
445
|
-
var
|
|
421
|
+
var global$f = global$l;
|
|
422
|
+
var isObject$8 = isObject$b;
|
|
423
|
+
|
|
424
|
+
var document$3 = global$f.document;
|
|
425
|
+
// typeof document.createElement is 'object' in old IE
|
|
426
|
+
var EXISTS$1 = isObject$8(document$3) && isObject$8(document$3.createElement);
|
|
427
|
+
|
|
428
|
+
var documentCreateElement$2 = function (it) {
|
|
429
|
+
return EXISTS$1 ? document$3.createElement(it) : {};
|
|
430
|
+
};
|
|
431
|
+
|
|
432
|
+
var DESCRIPTORS$c = descriptors;
|
|
433
|
+
var fails$g = fails$l;
|
|
434
|
+
var createElement$1 = documentCreateElement$2;
|
|
435
|
+
|
|
436
|
+
// Thanks to IE8 for its funny defineProperty
|
|
437
|
+
var ie8DomDefine = !DESCRIPTORS$c && !fails$g(function () {
|
|
438
|
+
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
439
|
+
return Object.defineProperty(createElement$1('div'), 'a', {
|
|
440
|
+
get: function () { return 7; }
|
|
441
|
+
}).a !== 7;
|
|
442
|
+
});
|
|
443
|
+
|
|
444
|
+
var DESCRIPTORS$b = descriptors;
|
|
445
|
+
var call$f = 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$9 = 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$b ? $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$9(O, P)) return createPropertyDescriptor$2(!call$f(propertyIsEnumerableModule$1.f, O, P), O[P]);
|
|
465
|
+
};
|
|
466
|
+
|
|
467
|
+
var objectDefineProperty = {};
|
|
468
|
+
|
|
469
|
+
var DESCRIPTORS$a = descriptors;
|
|
470
|
+
var fails$f = fails$l;
|
|
471
|
+
|
|
472
|
+
// V8 ~ Chrome 36-
|
|
473
|
+
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
|
|
474
|
+
var v8PrototypeDefineBug = DESCRIPTORS$a && fails$f(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$7 = isObject$b;
|
|
483
|
+
|
|
484
|
+
var $String$3 = String;
|
|
485
|
+
var $TypeError$c = TypeError;
|
|
486
|
+
|
|
487
|
+
// `Assert: Type(argument) is Object`
|
|
488
|
+
var anObject$e = function (argument) {
|
|
489
|
+
if (isObject$7(argument)) return argument;
|
|
490
|
+
throw new $TypeError$c($String$3(argument) + ' is not an object');
|
|
491
|
+
};
|
|
492
|
+
|
|
493
|
+
var DESCRIPTORS$9 = descriptors;
|
|
494
|
+
var IE8_DOM_DEFINE = ie8DomDefine;
|
|
447
495
|
var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
|
|
448
496
|
var anObject$d = anObject$e;
|
|
449
|
-
var toPropertyKey
|
|
497
|
+
var toPropertyKey = toPropertyKey$2;
|
|
450
498
|
|
|
451
|
-
var TypeError$
|
|
499
|
+
var $TypeError$b = 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
|
|
503
|
+
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
456
504
|
var ENUMERABLE = 'enumerable';
|
|
457
505
|
var CONFIGURABLE$1 = 'configurable';
|
|
458
506
|
var WRITABLE = 'writable';
|
|
459
507
|
|
|
460
508
|
// `Object.defineProperty` method
|
|
461
509
|
// https://tc39.es/ecma262/#sec-object.defineproperty
|
|
462
|
-
objectDefineProperty.f = DESCRIPTORS$
|
|
510
|
+
objectDefineProperty.f = DESCRIPTORS$9 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
|
|
463
511
|
anObject$d(O);
|
|
464
|
-
P = toPropertyKey
|
|
512
|
+
P = toPropertyKey(P);
|
|
465
513
|
anObject$d(Attributes);
|
|
466
514
|
if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
|
|
467
|
-
var current = $getOwnPropertyDescriptor
|
|
515
|
+
var current = $getOwnPropertyDescriptor(O, P);
|
|
468
516
|
if (current && current[WRITABLE]) {
|
|
469
517
|
O[P] = Attributes.value;
|
|
470
518
|
Attributes = {
|
|
@@ -476,25 +524,257 @@ objectDefineProperty.f = DESCRIPTORS$7 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
|
|
|
476
524
|
} return $defineProperty(O, P, Attributes);
|
|
477
525
|
} : $defineProperty : function defineProperty(O, P, Attributes) {
|
|
478
526
|
anObject$d(O);
|
|
479
|
-
P = toPropertyKey
|
|
527
|
+
P = toPropertyKey(P);
|
|
480
528
|
anObject$d(Attributes);
|
|
481
|
-
if (IE8_DOM_DEFINE
|
|
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$
|
|
532
|
+
if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$b('Accessors not supported');
|
|
485
533
|
if ('value' in Attributes) O[P] = Attributes.value;
|
|
486
534
|
return O;
|
|
487
535
|
};
|
|
488
536
|
|
|
537
|
+
var DESCRIPTORS$8 = descriptors;
|
|
538
|
+
var definePropertyModule$3 = objectDefineProperty;
|
|
539
|
+
var createPropertyDescriptor$1 = createPropertyDescriptor$3;
|
|
540
|
+
|
|
541
|
+
var createNonEnumerableProperty$5 = DESCRIPTORS$8 ? 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;
|
|
546
|
+
};
|
|
547
|
+
|
|
548
|
+
var makeBuiltIn$3 = {exports: {}};
|
|
549
|
+
|
|
550
|
+
var DESCRIPTORS$7 = descriptors;
|
|
551
|
+
var hasOwn$8 = hasOwnProperty_1;
|
|
552
|
+
|
|
553
|
+
var FunctionPrototype$1 = Function.prototype;
|
|
554
|
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
555
|
+
var getDescriptor = DESCRIPTORS$7 && Object.getOwnPropertyDescriptor;
|
|
556
|
+
|
|
557
|
+
var EXISTS = hasOwn$8(FunctionPrototype$1, 'name');
|
|
558
|
+
// additional protection from minified / mangled / dropped function names
|
|
559
|
+
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
|
|
560
|
+
var CONFIGURABLE = EXISTS && (!DESCRIPTORS$7 || (DESCRIPTORS$7 && getDescriptor(FunctionPrototype$1, 'name').configurable));
|
|
561
|
+
|
|
562
|
+
var functionName = {
|
|
563
|
+
EXISTS: EXISTS,
|
|
564
|
+
PROPER: PROPER,
|
|
565
|
+
CONFIGURABLE: CONFIGURABLE
|
|
566
|
+
};
|
|
567
|
+
|
|
568
|
+
var uncurryThis$f = functionUncurryThis;
|
|
569
|
+
var isCallable$g = isCallable$m;
|
|
570
|
+
var store$1 = sharedStoreExports;
|
|
571
|
+
|
|
572
|
+
var functionToString = uncurryThis$f(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$g(store$1.inspectSource)) {
|
|
576
|
+
store$1.inspectSource = function (it) {
|
|
577
|
+
return functionToString(it);
|
|
578
|
+
};
|
|
579
|
+
}
|
|
580
|
+
|
|
581
|
+
var inspectSource$3 = store$1.inspectSource;
|
|
582
|
+
|
|
583
|
+
var global$e = global$l;
|
|
584
|
+
var isCallable$f = isCallable$m;
|
|
585
|
+
|
|
586
|
+
var WeakMap$1 = global$e.WeakMap;
|
|
587
|
+
|
|
588
|
+
var weakMapBasicDetection = isCallable$f(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$d = global$l;
|
|
603
|
+
var isObject$6 = isObject$b;
|
|
604
|
+
var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
|
|
605
|
+
var hasOwn$7 = 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$2 = global$d.TypeError;
|
|
612
|
+
var WeakMap = global$d.WeakMap;
|
|
613
|
+
var set$1, get, has;
|
|
614
|
+
|
|
615
|
+
var enforce = function (it) {
|
|
616
|
+
return has(it) ? get(it) : set$1(it, {});
|
|
617
|
+
};
|
|
618
|
+
|
|
619
|
+
var getterFor = function (TYPE) {
|
|
620
|
+
return function (it) {
|
|
621
|
+
var state;
|
|
622
|
+
if (!isObject$6(it) || (state = get(it)).type !== TYPE) {
|
|
623
|
+
throw new TypeError$2('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$1 = function (it, metadata) {
|
|
636
|
+
if (store.has(it)) throw new TypeError$2(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$1 = function (it, metadata) {
|
|
651
|
+
if (hasOwn$7(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED);
|
|
652
|
+
metadata.facade = it;
|
|
653
|
+
createNonEnumerableProperty$4(it, STATE, metadata);
|
|
654
|
+
return metadata;
|
|
655
|
+
};
|
|
656
|
+
get = function (it) {
|
|
657
|
+
return hasOwn$7(it, STATE) ? it[STATE] : {};
|
|
658
|
+
};
|
|
659
|
+
has = function (it) {
|
|
660
|
+
return hasOwn$7(it, STATE);
|
|
661
|
+
};
|
|
662
|
+
}
|
|
663
|
+
|
|
664
|
+
var internalState = {
|
|
665
|
+
set: set$1,
|
|
666
|
+
get: get,
|
|
667
|
+
has: has,
|
|
668
|
+
enforce: enforce,
|
|
669
|
+
getterFor: getterFor
|
|
670
|
+
};
|
|
671
|
+
|
|
672
|
+
var uncurryThis$e = functionUncurryThis;
|
|
673
|
+
var fails$e = fails$l;
|
|
674
|
+
var isCallable$e = isCallable$m;
|
|
675
|
+
var hasOwn$6 = hasOwnProperty_1;
|
|
676
|
+
var DESCRIPTORS$6 = descriptors;
|
|
677
|
+
var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
|
|
678
|
+
var inspectSource$2 = inspectSource$3;
|
|
679
|
+
var InternalStateModule$2 = internalState;
|
|
680
|
+
|
|
681
|
+
var enforceInternalState = InternalStateModule$2.enforce;
|
|
682
|
+
var getInternalState$2 = InternalStateModule$2.get;
|
|
683
|
+
var $String$2 = String;
|
|
684
|
+
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
685
|
+
var defineProperty$5 = Object.defineProperty;
|
|
686
|
+
var stringSlice$5 = uncurryThis$e(''.slice);
|
|
687
|
+
var replace$2 = uncurryThis$e(''.replace);
|
|
688
|
+
var join = uncurryThis$e([].join);
|
|
689
|
+
|
|
690
|
+
var CONFIGURABLE_LENGTH = DESCRIPTORS$6 && !fails$e(function () {
|
|
691
|
+
return defineProperty$5(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
|
|
692
|
+
});
|
|
693
|
+
|
|
694
|
+
var TEMPLATE = String(String).split('String');
|
|
695
|
+
|
|
696
|
+
var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
|
|
697
|
+
if (stringSlice$5($String$2(name), 0, 7) === 'Symbol(') {
|
|
698
|
+
name = '[' + replace$2($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$6(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
|
|
703
|
+
if (DESCRIPTORS$6) defineProperty$5(value, 'name', { value: name, configurable: true });
|
|
704
|
+
else value.name = name;
|
|
705
|
+
}
|
|
706
|
+
if (CONFIGURABLE_LENGTH && options && hasOwn$6(options, 'arity') && value.length !== options.arity) {
|
|
707
|
+
defineProperty$5(value, 'length', { value: options.arity });
|
|
708
|
+
}
|
|
709
|
+
try {
|
|
710
|
+
if (options && hasOwn$6(options, 'constructor') && options.constructor) {
|
|
711
|
+
if (DESCRIPTORS$6) defineProperty$5(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$6(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$2(function toString() {
|
|
724
|
+
return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this);
|
|
725
|
+
}, 'toString');
|
|
726
|
+
|
|
727
|
+
var makeBuiltInExports = makeBuiltIn$3.exports;
|
|
728
|
+
|
|
729
|
+
var isCallable$d = isCallable$m;
|
|
730
|
+
var definePropertyModule$2 = objectDefineProperty;
|
|
731
|
+
var makeBuiltIn$1 = makeBuiltInExports;
|
|
732
|
+
var defineGlobalProperty$1 = defineGlobalProperty$3;
|
|
733
|
+
|
|
734
|
+
var defineBuiltIn$7 = 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$d(value)) makeBuiltIn$1(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
|
+
|
|
489
759
|
var ceil = Math.ceil;
|
|
490
760
|
var floor$1 = Math.floor;
|
|
491
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$1 : ceil)(n);
|
|
768
|
+
};
|
|
769
|
+
|
|
770
|
+
var trunc = mathTrunc;
|
|
771
|
+
|
|
492
772
|
// `ToIntegerOrInfinity` abstract operation
|
|
493
773
|
// https://tc39.es/ecma262/#sec-tointegerorinfinity
|
|
494
774
|
var toIntegerOrInfinity$4 = function (argument) {
|
|
495
775
|
var number = +argument;
|
|
496
|
-
// eslint-disable-next-line no-self-compare --
|
|
497
|
-
return number !== number || number === 0 ? 0 : (number
|
|
776
|
+
// eslint-disable-next-line no-self-compare -- NaN check
|
|
777
|
+
return number !== number || number === 0 ? 0 : trunc(number);
|
|
498
778
|
};
|
|
499
779
|
|
|
500
780
|
var toIntegerOrInfinity$3 = toIntegerOrInfinity$4;
|
|
@@ -517,34 +797,36 @@ var min$2 = Math.min;
|
|
|
517
797
|
// `ToLength` abstract operation
|
|
518
798
|
// https://tc39.es/ecma262/#sec-tolength
|
|
519
799
|
var toLength$3 = function (argument) {
|
|
520
|
-
|
|
800
|
+
var len = toIntegerOrInfinity$2(argument);
|
|
801
|
+
return len > 0 ? min$2(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
|
|
521
802
|
};
|
|
522
803
|
|
|
523
804
|
var toLength$2 = toLength$3;
|
|
524
805
|
|
|
525
806
|
// `LengthOfArrayLike` abstract operation
|
|
526
807
|
// https://tc39.es/ecma262/#sec-lengthofarraylike
|
|
527
|
-
var lengthOfArrayLike$
|
|
808
|
+
var lengthOfArrayLike$3 = function (obj) {
|
|
528
809
|
return toLength$2(obj.length);
|
|
529
810
|
};
|
|
530
811
|
|
|
531
|
-
var toIndexedObject$
|
|
812
|
+
var toIndexedObject$3 = toIndexedObject$5;
|
|
532
813
|
var toAbsoluteIndex = toAbsoluteIndex$1;
|
|
533
|
-
var lengthOfArrayLike$
|
|
814
|
+
var lengthOfArrayLike$2 = lengthOfArrayLike$3;
|
|
534
815
|
|
|
535
816
|
// `Array.prototype.{ indexOf, includes }` methods implementation
|
|
536
817
|
var createMethod$1 = function (IS_INCLUDES) {
|
|
537
818
|
return function ($this, el, fromIndex) {
|
|
538
|
-
var O = toIndexedObject$
|
|
539
|
-
var length = lengthOfArrayLike$
|
|
819
|
+
var O = toIndexedObject$3($this);
|
|
820
|
+
var length = lengthOfArrayLike$2(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
|
|
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
|
|
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;
|
|
@@ -561,24 +843,22 @@ var arrayIncludes = {
|
|
|
561
843
|
indexOf: createMethod$1(false)
|
|
562
844
|
};
|
|
563
845
|
|
|
564
|
-
var
|
|
565
|
-
|
|
566
|
-
var
|
|
567
|
-
var hasOwn$8 = hasOwnProperty_1;
|
|
568
|
-
var toIndexedObject$3 = toIndexedObject$5;
|
|
846
|
+
var uncurryThis$d = functionUncurryThis;
|
|
847
|
+
var hasOwn$5 = hasOwnProperty_1;
|
|
848
|
+
var toIndexedObject$2 = toIndexedObject$5;
|
|
569
849
|
var indexOf$1 = arrayIncludes.indexOf;
|
|
570
|
-
var hiddenKeys$
|
|
850
|
+
var hiddenKeys$2 = hiddenKeys$4;
|
|
571
851
|
|
|
572
|
-
var push$1 = uncurryThis$
|
|
852
|
+
var push$1 = uncurryThis$d([].push);
|
|
573
853
|
|
|
574
854
|
var objectKeysInternal = function (object, names) {
|
|
575
|
-
var O = toIndexedObject$
|
|
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$
|
|
859
|
+
for (key in O) !hasOwn$5(hiddenKeys$2, key) && hasOwn$5(O, key) && push$1(result, key);
|
|
580
860
|
// Don't enum bug & hidden keys
|
|
581
|
-
while (names.length > i) if (hasOwn$
|
|
861
|
+
while (names.length > i) if (hasOwn$5(O, key = names[i++])) {
|
|
582
862
|
~indexOf$1(result, key) || push$1(result, key);
|
|
583
863
|
}
|
|
584
864
|
return result;
|
|
@@ -598,31 +878,160 @@ 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$5 = getBuiltIn$7;
|
|
896
|
+
var uncurryThis$c = functionUncurryThis;
|
|
897
|
+
var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
|
|
898
|
+
var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
|
|
899
|
+
var anObject$c = anObject$e;
|
|
900
|
+
|
|
901
|
+
var concat$2 = uncurryThis$c([].concat);
|
|
902
|
+
|
|
903
|
+
// all object keys, includes non-enumerable and symbols
|
|
904
|
+
var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) {
|
|
905
|
+
var keys = getOwnPropertyNamesModule.f(anObject$c(it));
|
|
906
|
+
var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
|
|
907
|
+
return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys;
|
|
908
|
+
};
|
|
909
|
+
|
|
910
|
+
var hasOwn$4 = 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$4(target, key) && !(exceptions && hasOwn$4(exceptions, key))) {
|
|
922
|
+
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
};
|
|
926
|
+
|
|
927
|
+
var fails$d = fails$l;
|
|
928
|
+
var isCallable$c = isCallable$m;
|
|
929
|
+
|
|
930
|
+
var replacement = /#|\.prototype\./;
|
|
931
|
+
|
|
932
|
+
var isForced$2 = function (feature, detection) {
|
|
933
|
+
var value = data[normalize(feature)];
|
|
934
|
+
return value === POLYFILL ? true
|
|
935
|
+
: value === NATIVE ? false
|
|
936
|
+
: isCallable$c(detection) ? fails$d(detection)
|
|
937
|
+
: !!detection;
|
|
938
|
+
};
|
|
939
|
+
|
|
940
|
+
var normalize = isForced$2.normalize = function (string) {
|
|
941
|
+
return String(string).replace(replacement, '.').toLowerCase();
|
|
942
|
+
};
|
|
943
|
+
|
|
944
|
+
var data = isForced$2.data = {};
|
|
945
|
+
var NATIVE = isForced$2.NATIVE = 'N';
|
|
946
|
+
var POLYFILL = isForced$2.POLYFILL = 'P';
|
|
947
|
+
|
|
948
|
+
var isForced_1 = isForced$2;
|
|
949
|
+
|
|
950
|
+
var global$c = global$l;
|
|
951
|
+
var getOwnPropertyDescriptor$3 = objectGetOwnPropertyDescriptor.f;
|
|
952
|
+
var createNonEnumerableProperty$3 = createNonEnumerableProperty$5;
|
|
953
|
+
var defineBuiltIn$6 = defineBuiltIn$7;
|
|
954
|
+
var defineGlobalProperty = defineGlobalProperty$3;
|
|
955
|
+
var copyConstructorProperties = copyConstructorProperties$1;
|
|
956
|
+
var isForced$1 = 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$c;
|
|
980
|
+
} else if (STATIC) {
|
|
981
|
+
target = global$c[TARGET] || defineGlobalProperty(TARGET, {});
|
|
982
|
+
} else {
|
|
983
|
+
target = global$c[TARGET] && global$c[TARGET].prototype;
|
|
984
|
+
}
|
|
985
|
+
if (target) for (key in source) {
|
|
986
|
+
sourceProperty = source[key];
|
|
987
|
+
if (options.dontCallGetSet) {
|
|
988
|
+
descriptor = getOwnPropertyDescriptor$3(target, key);
|
|
989
|
+
targetProperty = descriptor && descriptor.value;
|
|
990
|
+
} else targetProperty = target[key];
|
|
991
|
+
FORCED = isForced$1(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$3(sourceProperty, 'sham', true);
|
|
1000
|
+
}
|
|
1001
|
+
defineBuiltIn$6(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
|
|
1014
|
+
return internalObjectKeys(O, enumBugKeys$1);
|
|
606
1015
|
};
|
|
607
1016
|
|
|
608
|
-
var DESCRIPTORS$
|
|
1017
|
+
var DESCRIPTORS$5 = descriptors;
|
|
609
1018
|
var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
|
|
610
|
-
var definePropertyModule
|
|
611
|
-
var anObject$
|
|
612
|
-
var toIndexedObject$
|
|
1019
|
+
var definePropertyModule = objectDefineProperty;
|
|
1020
|
+
var anObject$b = anObject$e;
|
|
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$
|
|
619
|
-
anObject$
|
|
620
|
-
var props = toIndexedObject$
|
|
1027
|
+
objectDefineProperties.f = DESCRIPTORS$5 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
|
|
1028
|
+
anObject$b(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
|
|
1034
|
+
while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
|
|
626
1035
|
return O;
|
|
627
1036
|
};
|
|
628
1037
|
|
|
@@ -630,30 +1039,20 @@ var getBuiltIn$4 = getBuiltIn$7;
|
|
|
630
1039
|
|
|
631
1040
|
var html$2 = getBuiltIn$4('document', 'documentElement');
|
|
632
1041
|
|
|
633
|
-
var shared$2 = shared$4.exports;
|
|
634
|
-
var uid = uid$2;
|
|
635
|
-
|
|
636
|
-
var keys = shared$2('keys');
|
|
637
|
-
|
|
638
|
-
var sharedKey$3 = function (key) {
|
|
639
|
-
return keys[key] || (keys[key] = uid(key));
|
|
640
|
-
};
|
|
641
|
-
|
|
642
1042
|
/* global ActiveXObject -- old IE, WSH */
|
|
643
|
-
|
|
644
|
-
var anObject$b = anObject$e;
|
|
1043
|
+
var anObject$a = anObject$e;
|
|
645
1044
|
var definePropertiesModule = objectDefineProperties;
|
|
646
|
-
var enumBugKeys
|
|
647
|
-
var hiddenKeys
|
|
1045
|
+
var enumBugKeys = enumBugKeys$3;
|
|
1046
|
+
var hiddenKeys = hiddenKeys$4;
|
|
648
1047
|
var html$1 = html$2;
|
|
649
1048
|
var documentCreateElement$1 = documentCreateElement$2;
|
|
650
|
-
var sharedKey$
|
|
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$
|
|
1055
|
+
var IE_PROTO$1 = sharedKey$1('IE_PROTO');
|
|
657
1056
|
|
|
658
1057
|
var EmptyConstructor = function () { /* empty */ };
|
|
659
1058
|
|
|
@@ -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
|
|
706
|
-
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys
|
|
1104
|
+
var length = enumBugKeys.length;
|
|
1105
|
+
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
|
|
707
1106
|
return NullProtoObject();
|
|
708
1107
|
};
|
|
709
1108
|
|
|
710
|
-
hiddenKeys
|
|
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$
|
|
1117
|
+
EmptyConstructor[PROTOTYPE] = anObject$a(O);
|
|
718
1118
|
result = new EmptyConstructor();
|
|
719
1119
|
EmptyConstructor[PROTOTYPE] = null;
|
|
720
1120
|
// add "__proto__" for Object.getPrototypeOf polyfill
|
|
@@ -725,15 +1125,15 @@ var objectCreate = Object.create || function create(O, Properties) {
|
|
|
725
1125
|
|
|
726
1126
|
var wellKnownSymbol$g = wellKnownSymbol$i;
|
|
727
1127
|
var create$2 = objectCreate;
|
|
728
|
-
var
|
|
1128
|
+
var defineProperty$4 = objectDefineProperty.f;
|
|
729
1129
|
|
|
730
1130
|
var UNSCOPABLES = wellKnownSymbol$g('unscopables');
|
|
731
1131
|
var ArrayPrototype$1 = Array.prototype;
|
|
732
1132
|
|
|
733
1133
|
// Array.prototype[@@unscopables]
|
|
734
1134
|
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
735
|
-
if (ArrayPrototype$1[UNSCOPABLES]
|
|
736
|
-
|
|
1135
|
+
if (ArrayPrototype$1[UNSCOPABLES] === undefined) {
|
|
1136
|
+
defineProperty$4(ArrayPrototype$1, UNSCOPABLES, {
|
|
737
1137
|
configurable: true,
|
|
738
1138
|
value: create$2(null)
|
|
739
1139
|
});
|
|
@@ -744,394 +1144,66 @@ var addToUnscopables$2 = function (key) {
|
|
|
744
1144
|
ArrayPrototype$1[UNSCOPABLES][key] = true;
|
|
745
1145
|
};
|
|
746
1146
|
|
|
747
|
-
var
|
|
748
|
-
|
|
749
|
-
var
|
|
750
|
-
var
|
|
751
|
-
var store$1 = sharedStore;
|
|
752
|
-
|
|
753
|
-
var functionToString = uncurryThis$f(Function.toString);
|
|
754
|
-
|
|
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');
|
|
1147
|
+
var $$d = _export;
|
|
1148
|
+
var $includes = arrayIncludes.includes;
|
|
1149
|
+
var fails$c = fails$l;
|
|
1150
|
+
var addToUnscopables$1 = addToUnscopables$2;
|
|
935
1151
|
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
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;
|
|
962
|
-
}
|
|
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);
|
|
1152
|
+
// FF99+ bug
|
|
1153
|
+
var BROKEN_ON_SPARSE = fails$c(function () {
|
|
1154
|
+
// eslint-disable-next-line es/no-array-prototype-includes -- detection
|
|
1155
|
+
return !Array(1).includes();
|
|
968
1156
|
});
|
|
969
1157
|
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
|
|
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
|
-
}
|
|
1158
|
+
// `Array.prototype.includes` method
|
|
1159
|
+
// https://tc39.es/ecma262/#sec-array.prototype.includes
|
|
1160
|
+
$$d({ 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);
|
|
1018
1163
|
}
|
|
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;
|
|
1164
|
+
});
|
|
1043
1165
|
|
|
1044
|
-
|
|
1045
|
-
|
|
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$
|
|
1171
|
+
var fails$b = fails$l;
|
|
1101
1172
|
|
|
1102
|
-
var correctPrototypeGetter = !fails$
|
|
1173
|
+
var correctPrototypeGetter = !fails$b(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
|
|
1110
|
-
var
|
|
1111
|
-
var
|
|
1112
|
-
var toObject$2 = toObject$4;
|
|
1180
|
+
var hasOwn$3 = hasOwnProperty_1;
|
|
1181
|
+
var isCallable$b = isCallable$m;
|
|
1182
|
+
var toObject$3 = toObject$5;
|
|
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$
|
|
1118
|
-
var ObjectPrototype = Object$
|
|
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
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1192
|
+
// eslint-disable-next-line es/no-object-getprototypeof -- safe
|
|
1193
|
+
var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object$1.getPrototypeOf : function (O) {
|
|
1194
|
+
var object = toObject$3(O);
|
|
1195
|
+
if (hasOwn$3(object, IE_PROTO)) return object[IE_PROTO];
|
|
1125
1196
|
var constructor = object.constructor;
|
|
1126
|
-
if (isCallable$
|
|
1197
|
+
if (isCallable$b(constructor) && object instanceof constructor) {
|
|
1127
1198
|
return constructor.prototype;
|
|
1128
|
-
} return object instanceof Object$
|
|
1199
|
+
} return object instanceof $Object$1 ? ObjectPrototype : null;
|
|
1129
1200
|
};
|
|
1130
1201
|
|
|
1131
|
-
var fails$
|
|
1132
|
-
var isCallable$
|
|
1202
|
+
var fails$a = fails$l;
|
|
1203
|
+
var isCallable$a = isCallable$m;
|
|
1204
|
+
var isObject$5 = isObject$b;
|
|
1133
1205
|
var getPrototypeOf$1 = objectGetPrototypeOf;
|
|
1134
|
-
var
|
|
1206
|
+
var defineBuiltIn$5 = defineBuiltIn$7;
|
|
1135
1207
|
var wellKnownSymbol$f = wellKnownSymbol$i;
|
|
1136
1208
|
|
|
1137
1209
|
var ITERATOR$5 = wellKnownSymbol$f('iterator');
|
|
@@ -1152,7 +1224,7 @@ if ([].keys) {
|
|
|
1152
1224
|
}
|
|
1153
1225
|
}
|
|
1154
1226
|
|
|
1155
|
-
var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2
|
|
1227
|
+
var NEW_ITERATOR_PROTOTYPE = !isObject$5(IteratorPrototype$2) || fails$a(function () {
|
|
1156
1228
|
var test = {};
|
|
1157
1229
|
// FF44- legacy iterators case
|
|
1158
1230
|
return IteratorPrototype$2[ITERATOR$5].call(test) !== test;
|
|
@@ -1162,8 +1234,8 @@ 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$
|
|
1166
|
-
|
|
1237
|
+
if (!isCallable$a(IteratorPrototype$2[ITERATOR$5])) {
|
|
1238
|
+
defineBuiltIn$5(IteratorPrototype$2, ITERATOR$5, function () {
|
|
1167
1239
|
return this;
|
|
1168
1240
|
});
|
|
1169
1241
|
}
|
|
@@ -1173,50 +1245,65 @@ var iteratorsCore = {
|
|
|
1173
1245
|
BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1
|
|
1174
1246
|
};
|
|
1175
1247
|
|
|
1176
|
-
var defineProperty$
|
|
1177
|
-
var hasOwn$
|
|
1248
|
+
var defineProperty$3 = objectDefineProperty.f;
|
|
1249
|
+
var hasOwn$2 = hasOwnProperty_1;
|
|
1178
1250
|
var wellKnownSymbol$e = wellKnownSymbol$i;
|
|
1179
1251
|
|
|
1180
|
-
var TO_STRING_TAG$
|
|
1252
|
+
var TO_STRING_TAG$2 = wellKnownSymbol$e('toStringTag');
|
|
1181
1253
|
|
|
1182
|
-
var setToStringTag$
|
|
1254
|
+
var setToStringTag$4 = function (target, TAG, STATIC) {
|
|
1183
1255
|
if (target && !STATIC) target = target.prototype;
|
|
1184
|
-
if (target && !hasOwn$
|
|
1185
|
-
defineProperty$
|
|
1256
|
+
if (target && !hasOwn$2(target, TO_STRING_TAG$2)) {
|
|
1257
|
+
defineProperty$3(target, TO_STRING_TAG$2, { configurable: true, value: TAG });
|
|
1186
1258
|
}
|
|
1187
1259
|
};
|
|
1188
1260
|
|
|
1189
1261
|
var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
|
|
1190
1262
|
var create$1 = objectCreate;
|
|
1191
1263
|
var createPropertyDescriptor = createPropertyDescriptor$3;
|
|
1192
|
-
var setToStringTag$
|
|
1264
|
+
var setToStringTag$3 = setToStringTag$4;
|
|
1193
1265
|
var Iterators$4 = iterators;
|
|
1194
1266
|
|
|
1195
1267
|
var returnThis$1 = function () { return this; };
|
|
1196
1268
|
|
|
1197
|
-
var
|
|
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
|
-
setToStringTag$
|
|
1272
|
+
setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false);
|
|
1201
1273
|
Iterators$4[TO_STRING_TAG] = returnThis$1;
|
|
1202
1274
|
return IteratorConstructor;
|
|
1203
1275
|
};
|
|
1204
1276
|
|
|
1205
|
-
var
|
|
1206
|
-
var
|
|
1277
|
+
var uncurryThis$b = functionUncurryThis;
|
|
1278
|
+
var aCallable$6 = aCallable$8;
|
|
1279
|
+
|
|
1280
|
+
var functionUncurryThisAccessor = function (object, key, method) {
|
|
1281
|
+
try {
|
|
1282
|
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
1283
|
+
return uncurryThis$b(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method]));
|
|
1284
|
+
} catch (error) { /* empty */ }
|
|
1285
|
+
};
|
|
1286
|
+
|
|
1287
|
+
var isObject$4 = isObject$b;
|
|
1207
1288
|
|
|
1208
|
-
var
|
|
1209
|
-
|
|
1289
|
+
var isPossiblePrototype$1 = function (argument) {
|
|
1290
|
+
return isObject$4(argument) || argument === null;
|
|
1291
|
+
};
|
|
1292
|
+
|
|
1293
|
+
var isPossiblePrototype = isPossiblePrototype$1;
|
|
1294
|
+
|
|
1295
|
+
var $String$1 = String;
|
|
1296
|
+
var $TypeError$a = TypeError;
|
|
1210
1297
|
|
|
1211
1298
|
var aPossiblePrototype$1 = function (argument) {
|
|
1212
|
-
if (
|
|
1213
|
-
throw TypeError$
|
|
1299
|
+
if (isPossiblePrototype(argument)) return argument;
|
|
1300
|
+
throw new $TypeError$a("Can't set " + $String$1(argument) + ' as a prototype');
|
|
1214
1301
|
};
|
|
1215
1302
|
|
|
1216
1303
|
/* eslint-disable no-proto -- safe */
|
|
1217
|
-
|
|
1218
|
-
var
|
|
1219
|
-
var
|
|
1304
|
+
var uncurryThisAccessor = functionUncurryThisAccessor;
|
|
1305
|
+
var isObject$3 = isObject$b;
|
|
1306
|
+
var requireObjectCoercible$4 = requireObjectCoercible$7;
|
|
1220
1307
|
var aPossiblePrototype = aPossiblePrototype$1;
|
|
1221
1308
|
|
|
1222
1309
|
// `Object.setPrototypeOf` method
|
|
@@ -1228,30 +1315,30 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
|
|
|
1228
1315
|
var test = {};
|
|
1229
1316
|
var setter;
|
|
1230
1317
|
try {
|
|
1231
|
-
|
|
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
|
-
|
|
1323
|
+
requireObjectCoercible$4(O);
|
|
1238
1324
|
aPossiblePrototype(proto);
|
|
1325
|
+
if (!isObject$3(O)) return O;
|
|
1239
1326
|
if (CORRECT_SETTER) setter(O, proto);
|
|
1240
1327
|
else O.__proto__ = proto;
|
|
1241
1328
|
return O;
|
|
1242
1329
|
};
|
|
1243
1330
|
}() : undefined);
|
|
1244
1331
|
|
|
1245
|
-
var $$
|
|
1246
|
-
var call$
|
|
1332
|
+
var $$c = _export;
|
|
1333
|
+
var call$e = functionCall;
|
|
1247
1334
|
var FunctionName = functionName;
|
|
1248
|
-
var isCallable$
|
|
1249
|
-
var createIteratorConstructor =
|
|
1335
|
+
var isCallable$9 = isCallable$m;
|
|
1336
|
+
var createIteratorConstructor = iteratorCreateConstructor;
|
|
1250
1337
|
var getPrototypeOf = objectGetPrototypeOf;
|
|
1251
1338
|
var setPrototypeOf$1 = objectSetPrototypeOf;
|
|
1252
|
-
var setToStringTag$
|
|
1253
|
-
var createNonEnumerableProperty$2 = createNonEnumerableProperty$
|
|
1254
|
-
var
|
|
1339
|
+
var setToStringTag$2 = setToStringTag$4;
|
|
1340
|
+
var createNonEnumerableProperty$2 = createNonEnumerableProperty$5;
|
|
1341
|
+
var defineBuiltIn$4 = defineBuiltIn$7;
|
|
1255
1342
|
var wellKnownSymbol$d = wellKnownSymbol$i;
|
|
1256
1343
|
var Iterators$3 = iterators;
|
|
1257
1344
|
var IteratorsCore = iteratorsCore;
|
|
@@ -1267,17 +1354,20 @@ var ENTRIES = 'entries';
|
|
|
1267
1354
|
|
|
1268
1355
|
var returnThis = function () { return this; };
|
|
1269
1356
|
|
|
1270
|
-
var
|
|
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
|
-
}
|
|
1368
|
+
}
|
|
1369
|
+
|
|
1370
|
+
return function () { return new IteratorConstructor(this); };
|
|
1281
1371
|
};
|
|
1282
1372
|
|
|
1283
1373
|
var TO_STRING_TAG = NAME + ' Iterator';
|
|
@@ -1287,7 +1377,7 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
|
|
|
1287
1377
|
|| IterablePrototype['@@iterator']
|
|
1288
1378
|
|| DEFAULT && IterablePrototype[DEFAULT];
|
|
1289
1379
|
var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
|
|
1290
|
-
var anyNativeIterator = NAME
|
|
1380
|
+
var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
|
|
1291
1381
|
var CurrentIteratorPrototype, methods, KEY;
|
|
1292
1382
|
|
|
1293
1383
|
// fix native
|
|
@@ -1297,22 +1387,22 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
|
|
|
1297
1387
|
if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
|
|
1298
1388
|
if (setPrototypeOf$1) {
|
|
1299
1389
|
setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype);
|
|
1300
|
-
} else if (!isCallable$
|
|
1301
|
-
|
|
1390
|
+
} else if (!isCallable$9(CurrentIteratorPrototype[ITERATOR$4])) {
|
|
1391
|
+
defineBuiltIn$4(CurrentIteratorPrototype, ITERATOR$4, returnThis);
|
|
1302
1392
|
}
|
|
1303
1393
|
}
|
|
1304
1394
|
// Set @@toStringTag to native iterators
|
|
1305
|
-
setToStringTag$
|
|
1395
|
+
setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true);
|
|
1306
1396
|
}
|
|
1307
1397
|
}
|
|
1308
1398
|
|
|
1309
1399
|
// fix Array.prototype.{ values, @@iterator }.name in V8 / FF
|
|
1310
|
-
if (PROPER_FUNCTION_NAME$1 && DEFAULT
|
|
1400
|
+
if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
|
|
1311
1401
|
if (CONFIGURABLE_FUNCTION_NAME) {
|
|
1312
1402
|
createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES);
|
|
1313
1403
|
} else {
|
|
1314
1404
|
INCORRECT_VALUES_NAME = true;
|
|
1315
|
-
defaultIterator = function values() { return call$
|
|
1405
|
+
defaultIterator = function values() { return call$e(nativeIterator, this); };
|
|
1316
1406
|
}
|
|
1317
1407
|
}
|
|
1318
1408
|
|
|
@@ -1325,313 +1415,111 @@ 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
|
-
|
|
1418
|
+
defineBuiltIn$4(IterablePrototype, KEY, methods[KEY]);
|
|
1329
1419
|
}
|
|
1330
|
-
} else $$
|
|
1420
|
+
} else $$c({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
|
|
1331
1421
|
}
|
|
1332
1422
|
|
|
1333
1423
|
// define iterator
|
|
1334
1424
|
if (IterablePrototype[ITERATOR$4] !== defaultIterator) {
|
|
1335
|
-
|
|
1425
|
+
defineBuiltIn$4(IterablePrototype, ITERATOR$4, defaultIterator, { name: DEFAULT });
|
|
1336
1426
|
}
|
|
1337
1427
|
Iterators$3[NAME] = defaultIterator;
|
|
1338
1428
|
|
|
1339
1429
|
return methods;
|
|
1340
1430
|
};
|
|
1341
1431
|
|
|
1342
|
-
|
|
1343
|
-
|
|
1344
|
-
var
|
|
1345
|
-
|
|
1346
|
-
|
|
1347
|
-
var defineIterator = defineIterator$1;
|
|
1348
|
-
var DESCRIPTORS$2 = descriptors;
|
|
1349
|
-
|
|
1350
|
-
var ARRAY_ITERATOR = 'Array Iterator';
|
|
1351
|
-
var setInternalState$1 = InternalStateModule$1.set;
|
|
1352
|
-
var getInternalState$2 = InternalStateModule$1.getterFor(ARRAY_ITERATOR);
|
|
1353
|
-
|
|
1354
|
-
// `Array.prototype.entries` method
|
|
1355
|
-
// https://tc39.es/ecma262/#sec-array.prototype.entries
|
|
1356
|
-
// `Array.prototype.keys` method
|
|
1357
|
-
// https://tc39.es/ecma262/#sec-array.prototype.keys
|
|
1358
|
-
// `Array.prototype.values` method
|
|
1359
|
-
// https://tc39.es/ecma262/#sec-array.prototype.values
|
|
1360
|
-
// `Array.prototype[@@iterator]` method
|
|
1361
|
-
// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
|
|
1362
|
-
// `CreateArrayIterator` internal method
|
|
1363
|
-
// https://tc39.es/ecma262/#sec-createarrayiterator
|
|
1364
|
-
var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
|
|
1365
|
-
setInternalState$1(this, {
|
|
1366
|
-
type: ARRAY_ITERATOR,
|
|
1367
|
-
target: toIndexedObject(iterated), // target
|
|
1368
|
-
index: 0, // next index
|
|
1369
|
-
kind: kind // kind
|
|
1370
|
-
});
|
|
1371
|
-
// `%ArrayIteratorPrototype%.next` method
|
|
1372
|
-
// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
|
|
1373
|
-
}, function () {
|
|
1374
|
-
var state = getInternalState$2(this);
|
|
1375
|
-
var target = state.target;
|
|
1376
|
-
var kind = state.kind;
|
|
1377
|
-
var index = state.index++;
|
|
1378
|
-
if (!target || index >= target.length) {
|
|
1379
|
-
state.target = undefined;
|
|
1380
|
-
return { value: undefined, done: true };
|
|
1381
|
-
}
|
|
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 };
|
|
1385
|
-
}, 'values');
|
|
1386
|
-
|
|
1387
|
-
// argumentsList[@@iterator] is %ArrayProto_values%
|
|
1388
|
-
// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
|
|
1389
|
-
// https://tc39.es/ecma262/#sec-createmappedargumentsobject
|
|
1390
|
-
var values = Iterators$2.Arguments = Iterators$2.Array;
|
|
1391
|
-
|
|
1392
|
-
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
1393
|
-
addToUnscopables$1('keys');
|
|
1394
|
-
addToUnscopables$1('values');
|
|
1395
|
-
addToUnscopables$1('entries');
|
|
1396
|
-
|
|
1397
|
-
// V8 ~ Chrome 45- bug
|
|
1398
|
-
if (DESCRIPTORS$2 && values.name !== 'values') try {
|
|
1399
|
-
defineProperty$1(values, 'name', { value: 'values' });
|
|
1400
|
-
} catch (error) { /* empty */ }
|
|
1401
|
-
|
|
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;
|
|
1452
|
-
|
|
1453
|
-
var ITERATOR$3 = wellKnownSymbol$c('iterator');
|
|
1454
|
-
var TO_STRING_TAG$2 = wellKnownSymbol$c('toStringTag');
|
|
1455
|
-
var ArrayValues = ArrayIteratorMethods.values;
|
|
1456
|
-
|
|
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);
|
|
1467
|
-
}
|
|
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
|
-
}
|
|
1475
|
-
}
|
|
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');
|
|
1484
|
-
|
|
1485
|
-
var $$5 = _export;
|
|
1486
|
-
var $includes = arrayIncludes.includes;
|
|
1487
|
-
var addToUnscopables = addToUnscopables$2;
|
|
1488
|
-
|
|
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
|
-
}
|
|
1495
|
-
});
|
|
1496
|
-
|
|
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');
|
|
1505
|
-
|
|
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');
|
|
1527
|
-
var test = {};
|
|
1528
|
-
|
|
1529
|
-
test[TO_STRING_TAG$1] = 'z';
|
|
1530
|
-
|
|
1531
|
-
var toStringTagSupport = String(test) === '[object z]';
|
|
1532
|
-
|
|
1533
|
-
var global$h = global$G;
|
|
1534
|
-
var TO_STRING_TAG_SUPPORT = toStringTagSupport;
|
|
1535
|
-
var isCallable$5 = isCallable$j;
|
|
1536
|
-
var classofRaw = classofRaw$1;
|
|
1537
|
-
var wellKnownSymbol$9 = wellKnownSymbol$i;
|
|
1538
|
-
|
|
1539
|
-
var TO_STRING_TAG = wellKnownSymbol$9('toStringTag');
|
|
1540
|
-
var Object$1 = global$h.Object;
|
|
1541
|
-
|
|
1542
|
-
// ES3 wrong here
|
|
1543
|
-
var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
|
|
1544
|
-
|
|
1545
|
-
// fallback for IE11 Script Access Denied error
|
|
1546
|
-
var tryGet = function (it, key) {
|
|
1547
|
-
try {
|
|
1548
|
-
return it[key];
|
|
1549
|
-
} catch (error) { /* empty */ }
|
|
1550
|
-
};
|
|
1551
|
-
|
|
1552
|
-
// getting tag from ES6+ `Object.prototype.toString`
|
|
1553
|
-
var classof$5 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
|
|
1554
|
-
var O, tag, result;
|
|
1555
|
-
return it === undefined ? 'Undefined' : it === null ? 'Null'
|
|
1556
|
-
// @@toStringTag case
|
|
1557
|
-
: typeof (tag = tryGet(O = Object$1(it), TO_STRING_TAG)) == 'string' ? tag
|
|
1558
|
-
// builtinTag case
|
|
1559
|
-
: CORRECT_ARGUMENTS ? classofRaw(O)
|
|
1560
|
-
// ES3 arguments fallback
|
|
1561
|
-
: (result = classofRaw(O)) == 'Object' && isCallable$5(O.callee) ? 'Arguments' : result;
|
|
1562
|
-
};
|
|
1563
|
-
|
|
1564
|
-
var global$g = global$G;
|
|
1565
|
-
var classof$4 = classof$5;
|
|
1566
|
-
|
|
1567
|
-
var String$2 = global$g.String;
|
|
1568
|
-
|
|
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);
|
|
1572
|
-
};
|
|
1573
|
-
|
|
1574
|
-
var wellKnownSymbol$8 = wellKnownSymbol$i;
|
|
1575
|
-
|
|
1576
|
-
var MATCH = wellKnownSymbol$8('match');
|
|
1577
|
-
|
|
1578
|
-
var correctIsRegexpLogic = function (METHOD_NAME) {
|
|
1579
|
-
var regexp = /./;
|
|
1580
|
-
try {
|
|
1581
|
-
'/./'[METHOD_NAME](regexp);
|
|
1582
|
-
} catch (error1) {
|
|
1583
|
-
try {
|
|
1584
|
-
regexp[MATCH] = false;
|
|
1585
|
-
return '/./'[METHOD_NAME](regexp);
|
|
1586
|
-
} catch (error2) { /* empty */ }
|
|
1587
|
-
} return false;
|
|
1588
|
-
};
|
|
1589
|
-
|
|
1590
|
-
var $$4 = _export;
|
|
1591
|
-
var uncurryThis$b = functionUncurryThis;
|
|
1592
|
-
var notARegExp$1 = notARegexp;
|
|
1593
|
-
var requireObjectCoercible$3 = requireObjectCoercible$6;
|
|
1594
|
-
var toString$4 = toString$5;
|
|
1595
|
-
var correctIsRegExpLogic$1 = correctIsRegexpLogic;
|
|
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
|
+
};
|
|
1596
1437
|
|
|
1597
|
-
var
|
|
1438
|
+
var toIndexedObject = toIndexedObject$5;
|
|
1439
|
+
var addToUnscopables = addToUnscopables$2;
|
|
1440
|
+
var Iterators$2 = iterators;
|
|
1441
|
+
var InternalStateModule$1 = internalState;
|
|
1442
|
+
var defineProperty$2 = objectDefineProperty.f;
|
|
1443
|
+
var defineIterator = iteratorDefine;
|
|
1444
|
+
var createIterResultObject = createIterResultObject$1;
|
|
1445
|
+
var DESCRIPTORS$4 = descriptors;
|
|
1598
1446
|
|
|
1599
|
-
|
|
1600
|
-
|
|
1601
|
-
|
|
1602
|
-
|
|
1603
|
-
|
|
1604
|
-
|
|
1605
|
-
|
|
1606
|
-
|
|
1607
|
-
|
|
1447
|
+
var ARRAY_ITERATOR = 'Array Iterator';
|
|
1448
|
+
var setInternalState$1 = InternalStateModule$1.set;
|
|
1449
|
+
var getInternalState$1 = InternalStateModule$1.getterFor(ARRAY_ITERATOR);
|
|
1450
|
+
|
|
1451
|
+
// `Array.prototype.entries` method
|
|
1452
|
+
// https://tc39.es/ecma262/#sec-array.prototype.entries
|
|
1453
|
+
// `Array.prototype.keys` method
|
|
1454
|
+
// https://tc39.es/ecma262/#sec-array.prototype.keys
|
|
1455
|
+
// `Array.prototype.values` method
|
|
1456
|
+
// https://tc39.es/ecma262/#sec-array.prototype.values
|
|
1457
|
+
// `Array.prototype[@@iterator]` method
|
|
1458
|
+
// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
|
|
1459
|
+
// `CreateArrayIterator` internal method
|
|
1460
|
+
// https://tc39.es/ecma262/#sec-createarrayiterator
|
|
1461
|
+
var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
|
|
1462
|
+
setInternalState$1(this, {
|
|
1463
|
+
type: ARRAY_ITERATOR,
|
|
1464
|
+
target: toIndexedObject(iterated), // target
|
|
1465
|
+
index: 0, // next index
|
|
1466
|
+
kind: kind // kind
|
|
1467
|
+
});
|
|
1468
|
+
// `%ArrayIteratorPrototype%.next` method
|
|
1469
|
+
// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
|
|
1470
|
+
}, function () {
|
|
1471
|
+
var state = getInternalState$1(this);
|
|
1472
|
+
var target = state.target;
|
|
1473
|
+
var index = state.index++;
|
|
1474
|
+
if (!target || index >= target.length) {
|
|
1475
|
+
state.target = undefined;
|
|
1476
|
+
return createIterResultObject(undefined, true);
|
|
1608
1477
|
}
|
|
1609
|
-
|
|
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);
|
|
1482
|
+
}, 'values');
|
|
1610
1483
|
|
|
1611
|
-
|
|
1484
|
+
// argumentsList[@@iterator] is %ArrayProto_values%
|
|
1485
|
+
// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
|
|
1486
|
+
// https://tc39.es/ecma262/#sec-createmappedargumentsobject
|
|
1487
|
+
var values = Iterators$2.Arguments = Iterators$2.Array;
|
|
1488
|
+
|
|
1489
|
+
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
1490
|
+
addToUnscopables('keys');
|
|
1491
|
+
addToUnscopables('values');
|
|
1492
|
+
addToUnscopables('entries');
|
|
1493
|
+
|
|
1494
|
+
// V8 ~ Chrome 45- bug
|
|
1495
|
+
if (DESCRIPTORS$4 && values.name !== 'values') try {
|
|
1496
|
+
defineProperty$2(values, 'name', { value: 'values' });
|
|
1497
|
+
} catch (error) { /* empty */ }
|
|
1498
|
+
|
|
1499
|
+
var DESCRIPTORS$3 = descriptors;
|
|
1612
1500
|
var uncurryThis$a = functionUncurryThis;
|
|
1613
|
-
var call$
|
|
1614
|
-
var fails$
|
|
1501
|
+
var call$d = functionCall;
|
|
1502
|
+
var fails$9 = fails$l;
|
|
1615
1503
|
var objectKeys = objectKeys$2;
|
|
1616
1504
|
var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
|
|
1617
1505
|
var propertyIsEnumerableModule = objectPropertyIsEnumerable;
|
|
1618
|
-
var toObject$
|
|
1506
|
+
var toObject$2 = toObject$5;
|
|
1619
1507
|
var IndexedObject = indexedObject;
|
|
1620
1508
|
|
|
1621
1509
|
// eslint-disable-next-line es/no-object-assign -- safe
|
|
1622
1510
|
var $assign = Object.assign;
|
|
1623
1511
|
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
1624
|
-
var defineProperty = Object.defineProperty;
|
|
1512
|
+
var defineProperty$1 = Object.defineProperty;
|
|
1625
1513
|
var concat$1 = uncurryThis$a([].concat);
|
|
1626
1514
|
|
|
1627
1515
|
// `Object.assign` method
|
|
1628
1516
|
// https://tc39.es/ecma262/#sec-object.assign
|
|
1629
|
-
var objectAssign = !$assign || fails$
|
|
1517
|
+
var objectAssign = !$assign || fails$9(function () {
|
|
1630
1518
|
// should have correct order of operations (Edge bug)
|
|
1631
|
-
if (DESCRIPTORS$
|
|
1519
|
+
if (DESCRIPTORS$3 && $assign({ b: 1 }, $assign(defineProperty$1({}, 'a', {
|
|
1632
1520
|
enumerable: true,
|
|
1633
1521
|
get: function () {
|
|
1634
|
-
defineProperty(this, 'b', {
|
|
1522
|
+
defineProperty$1(this, 'b', {
|
|
1635
1523
|
value: 3,
|
|
1636
1524
|
enumerable: false
|
|
1637
1525
|
});
|
|
@@ -1641,13 +1529,13 @@ var objectAssign = !$assign || fails$8(function () {
|
|
|
1641
1529
|
var A = {};
|
|
1642
1530
|
var B = {};
|
|
1643
1531
|
// eslint-disable-next-line es/no-symbol -- safe
|
|
1644
|
-
var symbol = Symbol();
|
|
1532
|
+
var symbol = Symbol('assign detection');
|
|
1645
1533
|
var alphabet = 'abcdefghijklmnopqrst';
|
|
1646
1534
|
A[symbol] = 7;
|
|
1647
1535
|
alphabet.split('').forEach(function (chr) { B[chr] = chr; });
|
|
1648
|
-
return $assign({}, A)[symbol]
|
|
1536
|
+
return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;
|
|
1649
1537
|
}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
|
|
1650
|
-
var T = toObject$
|
|
1538
|
+
var T = toObject$2(target);
|
|
1651
1539
|
var argumentsLength = arguments.length;
|
|
1652
1540
|
var index = 1;
|
|
1653
1541
|
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
@@ -1660,67 +1548,267 @@ var objectAssign = !$assign || fails$8(function () {
|
|
|
1660
1548
|
var key;
|
|
1661
1549
|
while (length > j) {
|
|
1662
1550
|
key = keys[j++];
|
|
1663
|
-
if (!DESCRIPTORS$
|
|
1551
|
+
if (!DESCRIPTORS$3 || call$d(propertyIsEnumerable, S, key)) T[key] = S[key];
|
|
1664
1552
|
}
|
|
1665
1553
|
} return T;
|
|
1666
1554
|
} : $assign;
|
|
1667
1555
|
|
|
1668
|
-
var $$
|
|
1556
|
+
var $$b = _export;
|
|
1669
1557
|
var assign = objectAssign;
|
|
1670
1558
|
|
|
1671
1559
|
// `Object.assign` method
|
|
1672
1560
|
// https://tc39.es/ecma262/#sec-object.assign
|
|
1673
1561
|
// eslint-disable-next-line es/no-object-assign -- required for testing
|
|
1674
|
-
$$
|
|
1562
|
+
$$b({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
|
|
1675
1563
|
assign: assign
|
|
1676
1564
|
});
|
|
1677
1565
|
|
|
1678
|
-
var
|
|
1566
|
+
var wellKnownSymbol$c = wellKnownSymbol$i;
|
|
1567
|
+
|
|
1568
|
+
var TO_STRING_TAG$1 = wellKnownSymbol$c('toStringTag');
|
|
1569
|
+
var test = {};
|
|
1570
|
+
|
|
1571
|
+
test[TO_STRING_TAG$1] = 'z';
|
|
1572
|
+
|
|
1573
|
+
var toStringTagSupport = String(test) === '[object z]';
|
|
1574
|
+
|
|
1575
|
+
var TO_STRING_TAG_SUPPORT = toStringTagSupport;
|
|
1576
|
+
var isCallable$8 = isCallable$m;
|
|
1577
|
+
var classofRaw$1 = classofRaw$2;
|
|
1578
|
+
var wellKnownSymbol$b = wellKnownSymbol$i;
|
|
1579
|
+
|
|
1580
|
+
var TO_STRING_TAG = wellKnownSymbol$b('toStringTag');
|
|
1581
|
+
var $Object = Object;
|
|
1582
|
+
|
|
1583
|
+
// ES3 wrong here
|
|
1584
|
+
var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments';
|
|
1585
|
+
|
|
1586
|
+
// fallback for IE11 Script Access Denied error
|
|
1587
|
+
var tryGet = function (it, key) {
|
|
1588
|
+
try {
|
|
1589
|
+
return it[key];
|
|
1590
|
+
} catch (error) { /* empty */ }
|
|
1591
|
+
};
|
|
1592
|
+
|
|
1593
|
+
// getting tag from ES6+ `Object.prototype.toString`
|
|
1594
|
+
var classof$7 = TO_STRING_TAG_SUPPORT ? classofRaw$1 : function (it) {
|
|
1595
|
+
var O, tag, result;
|
|
1596
|
+
return it === undefined ? 'Undefined' : it === null ? 'Null'
|
|
1597
|
+
// @@toStringTag case
|
|
1598
|
+
: typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
|
|
1599
|
+
// builtinTag case
|
|
1600
|
+
: CORRECT_ARGUMENTS ? classofRaw$1(O)
|
|
1601
|
+
// ES3 arguments fallback
|
|
1602
|
+
: (result = classofRaw$1(O)) === 'Object' && isCallable$8(O.callee) ? 'Arguments' : result;
|
|
1603
|
+
};
|
|
1604
|
+
|
|
1605
|
+
var classof$6 = classof$7;
|
|
1606
|
+
|
|
1607
|
+
var $String = String;
|
|
1608
|
+
|
|
1609
|
+
var toString$6 = function (argument) {
|
|
1610
|
+
if (classof$6(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
|
|
1611
|
+
return $String(argument);
|
|
1612
|
+
};
|
|
1613
|
+
|
|
1614
|
+
var anObject$9 = anObject$e;
|
|
1679
1615
|
|
|
1680
1616
|
// `RegExp.prototype.flags` getter implementation
|
|
1681
1617
|
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
|
|
1682
1618
|
var regexpFlags$1 = function () {
|
|
1683
|
-
var that = anObject$
|
|
1619
|
+
var that = anObject$9(this);
|
|
1684
1620
|
var result = '';
|
|
1621
|
+
if (that.hasIndices) result += 'd';
|
|
1685
1622
|
if (that.global) result += 'g';
|
|
1686
1623
|
if (that.ignoreCase) result += 'i';
|
|
1687
1624
|
if (that.multiline) result += 'm';
|
|
1688
1625
|
if (that.dotAll) result += 's';
|
|
1689
1626
|
if (that.unicode) result += 'u';
|
|
1627
|
+
if (that.unicodeSets) result += 'v';
|
|
1690
1628
|
if (that.sticky) result += 'y';
|
|
1691
1629
|
return result;
|
|
1692
1630
|
};
|
|
1693
1631
|
|
|
1694
|
-
var
|
|
1695
|
-
var
|
|
1696
|
-
var redefine$3 = redefine$7.exports;
|
|
1697
|
-
var anObject$7 = anObject$e;
|
|
1632
|
+
var call$c = functionCall;
|
|
1633
|
+
var hasOwn$1 = hasOwnProperty_1;
|
|
1698
1634
|
var isPrototypeOf$2 = objectIsPrototypeOf;
|
|
1699
|
-
var $toString = toString$5;
|
|
1700
|
-
var fails$7 = fails$i;
|
|
1701
1635
|
var regExpFlags = regexpFlags$1;
|
|
1702
1636
|
|
|
1637
|
+
var RegExpPrototype$2 = RegExp.prototype;
|
|
1638
|
+
|
|
1639
|
+
var regexpGetFlags = function (R) {
|
|
1640
|
+
var flags = R.flags;
|
|
1641
|
+
return flags === undefined && !('flags' in RegExpPrototype$2) && !hasOwn$1(R, 'flags') && isPrototypeOf$2(RegExpPrototype$2, R)
|
|
1642
|
+
? call$c(regExpFlags, R) : flags;
|
|
1643
|
+
};
|
|
1644
|
+
|
|
1645
|
+
var PROPER_FUNCTION_NAME = functionName.PROPER;
|
|
1646
|
+
var defineBuiltIn$3 = defineBuiltIn$7;
|
|
1647
|
+
var anObject$8 = anObject$e;
|
|
1648
|
+
var $toString = toString$6;
|
|
1649
|
+
var fails$8 = fails$l;
|
|
1650
|
+
var getRegExpFlags = regexpGetFlags;
|
|
1651
|
+
|
|
1703
1652
|
var TO_STRING = 'toString';
|
|
1704
1653
|
var RegExpPrototype$1 = RegExp.prototype;
|
|
1705
|
-
var
|
|
1706
|
-
var getFlags = uncurryThis$9(regExpFlags);
|
|
1654
|
+
var nativeToString = RegExpPrototype$1[TO_STRING];
|
|
1707
1655
|
|
|
1708
|
-
var NOT_GENERIC = fails$
|
|
1656
|
+
var NOT_GENERIC = fails$8(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
|
|
1709
1657
|
// FF44- RegExp#toString has a wrong name
|
|
1710
|
-
var INCORRECT_NAME = PROPER_FUNCTION_NAME &&
|
|
1658
|
+
var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING;
|
|
1711
1659
|
|
|
1712
1660
|
// `RegExp.prototype.toString` method
|
|
1713
1661
|
// https://tc39.es/ecma262/#sec-regexp.prototype.tostring
|
|
1714
1662
|
if (NOT_GENERIC || INCORRECT_NAME) {
|
|
1715
|
-
|
|
1716
|
-
var R = anObject$
|
|
1717
|
-
var
|
|
1718
|
-
var
|
|
1719
|
-
|
|
1720
|
-
return '/' + p + '/' + f;
|
|
1663
|
+
defineBuiltIn$3(RegExpPrototype$1, TO_STRING, function toString() {
|
|
1664
|
+
var R = anObject$8(this);
|
|
1665
|
+
var pattern = $toString(R.source);
|
|
1666
|
+
var flags = $toString(getRegExpFlags(R));
|
|
1667
|
+
return '/' + pattern + '/' + flags;
|
|
1721
1668
|
}, { unsafe: true });
|
|
1722
1669
|
}
|
|
1723
1670
|
|
|
1671
|
+
var isObject$2 = isObject$b;
|
|
1672
|
+
var classof$5 = classofRaw$2;
|
|
1673
|
+
var wellKnownSymbol$a = wellKnownSymbol$i;
|
|
1674
|
+
|
|
1675
|
+
var MATCH$1 = wellKnownSymbol$a('match');
|
|
1676
|
+
|
|
1677
|
+
// `IsRegExp` abstract operation
|
|
1678
|
+
// https://tc39.es/ecma262/#sec-isregexp
|
|
1679
|
+
var isRegexp = function (it) {
|
|
1680
|
+
var isRegExp;
|
|
1681
|
+
return isObject$2(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$5(it) === 'RegExp');
|
|
1682
|
+
};
|
|
1683
|
+
|
|
1684
|
+
var isRegExp = isRegexp;
|
|
1685
|
+
|
|
1686
|
+
var $TypeError$9 = TypeError;
|
|
1687
|
+
|
|
1688
|
+
var notARegexp = function (it) {
|
|
1689
|
+
if (isRegExp(it)) {
|
|
1690
|
+
throw new $TypeError$9("The method doesn't accept regular expressions");
|
|
1691
|
+
} return it;
|
|
1692
|
+
};
|
|
1693
|
+
|
|
1694
|
+
var wellKnownSymbol$9 = wellKnownSymbol$i;
|
|
1695
|
+
|
|
1696
|
+
var MATCH = wellKnownSymbol$9('match');
|
|
1697
|
+
|
|
1698
|
+
var correctIsRegexpLogic = function (METHOD_NAME) {
|
|
1699
|
+
var regexp = /./;
|
|
1700
|
+
try {
|
|
1701
|
+
'/./'[METHOD_NAME](regexp);
|
|
1702
|
+
} catch (error1) {
|
|
1703
|
+
try {
|
|
1704
|
+
regexp[MATCH] = false;
|
|
1705
|
+
return '/./'[METHOD_NAME](regexp);
|
|
1706
|
+
} catch (error2) { /* empty */ }
|
|
1707
|
+
} return false;
|
|
1708
|
+
};
|
|
1709
|
+
|
|
1710
|
+
var $$a = _export;
|
|
1711
|
+
var uncurryThis$9 = functionUncurryThis;
|
|
1712
|
+
var notARegExp$1 = notARegexp;
|
|
1713
|
+
var requireObjectCoercible$3 = requireObjectCoercible$7;
|
|
1714
|
+
var toString$5 = toString$6;
|
|
1715
|
+
var correctIsRegExpLogic$1 = correctIsRegexpLogic;
|
|
1716
|
+
|
|
1717
|
+
var stringIndexOf$1 = uncurryThis$9(''.indexOf);
|
|
1718
|
+
|
|
1719
|
+
// `String.prototype.includes` method
|
|
1720
|
+
// https://tc39.es/ecma262/#sec-string.prototype.includes
|
|
1721
|
+
$$a({ target: 'String', proto: true, forced: !correctIsRegExpLogic$1('includes') }, {
|
|
1722
|
+
includes: function includes(searchString /* , position = 0 */) {
|
|
1723
|
+
return !!~stringIndexOf$1(
|
|
1724
|
+
toString$5(requireObjectCoercible$3(this)),
|
|
1725
|
+
toString$5(notARegExp$1(searchString)),
|
|
1726
|
+
arguments.length > 1 ? arguments[1] : undefined
|
|
1727
|
+
);
|
|
1728
|
+
}
|
|
1729
|
+
});
|
|
1730
|
+
|
|
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
|
+
};
|
|
1766
|
+
|
|
1767
|
+
// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
|
|
1768
|
+
var documentCreateElement = documentCreateElement$2;
|
|
1769
|
+
|
|
1770
|
+
var classList = documentCreateElement('span').classList;
|
|
1771
|
+
var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
|
|
1772
|
+
|
|
1773
|
+
var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
|
|
1774
|
+
|
|
1775
|
+
var global$b = global$l;
|
|
1776
|
+
var DOMIterables = domIterables;
|
|
1777
|
+
var DOMTokenListPrototype = domTokenListPrototype;
|
|
1778
|
+
var ArrayIteratorMethods = es_array_iterator;
|
|
1779
|
+
var createNonEnumerableProperty$1 = createNonEnumerableProperty$5;
|
|
1780
|
+
var setToStringTag$1 = setToStringTag$4;
|
|
1781
|
+
var wellKnownSymbol$8 = wellKnownSymbol$i;
|
|
1782
|
+
|
|
1783
|
+
var ITERATOR$3 = wellKnownSymbol$8('iterator');
|
|
1784
|
+
var ArrayValues = ArrayIteratorMethods.values;
|
|
1785
|
+
|
|
1786
|
+
var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
|
|
1787
|
+
if (CollectionPrototype) {
|
|
1788
|
+
// some Chrome versions have non-configurable methods on DOMTokenList
|
|
1789
|
+
if (CollectionPrototype[ITERATOR$3] !== ArrayValues) try {
|
|
1790
|
+
createNonEnumerableProperty$1(CollectionPrototype, ITERATOR$3, ArrayValues);
|
|
1791
|
+
} catch (error) {
|
|
1792
|
+
CollectionPrototype[ITERATOR$3] = ArrayValues;
|
|
1793
|
+
}
|
|
1794
|
+
setToStringTag$1(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$1(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$b[COLLECTION_NAME] && global$b[COLLECTION_NAME].prototype, COLLECTION_NAME);
|
|
1808
|
+
}
|
|
1809
|
+
|
|
1810
|
+
handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
|
|
1811
|
+
|
|
1724
1812
|
var KeyboardLayoutName;
|
|
1725
1813
|
(function (KeyboardLayoutName) {
|
|
1726
1814
|
KeyboardLayoutName["DEFAULT"] = "default";
|
|
@@ -1994,290 +2082,72 @@ function toggleLayout(keyboardLayoutName) {
|
|
|
1994
2082
|
return keyboardLayoutName === KeyboardLayoutName.DEFAULT ? KeyboardLayoutName.SHIFT : KeyboardLayoutName.DEFAULT;
|
|
1995
2083
|
}
|
|
1996
2084
|
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;
|
|
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;
|
|
2037
2090
|
}
|
|
2038
|
-
}
|
|
2091
|
+
}
|
|
2039
2092
|
|
|
2040
|
-
var global$
|
|
2093
|
+
var global$a = global$l;
|
|
2094
|
+
var classof$4 = classofRaw$2;
|
|
2041
2095
|
|
|
2042
|
-
var
|
|
2096
|
+
var engineIsNode = classof$4(global$a.process) === 'process';
|
|
2043
2097
|
|
|
2044
|
-
var
|
|
2098
|
+
var makeBuiltIn = makeBuiltInExports;
|
|
2099
|
+
var defineProperty = objectDefineProperty;
|
|
2045
2100
|
|
|
2046
|
-
var
|
|
2047
|
-
|
|
2048
|
-
|
|
2101
|
+
var defineBuiltInAccessor$1 = function (target, name, descriptor) {
|
|
2102
|
+
if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
|
|
2103
|
+
if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
|
|
2104
|
+
return defineProperty.f(target, name, descriptor);
|
|
2049
2105
|
};
|
|
2050
2106
|
|
|
2051
|
-
var getBuiltIn$
|
|
2052
|
-
var
|
|
2107
|
+
var getBuiltIn$3 = getBuiltIn$7;
|
|
2108
|
+
var defineBuiltInAccessor = defineBuiltInAccessor$1;
|
|
2053
2109
|
var wellKnownSymbol$7 = wellKnownSymbol$i;
|
|
2054
|
-
var DESCRIPTORS = descriptors;
|
|
2110
|
+
var DESCRIPTORS$2 = descriptors;
|
|
2055
2111
|
|
|
2056
2112
|
var SPECIES$3 = wellKnownSymbol$7('species');
|
|
2057
2113
|
|
|
2058
2114
|
var setSpecies$1 = function (CONSTRUCTOR_NAME) {
|
|
2059
|
-
var Constructor = getBuiltIn$
|
|
2060
|
-
var defineProperty = definePropertyModule.f;
|
|
2115
|
+
var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
|
|
2061
2116
|
|
|
2062
|
-
if (DESCRIPTORS && Constructor && !Constructor[SPECIES$3]) {
|
|
2063
|
-
|
|
2117
|
+
if (DESCRIPTORS$2 && Constructor && !Constructor[SPECIES$3]) {
|
|
2118
|
+
defineBuiltInAccessor(Constructor, SPECIES$3, {
|
|
2064
2119
|
configurable: true,
|
|
2065
2120
|
get: function () { return this; }
|
|
2066
2121
|
});
|
|
2067
2122
|
}
|
|
2068
2123
|
};
|
|
2069
2124
|
|
|
2070
|
-
var global$e = global$G;
|
|
2071
2125
|
var isPrototypeOf$1 = objectIsPrototypeOf;
|
|
2072
2126
|
|
|
2073
|
-
var TypeError$
|
|
2127
|
+
var $TypeError$8 = TypeError;
|
|
2074
2128
|
|
|
2075
2129
|
var anInstance$1 = function (it, Prototype) {
|
|
2076
2130
|
if (isPrototypeOf$1(Prototype, it)) return it;
|
|
2077
|
-
throw TypeError$
|
|
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;
|
|
2131
|
+
throw new $TypeError$8('Incorrect invocation');
|
|
2261
2132
|
};
|
|
2262
2133
|
|
|
2263
|
-
var uncurryThis$
|
|
2264
|
-
var fails$
|
|
2265
|
-
var isCallable$
|
|
2266
|
-
var classof$
|
|
2267
|
-
var getBuiltIn$
|
|
2268
|
-
var inspectSource$1 = inspectSource$
|
|
2134
|
+
var uncurryThis$8 = functionUncurryThis;
|
|
2135
|
+
var fails$7 = fails$l;
|
|
2136
|
+
var isCallable$7 = isCallable$m;
|
|
2137
|
+
var classof$3 = classof$7;
|
|
2138
|
+
var getBuiltIn$2 = getBuiltIn$7;
|
|
2139
|
+
var inspectSource$1 = inspectSource$3;
|
|
2269
2140
|
|
|
2270
2141
|
var noop = function () { /* empty */ };
|
|
2271
|
-
var
|
|
2272
|
-
var construct = getBuiltIn$1('Reflect', 'construct');
|
|
2142
|
+
var construct = getBuiltIn$2('Reflect', 'construct');
|
|
2273
2143
|
var constructorRegExp = /^\s*(?:class|function)\b/;
|
|
2274
|
-
var exec$1 = uncurryThis$
|
|
2275
|
-
var INCORRECT_TO_STRING = !constructorRegExp.
|
|
2144
|
+
var exec$1 = uncurryThis$8(constructorRegExp.exec);
|
|
2145
|
+
var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
|
|
2276
2146
|
|
|
2277
2147
|
var isConstructorModern = function isConstructor(argument) {
|
|
2278
|
-
if (!isCallable$
|
|
2148
|
+
if (!isCallable$7(argument)) return false;
|
|
2279
2149
|
try {
|
|
2280
|
-
construct(noop,
|
|
2150
|
+
construct(noop, [], argument);
|
|
2281
2151
|
return true;
|
|
2282
2152
|
} catch (error) {
|
|
2283
2153
|
return false;
|
|
@@ -2285,8 +2155,8 @@ var isConstructorModern = function isConstructor(argument) {
|
|
|
2285
2155
|
};
|
|
2286
2156
|
|
|
2287
2157
|
var isConstructorLegacy = function isConstructor(argument) {
|
|
2288
|
-
if (!isCallable$
|
|
2289
|
-
switch (classof$
|
|
2158
|
+
if (!isCallable$7(argument)) return false;
|
|
2159
|
+
switch (classof$3(argument)) {
|
|
2290
2160
|
case 'AsyncFunction':
|
|
2291
2161
|
case 'GeneratorFunction':
|
|
2292
2162
|
case 'AsyncGeneratorFunction': return false;
|
|
@@ -2305,7 +2175,7 @@ isConstructorLegacy.sham = true;
|
|
|
2305
2175
|
|
|
2306
2176
|
// `IsConstructor` abstract operation
|
|
2307
2177
|
// https://tc39.es/ecma262/#sec-isconstructor
|
|
2308
|
-
var isConstructor$1 = !construct || fails$
|
|
2178
|
+
var isConstructor$1 = !construct || fails$7(function () {
|
|
2309
2179
|
var called;
|
|
2310
2180
|
return isConstructorModern(isConstructorModern.call)
|
|
2311
2181
|
|| !isConstructorModern(Object)
|
|
@@ -2313,67 +2183,95 @@ var isConstructor$1 = !construct || fails$6(function () {
|
|
|
2313
2183
|
|| called;
|
|
2314
2184
|
}) ? isConstructorLegacy : isConstructorModern;
|
|
2315
2185
|
|
|
2316
|
-
var global$b = global$G;
|
|
2317
2186
|
var isConstructor = isConstructor$1;
|
|
2318
|
-
var tryToString = tryToString$4;
|
|
2187
|
+
var tryToString$2 = tryToString$4;
|
|
2319
2188
|
|
|
2320
|
-
var TypeError$
|
|
2189
|
+
var $TypeError$7 = TypeError;
|
|
2321
2190
|
|
|
2322
2191
|
// `Assert: IsConstructor(argument) is true`
|
|
2323
2192
|
var aConstructor$1 = function (argument) {
|
|
2324
2193
|
if (isConstructor(argument)) return argument;
|
|
2325
|
-
throw TypeError$
|
|
2194
|
+
throw new $TypeError$7(tryToString$2(argument) + ' is not a constructor');
|
|
2326
2195
|
};
|
|
2327
2196
|
|
|
2328
|
-
var anObject$
|
|
2197
|
+
var anObject$7 = anObject$e;
|
|
2329
2198
|
var aConstructor = aConstructor$1;
|
|
2330
|
-
var
|
|
2199
|
+
var isNullOrUndefined$2 = isNullOrUndefined$5;
|
|
2200
|
+
var wellKnownSymbol$6 = wellKnownSymbol$i;
|
|
2331
2201
|
|
|
2332
|
-
var SPECIES$2 = wellKnownSymbol$
|
|
2202
|
+
var SPECIES$2 = wellKnownSymbol$6('species');
|
|
2333
2203
|
|
|
2334
2204
|
// `SpeciesConstructor` abstract operation
|
|
2335
2205
|
// https://tc39.es/ecma262/#sec-speciesconstructor
|
|
2336
2206
|
var speciesConstructor$1 = function (O, defaultConstructor) {
|
|
2337
|
-
var C = anObject$
|
|
2207
|
+
var C = anObject$7(O).constructor;
|
|
2338
2208
|
var S;
|
|
2339
|
-
return C === undefined || (S = anObject$
|
|
2209
|
+
return C === undefined || isNullOrUndefined$2(S = anObject$7(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S);
|
|
2340
2210
|
};
|
|
2341
2211
|
|
|
2342
|
-
var NATIVE_BIND = functionBindNative;
|
|
2212
|
+
var NATIVE_BIND$1 = functionBindNative;
|
|
2343
2213
|
|
|
2344
2214
|
var FunctionPrototype = Function.prototype;
|
|
2345
2215
|
var apply$2 = FunctionPrototype.apply;
|
|
2346
|
-
var call$
|
|
2216
|
+
var call$b = FunctionPrototype.call;
|
|
2347
2217
|
|
|
2348
2218
|
// eslint-disable-next-line es/no-reflect -- safe
|
|
2349
|
-
var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call$
|
|
2350
|
-
return call$
|
|
2219
|
+
var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$b.bind(apply$2) : function () {
|
|
2220
|
+
return call$b.apply(apply$2, arguments);
|
|
2351
2221
|
});
|
|
2352
2222
|
|
|
2223
|
+
var classofRaw = classofRaw$2;
|
|
2224
|
+
var uncurryThis$7 = functionUncurryThis;
|
|
2225
|
+
|
|
2226
|
+
var functionUncurryThisClause = function (fn) {
|
|
2227
|
+
// Nashorn bug:
|
|
2228
|
+
// https://github.com/zloirock/core-js/issues/1128
|
|
2229
|
+
// https://github.com/zloirock/core-js/issues/1130
|
|
2230
|
+
if (classofRaw(fn) === 'Function') return uncurryThis$7(fn);
|
|
2231
|
+
};
|
|
2232
|
+
|
|
2233
|
+
var uncurryThis$6 = functionUncurryThisClause;
|
|
2234
|
+
var aCallable$5 = aCallable$8;
|
|
2235
|
+
var NATIVE_BIND = functionBindNative;
|
|
2236
|
+
|
|
2237
|
+
var bind$4 = uncurryThis$6(uncurryThis$6.bind);
|
|
2238
|
+
|
|
2239
|
+
// optional / simple context binding
|
|
2240
|
+
var functionBindContext = function (fn, that) {
|
|
2241
|
+
aCallable$5(fn);
|
|
2242
|
+
return that === undefined ? fn : NATIVE_BIND ? bind$4(fn, that) : function (/* ...args */) {
|
|
2243
|
+
return fn.apply(that, arguments);
|
|
2244
|
+
};
|
|
2245
|
+
};
|
|
2246
|
+
|
|
2353
2247
|
var uncurryThis$5 = functionUncurryThis;
|
|
2354
2248
|
|
|
2355
2249
|
var arraySlice$1 = uncurryThis$5([].slice);
|
|
2356
2250
|
|
|
2357
|
-
var
|
|
2251
|
+
var $TypeError$6 = TypeError;
|
|
2358
2252
|
|
|
2359
|
-
var
|
|
2253
|
+
var validateArgumentsLength$1 = function (passed, required) {
|
|
2254
|
+
if (passed < required) throw new $TypeError$6('Not enough arguments');
|
|
2255
|
+
return passed;
|
|
2256
|
+
};
|
|
2360
2257
|
|
|
2361
|
-
var
|
|
2362
|
-
var global$a = global$G;
|
|
2258
|
+
var userAgent$2 = engineUserAgent;
|
|
2363
2259
|
|
|
2364
|
-
|
|
2260
|
+
// eslint-disable-next-line redos/no-vulnerable -- safe
|
|
2261
|
+
var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
|
|
2365
2262
|
|
|
2366
|
-
var global$9 = global$
|
|
2263
|
+
var global$9 = global$l;
|
|
2367
2264
|
var apply$1 = functionApply;
|
|
2368
|
-
var bind$
|
|
2369
|
-
var isCallable$
|
|
2265
|
+
var bind$3 = functionBindContext;
|
|
2266
|
+
var isCallable$6 = isCallable$m;
|
|
2370
2267
|
var hasOwn = hasOwnProperty_1;
|
|
2371
|
-
var fails$
|
|
2268
|
+
var fails$6 = fails$l;
|
|
2372
2269
|
var html = html$2;
|
|
2373
2270
|
var arraySlice = arraySlice$1;
|
|
2374
2271
|
var createElement = documentCreateElement$2;
|
|
2272
|
+
var validateArgumentsLength = validateArgumentsLength$1;
|
|
2375
2273
|
var IS_IOS$1 = engineIsIos;
|
|
2376
|
-
var IS_NODE$
|
|
2274
|
+
var IS_NODE$3 = engineIsNode;
|
|
2377
2275
|
|
|
2378
2276
|
var set = global$9.setImmediate;
|
|
2379
2277
|
var clear = global$9.clearImmediate;
|
|
@@ -2383,19 +2281,19 @@ var Function$1 = global$9.Function;
|
|
|
2383
2281
|
var MessageChannel = global$9.MessageChannel;
|
|
2384
2282
|
var String$1 = global$9.String;
|
|
2385
2283
|
var counter = 0;
|
|
2386
|
-
var queue$
|
|
2284
|
+
var queue$2 = {};
|
|
2387
2285
|
var ONREADYSTATECHANGE = 'onreadystatechange';
|
|
2388
|
-
var location, defer, channel, port;
|
|
2286
|
+
var $location, defer, channel, port;
|
|
2389
2287
|
|
|
2390
|
-
|
|
2288
|
+
fails$6(function () {
|
|
2391
2289
|
// Deno throws a ReferenceError on `location` access without `--location` flag
|
|
2392
|
-
location = global$9.location;
|
|
2393
|
-
}
|
|
2290
|
+
$location = global$9.location;
|
|
2291
|
+
});
|
|
2394
2292
|
|
|
2395
2293
|
var run = function (id) {
|
|
2396
|
-
if (hasOwn(queue$
|
|
2397
|
-
var fn = queue$
|
|
2398
|
-
delete queue$
|
|
2294
|
+
if (hasOwn(queue$2, id)) {
|
|
2295
|
+
var fn = queue$2[id];
|
|
2296
|
+
delete queue$2[id];
|
|
2399
2297
|
fn();
|
|
2400
2298
|
}
|
|
2401
2299
|
};
|
|
@@ -2406,30 +2304,32 @@ var runner = function (id) {
|
|
|
2406
2304
|
};
|
|
2407
2305
|
};
|
|
2408
2306
|
|
|
2409
|
-
var
|
|
2307
|
+
var eventListener = function (event) {
|
|
2410
2308
|
run(event.data);
|
|
2411
2309
|
};
|
|
2412
2310
|
|
|
2413
|
-
var
|
|
2311
|
+
var globalPostMessageDefer = function (id) {
|
|
2414
2312
|
// old engines have not location.origin
|
|
2415
|
-
global$9.postMessage(String$1(id), location.protocol + '//' + location.host);
|
|
2313
|
+
global$9.postMessage(String$1(id), $location.protocol + '//' + $location.host);
|
|
2416
2314
|
};
|
|
2417
2315
|
|
|
2418
2316
|
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
|
|
2419
2317
|
if (!set || !clear) {
|
|
2420
|
-
set = function setImmediate(
|
|
2318
|
+
set = function setImmediate(handler) {
|
|
2319
|
+
validateArgumentsLength(arguments.length, 1);
|
|
2320
|
+
var fn = isCallable$6(handler) ? handler : Function$1(handler);
|
|
2421
2321
|
var args = arraySlice(arguments, 1);
|
|
2422
|
-
queue$
|
|
2423
|
-
apply$1(
|
|
2322
|
+
queue$2[++counter] = function () {
|
|
2323
|
+
apply$1(fn, undefined, args);
|
|
2424
2324
|
};
|
|
2425
2325
|
defer(counter);
|
|
2426
2326
|
return counter;
|
|
2427
2327
|
};
|
|
2428
2328
|
clear = function clearImmediate(id) {
|
|
2429
|
-
delete queue$
|
|
2329
|
+
delete queue$2[id];
|
|
2430
2330
|
};
|
|
2431
2331
|
// Node.js 0.8-
|
|
2432
|
-
if (IS_NODE$
|
|
2332
|
+
if (IS_NODE$3) {
|
|
2433
2333
|
defer = function (id) {
|
|
2434
2334
|
process$2.nextTick(runner(id));
|
|
2435
2335
|
};
|
|
@@ -2443,19 +2343,19 @@ if (!set || !clear) {
|
|
|
2443
2343
|
} else if (MessageChannel && !IS_IOS$1) {
|
|
2444
2344
|
channel = new MessageChannel();
|
|
2445
2345
|
port = channel.port2;
|
|
2446
|
-
channel.port1.onmessage =
|
|
2447
|
-
defer = bind$
|
|
2346
|
+
channel.port1.onmessage = eventListener;
|
|
2347
|
+
defer = bind$3(port.postMessage, port);
|
|
2448
2348
|
// Browsers with postMessage, skip WebWorkers
|
|
2449
2349
|
// IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
|
|
2450
2350
|
} else if (
|
|
2451
2351
|
global$9.addEventListener &&
|
|
2452
|
-
isCallable$
|
|
2352
|
+
isCallable$6(global$9.postMessage) &&
|
|
2453
2353
|
!global$9.importScripts &&
|
|
2454
|
-
location && location.protocol !== 'file:' &&
|
|
2455
|
-
!fails$
|
|
2354
|
+
$location && $location.protocol !== 'file:' &&
|
|
2355
|
+
!fails$6(globalPostMessageDefer)
|
|
2456
2356
|
) {
|
|
2457
|
-
defer =
|
|
2458
|
-
global$9.addEventListener('message',
|
|
2357
|
+
defer = globalPostMessageDefer;
|
|
2358
|
+
global$9.addEventListener('message', eventListener, false);
|
|
2459
2359
|
// IE8-
|
|
2460
2360
|
} else if (ONREADYSTATECHANGE in createElement('script')) {
|
|
2461
2361
|
defer = function (id) {
|
|
@@ -2477,56 +2377,88 @@ var task$1 = {
|
|
|
2477
2377
|
clear: clear
|
|
2478
2378
|
};
|
|
2479
2379
|
|
|
2380
|
+
var global$8 = global$l;
|
|
2381
|
+
var DESCRIPTORS$1 = descriptors;
|
|
2382
|
+
|
|
2383
|
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
2384
|
+
var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor;
|
|
2385
|
+
|
|
2386
|
+
// Avoid NodeJS experimental warning
|
|
2387
|
+
var safeGetBuiltIn$1 = function (name) {
|
|
2388
|
+
if (!DESCRIPTORS$1) return global$8[name];
|
|
2389
|
+
var descriptor = getOwnPropertyDescriptor$2(global$8, name);
|
|
2390
|
+
return descriptor && descriptor.value;
|
|
2391
|
+
};
|
|
2392
|
+
|
|
2393
|
+
var Queue$2 = function () {
|
|
2394
|
+
this.head = null;
|
|
2395
|
+
this.tail = null;
|
|
2396
|
+
};
|
|
2397
|
+
|
|
2398
|
+
Queue$2.prototype = {
|
|
2399
|
+
add: function (item) {
|
|
2400
|
+
var entry = { item: item, next: null };
|
|
2401
|
+
var tail = this.tail;
|
|
2402
|
+
if (tail) tail.next = entry;
|
|
2403
|
+
else this.head = entry;
|
|
2404
|
+
this.tail = entry;
|
|
2405
|
+
},
|
|
2406
|
+
get: function () {
|
|
2407
|
+
var entry = this.head;
|
|
2408
|
+
if (entry) {
|
|
2409
|
+
var next = this.head = entry.next;
|
|
2410
|
+
if (next === null) this.tail = null;
|
|
2411
|
+
return entry.item;
|
|
2412
|
+
}
|
|
2413
|
+
}
|
|
2414
|
+
};
|
|
2415
|
+
|
|
2416
|
+
var queue$1 = Queue$2;
|
|
2417
|
+
|
|
2480
2418
|
var userAgent$1 = engineUserAgent;
|
|
2481
|
-
var global$8 = global$G;
|
|
2482
2419
|
|
|
2483
|
-
var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) &&
|
|
2420
|
+
var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined';
|
|
2484
2421
|
|
|
2485
2422
|
var userAgent = engineUserAgent;
|
|
2486
2423
|
|
|
2487
2424
|
var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
|
|
2488
2425
|
|
|
2489
|
-
var global$7 = global$
|
|
2490
|
-
var
|
|
2491
|
-
var
|
|
2426
|
+
var global$7 = global$l;
|
|
2427
|
+
var safeGetBuiltIn = safeGetBuiltIn$1;
|
|
2428
|
+
var bind$2 = functionBindContext;
|
|
2492
2429
|
var macrotask = task$1.set;
|
|
2430
|
+
var Queue$1 = queue$1;
|
|
2493
2431
|
var IS_IOS = engineIsIos;
|
|
2494
2432
|
var IS_IOS_PEBBLE = engineIsIosPebble;
|
|
2495
2433
|
var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
|
|
2496
|
-
var IS_NODE$
|
|
2434
|
+
var IS_NODE$2 = engineIsNode;
|
|
2497
2435
|
|
|
2498
2436
|
var MutationObserver = global$7.MutationObserver || global$7.WebKitMutationObserver;
|
|
2499
2437
|
var document$2 = global$7.document;
|
|
2500
2438
|
var process$1 = global$7.process;
|
|
2501
2439
|
var Promise$1 = global$7.Promise;
|
|
2502
|
-
|
|
2503
|
-
var
|
|
2504
|
-
var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
|
|
2505
|
-
|
|
2506
|
-
var flush, head, last, notify$1, toggle, node, promise, then;
|
|
2440
|
+
var microtask$1 = safeGetBuiltIn('queueMicrotask');
|
|
2441
|
+
var notify$1, toggle, node, promise, then;
|
|
2507
2442
|
|
|
2508
2443
|
// modern engines have queueMicrotask method
|
|
2509
|
-
if (!
|
|
2510
|
-
|
|
2444
|
+
if (!microtask$1) {
|
|
2445
|
+
var queue = new Queue$1();
|
|
2446
|
+
|
|
2447
|
+
var flush = function () {
|
|
2511
2448
|
var parent, fn;
|
|
2512
|
-
if (IS_NODE$
|
|
2513
|
-
while (
|
|
2514
|
-
fn
|
|
2515
|
-
|
|
2516
|
-
|
|
2517
|
-
|
|
2518
|
-
|
|
2519
|
-
if (head) notify$1();
|
|
2520
|
-
else last = undefined;
|
|
2521
|
-
throw error;
|
|
2522
|
-
}
|
|
2523
|
-
} last = undefined;
|
|
2449
|
+
if (IS_NODE$2 && (parent = process$1.domain)) parent.exit();
|
|
2450
|
+
while (fn = queue.get()) try {
|
|
2451
|
+
fn();
|
|
2452
|
+
} catch (error) {
|
|
2453
|
+
if (queue.head) notify$1();
|
|
2454
|
+
throw error;
|
|
2455
|
+
}
|
|
2524
2456
|
if (parent) parent.enter();
|
|
2525
2457
|
};
|
|
2526
2458
|
|
|
2527
2459
|
// browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
|
|
2528
2460
|
// also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
|
|
2529
|
-
if (!IS_IOS && !IS_NODE$
|
|
2461
|
+
if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
|
|
2530
2462
|
toggle = true;
|
|
2531
2463
|
node = document$2.createTextNode('');
|
|
2532
2464
|
new MutationObserver(flush).observe(node, { characterData: true });
|
|
@@ -2539,52 +2471,126 @@ if (!queueMicrotask) {
|
|
|
2539
2471
|
promise = Promise$1.resolve(undefined);
|
|
2540
2472
|
// workaround of WebKit ~ iOS Safari 10.1 bug
|
|
2541
2473
|
promise.constructor = Promise$1;
|
|
2542
|
-
then = bind$
|
|
2474
|
+
then = bind$2(promise.then, promise);
|
|
2543
2475
|
notify$1 = function () {
|
|
2544
2476
|
then(flush);
|
|
2545
2477
|
};
|
|
2546
2478
|
// Node.js without promises
|
|
2547
|
-
} else if (IS_NODE$
|
|
2479
|
+
} else if (IS_NODE$2) {
|
|
2548
2480
|
notify$1 = function () {
|
|
2549
2481
|
process$1.nextTick(flush);
|
|
2550
2482
|
};
|
|
2551
2483
|
// for other environments - macrotask based on:
|
|
2552
2484
|
// - setImmediate
|
|
2553
2485
|
// - MessageChannel
|
|
2554
|
-
// - window.
|
|
2486
|
+
// - window.postMessage
|
|
2555
2487
|
// - onreadystatechange
|
|
2556
2488
|
// - setTimeout
|
|
2557
2489
|
} else {
|
|
2558
|
-
//
|
|
2559
|
-
macrotask = bind$
|
|
2490
|
+
// `webpack` dev server bug on IE global methods - use bind(fn, global)
|
|
2491
|
+
macrotask = bind$2(macrotask, global$7);
|
|
2560
2492
|
notify$1 = function () {
|
|
2561
2493
|
macrotask(flush);
|
|
2562
2494
|
};
|
|
2563
|
-
}
|
|
2564
|
-
|
|
2495
|
+
}
|
|
2496
|
+
|
|
2497
|
+
microtask$1 = function (fn) {
|
|
2498
|
+
if (!queue.head) notify$1();
|
|
2499
|
+
queue.add(fn);
|
|
2500
|
+
};
|
|
2501
|
+
}
|
|
2502
|
+
|
|
2503
|
+
var microtask_1 = microtask$1;
|
|
2504
|
+
|
|
2505
|
+
var hostReportErrors$1 = function (a, b) {
|
|
2506
|
+
try {
|
|
2507
|
+
// eslint-disable-next-line no-console -- safe
|
|
2508
|
+
arguments.length === 1 ? console.error(a) : console.error(a, b);
|
|
2509
|
+
} catch (error) { /* empty */ }
|
|
2510
|
+
};
|
|
2511
|
+
|
|
2512
|
+
var perform$3 = function (exec) {
|
|
2513
|
+
try {
|
|
2514
|
+
return { error: false, value: exec() };
|
|
2515
|
+
} catch (error) {
|
|
2516
|
+
return { error: true, value: error };
|
|
2517
|
+
}
|
|
2518
|
+
};
|
|
2519
|
+
|
|
2520
|
+
var global$6 = global$l;
|
|
2521
|
+
|
|
2522
|
+
var promiseNativeConstructor = global$6.Promise;
|
|
2523
|
+
|
|
2524
|
+
/* global Deno -- Deno case */
|
|
2525
|
+
var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
|
|
2526
|
+
|
|
2527
|
+
var IS_DENO$1 = engineIsDeno;
|
|
2528
|
+
var IS_NODE$1 = engineIsNode;
|
|
2529
|
+
|
|
2530
|
+
var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1
|
|
2531
|
+
&& typeof window == 'object'
|
|
2532
|
+
&& typeof document == 'object';
|
|
2533
|
+
|
|
2534
|
+
var global$5 = global$l;
|
|
2535
|
+
var NativePromiseConstructor$3 = promiseNativeConstructor;
|
|
2536
|
+
var isCallable$5 = isCallable$m;
|
|
2537
|
+
var isForced = isForced_1;
|
|
2538
|
+
var inspectSource = inspectSource$3;
|
|
2539
|
+
var wellKnownSymbol$5 = wellKnownSymbol$i;
|
|
2540
|
+
var IS_BROWSER = engineIsBrowser;
|
|
2541
|
+
var IS_DENO = engineIsDeno;
|
|
2542
|
+
var V8_VERSION = engineV8Version;
|
|
2543
|
+
|
|
2544
|
+
NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype;
|
|
2545
|
+
var SPECIES$1 = wellKnownSymbol$5('species');
|
|
2546
|
+
var SUBCLASSING = false;
|
|
2547
|
+
var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$5(global$5.PromiseRejectionEvent);
|
|
2548
|
+
|
|
2549
|
+
var FORCED_PROMISE_CONSTRUCTOR$5 = isForced('Promise', function () {
|
|
2550
|
+
var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3);
|
|
2551
|
+
var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3);
|
|
2552
|
+
// V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
|
|
2553
|
+
// https://bugs.chromium.org/p/chromium/issues/detail?id=830565
|
|
2554
|
+
// We can't detect it synchronously, so just check versions
|
|
2555
|
+
if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
|
|
2556
|
+
// We can't use @@species feature detection in V8 since it causes
|
|
2557
|
+
// deoptimization and performance degradation
|
|
2558
|
+
// https://github.com/zloirock/core-js/issues/679
|
|
2559
|
+
if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
|
|
2560
|
+
// Detect correctness of subclassing with @@species support
|
|
2561
|
+
var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); });
|
|
2562
|
+
var FakePromise = function (exec) {
|
|
2563
|
+
exec(function () { /* empty */ }, function () { /* empty */ });
|
|
2564
|
+
};
|
|
2565
|
+
var constructor = promise.constructor = {};
|
|
2566
|
+
constructor[SPECIES$1] = FakePromise;
|
|
2567
|
+
SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
|
|
2568
|
+
if (!SUBCLASSING) return true;
|
|
2569
|
+
// Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
|
|
2570
|
+
} return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1;
|
|
2571
|
+
});
|
|
2565
2572
|
|
|
2566
|
-
var
|
|
2567
|
-
|
|
2568
|
-
|
|
2569
|
-
|
|
2570
|
-
head = task;
|
|
2571
|
-
notify$1();
|
|
2572
|
-
} last = task;
|
|
2573
|
+
var promiseConstructorDetection = {
|
|
2574
|
+
CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5,
|
|
2575
|
+
REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1,
|
|
2576
|
+
SUBCLASSING: SUBCLASSING
|
|
2573
2577
|
};
|
|
2574
2578
|
|
|
2575
2579
|
var newPromiseCapability$2 = {};
|
|
2576
2580
|
|
|
2577
|
-
var aCallable$
|
|
2581
|
+
var aCallable$4 = aCallable$8;
|
|
2582
|
+
|
|
2583
|
+
var $TypeError$5 = TypeError;
|
|
2578
2584
|
|
|
2579
2585
|
var PromiseCapability = function (C) {
|
|
2580
2586
|
var resolve, reject;
|
|
2581
2587
|
this.promise = new C(function ($$resolve, $$reject) {
|
|
2582
|
-
if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
|
|
2588
|
+
if (resolve !== undefined || reject !== undefined) throw new $TypeError$5('Bad Promise constructor');
|
|
2583
2589
|
resolve = $$resolve;
|
|
2584
2590
|
reject = $$reject;
|
|
2585
2591
|
});
|
|
2586
|
-
this.resolve = aCallable$
|
|
2587
|
-
this.reject = aCallable$
|
|
2592
|
+
this.resolve = aCallable$4(resolve);
|
|
2593
|
+
this.reject = aCallable$4(reject);
|
|
2588
2594
|
};
|
|
2589
2595
|
|
|
2590
2596
|
// `NewPromiseCapability` abstract operation
|
|
@@ -2593,111 +2599,45 @@ newPromiseCapability$2.f = function (C) {
|
|
|
2593
2599
|
return new PromiseCapability(C);
|
|
2594
2600
|
};
|
|
2595
2601
|
|
|
2596
|
-
var
|
|
2597
|
-
var
|
|
2598
|
-
var
|
|
2599
|
-
|
|
2600
|
-
var
|
|
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
|
-
};
|
|
2608
|
-
|
|
2609
|
-
var global$6 = global$G;
|
|
2610
|
-
|
|
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
|
-
};
|
|
2617
|
-
|
|
2618
|
-
var perform$1 = function (exec) {
|
|
2619
|
-
try {
|
|
2620
|
-
return { error: false, value: exec() };
|
|
2621
|
-
} catch (error) {
|
|
2622
|
-
return { error: true, value: error };
|
|
2623
|
-
}
|
|
2624
|
-
};
|
|
2625
|
-
|
|
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
|
-
}
|
|
2646
|
-
};
|
|
2647
|
-
|
|
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;
|
|
2602
|
+
var $$9 = _export;
|
|
2603
|
+
var IS_NODE = engineIsNode;
|
|
2604
|
+
var global$4 = global$l;
|
|
2605
|
+
var call$a = functionCall;
|
|
2606
|
+
var defineBuiltIn$2 = defineBuiltIn$7;
|
|
2659
2607
|
var setPrototypeOf = objectSetPrototypeOf;
|
|
2660
|
-
var setToStringTag = setToStringTag$
|
|
2608
|
+
var setToStringTag = setToStringTag$4;
|
|
2661
2609
|
var setSpecies = setSpecies$1;
|
|
2662
|
-
var aCallable = aCallable$
|
|
2663
|
-
var isCallable$
|
|
2664
|
-
var isObject = isObject$
|
|
2610
|
+
var aCallable$3 = aCallable$8;
|
|
2611
|
+
var isCallable$4 = isCallable$m;
|
|
2612
|
+
var isObject$1 = isObject$b;
|
|
2665
2613
|
var anInstance = anInstance$1;
|
|
2666
|
-
var inspectSource = inspectSource$4;
|
|
2667
|
-
var iterate = iterate$1;
|
|
2668
|
-
var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
|
|
2669
2614
|
var speciesConstructor = speciesConstructor$1;
|
|
2670
2615
|
var task = task$1.set;
|
|
2671
|
-
var microtask =
|
|
2672
|
-
var promiseResolve = promiseResolve$1;
|
|
2616
|
+
var microtask = microtask_1;
|
|
2673
2617
|
var hostReportErrors = hostReportErrors$1;
|
|
2674
|
-
var
|
|
2675
|
-
var
|
|
2676
|
-
var Queue = queue;
|
|
2618
|
+
var perform$2 = perform$3;
|
|
2619
|
+
var Queue = queue$1;
|
|
2677
2620
|
var InternalStateModule = internalState;
|
|
2678
|
-
var
|
|
2679
|
-
var
|
|
2680
|
-
var
|
|
2681
|
-
var IS_NODE = engineIsNode;
|
|
2682
|
-
var V8_VERSION = engineV8Version;
|
|
2621
|
+
var NativePromiseConstructor$2 = promiseNativeConstructor;
|
|
2622
|
+
var PromiseConstructorDetection = promiseConstructorDetection;
|
|
2623
|
+
var newPromiseCapabilityModule$3 = newPromiseCapability$2;
|
|
2683
2624
|
|
|
2684
|
-
var SPECIES$1 = wellKnownSymbol$2('species');
|
|
2685
2625
|
var PROMISE = 'Promise';
|
|
2686
|
-
|
|
2687
|
-
var
|
|
2688
|
-
var
|
|
2626
|
+
var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR;
|
|
2627
|
+
var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
|
|
2628
|
+
var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
|
|
2689
2629
|
var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
|
|
2690
|
-
var
|
|
2691
|
-
var
|
|
2692
|
-
var
|
|
2693
|
-
var
|
|
2694
|
-
var
|
|
2695
|
-
var
|
|
2696
|
-
var
|
|
2697
|
-
var
|
|
2698
|
-
|
|
2699
|
-
|
|
2700
|
-
var
|
|
2630
|
+
var setInternalState = InternalStateModule.set;
|
|
2631
|
+
var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype;
|
|
2632
|
+
var PromiseConstructor = NativePromiseConstructor$2;
|
|
2633
|
+
var PromisePrototype = NativePromisePrototype$1;
|
|
2634
|
+
var TypeError$1 = global$4.TypeError;
|
|
2635
|
+
var document$1 = global$4.document;
|
|
2636
|
+
var process = global$4.process;
|
|
2637
|
+
var newPromiseCapability$1 = newPromiseCapabilityModule$3.f;
|
|
2638
|
+
var newGenericPromiseCapability = newPromiseCapability$1;
|
|
2639
|
+
|
|
2640
|
+
var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$4.dispatchEvent);
|
|
2701
2641
|
var UNHANDLED_REJECTION = 'unhandledrejection';
|
|
2702
2642
|
var REJECTION_HANDLED = 'rejectionhandled';
|
|
2703
2643
|
var PENDING = 0;
|
|
@@ -2705,47 +2645,18 @@ var FULFILLED = 1;
|
|
|
2705
2645
|
var REJECTED = 2;
|
|
2706
2646
|
var HANDLED = 1;
|
|
2707
2647
|
var UNHANDLED = 2;
|
|
2708
|
-
var SUBCLASSING = false;
|
|
2709
2648
|
|
|
2710
2649
|
var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
|
|
2711
2650
|
|
|
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
|
-
});
|
|
2735
|
-
|
|
2736
|
-
var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
|
|
2737
|
-
PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
|
|
2738
|
-
});
|
|
2739
|
-
|
|
2740
2651
|
// helpers
|
|
2741
2652
|
var isThenable = function (it) {
|
|
2742
2653
|
var then;
|
|
2743
|
-
return isObject(it) && isCallable$
|
|
2654
|
+
return isObject$1(it) && isCallable$4(then = it.then) ? then : false;
|
|
2744
2655
|
};
|
|
2745
2656
|
|
|
2746
2657
|
var callReaction = function (reaction, state) {
|
|
2747
2658
|
var value = state.value;
|
|
2748
|
-
var ok = state.state
|
|
2659
|
+
var ok = state.state === FULFILLED;
|
|
2749
2660
|
var handler = ok ? reaction.ok : reaction.fail;
|
|
2750
2661
|
var resolve = reaction.resolve;
|
|
2751
2662
|
var reject = reaction.reject;
|
|
@@ -2767,9 +2678,9 @@ var callReaction = function (reaction, state) {
|
|
|
2767
2678
|
}
|
|
2768
2679
|
}
|
|
2769
2680
|
if (result === reaction.promise) {
|
|
2770
|
-
reject(TypeError$
|
|
2681
|
+
reject(new TypeError$1('Promise-chain cycle'));
|
|
2771
2682
|
} else if (then = isThenable(result)) {
|
|
2772
|
-
call$
|
|
2683
|
+
call$a(then, result, resolve, reject);
|
|
2773
2684
|
} else resolve(result);
|
|
2774
2685
|
} else reject(value);
|
|
2775
2686
|
} catch (error) {
|
|
@@ -2799,20 +2710,20 @@ var dispatchEvent = function (name, promise, reason) {
|
|
|
2799
2710
|
event.promise = promise;
|
|
2800
2711
|
event.reason = reason;
|
|
2801
2712
|
event.initEvent(name, false, true);
|
|
2802
|
-
global$
|
|
2713
|
+
global$4.dispatchEvent(event);
|
|
2803
2714
|
} else event = { promise: promise, reason: reason };
|
|
2804
|
-
if (!
|
|
2715
|
+
if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$4['on' + name])) handler(event);
|
|
2805
2716
|
else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
|
|
2806
2717
|
};
|
|
2807
2718
|
|
|
2808
2719
|
var onUnhandled = function (state) {
|
|
2809
|
-
call$
|
|
2720
|
+
call$a(task, global$4, function () {
|
|
2810
2721
|
var promise = state.facade;
|
|
2811
2722
|
var value = state.value;
|
|
2812
2723
|
var IS_UNHANDLED = isUnhandled(state);
|
|
2813
2724
|
var result;
|
|
2814
2725
|
if (IS_UNHANDLED) {
|
|
2815
|
-
result = perform(function () {
|
|
2726
|
+
result = perform$2(function () {
|
|
2816
2727
|
if (IS_NODE) {
|
|
2817
2728
|
process.emit('unhandledRejection', value, promise);
|
|
2818
2729
|
} else dispatchEvent(UNHANDLED_REJECTION, promise, value);
|
|
@@ -2829,7 +2740,7 @@ var isUnhandled = function (state) {
|
|
|
2829
2740
|
};
|
|
2830
2741
|
|
|
2831
2742
|
var onHandleUnhandled = function (state) {
|
|
2832
|
-
call$
|
|
2743
|
+
call$a(task, global$4, function () {
|
|
2833
2744
|
var promise = state.facade;
|
|
2834
2745
|
if (IS_NODE) {
|
|
2835
2746
|
process.emit('rejectionHandled', promise);
|
|
@@ -2837,7 +2748,7 @@ var onHandleUnhandled = function (state) {
|
|
|
2837
2748
|
});
|
|
2838
2749
|
};
|
|
2839
2750
|
|
|
2840
|
-
var bind = function (fn, state, unwrap) {
|
|
2751
|
+
var bind$1 = function (fn, state, unwrap) {
|
|
2841
2752
|
return function (value) {
|
|
2842
2753
|
fn(state, value, unwrap);
|
|
2843
2754
|
};
|
|
@@ -2857,15 +2768,15 @@ var internalResolve = function (state, value, unwrap) {
|
|
|
2857
2768
|
state.done = true;
|
|
2858
2769
|
if (unwrap) state = unwrap;
|
|
2859
2770
|
try {
|
|
2860
|
-
if (state.facade === value) throw TypeError$
|
|
2771
|
+
if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself");
|
|
2861
2772
|
var then = isThenable(value);
|
|
2862
2773
|
if (then) {
|
|
2863
2774
|
microtask(function () {
|
|
2864
2775
|
var wrapper = { done: false };
|
|
2865
2776
|
try {
|
|
2866
|
-
call$
|
|
2867
|
-
bind(internalResolve, wrapper, state),
|
|
2868
|
-
bind(internalReject, wrapper, state)
|
|
2777
|
+
call$a(then, value,
|
|
2778
|
+
bind$1(internalResolve, wrapper, state),
|
|
2779
|
+
bind$1(internalReject, wrapper, state)
|
|
2869
2780
|
);
|
|
2870
2781
|
} catch (error) {
|
|
2871
2782
|
internalReject(wrapper, error, state);
|
|
@@ -2876,150 +2787,312 @@ var internalResolve = function (state, value, unwrap) {
|
|
|
2876
2787
|
state.state = FULFILLED;
|
|
2877
2788
|
notify(state, false);
|
|
2878
2789
|
}
|
|
2879
|
-
} catch (error) {
|
|
2880
|
-
internalReject({ done: false }, error, state);
|
|
2790
|
+
} catch (error) {
|
|
2791
|
+
internalReject({ done: false }, error, state);
|
|
2792
|
+
}
|
|
2793
|
+
};
|
|
2794
|
+
|
|
2795
|
+
// constructor polyfill
|
|
2796
|
+
if (FORCED_PROMISE_CONSTRUCTOR$4) {
|
|
2797
|
+
// 25.4.3.1 Promise(executor)
|
|
2798
|
+
PromiseConstructor = function Promise(executor) {
|
|
2799
|
+
anInstance(this, PromisePrototype);
|
|
2800
|
+
aCallable$3(executor);
|
|
2801
|
+
call$a(Internal, this);
|
|
2802
|
+
var state = getInternalPromiseState(this);
|
|
2803
|
+
try {
|
|
2804
|
+
executor(bind$1(internalResolve, state), bind$1(internalReject, state));
|
|
2805
|
+
} catch (error) {
|
|
2806
|
+
internalReject(state, error);
|
|
2807
|
+
}
|
|
2808
|
+
};
|
|
2809
|
+
|
|
2810
|
+
PromisePrototype = PromiseConstructor.prototype;
|
|
2811
|
+
|
|
2812
|
+
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
2813
|
+
Internal = function Promise(executor) {
|
|
2814
|
+
setInternalState(this, {
|
|
2815
|
+
type: PROMISE,
|
|
2816
|
+
done: false,
|
|
2817
|
+
notified: false,
|
|
2818
|
+
parent: false,
|
|
2819
|
+
reactions: new Queue(),
|
|
2820
|
+
rejection: false,
|
|
2821
|
+
state: PENDING,
|
|
2822
|
+
value: undefined
|
|
2823
|
+
});
|
|
2824
|
+
};
|
|
2825
|
+
|
|
2826
|
+
// `Promise.prototype.then` method
|
|
2827
|
+
// https://tc39.es/ecma262/#sec-promise.prototype.then
|
|
2828
|
+
Internal.prototype = defineBuiltIn$2(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
|
|
2829
|
+
var state = getInternalPromiseState(this);
|
|
2830
|
+
var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor));
|
|
2831
|
+
state.parent = true;
|
|
2832
|
+
reaction.ok = isCallable$4(onFulfilled) ? onFulfilled : true;
|
|
2833
|
+
reaction.fail = isCallable$4(onRejected) && onRejected;
|
|
2834
|
+
reaction.domain = IS_NODE ? process.domain : undefined;
|
|
2835
|
+
if (state.state === PENDING) state.reactions.add(reaction);
|
|
2836
|
+
else microtask(function () {
|
|
2837
|
+
callReaction(reaction, state);
|
|
2838
|
+
});
|
|
2839
|
+
return reaction.promise;
|
|
2840
|
+
});
|
|
2841
|
+
|
|
2842
|
+
OwnPromiseCapability = function () {
|
|
2843
|
+
var promise = new Internal();
|
|
2844
|
+
var state = getInternalPromiseState(promise);
|
|
2845
|
+
this.promise = promise;
|
|
2846
|
+
this.resolve = bind$1(internalResolve, state);
|
|
2847
|
+
this.reject = bind$1(internalReject, state);
|
|
2848
|
+
};
|
|
2849
|
+
|
|
2850
|
+
newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) {
|
|
2851
|
+
return C === PromiseConstructor || C === PromiseWrapper
|
|
2852
|
+
? new OwnPromiseCapability(C)
|
|
2853
|
+
: newGenericPromiseCapability(C);
|
|
2854
|
+
};
|
|
2855
|
+
|
|
2856
|
+
if (isCallable$4(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) {
|
|
2857
|
+
nativeThen = NativePromisePrototype$1.then;
|
|
2858
|
+
|
|
2859
|
+
if (!NATIVE_PROMISE_SUBCLASSING) {
|
|
2860
|
+
// make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
|
|
2861
|
+
defineBuiltIn$2(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) {
|
|
2862
|
+
var that = this;
|
|
2863
|
+
return new PromiseConstructor(function (resolve, reject) {
|
|
2864
|
+
call$a(nativeThen, that, resolve, reject);
|
|
2865
|
+
}).then(onFulfilled, onRejected);
|
|
2866
|
+
// https://github.com/zloirock/core-js/issues/640
|
|
2867
|
+
}, { unsafe: true });
|
|
2868
|
+
}
|
|
2869
|
+
|
|
2870
|
+
// make `.constructor === Promise` work for native promise-based APIs
|
|
2871
|
+
try {
|
|
2872
|
+
delete NativePromisePrototype$1.constructor;
|
|
2873
|
+
} catch (error) { /* empty */ }
|
|
2874
|
+
|
|
2875
|
+
// make `instanceof Promise` work for native promise-based APIs
|
|
2876
|
+
if (setPrototypeOf) {
|
|
2877
|
+
setPrototypeOf(NativePromisePrototype$1, PromisePrototype);
|
|
2878
|
+
}
|
|
2879
|
+
}
|
|
2880
|
+
}
|
|
2881
|
+
|
|
2882
|
+
$$9({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
|
|
2883
|
+
Promise: PromiseConstructor
|
|
2884
|
+
});
|
|
2885
|
+
|
|
2886
|
+
setToStringTag(PromiseConstructor, PROMISE, false);
|
|
2887
|
+
setSpecies(PROMISE);
|
|
2888
|
+
|
|
2889
|
+
var wellKnownSymbol$4 = wellKnownSymbol$i;
|
|
2890
|
+
var Iterators$1 = iterators;
|
|
2891
|
+
|
|
2892
|
+
var ITERATOR$2 = wellKnownSymbol$4('iterator');
|
|
2893
|
+
var ArrayPrototype = Array.prototype;
|
|
2894
|
+
|
|
2895
|
+
// check on default Array iterator
|
|
2896
|
+
var isArrayIteratorMethod$1 = function (it) {
|
|
2897
|
+
return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it);
|
|
2898
|
+
};
|
|
2899
|
+
|
|
2900
|
+
var classof$2 = classof$7;
|
|
2901
|
+
var getMethod$2 = getMethod$4;
|
|
2902
|
+
var isNullOrUndefined$1 = isNullOrUndefined$5;
|
|
2903
|
+
var Iterators = iterators;
|
|
2904
|
+
var wellKnownSymbol$3 = wellKnownSymbol$i;
|
|
2905
|
+
|
|
2906
|
+
var ITERATOR$1 = wellKnownSymbol$3('iterator');
|
|
2907
|
+
|
|
2908
|
+
var getIteratorMethod$2 = function (it) {
|
|
2909
|
+
if (!isNullOrUndefined$1(it)) return getMethod$2(it, ITERATOR$1)
|
|
2910
|
+
|| getMethod$2(it, '@@iterator')
|
|
2911
|
+
|| Iterators[classof$2(it)];
|
|
2912
|
+
};
|
|
2913
|
+
|
|
2914
|
+
var call$9 = functionCall;
|
|
2915
|
+
var aCallable$2 = aCallable$8;
|
|
2916
|
+
var anObject$6 = anObject$e;
|
|
2917
|
+
var tryToString$1 = tryToString$4;
|
|
2918
|
+
var getIteratorMethod$1 = getIteratorMethod$2;
|
|
2919
|
+
|
|
2920
|
+
var $TypeError$4 = TypeError;
|
|
2921
|
+
|
|
2922
|
+
var getIterator$1 = function (argument, usingIterator) {
|
|
2923
|
+
var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
|
|
2924
|
+
if (aCallable$2(iteratorMethod)) return anObject$6(call$9(iteratorMethod, argument));
|
|
2925
|
+
throw new $TypeError$4(tryToString$1(argument) + ' is not iterable');
|
|
2926
|
+
};
|
|
2927
|
+
|
|
2928
|
+
var call$8 = functionCall;
|
|
2929
|
+
var anObject$5 = anObject$e;
|
|
2930
|
+
var getMethod$1 = getMethod$4;
|
|
2931
|
+
|
|
2932
|
+
var iteratorClose$1 = function (iterator, kind, value) {
|
|
2933
|
+
var innerResult, innerError;
|
|
2934
|
+
anObject$5(iterator);
|
|
2935
|
+
try {
|
|
2936
|
+
innerResult = getMethod$1(iterator, 'return');
|
|
2937
|
+
if (!innerResult) {
|
|
2938
|
+
if (kind === 'throw') throw value;
|
|
2939
|
+
return value;
|
|
2940
|
+
}
|
|
2941
|
+
innerResult = call$8(innerResult, iterator);
|
|
2942
|
+
} catch (error) {
|
|
2943
|
+
innerError = true;
|
|
2944
|
+
innerResult = error;
|
|
2945
|
+
}
|
|
2946
|
+
if (kind === 'throw') throw value;
|
|
2947
|
+
if (innerError) throw innerResult;
|
|
2948
|
+
anObject$5(innerResult);
|
|
2949
|
+
return value;
|
|
2950
|
+
};
|
|
2951
|
+
|
|
2952
|
+
var bind = functionBindContext;
|
|
2953
|
+
var call$7 = functionCall;
|
|
2954
|
+
var anObject$4 = anObject$e;
|
|
2955
|
+
var tryToString = tryToString$4;
|
|
2956
|
+
var isArrayIteratorMethod = isArrayIteratorMethod$1;
|
|
2957
|
+
var lengthOfArrayLike$1 = lengthOfArrayLike$3;
|
|
2958
|
+
var isPrototypeOf = objectIsPrototypeOf;
|
|
2959
|
+
var getIterator = getIterator$1;
|
|
2960
|
+
var getIteratorMethod = getIteratorMethod$2;
|
|
2961
|
+
var iteratorClose = iteratorClose$1;
|
|
2962
|
+
|
|
2963
|
+
var $TypeError$3 = TypeError;
|
|
2964
|
+
|
|
2965
|
+
var Result = function (stopped, result) {
|
|
2966
|
+
this.stopped = stopped;
|
|
2967
|
+
this.result = result;
|
|
2968
|
+
};
|
|
2969
|
+
|
|
2970
|
+
var ResultPrototype = Result.prototype;
|
|
2971
|
+
|
|
2972
|
+
var iterate$2 = function (iterable, unboundFunction, options) {
|
|
2973
|
+
var that = options && options.that;
|
|
2974
|
+
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
|
|
2975
|
+
var IS_RECORD = !!(options && options.IS_RECORD);
|
|
2976
|
+
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
|
|
2977
|
+
var INTERRUPTED = !!(options && options.INTERRUPTED);
|
|
2978
|
+
var fn = bind(unboundFunction, that);
|
|
2979
|
+
var iterator, iterFn, index, length, result, next, step;
|
|
2980
|
+
|
|
2981
|
+
var stop = function (condition) {
|
|
2982
|
+
if (iterator) iteratorClose(iterator, 'normal', condition);
|
|
2983
|
+
return new Result(true, condition);
|
|
2984
|
+
};
|
|
2985
|
+
|
|
2986
|
+
var callFn = function (value) {
|
|
2987
|
+
if (AS_ENTRIES) {
|
|
2988
|
+
anObject$4(value);
|
|
2989
|
+
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
|
|
2990
|
+
} return INTERRUPTED ? fn(value, stop) : fn(value);
|
|
2991
|
+
};
|
|
2992
|
+
|
|
2993
|
+
if (IS_RECORD) {
|
|
2994
|
+
iterator = iterable.iterator;
|
|
2995
|
+
} else if (IS_ITERATOR) {
|
|
2996
|
+
iterator = iterable;
|
|
2997
|
+
} else {
|
|
2998
|
+
iterFn = getIteratorMethod(iterable);
|
|
2999
|
+
if (!iterFn) throw new $TypeError$3(tryToString(iterable) + ' is not iterable');
|
|
3000
|
+
// optimisation for array iterators
|
|
3001
|
+
if (isArrayIteratorMethod(iterFn)) {
|
|
3002
|
+
for (index = 0, length = lengthOfArrayLike$1(iterable); length > index; index++) {
|
|
3003
|
+
result = callFn(iterable[index]);
|
|
3004
|
+
if (result && isPrototypeOf(ResultPrototype, result)) return result;
|
|
3005
|
+
} return new Result(false);
|
|
3006
|
+
}
|
|
3007
|
+
iterator = getIterator(iterable, iterFn);
|
|
2881
3008
|
}
|
|
2882
|
-
};
|
|
2883
3009
|
|
|
2884
|
-
|
|
2885
|
-
|
|
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);
|
|
3010
|
+
next = IS_RECORD ? iterable.next : iterator.next;
|
|
3011
|
+
while (!(step = call$7(next, iterator)).done) {
|
|
2892
3012
|
try {
|
|
2893
|
-
|
|
3013
|
+
result = callFn(step.value);
|
|
2894
3014
|
} catch (error) {
|
|
2895
|
-
|
|
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);
|
|
3015
|
+
iteratorClose(iterator, 'throw', error);
|
|
2933
3016
|
}
|
|
2934
|
-
|
|
2935
|
-
|
|
2936
|
-
|
|
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 });
|
|
3017
|
+
if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
|
|
3018
|
+
} return new Result(false);
|
|
3019
|
+
};
|
|
2960
3020
|
|
|
2961
|
-
|
|
2962
|
-
redefine$1(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });
|
|
2963
|
-
}
|
|
3021
|
+
var wellKnownSymbol$2 = wellKnownSymbol$i;
|
|
2964
3022
|
|
|
2965
|
-
|
|
2966
|
-
|
|
2967
|
-
delete NativePromisePrototype.constructor;
|
|
2968
|
-
} catch (error) { /* empty */ }
|
|
3023
|
+
var ITERATOR = wellKnownSymbol$2('iterator');
|
|
3024
|
+
var SAFE_CLOSING = false;
|
|
2969
3025
|
|
|
2970
|
-
|
|
2971
|
-
|
|
2972
|
-
|
|
3026
|
+
try {
|
|
3027
|
+
var called = 0;
|
|
3028
|
+
var iteratorWithReturn = {
|
|
3029
|
+
next: function () {
|
|
3030
|
+
return { done: !!called++ };
|
|
3031
|
+
},
|
|
3032
|
+
'return': function () {
|
|
3033
|
+
SAFE_CLOSING = true;
|
|
2973
3034
|
}
|
|
2974
|
-
}
|
|
2975
|
-
|
|
2976
|
-
|
|
2977
|
-
|
|
2978
|
-
|
|
2979
|
-
});
|
|
2980
|
-
|
|
2981
|
-
setToStringTag(PromiseConstructor, PROMISE, false);
|
|
2982
|
-
setSpecies(PROMISE);
|
|
3035
|
+
};
|
|
3036
|
+
iteratorWithReturn[ITERATOR] = function () {
|
|
3037
|
+
return this;
|
|
3038
|
+
};
|
|
3039
|
+
// eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
|
|
3040
|
+
Array.from(iteratorWithReturn, function () { throw 2; });
|
|
3041
|
+
} catch (error) { /* empty */ }
|
|
2983
3042
|
|
|
2984
|
-
|
|
3043
|
+
var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
|
|
3044
|
+
try {
|
|
3045
|
+
if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
|
|
3046
|
+
} catch (error) { return false; } // workaround of old WebKit + `eval` bug
|
|
3047
|
+
var ITERATION_SUPPORT = false;
|
|
3048
|
+
try {
|
|
3049
|
+
var object = {};
|
|
3050
|
+
object[ITERATOR] = function () {
|
|
3051
|
+
return {
|
|
3052
|
+
next: function () {
|
|
3053
|
+
return { done: ITERATION_SUPPORT = true };
|
|
3054
|
+
}
|
|
3055
|
+
};
|
|
3056
|
+
};
|
|
3057
|
+
exec(object);
|
|
3058
|
+
} catch (error) { /* empty */ }
|
|
3059
|
+
return ITERATION_SUPPORT;
|
|
3060
|
+
};
|
|
2985
3061
|
|
|
2986
|
-
|
|
2987
|
-
|
|
2988
|
-
|
|
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
|
-
});
|
|
3062
|
+
var NativePromiseConstructor$1 = promiseNativeConstructor;
|
|
3063
|
+
var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
|
|
3064
|
+
var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR;
|
|
2996
3065
|
|
|
2997
|
-
|
|
2998
|
-
|
|
2999
|
-
// https://tc39.es/ecma262/#sec-promise.resolve
|
|
3000
|
-
resolve: function resolve(x) {
|
|
3001
|
-
return promiseResolve(this, x);
|
|
3002
|
-
}
|
|
3066
|
+
var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration(function (iterable) {
|
|
3067
|
+
NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ });
|
|
3003
3068
|
});
|
|
3004
3069
|
|
|
3005
|
-
$$
|
|
3006
|
-
|
|
3007
|
-
|
|
3070
|
+
var $$8 = _export;
|
|
3071
|
+
var call$6 = functionCall;
|
|
3072
|
+
var aCallable$1 = aCallable$8;
|
|
3073
|
+
var newPromiseCapabilityModule$2 = newPromiseCapability$2;
|
|
3074
|
+
var perform$1 = perform$3;
|
|
3075
|
+
var iterate$1 = iterate$2;
|
|
3076
|
+
var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration;
|
|
3077
|
+
|
|
3078
|
+
// `Promise.all` method
|
|
3079
|
+
// https://tc39.es/ecma262/#sec-promise.all
|
|
3080
|
+
$$8({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
|
|
3008
3081
|
all: function all(iterable) {
|
|
3009
3082
|
var C = this;
|
|
3010
|
-
var capability =
|
|
3083
|
+
var capability = newPromiseCapabilityModule$2.f(C);
|
|
3011
3084
|
var resolve = capability.resolve;
|
|
3012
3085
|
var reject = capability.reject;
|
|
3013
|
-
var result = perform(function () {
|
|
3014
|
-
var $promiseResolve = aCallable(C.resolve);
|
|
3086
|
+
var result = perform$1(function () {
|
|
3087
|
+
var $promiseResolve = aCallable$1(C.resolve);
|
|
3015
3088
|
var values = [];
|
|
3016
3089
|
var counter = 0;
|
|
3017
3090
|
var remaining = 1;
|
|
3018
|
-
iterate(iterable, function (promise) {
|
|
3091
|
+
iterate$1(iterable, function (promise) {
|
|
3019
3092
|
var index = counter++;
|
|
3020
3093
|
var alreadyCalled = false;
|
|
3021
3094
|
remaining++;
|
|
3022
|
-
call$
|
|
3095
|
+
call$6($promiseResolve, C, promise).then(function (value) {
|
|
3023
3096
|
if (alreadyCalled) return;
|
|
3024
3097
|
alreadyCalled = true;
|
|
3025
3098
|
values[index] = value;
|
|
@@ -3030,17 +3103,53 @@ $$1({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
|
|
|
3030
3103
|
});
|
|
3031
3104
|
if (result.error) reject(result.value);
|
|
3032
3105
|
return capability.promise;
|
|
3033
|
-
}
|
|
3034
|
-
|
|
3035
|
-
|
|
3106
|
+
}
|
|
3107
|
+
});
|
|
3108
|
+
|
|
3109
|
+
var $$7 = _export;
|
|
3110
|
+
var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
|
|
3111
|
+
var NativePromiseConstructor = promiseNativeConstructor;
|
|
3112
|
+
var getBuiltIn$1 = getBuiltIn$7;
|
|
3113
|
+
var isCallable$3 = isCallable$m;
|
|
3114
|
+
var defineBuiltIn$1 = defineBuiltIn$7;
|
|
3115
|
+
|
|
3116
|
+
var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
|
|
3117
|
+
|
|
3118
|
+
// `Promise.prototype.catch` method
|
|
3119
|
+
// https://tc39.es/ecma262/#sec-promise.prototype.catch
|
|
3120
|
+
$$7({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
|
|
3121
|
+
'catch': function (onRejected) {
|
|
3122
|
+
return this.then(undefined, onRejected);
|
|
3123
|
+
}
|
|
3124
|
+
});
|
|
3125
|
+
|
|
3126
|
+
// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
|
|
3127
|
+
if (isCallable$3(NativePromiseConstructor)) {
|
|
3128
|
+
var method = getBuiltIn$1('Promise').prototype['catch'];
|
|
3129
|
+
if (NativePromisePrototype['catch'] !== method) {
|
|
3130
|
+
defineBuiltIn$1(NativePromisePrototype, 'catch', method, { unsafe: true });
|
|
3131
|
+
}
|
|
3132
|
+
}
|
|
3133
|
+
|
|
3134
|
+
var $$6 = _export;
|
|
3135
|
+
var call$5 = functionCall;
|
|
3136
|
+
var aCallable = aCallable$8;
|
|
3137
|
+
var newPromiseCapabilityModule$1 = newPromiseCapability$2;
|
|
3138
|
+
var perform = perform$3;
|
|
3139
|
+
var iterate = iterate$2;
|
|
3140
|
+
var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration;
|
|
3141
|
+
|
|
3142
|
+
// `Promise.race` method
|
|
3143
|
+
// https://tc39.es/ecma262/#sec-promise.race
|
|
3144
|
+
$$6({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
|
|
3036
3145
|
race: function race(iterable) {
|
|
3037
3146
|
var C = this;
|
|
3038
|
-
var capability =
|
|
3147
|
+
var capability = newPromiseCapabilityModule$1.f(C);
|
|
3039
3148
|
var reject = capability.reject;
|
|
3040
3149
|
var result = perform(function () {
|
|
3041
3150
|
var $promiseResolve = aCallable(C.resolve);
|
|
3042
3151
|
iterate(iterable, function (promise) {
|
|
3043
|
-
call$
|
|
3152
|
+
call$5($promiseResolve, C, promise).then(capability.resolve, reject);
|
|
3044
3153
|
});
|
|
3045
3154
|
});
|
|
3046
3155
|
if (result.error) reject(result.value);
|
|
@@ -3048,29 +3157,72 @@ $$1({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
|
|
|
3048
3157
|
}
|
|
3049
3158
|
});
|
|
3050
3159
|
|
|
3051
|
-
var
|
|
3052
|
-
var
|
|
3160
|
+
var $$5 = _export;
|
|
3161
|
+
var newPromiseCapabilityModule = newPromiseCapability$2;
|
|
3162
|
+
var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
|
|
3163
|
+
|
|
3164
|
+
// `Promise.reject` method
|
|
3165
|
+
// https://tc39.es/ecma262/#sec-promise.reject
|
|
3166
|
+
$$5({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
|
|
3167
|
+
reject: function reject(r) {
|
|
3168
|
+
var capability = newPromiseCapabilityModule.f(this);
|
|
3169
|
+
var capabilityReject = capability.reject;
|
|
3170
|
+
capabilityReject(r);
|
|
3171
|
+
return capability.promise;
|
|
3172
|
+
}
|
|
3173
|
+
});
|
|
3174
|
+
|
|
3175
|
+
var anObject$3 = anObject$e;
|
|
3176
|
+
var isObject = isObject$b;
|
|
3177
|
+
var newPromiseCapability = newPromiseCapability$2;
|
|
3178
|
+
|
|
3179
|
+
var promiseResolve$1 = function (C, x) {
|
|
3180
|
+
anObject$3(C);
|
|
3181
|
+
if (isObject(x) && x.constructor === C) return x;
|
|
3182
|
+
var promiseCapability = newPromiseCapability.f(C);
|
|
3183
|
+
var resolve = promiseCapability.resolve;
|
|
3184
|
+
resolve(x);
|
|
3185
|
+
return promiseCapability.promise;
|
|
3186
|
+
};
|
|
3187
|
+
|
|
3188
|
+
var $$4 = _export;
|
|
3189
|
+
var getBuiltIn = getBuiltIn$7;
|
|
3190
|
+
var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR;
|
|
3191
|
+
var promiseResolve = promiseResolve$1;
|
|
3192
|
+
|
|
3193
|
+
getBuiltIn('Promise');
|
|
3194
|
+
|
|
3195
|
+
// `Promise.resolve` method
|
|
3196
|
+
// https://tc39.es/ecma262/#sec-promise.resolve
|
|
3197
|
+
$$4({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
|
|
3198
|
+
resolve: function resolve(x) {
|
|
3199
|
+
return promiseResolve(this, x);
|
|
3200
|
+
}
|
|
3201
|
+
});
|
|
3202
|
+
|
|
3203
|
+
var fails$5 = fails$l;
|
|
3204
|
+
var global$3 = global$l;
|
|
3053
3205
|
|
|
3054
3206
|
// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
|
|
3055
|
-
var $RegExp$2 = global$
|
|
3207
|
+
var $RegExp$2 = global$3.RegExp;
|
|
3056
3208
|
|
|
3057
|
-
var UNSUPPORTED_Y$1 = fails$
|
|
3209
|
+
var UNSUPPORTED_Y$1 = fails$5(function () {
|
|
3058
3210
|
var re = $RegExp$2('a', 'y');
|
|
3059
3211
|
re.lastIndex = 2;
|
|
3060
|
-
return re.exec('abcd')
|
|
3212
|
+
return re.exec('abcd') !== null;
|
|
3061
3213
|
});
|
|
3062
3214
|
|
|
3063
3215
|
// UC Browser bug
|
|
3064
3216
|
// https://github.com/zloirock/core-js/issues/1008
|
|
3065
|
-
var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$
|
|
3217
|
+
var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$5(function () {
|
|
3066
3218
|
return !$RegExp$2('a', 'y').sticky;
|
|
3067
3219
|
});
|
|
3068
3220
|
|
|
3069
|
-
var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$
|
|
3221
|
+
var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$5(function () {
|
|
3070
3222
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=773687
|
|
3071
3223
|
var re = $RegExp$2('^r', 'gy');
|
|
3072
3224
|
re.lastIndex = 2;
|
|
3073
|
-
return re.exec('str')
|
|
3225
|
+
return re.exec('str') !== null;
|
|
3074
3226
|
});
|
|
3075
3227
|
|
|
3076
3228
|
var regexpStickyHelpers = {
|
|
@@ -3079,24 +3231,24 @@ var regexpStickyHelpers = {
|
|
|
3079
3231
|
UNSUPPORTED_Y: UNSUPPORTED_Y$1
|
|
3080
3232
|
};
|
|
3081
3233
|
|
|
3082
|
-
var fails$
|
|
3083
|
-
var global$
|
|
3234
|
+
var fails$4 = fails$l;
|
|
3235
|
+
var global$2 = global$l;
|
|
3084
3236
|
|
|
3085
3237
|
// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
|
|
3086
|
-
var $RegExp$1 = global$
|
|
3238
|
+
var $RegExp$1 = global$2.RegExp;
|
|
3087
3239
|
|
|
3088
|
-
var regexpUnsupportedDotAll = fails$
|
|
3240
|
+
var regexpUnsupportedDotAll = fails$4(function () {
|
|
3089
3241
|
var re = $RegExp$1('.', 's');
|
|
3090
|
-
return !(re.dotAll && re.
|
|
3242
|
+
return !(re.dotAll && re.test('\n') && re.flags === 's');
|
|
3091
3243
|
});
|
|
3092
3244
|
|
|
3093
|
-
var fails$
|
|
3094
|
-
var global$
|
|
3245
|
+
var fails$3 = fails$l;
|
|
3246
|
+
var global$1 = global$l;
|
|
3095
3247
|
|
|
3096
3248
|
// babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
|
|
3097
|
-
var $RegExp = global$
|
|
3249
|
+
var $RegExp = global$1.RegExp;
|
|
3098
3250
|
|
|
3099
|
-
var regexpUnsupportedNcg = fails$
|
|
3251
|
+
var regexpUnsupportedNcg = fails$3(function () {
|
|
3100
3252
|
var re = $RegExp('(?<a>b)', 'g');
|
|
3101
3253
|
return re.exec('b').groups.a !== 'b' ||
|
|
3102
3254
|
'b'.replace(re, '$<a>c') !== 'bc';
|
|
@@ -3104,12 +3256,12 @@ var regexpUnsupportedNcg = fails$2(function () {
|
|
|
3104
3256
|
|
|
3105
3257
|
/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
|
|
3106
3258
|
/* eslint-disable regexp/no-useless-quantifier -- testing */
|
|
3107
|
-
var call$
|
|
3259
|
+
var call$4 = functionCall;
|
|
3108
3260
|
var uncurryThis$4 = functionUncurryThis;
|
|
3109
|
-
var toString$
|
|
3261
|
+
var toString$4 = toString$6;
|
|
3110
3262
|
var regexpFlags = regexpFlags$1;
|
|
3111
3263
|
var stickyHelpers = regexpStickyHelpers;
|
|
3112
|
-
var shared = shared$4
|
|
3264
|
+
var shared = shared$4;
|
|
3113
3265
|
var create = objectCreate;
|
|
3114
3266
|
var getInternalState = internalState.get;
|
|
3115
3267
|
var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
|
|
@@ -3121,13 +3273,13 @@ var patchedExec = nativeExec;
|
|
|
3121
3273
|
var charAt$3 = uncurryThis$4(''.charAt);
|
|
3122
3274
|
var indexOf = uncurryThis$4(''.indexOf);
|
|
3123
3275
|
var replace$1 = uncurryThis$4(''.replace);
|
|
3124
|
-
var stringSlice$
|
|
3276
|
+
var stringSlice$4 = uncurryThis$4(''.slice);
|
|
3125
3277
|
|
|
3126
3278
|
var UPDATES_LAST_INDEX_WRONG = (function () {
|
|
3127
3279
|
var re1 = /a/;
|
|
3128
3280
|
var re2 = /b*/g;
|
|
3129
|
-
call$
|
|
3130
|
-
call$
|
|
3281
|
+
call$4(nativeExec, re1, 'a');
|
|
3282
|
+
call$4(nativeExec, re2, 'a');
|
|
3131
3283
|
return re1.lastIndex !== 0 || re2.lastIndex !== 0;
|
|
3132
3284
|
})();
|
|
3133
3285
|
|
|
@@ -3142,20 +3294,20 @@ if (PATCH) {
|
|
|
3142
3294
|
patchedExec = function exec(string) {
|
|
3143
3295
|
var re = this;
|
|
3144
3296
|
var state = getInternalState(re);
|
|
3145
|
-
var str = toString$
|
|
3297
|
+
var str = toString$4(string);
|
|
3146
3298
|
var raw = state.raw;
|
|
3147
3299
|
var result, reCopy, lastIndex, match, i, object, group;
|
|
3148
3300
|
|
|
3149
3301
|
if (raw) {
|
|
3150
3302
|
raw.lastIndex = re.lastIndex;
|
|
3151
|
-
result = call$
|
|
3303
|
+
result = call$4(patchedExec, raw, str);
|
|
3152
3304
|
re.lastIndex = raw.lastIndex;
|
|
3153
3305
|
return result;
|
|
3154
3306
|
}
|
|
3155
3307
|
|
|
3156
3308
|
var groups = state.groups;
|
|
3157
3309
|
var sticky = UNSUPPORTED_Y && re.sticky;
|
|
3158
|
-
var flags = call$
|
|
3310
|
+
var flags = call$4(regexpFlags, re);
|
|
3159
3311
|
var source = re.source;
|
|
3160
3312
|
var charsAdded = 0;
|
|
3161
3313
|
var strCopy = str;
|
|
@@ -3166,7 +3318,7 @@ if (PATCH) {
|
|
|
3166
3318
|
flags += 'g';
|
|
3167
3319
|
}
|
|
3168
3320
|
|
|
3169
|
-
strCopy = stringSlice$
|
|
3321
|
+
strCopy = stringSlice$4(str, re.lastIndex);
|
|
3170
3322
|
// Support anchored sticky behavior.
|
|
3171
3323
|
if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$3(str, re.lastIndex - 1) !== '\n')) {
|
|
3172
3324
|
source = '(?: ' + source + ')';
|
|
@@ -3183,12 +3335,12 @@ if (PATCH) {
|
|
|
3183
3335
|
}
|
|
3184
3336
|
if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
|
|
3185
3337
|
|
|
3186
|
-
match = call$
|
|
3338
|
+
match = call$4(nativeExec, sticky ? reCopy : re, strCopy);
|
|
3187
3339
|
|
|
3188
3340
|
if (sticky) {
|
|
3189
3341
|
if (match) {
|
|
3190
|
-
match.input = stringSlice$
|
|
3191
|
-
match[0] = stringSlice$
|
|
3342
|
+
match.input = stringSlice$4(match.input, charsAdded);
|
|
3343
|
+
match[0] = stringSlice$4(match[0], charsAdded);
|
|
3192
3344
|
match.index = re.lastIndex;
|
|
3193
3345
|
re.lastIndex += match[0].length;
|
|
3194
3346
|
} else re.lastIndex = 0;
|
|
@@ -3197,8 +3349,8 @@ if (PATCH) {
|
|
|
3197
3349
|
}
|
|
3198
3350
|
if (NPCG_INCLUDED && match && match.length > 1) {
|
|
3199
3351
|
// Fix browsers whose `exec` methods don't consistently return `undefined`
|
|
3200
|
-
// for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
|
|
3201
|
-
call$
|
|
3352
|
+
// for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
|
|
3353
|
+
call$4(nativeReplace, match[0], reCopy, function () {
|
|
3202
3354
|
for (i = 1; i < arguments.length - 2; i++) {
|
|
3203
3355
|
if (arguments[i] === undefined) match[i] = undefined;
|
|
3204
3356
|
}
|
|
@@ -3219,23 +3371,23 @@ if (PATCH) {
|
|
|
3219
3371
|
|
|
3220
3372
|
var regexpExec$2 = patchedExec;
|
|
3221
3373
|
|
|
3222
|
-
var
|
|
3374
|
+
var $$3 = _export;
|
|
3223
3375
|
var exec = regexpExec$2;
|
|
3224
3376
|
|
|
3225
3377
|
// `RegExp.prototype.exec` method
|
|
3226
3378
|
// https://tc39.es/ecma262/#sec-regexp.prototype.exec
|
|
3227
|
-
|
|
3379
|
+
$$3({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
|
|
3228
3380
|
exec: exec
|
|
3229
3381
|
});
|
|
3230
3382
|
|
|
3231
3383
|
// TODO: Remove from `core-js@4` since it's moved to entry points
|
|
3232
3384
|
|
|
3233
|
-
var
|
|
3234
|
-
var
|
|
3385
|
+
var call$3 = functionCall;
|
|
3386
|
+
var defineBuiltIn = defineBuiltIn$7;
|
|
3235
3387
|
var regexpExec$1 = regexpExec$2;
|
|
3236
|
-
var fails$
|
|
3388
|
+
var fails$2 = fails$l;
|
|
3237
3389
|
var wellKnownSymbol$1 = wellKnownSymbol$i;
|
|
3238
|
-
var createNonEnumerableProperty = createNonEnumerableProperty$
|
|
3390
|
+
var createNonEnumerableProperty = createNonEnumerableProperty$5;
|
|
3239
3391
|
|
|
3240
3392
|
var SPECIES = wellKnownSymbol$1('species');
|
|
3241
3393
|
var RegExpPrototype = RegExp.prototype;
|
|
@@ -3243,14 +3395,14 @@ var RegExpPrototype = RegExp.prototype;
|
|
|
3243
3395
|
var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
|
|
3244
3396
|
var SYMBOL = wellKnownSymbol$1(KEY);
|
|
3245
3397
|
|
|
3246
|
-
var DELEGATES_TO_SYMBOL = !fails$
|
|
3247
|
-
// String methods call symbol-named
|
|
3398
|
+
var DELEGATES_TO_SYMBOL = !fails$2(function () {
|
|
3399
|
+
// String methods call symbol-named RegExp methods
|
|
3248
3400
|
var O = {};
|
|
3249
3401
|
O[SYMBOL] = function () { return 7; };
|
|
3250
|
-
return ''[KEY](O)
|
|
3402
|
+
return ''[KEY](O) !== 7;
|
|
3251
3403
|
});
|
|
3252
3404
|
|
|
3253
|
-
var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$
|
|
3405
|
+
var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$2(function () {
|
|
3254
3406
|
// Symbol-named RegExp methods call .exec
|
|
3255
3407
|
var execCalled = false;
|
|
3256
3408
|
var re = /a/;
|
|
@@ -3268,7 +3420,10 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
|
|
|
3268
3420
|
re[SYMBOL] = /./[SYMBOL];
|
|
3269
3421
|
}
|
|
3270
3422
|
|
|
3271
|
-
re.exec = function () {
|
|
3423
|
+
re.exec = function () {
|
|
3424
|
+
execCalled = true;
|
|
3425
|
+
return null;
|
|
3426
|
+
};
|
|
3272
3427
|
|
|
3273
3428
|
re[SYMBOL]('');
|
|
3274
3429
|
return !execCalled;
|
|
@@ -3279,41 +3434,40 @@ var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
|
|
|
3279
3434
|
!DELEGATES_TO_EXEC ||
|
|
3280
3435
|
FORCED
|
|
3281
3436
|
) {
|
|
3282
|
-
var
|
|
3437
|
+
var nativeRegExpMethod = /./[SYMBOL];
|
|
3283
3438
|
var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
|
|
3284
|
-
var uncurriedNativeMethod = uncurryThis$3(nativeMethod);
|
|
3285
3439
|
var $exec = regexp.exec;
|
|
3286
3440
|
if ($exec === regexpExec$1 || $exec === RegExpPrototype.exec) {
|
|
3287
3441
|
if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
|
|
3288
3442
|
// The native String method already delegates to @@method (this
|
|
3289
3443
|
// polyfilled function), leasing to infinite recursion.
|
|
3290
3444
|
// We avoid it by directly calling the native @@method method.
|
|
3291
|
-
return { done: true, value:
|
|
3445
|
+
return { done: true, value: call$3(nativeRegExpMethod, regexp, str, arg2) };
|
|
3292
3446
|
}
|
|
3293
|
-
return { done: true, value:
|
|
3447
|
+
return { done: true, value: call$3(nativeMethod, str, regexp, arg2) };
|
|
3294
3448
|
}
|
|
3295
3449
|
return { done: false };
|
|
3296
3450
|
});
|
|
3297
3451
|
|
|
3298
|
-
|
|
3299
|
-
|
|
3452
|
+
defineBuiltIn(String.prototype, KEY, methods[0]);
|
|
3453
|
+
defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]);
|
|
3300
3454
|
}
|
|
3301
3455
|
|
|
3302
3456
|
if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
|
|
3303
3457
|
};
|
|
3304
3458
|
|
|
3305
|
-
var uncurryThis$
|
|
3459
|
+
var uncurryThis$3 = functionUncurryThis;
|
|
3306
3460
|
var toIntegerOrInfinity$1 = toIntegerOrInfinity$4;
|
|
3307
|
-
var toString$
|
|
3308
|
-
var requireObjectCoercible$
|
|
3461
|
+
var toString$3 = toString$6;
|
|
3462
|
+
var requireObjectCoercible$2 = requireObjectCoercible$7;
|
|
3309
3463
|
|
|
3310
|
-
var charAt$2 = uncurryThis$
|
|
3311
|
-
var charCodeAt = uncurryThis$
|
|
3312
|
-
var stringSlice$
|
|
3464
|
+
var charAt$2 = uncurryThis$3(''.charAt);
|
|
3465
|
+
var charCodeAt = uncurryThis$3(''.charCodeAt);
|
|
3466
|
+
var stringSlice$3 = uncurryThis$3(''.slice);
|
|
3313
3467
|
|
|
3314
3468
|
var createMethod = function (CONVERT_TO_STRING) {
|
|
3315
3469
|
return function ($this, pos) {
|
|
3316
|
-
var S = toString$
|
|
3470
|
+
var S = toString$3(requireObjectCoercible$2($this));
|
|
3317
3471
|
var position = toIntegerOrInfinity$1(pos);
|
|
3318
3472
|
var size = S.length;
|
|
3319
3473
|
var first, second;
|
|
@@ -3325,7 +3479,7 @@ var createMethod = function (CONVERT_TO_STRING) {
|
|
|
3325
3479
|
? charAt$2(S, position)
|
|
3326
3480
|
: first
|
|
3327
3481
|
: CONVERT_TO_STRING
|
|
3328
|
-
? stringSlice$
|
|
3482
|
+
? stringSlice$3(S, position, position + 2)
|
|
3329
3483
|
: (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
|
|
3330
3484
|
};
|
|
3331
3485
|
};
|
|
@@ -3347,13 +3501,14 @@ var advanceStringIndex$1 = function (S, index, unicode) {
|
|
|
3347
3501
|
return index + (unicode ? charAt$1(S, index).length : 1);
|
|
3348
3502
|
};
|
|
3349
3503
|
|
|
3350
|
-
var uncurryThis$
|
|
3351
|
-
var toObject = toObject$
|
|
3504
|
+
var uncurryThis$2 = functionUncurryThis;
|
|
3505
|
+
var toObject$1 = toObject$5;
|
|
3352
3506
|
|
|
3353
3507
|
var floor = Math.floor;
|
|
3354
|
-
var charAt = uncurryThis$
|
|
3355
|
-
var replace = uncurryThis$
|
|
3356
|
-
var stringSlice$
|
|
3508
|
+
var charAt = uncurryThis$2(''.charAt);
|
|
3509
|
+
var replace = uncurryThis$2(''.replace);
|
|
3510
|
+
var stringSlice$2 = uncurryThis$2(''.slice);
|
|
3511
|
+
// eslint-disable-next-line redos/no-vulnerable -- safe
|
|
3357
3512
|
var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
|
|
3358
3513
|
var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
|
|
3359
3514
|
|
|
@@ -3364,7 +3519,7 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
|
|
|
3364
3519
|
var m = captures.length;
|
|
3365
3520
|
var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
|
|
3366
3521
|
if (namedCaptures !== undefined) {
|
|
3367
|
-
namedCaptures = toObject(namedCaptures);
|
|
3522
|
+
namedCaptures = toObject$1(namedCaptures);
|
|
3368
3523
|
symbols = SUBSTITUTION_SYMBOLS;
|
|
3369
3524
|
}
|
|
3370
3525
|
return replace(replacement, symbols, function (match, ch) {
|
|
@@ -3372,10 +3527,10 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
|
|
|
3372
3527
|
switch (charAt(ch, 0)) {
|
|
3373
3528
|
case '$': return '$';
|
|
3374
3529
|
case '&': return matched;
|
|
3375
|
-
case '`': return stringSlice$
|
|
3376
|
-
case "'": return stringSlice$
|
|
3530
|
+
case '`': return stringSlice$2(str, 0, position);
|
|
3531
|
+
case "'": return stringSlice$2(str, tailPos);
|
|
3377
3532
|
case '<':
|
|
3378
|
-
capture = namedCaptures[stringSlice$
|
|
3533
|
+
capture = namedCaptures[stringSlice$2(ch, 1, -1)];
|
|
3379
3534
|
break;
|
|
3380
3535
|
default: // \d\d?
|
|
3381
3536
|
var n = +ch;
|
|
@@ -3392,39 +3547,39 @@ var getSubstitution$1 = function (matched, str, position, captures, namedCapture
|
|
|
3392
3547
|
});
|
|
3393
3548
|
};
|
|
3394
3549
|
|
|
3395
|
-
var
|
|
3396
|
-
var
|
|
3397
|
-
var
|
|
3398
|
-
var
|
|
3399
|
-
var classof = classofRaw$1;
|
|
3550
|
+
var call$2 = functionCall;
|
|
3551
|
+
var anObject$2 = anObject$e;
|
|
3552
|
+
var isCallable$2 = isCallable$m;
|
|
3553
|
+
var classof$1 = classofRaw$2;
|
|
3400
3554
|
var regexpExec = regexpExec$2;
|
|
3401
3555
|
|
|
3402
|
-
var TypeError$
|
|
3556
|
+
var $TypeError$2 = TypeError;
|
|
3403
3557
|
|
|
3404
3558
|
// `RegExpExec` abstract operation
|
|
3405
3559
|
// https://tc39.es/ecma262/#sec-regexpexec
|
|
3406
3560
|
var regexpExecAbstract = function (R, S) {
|
|
3407
3561
|
var exec = R.exec;
|
|
3408
|
-
if (isCallable$
|
|
3409
|
-
var result = call$
|
|
3410
|
-
if (result !== null) anObject$
|
|
3562
|
+
if (isCallable$2(exec)) {
|
|
3563
|
+
var result = call$2(exec, R, S);
|
|
3564
|
+
if (result !== null) anObject$2(result);
|
|
3411
3565
|
return result;
|
|
3412
3566
|
}
|
|
3413
|
-
if (classof(R) === 'RegExp') return call$
|
|
3414
|
-
throw TypeError$
|
|
3567
|
+
if (classof$1(R) === 'RegExp') return call$2(regexpExec, R, S);
|
|
3568
|
+
throw new $TypeError$2('RegExp#exec called on incompatible receiver');
|
|
3415
3569
|
};
|
|
3416
3570
|
|
|
3417
3571
|
var apply = functionApply;
|
|
3418
|
-
var call = functionCall;
|
|
3419
|
-
var uncurryThis = functionUncurryThis;
|
|
3572
|
+
var call$1 = functionCall;
|
|
3573
|
+
var uncurryThis$1 = functionUncurryThis;
|
|
3420
3574
|
var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
|
|
3421
|
-
var fails = fails$
|
|
3422
|
-
var anObject = anObject$e;
|
|
3423
|
-
var isCallable = isCallable$
|
|
3575
|
+
var fails$1 = fails$l;
|
|
3576
|
+
var anObject$1 = anObject$e;
|
|
3577
|
+
var isCallable$1 = isCallable$m;
|
|
3578
|
+
var isNullOrUndefined = isNullOrUndefined$5;
|
|
3424
3579
|
var toIntegerOrInfinity = toIntegerOrInfinity$4;
|
|
3425
|
-
var toLength = toLength$3;
|
|
3426
|
-
var toString = toString$
|
|
3427
|
-
var requireObjectCoercible = requireObjectCoercible$
|
|
3580
|
+
var toLength$1 = toLength$3;
|
|
3581
|
+
var toString$2 = toString$6;
|
|
3582
|
+
var requireObjectCoercible$1 = requireObjectCoercible$7;
|
|
3428
3583
|
var advanceStringIndex = advanceStringIndex$1;
|
|
3429
3584
|
var getMethod = getMethod$4;
|
|
3430
3585
|
var getSubstitution = getSubstitution$1;
|
|
@@ -3433,11 +3588,11 @@ var wellKnownSymbol = wellKnownSymbol$i;
|
|
|
3433
3588
|
|
|
3434
3589
|
var REPLACE = wellKnownSymbol('replace');
|
|
3435
3590
|
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);
|
|
3591
|
+
var min$1 = Math.min;
|
|
3592
|
+
var concat = uncurryThis$1([].concat);
|
|
3593
|
+
var push = uncurryThis$1([].push);
|
|
3594
|
+
var stringIndexOf = uncurryThis$1(''.indexOf);
|
|
3595
|
+
var stringSlice$1 = uncurryThis$1(''.slice);
|
|
3441
3596
|
|
|
3442
3597
|
var maybeToString = function (it) {
|
|
3443
3598
|
return it === undefined ? it : String(it);
|
|
@@ -3458,7 +3613,7 @@ var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
|
|
|
3458
3613
|
return false;
|
|
3459
3614
|
})();
|
|
3460
3615
|
|
|
3461
|
-
var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
|
|
3616
|
+
var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$1(function () {
|
|
3462
3617
|
var re = /./;
|
|
3463
3618
|
re.exec = function () {
|
|
3464
3619
|
var result = [];
|
|
@@ -3477,17 +3632,17 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
|
|
|
3477
3632
|
// `String.prototype.replace` method
|
|
3478
3633
|
// https://tc39.es/ecma262/#sec-string.prototype.replace
|
|
3479
3634
|
function replace(searchValue, replaceValue) {
|
|
3480
|
-
var O = requireObjectCoercible(this);
|
|
3481
|
-
var replacer = searchValue
|
|
3635
|
+
var O = requireObjectCoercible$1(this);
|
|
3636
|
+
var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE);
|
|
3482
3637
|
return replacer
|
|
3483
|
-
? call(replacer, searchValue, O, replaceValue)
|
|
3484
|
-
: call(nativeReplace, toString(O), searchValue, replaceValue);
|
|
3638
|
+
? call$1(replacer, searchValue, O, replaceValue)
|
|
3639
|
+
: call$1(nativeReplace, toString$2(O), searchValue, replaceValue);
|
|
3485
3640
|
},
|
|
3486
3641
|
// `RegExp.prototype[@@replace]` method
|
|
3487
3642
|
// https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
|
|
3488
3643
|
function (string, replaceValue) {
|
|
3489
|
-
var rx = anObject(this);
|
|
3490
|
-
var S = toString(string);
|
|
3644
|
+
var rx = anObject$1(this);
|
|
3645
|
+
var S = toString$2(string);
|
|
3491
3646
|
|
|
3492
3647
|
if (
|
|
3493
3648
|
typeof replaceValue == 'string' &&
|
|
@@ -3498,24 +3653,27 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
|
|
|
3498
3653
|
if (res.done) return res.value;
|
|
3499
3654
|
}
|
|
3500
3655
|
|
|
3501
|
-
var functionalReplace = isCallable(replaceValue);
|
|
3502
|
-
if (!functionalReplace) replaceValue = toString(replaceValue);
|
|
3656
|
+
var functionalReplace = isCallable$1(replaceValue);
|
|
3657
|
+
if (!functionalReplace) replaceValue = toString$2(replaceValue);
|
|
3503
3658
|
|
|
3504
3659
|
var global = rx.global;
|
|
3660
|
+
var fullUnicode;
|
|
3505
3661
|
if (global) {
|
|
3506
|
-
|
|
3662
|
+
fullUnicode = rx.unicode;
|
|
3507
3663
|
rx.lastIndex = 0;
|
|
3508
3664
|
}
|
|
3665
|
+
|
|
3509
3666
|
var results = [];
|
|
3667
|
+
var result;
|
|
3510
3668
|
while (true) {
|
|
3511
|
-
|
|
3669
|
+
result = regExpExec(rx, S);
|
|
3512
3670
|
if (result === null) break;
|
|
3513
3671
|
|
|
3514
3672
|
push(results, result);
|
|
3515
3673
|
if (!global) break;
|
|
3516
3674
|
|
|
3517
|
-
var matchStr = toString(result[0]);
|
|
3518
|
-
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
|
|
3675
|
+
var matchStr = toString$2(result[0]);
|
|
3676
|
+
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength$1(rx.lastIndex), fullUnicode);
|
|
3519
3677
|
}
|
|
3520
3678
|
|
|
3521
3679
|
var accumulatedResult = '';
|
|
@@ -3523,9 +3681,10 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
|
|
|
3523
3681
|
for (var i = 0; i < results.length; i++) {
|
|
3524
3682
|
result = results[i];
|
|
3525
3683
|
|
|
3526
|
-
var matched = toString(result[0]);
|
|
3527
|
-
var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
|
|
3684
|
+
var matched = toString$2(result[0]);
|
|
3685
|
+
var position = max(min$1(toIntegerOrInfinity(result.index), S.length), 0);
|
|
3528
3686
|
var captures = [];
|
|
3687
|
+
var replacement;
|
|
3529
3688
|
// NOTE: This is equivalent to
|
|
3530
3689
|
// captures = result.slice(1).map(maybeToString)
|
|
3531
3690
|
// but for some reason `nativeSlice.call(result, 1, result.length)` (called in
|
|
@@ -3536,20 +3695,52 @@ fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNa
|
|
|
3536
3695
|
if (functionalReplace) {
|
|
3537
3696
|
var replacerArgs = concat([matched], captures, position, S);
|
|
3538
3697
|
if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
|
|
3539
|
-
|
|
3698
|
+
replacement = toString$2(apply(replaceValue, undefined, replacerArgs));
|
|
3540
3699
|
} else {
|
|
3541
3700
|
replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
|
|
3542
3701
|
}
|
|
3543
3702
|
if (position >= nextSourcePosition) {
|
|
3544
|
-
accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
|
|
3703
|
+
accumulatedResult += stringSlice$1(S, nextSourcePosition, position) + replacement;
|
|
3545
3704
|
nextSourcePosition = position + matched.length;
|
|
3546
3705
|
}
|
|
3547
3706
|
}
|
|
3548
|
-
|
|
3707
|
+
|
|
3708
|
+
return accumulatedResult + stringSlice$1(S, nextSourcePosition);
|
|
3549
3709
|
}
|
|
3550
3710
|
];
|
|
3551
3711
|
}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
|
|
3552
3712
|
|
|
3713
|
+
var $$2 = _export;
|
|
3714
|
+
var uncurryThis = functionUncurryThisClause;
|
|
3715
|
+
var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
|
|
3716
|
+
var toLength = toLength$3;
|
|
3717
|
+
var toString$1 = toString$6;
|
|
3718
|
+
var notARegExp = notARegexp;
|
|
3719
|
+
var requireObjectCoercible = requireObjectCoercible$7;
|
|
3720
|
+
var correctIsRegExpLogic = correctIsRegexpLogic;
|
|
3721
|
+
|
|
3722
|
+
var stringSlice = uncurryThis(''.slice);
|
|
3723
|
+
var min = Math.min;
|
|
3724
|
+
|
|
3725
|
+
var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
|
|
3726
|
+
// https://github.com/zloirock/core-js/pull/702
|
|
3727
|
+
var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () {
|
|
3728
|
+
var descriptor = getOwnPropertyDescriptor$1(String.prototype, 'startsWith');
|
|
3729
|
+
return descriptor && !descriptor.writable;
|
|
3730
|
+
}();
|
|
3731
|
+
|
|
3732
|
+
// `String.prototype.startsWith` method
|
|
3733
|
+
// https://tc39.es/ecma262/#sec-string.prototype.startswith
|
|
3734
|
+
$$2({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
|
|
3735
|
+
startsWith: function startsWith(searchString /* , position = 0 */) {
|
|
3736
|
+
var that = toString$1(requireObjectCoercible(this));
|
|
3737
|
+
notARegExp(searchString);
|
|
3738
|
+
var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));
|
|
3739
|
+
var search = toString$1(searchString);
|
|
3740
|
+
return stringSlice(that, index, index + search.length) === search;
|
|
3741
|
+
}
|
|
3742
|
+
});
|
|
3743
|
+
|
|
3553
3744
|
/******************************************************************************
|
|
3554
3745
|
Copyright (c) Microsoft Corporation.
|
|
3555
3746
|
|
|
@@ -3564,6 +3755,8 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
|
3564
3755
|
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
3565
3756
|
PERFORMANCE OF THIS SOFTWARE.
|
|
3566
3757
|
***************************************************************************** */
|
|
3758
|
+
/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
|
|
3759
|
+
|
|
3567
3760
|
|
|
3568
3761
|
function __awaiter(thisArg, _arguments, P, generator) {
|
|
3569
3762
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
@@ -3573,7 +3766,133 @@ function __awaiter(thisArg, _arguments, P, generator) {
|
|
|
3573
3766
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
3574
3767
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
3575
3768
|
});
|
|
3576
|
-
}
|
|
3769
|
+
}
|
|
3770
|
+
|
|
3771
|
+
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
|
|
3772
|
+
var e = new Error(message);
|
|
3773
|
+
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
|
3774
|
+
};
|
|
3775
|
+
|
|
3776
|
+
var classof = classofRaw$2;
|
|
3777
|
+
|
|
3778
|
+
// `IsArray` abstract operation
|
|
3779
|
+
// https://tc39.es/ecma262/#sec-isarray
|
|
3780
|
+
// eslint-disable-next-line es/no-array-isarray -- safe
|
|
3781
|
+
var isArray$1 = Array.isArray || function isArray(argument) {
|
|
3782
|
+
return classof(argument) === 'Array';
|
|
3783
|
+
};
|
|
3784
|
+
|
|
3785
|
+
var DESCRIPTORS = descriptors;
|
|
3786
|
+
var isArray = isArray$1;
|
|
3787
|
+
|
|
3788
|
+
var $TypeError$1 = TypeError;
|
|
3789
|
+
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
3790
|
+
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
3791
|
+
|
|
3792
|
+
// Safari < 13 does not throw an error in this case
|
|
3793
|
+
var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
|
|
3794
|
+
// makes no sense without proper strict mode support
|
|
3795
|
+
if (this !== undefined) return true;
|
|
3796
|
+
try {
|
|
3797
|
+
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
3798
|
+
Object.defineProperty([], 'length', { writable: false }).length = 1;
|
|
3799
|
+
} catch (error) {
|
|
3800
|
+
return error instanceof TypeError;
|
|
3801
|
+
}
|
|
3802
|
+
}();
|
|
3803
|
+
|
|
3804
|
+
var arraySetLength = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
|
|
3805
|
+
if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
|
|
3806
|
+
throw new $TypeError$1('Cannot set read only .length');
|
|
3807
|
+
} return O.length = length;
|
|
3808
|
+
} : function (O, length) {
|
|
3809
|
+
return O.length = length;
|
|
3810
|
+
};
|
|
3811
|
+
|
|
3812
|
+
var $TypeError = TypeError;
|
|
3813
|
+
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
|
|
3814
|
+
|
|
3815
|
+
var doesNotExceedSafeInteger$1 = function (it) {
|
|
3816
|
+
if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
|
|
3817
|
+
return it;
|
|
3818
|
+
};
|
|
3819
|
+
|
|
3820
|
+
var $$1 = _export;
|
|
3821
|
+
var toObject = toObject$5;
|
|
3822
|
+
var lengthOfArrayLike = lengthOfArrayLike$3;
|
|
3823
|
+
var setArrayLength = arraySetLength;
|
|
3824
|
+
var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1;
|
|
3825
|
+
var fails = fails$l;
|
|
3826
|
+
|
|
3827
|
+
var INCORRECT_TO_LENGTH = fails(function () {
|
|
3828
|
+
return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
|
|
3829
|
+
});
|
|
3830
|
+
|
|
3831
|
+
// V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError
|
|
3832
|
+
// https://bugs.chromium.org/p/v8/issues/detail?id=12681
|
|
3833
|
+
var properErrorOnNonWritableLength = function () {
|
|
3834
|
+
try {
|
|
3835
|
+
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
3836
|
+
Object.defineProperty([], 'length', { writable: false }).push();
|
|
3837
|
+
} catch (error) {
|
|
3838
|
+
return error instanceof TypeError;
|
|
3839
|
+
}
|
|
3840
|
+
};
|
|
3841
|
+
|
|
3842
|
+
var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();
|
|
3843
|
+
|
|
3844
|
+
// `Array.prototype.push` method
|
|
3845
|
+
// https://tc39.es/ecma262/#sec-array.prototype.push
|
|
3846
|
+
$$1({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
|
|
3847
|
+
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
3848
|
+
push: function push(item) {
|
|
3849
|
+
var O = toObject(this);
|
|
3850
|
+
var len = lengthOfArrayLike(O);
|
|
3851
|
+
var argCount = arguments.length;
|
|
3852
|
+
doesNotExceedSafeInteger(len + argCount);
|
|
3853
|
+
for (var i = 0; i < argCount; i++) {
|
|
3854
|
+
O[len] = arguments[i];
|
|
3855
|
+
len++;
|
|
3856
|
+
}
|
|
3857
|
+
setArrayLength(O, len);
|
|
3858
|
+
return len;
|
|
3859
|
+
}
|
|
3860
|
+
});
|
|
3861
|
+
|
|
3862
|
+
// TODO: Remove from `core-js@4` since it's moved to entry points
|
|
3863
|
+
|
|
3864
|
+
var $ = _export;
|
|
3865
|
+
var call = functionCall;
|
|
3866
|
+
var isCallable = isCallable$m;
|
|
3867
|
+
var anObject = anObject$e;
|
|
3868
|
+
var toString = toString$6;
|
|
3869
|
+
|
|
3870
|
+
var DELEGATES_TO_EXEC = function () {
|
|
3871
|
+
var execCalled = false;
|
|
3872
|
+
var re = /[ac]/;
|
|
3873
|
+
re.exec = function () {
|
|
3874
|
+
execCalled = true;
|
|
3875
|
+
return /./.exec.apply(this, arguments);
|
|
3876
|
+
};
|
|
3877
|
+
return re.test('abc') === true && execCalled;
|
|
3878
|
+
}();
|
|
3879
|
+
|
|
3880
|
+
var nativeTest = /./.test;
|
|
3881
|
+
|
|
3882
|
+
// `RegExp.prototype.test` method
|
|
3883
|
+
// https://tc39.es/ecma262/#sec-regexp.prototype.test
|
|
3884
|
+
$({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, {
|
|
3885
|
+
test: function (S) {
|
|
3886
|
+
var R = anObject(this);
|
|
3887
|
+
var string = toString(S);
|
|
3888
|
+
var exec = R.exec;
|
|
3889
|
+
if (!isCallable(exec)) return call(nativeTest, R, string);
|
|
3890
|
+
var result = call(exec, R, string);
|
|
3891
|
+
if (result === null) return false;
|
|
3892
|
+
anObject(result);
|
|
3893
|
+
return true;
|
|
3894
|
+
}
|
|
3895
|
+
});
|
|
3577
3896
|
|
|
3578
3897
|
const MQTT_TIMEOUT_SECONDS = 3;
|
|
3579
3898
|
const MQTT_TIMEOUT_MS = MQTT_TIMEOUT_SECONDS * 1000;
|