@trackunit/react-core-hooks 0.0.54 → 0.0.55
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.js
CHANGED
|
@@ -1,12 +1,13 @@
|
|
|
1
|
-
import { jsx } from 'react/jsx-runtime';
|
|
1
|
+
import { jsx, Fragment } from 'react/jsx-runtime';
|
|
2
2
|
import { useFlags } from 'launchdarkly-react-client-sdk';
|
|
3
3
|
import * as React from 'react';
|
|
4
|
-
import { useContext, createContext } from 'react';
|
|
5
|
-
import {
|
|
4
|
+
import React__default, { useContext, createContext } from 'react';
|
|
5
|
+
import { useLocation, useNavigate, generatePath, createSearchParams, BrowserRouter } from 'react-router-dom';
|
|
6
|
+
import { NavigationRuntime, AssetRuntime, CustomFieldRuntime, RestRuntime } from '@trackunit/iris-app-runtime-core';
|
|
6
7
|
|
|
7
8
|
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
|
8
9
|
|
|
9
|
-
var fails$
|
|
10
|
+
var fails$k = function (exec) {
|
|
10
11
|
try {
|
|
11
12
|
return !!exec();
|
|
12
13
|
} catch (error) {
|
|
@@ -14,70 +15,70 @@ var fails$b = function (exec) {
|
|
|
14
15
|
}
|
|
15
16
|
};
|
|
16
17
|
|
|
17
|
-
var fails$
|
|
18
|
+
var fails$j = fails$k;
|
|
18
19
|
|
|
19
|
-
var functionBindNative = !fails$
|
|
20
|
+
var functionBindNative = !fails$j(function () {
|
|
20
21
|
// eslint-disable-next-line es-x/no-function-prototype-bind -- safe
|
|
21
22
|
var test = (function () { /* empty */ }).bind();
|
|
22
23
|
// eslint-disable-next-line no-prototype-builtins -- safe
|
|
23
24
|
return typeof test != 'function' || test.hasOwnProperty('prototype');
|
|
24
25
|
});
|
|
25
26
|
|
|
26
|
-
var NATIVE_BIND$
|
|
27
|
+
var NATIVE_BIND$3 = functionBindNative;
|
|
27
28
|
|
|
28
|
-
var FunctionPrototype$
|
|
29
|
-
var bind = FunctionPrototype$
|
|
30
|
-
var call$
|
|
31
|
-
var uncurryThis$
|
|
29
|
+
var FunctionPrototype$2 = Function.prototype;
|
|
30
|
+
var bind$5 = FunctionPrototype$2.bind;
|
|
31
|
+
var call$j = FunctionPrototype$2.call;
|
|
32
|
+
var uncurryThis$k = NATIVE_BIND$3 && bind$5.bind(call$j, call$j);
|
|
32
33
|
|
|
33
|
-
var functionUncurryThis = NATIVE_BIND$
|
|
34
|
-
return fn && uncurryThis$
|
|
34
|
+
var functionUncurryThis = NATIVE_BIND$3 ? function (fn) {
|
|
35
|
+
return fn && uncurryThis$k(fn);
|
|
35
36
|
} : function (fn) {
|
|
36
37
|
return fn && function () {
|
|
37
|
-
return call$
|
|
38
|
+
return call$j.apply(fn, arguments);
|
|
38
39
|
};
|
|
39
40
|
};
|
|
40
41
|
|
|
41
|
-
var uncurryThis$
|
|
42
|
+
var uncurryThis$j = functionUncurryThis;
|
|
42
43
|
|
|
43
|
-
var toString$
|
|
44
|
-
var stringSlice = uncurryThis$
|
|
44
|
+
var toString$7 = uncurryThis$j({}.toString);
|
|
45
|
+
var stringSlice$4 = uncurryThis$j(''.slice);
|
|
45
46
|
|
|
46
|
-
var classofRaw = function (it) {
|
|
47
|
-
return stringSlice(toString$
|
|
47
|
+
var classofRaw$1 = function (it) {
|
|
48
|
+
return stringSlice$4(toString$7(it), 8, -1);
|
|
48
49
|
};
|
|
49
50
|
|
|
50
|
-
var uncurryThis$
|
|
51
|
-
var fails$
|
|
52
|
-
var classof = classofRaw;
|
|
51
|
+
var uncurryThis$i = functionUncurryThis;
|
|
52
|
+
var fails$i = fails$k;
|
|
53
|
+
var classof$7 = classofRaw$1;
|
|
53
54
|
|
|
54
|
-
var $Object$
|
|
55
|
-
var split = uncurryThis$
|
|
55
|
+
var $Object$4 = Object;
|
|
56
|
+
var split = uncurryThis$i(''.split);
|
|
56
57
|
|
|
57
58
|
// fallback for non-array-like ES3 and non-enumerable old V8 strings
|
|
58
|
-
var indexedObject = fails$
|
|
59
|
+
var indexedObject = fails$i(function () {
|
|
59
60
|
// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
|
|
60
61
|
// eslint-disable-next-line no-prototype-builtins -- safe
|
|
61
|
-
return !$Object$
|
|
62
|
+
return !$Object$4('z').propertyIsEnumerable(0);
|
|
62
63
|
}) ? function (it) {
|
|
63
|
-
return classof(it) == 'String' ? split(it, '') : $Object$
|
|
64
|
-
} : $Object$
|
|
64
|
+
return classof$7(it) == 'String' ? split(it, '') : $Object$4(it);
|
|
65
|
+
} : $Object$4;
|
|
65
66
|
|
|
66
|
-
var $TypeError$
|
|
67
|
+
var $TypeError$d = TypeError;
|
|
67
68
|
|
|
68
69
|
// `RequireObjectCoercible` abstract operation
|
|
69
70
|
// https://tc39.es/ecma262/#sec-requireobjectcoercible
|
|
70
|
-
var requireObjectCoercible$
|
|
71
|
-
if (it == undefined) throw $TypeError$
|
|
71
|
+
var requireObjectCoercible$6 = function (it) {
|
|
72
|
+
if (it == undefined) throw $TypeError$d("Can't call method on " + it);
|
|
72
73
|
return it;
|
|
73
74
|
};
|
|
74
75
|
|
|
75
76
|
// toObject with fallback for non-array-like ES3 strings
|
|
76
77
|
var IndexedObject$1 = indexedObject;
|
|
77
|
-
var requireObjectCoercible$
|
|
78
|
+
var requireObjectCoercible$5 = requireObjectCoercible$6;
|
|
78
79
|
|
|
79
80
|
var toIndexedObject$5 = function (it) {
|
|
80
|
-
return IndexedObject$1(requireObjectCoercible$
|
|
81
|
+
return IndexedObject$1(requireObjectCoercible$5(it));
|
|
81
82
|
};
|
|
82
83
|
|
|
83
84
|
var check = function (it) {
|
|
@@ -85,7 +86,7 @@ var check = function (it) {
|
|
|
85
86
|
};
|
|
86
87
|
|
|
87
88
|
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
|
|
88
|
-
var global$
|
|
89
|
+
var global$m =
|
|
89
90
|
// eslint-disable-next-line es-x/no-global-this -- safe
|
|
90
91
|
check(typeof globalThis == 'object' && globalThis) ||
|
|
91
92
|
check(typeof window == 'object' && window) ||
|
|
@@ -95,32 +96,32 @@ var global$b =
|
|
|
95
96
|
// eslint-disable-next-line no-new-func -- fallback
|
|
96
97
|
(function () { return this; })() || Function('return this')();
|
|
97
98
|
|
|
98
|
-
var shared$
|
|
99
|
+
var shared$4 = {exports: {}};
|
|
99
100
|
|
|
100
|
-
var global$
|
|
101
|
+
var global$l = global$m;
|
|
101
102
|
|
|
102
103
|
// eslint-disable-next-line es-x/no-object-defineproperty -- safe
|
|
103
104
|
var defineProperty$5 = Object.defineProperty;
|
|
104
105
|
|
|
105
106
|
var defineGlobalProperty$3 = function (key, value) {
|
|
106
107
|
try {
|
|
107
|
-
defineProperty$5(global$
|
|
108
|
+
defineProperty$5(global$l, key, { value: value, configurable: true, writable: true });
|
|
108
109
|
} catch (error) {
|
|
109
|
-
global$
|
|
110
|
+
global$l[key] = value;
|
|
110
111
|
} return value;
|
|
111
112
|
};
|
|
112
113
|
|
|
113
|
-
var global$
|
|
114
|
+
var global$k = global$m;
|
|
114
115
|
var defineGlobalProperty$2 = defineGlobalProperty$3;
|
|
115
116
|
|
|
116
117
|
var SHARED = '__core-js_shared__';
|
|
117
|
-
var store$3 = global$
|
|
118
|
+
var store$3 = global$k[SHARED] || defineGlobalProperty$2(SHARED, {});
|
|
118
119
|
|
|
119
120
|
var sharedStore = store$3;
|
|
120
121
|
|
|
121
122
|
var store$2 = sharedStore;
|
|
122
123
|
|
|
123
|
-
(shared$
|
|
124
|
+
(shared$4.exports = function (key, value) {
|
|
124
125
|
return store$2[key] || (store$2[key] = value !== undefined ? value : {});
|
|
125
126
|
})('versions', []).push({
|
|
126
127
|
version: '3.24.1',
|
|
@@ -130,65 +131,65 @@ var store$2 = sharedStore;
|
|
|
130
131
|
source: 'https://github.com/zloirock/core-js'
|
|
131
132
|
});
|
|
132
133
|
|
|
133
|
-
var requireObjectCoercible = requireObjectCoercible$
|
|
134
|
+
var requireObjectCoercible$4 = requireObjectCoercible$6;
|
|
134
135
|
|
|
135
|
-
var $Object$
|
|
136
|
+
var $Object$3 = Object;
|
|
136
137
|
|
|
137
138
|
// `ToObject` abstract operation
|
|
138
139
|
// https://tc39.es/ecma262/#sec-toobject
|
|
139
|
-
var toObject$
|
|
140
|
-
return $Object$
|
|
140
|
+
var toObject$4 = function (argument) {
|
|
141
|
+
return $Object$3(requireObjectCoercible$4(argument));
|
|
141
142
|
};
|
|
142
143
|
|
|
143
|
-
var uncurryThis$
|
|
144
|
-
var toObject$
|
|
144
|
+
var uncurryThis$h = functionUncurryThis;
|
|
145
|
+
var toObject$3 = toObject$4;
|
|
145
146
|
|
|
146
|
-
var hasOwnProperty = uncurryThis$
|
|
147
|
+
var hasOwnProperty = uncurryThis$h({}.hasOwnProperty);
|
|
147
148
|
|
|
148
149
|
// `HasOwnProperty` abstract operation
|
|
149
150
|
// https://tc39.es/ecma262/#sec-hasownproperty
|
|
150
151
|
// eslint-disable-next-line es-x/no-object-hasown -- safe
|
|
151
152
|
var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
|
|
152
|
-
return hasOwnProperty(toObject$
|
|
153
|
+
return hasOwnProperty(toObject$3(it), key);
|
|
153
154
|
};
|
|
154
155
|
|
|
155
|
-
var uncurryThis$
|
|
156
|
+
var uncurryThis$g = functionUncurryThis;
|
|
156
157
|
|
|
157
158
|
var id = 0;
|
|
158
159
|
var postfix = Math.random();
|
|
159
|
-
var toString = uncurryThis$
|
|
160
|
+
var toString$6 = uncurryThis$g(1.0.toString);
|
|
160
161
|
|
|
161
162
|
var uid$2 = function (key) {
|
|
162
|
-
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
|
|
163
|
+
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$6(++id + postfix, 36);
|
|
163
164
|
};
|
|
164
165
|
|
|
165
166
|
// `IsCallable` abstract operation
|
|
166
167
|
// https://tc39.es/ecma262/#sec-iscallable
|
|
167
|
-
var isCallable$
|
|
168
|
+
var isCallable$n = function (argument) {
|
|
168
169
|
return typeof argument == 'function';
|
|
169
170
|
};
|
|
170
171
|
|
|
171
|
-
var global$
|
|
172
|
-
var isCallable$
|
|
172
|
+
var global$j = global$m;
|
|
173
|
+
var isCallable$m = isCallable$n;
|
|
173
174
|
|
|
174
175
|
var aFunction = function (argument) {
|
|
175
|
-
return isCallable$
|
|
176
|
+
return isCallable$m(argument) ? argument : undefined;
|
|
176
177
|
};
|
|
177
178
|
|
|
178
|
-
var getBuiltIn$
|
|
179
|
-
return arguments.length < 2 ? aFunction(global$
|
|
179
|
+
var getBuiltIn$9 = function (namespace, method) {
|
|
180
|
+
return arguments.length < 2 ? aFunction(global$j[namespace]) : global$j[namespace] && global$j[namespace][method];
|
|
180
181
|
};
|
|
181
182
|
|
|
182
|
-
var getBuiltIn$
|
|
183
|
+
var getBuiltIn$8 = getBuiltIn$9;
|
|
183
184
|
|
|
184
|
-
var engineUserAgent = getBuiltIn$
|
|
185
|
+
var engineUserAgent = getBuiltIn$8('navigator', 'userAgent') || '';
|
|
185
186
|
|
|
186
|
-
var global$
|
|
187
|
-
var userAgent = engineUserAgent;
|
|
187
|
+
var global$i = global$m;
|
|
188
|
+
var userAgent$3 = engineUserAgent;
|
|
188
189
|
|
|
189
|
-
var process = global$
|
|
190
|
-
var Deno = global$
|
|
191
|
-
var versions = process && process.versions || Deno && Deno.version;
|
|
190
|
+
var process$3 = global$i.process;
|
|
191
|
+
var Deno$1 = global$i.Deno;
|
|
192
|
+
var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version;
|
|
192
193
|
var v8 = versions && versions.v8;
|
|
193
194
|
var match, version;
|
|
194
195
|
|
|
@@ -201,10 +202,10 @@ if (v8) {
|
|
|
201
202
|
|
|
202
203
|
// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
|
|
203
204
|
// so check `userAgent` even if `.v8` exists, but 0
|
|
204
|
-
if (!version && userAgent) {
|
|
205
|
-
match = userAgent.match(/Edge\/(\d+)/);
|
|
205
|
+
if (!version && userAgent$3) {
|
|
206
|
+
match = userAgent$3.match(/Edge\/(\d+)/);
|
|
206
207
|
if (!match || match[1] >= 74) {
|
|
207
|
-
match = userAgent.match(/Chrome\/(\d+)/);
|
|
208
|
+
match = userAgent$3.match(/Chrome\/(\d+)/);
|
|
208
209
|
if (match) version = +match[1];
|
|
209
210
|
}
|
|
210
211
|
}
|
|
@@ -213,17 +214,17 @@ var engineV8Version = version;
|
|
|
213
214
|
|
|
214
215
|
/* eslint-disable es-x/no-symbol -- required for testing */
|
|
215
216
|
|
|
216
|
-
var V8_VERSION = engineV8Version;
|
|
217
|
-
var fails$
|
|
217
|
+
var V8_VERSION$1 = engineV8Version;
|
|
218
|
+
var fails$h = fails$k;
|
|
218
219
|
|
|
219
220
|
// eslint-disable-next-line es-x/no-object-getownpropertysymbols -- required for testing
|
|
220
|
-
var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$
|
|
221
|
+
var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$h(function () {
|
|
221
222
|
var symbol = Symbol();
|
|
222
223
|
// Chrome 38 Symbol has incorrect toString conversion
|
|
223
224
|
// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
|
|
224
225
|
return !String(symbol) || !(Object(symbol) instanceof Symbol) ||
|
|
225
226
|
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
|
|
226
|
-
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
|
|
227
|
+
!Symbol.sham && V8_VERSION$1 && V8_VERSION$1 < 41;
|
|
227
228
|
});
|
|
228
229
|
|
|
229
230
|
/* eslint-disable es-x/no-symbol -- required for testing */
|
|
@@ -234,22 +235,22 @@ var useSymbolAsUid = NATIVE_SYMBOL$1
|
|
|
234
235
|
&& !Symbol.sham
|
|
235
236
|
&& typeof Symbol.iterator == 'symbol';
|
|
236
237
|
|
|
237
|
-
var global$
|
|
238
|
-
var shared$
|
|
239
|
-
var hasOwn$
|
|
238
|
+
var global$h = global$m;
|
|
239
|
+
var shared$3 = shared$4.exports;
|
|
240
|
+
var hasOwn$a = hasOwnProperty_1;
|
|
240
241
|
var uid$1 = uid$2;
|
|
241
242
|
var NATIVE_SYMBOL = nativeSymbol;
|
|
242
243
|
var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
|
|
243
244
|
|
|
244
|
-
var WellKnownSymbolsStore = shared$
|
|
245
|
-
var Symbol$1 = global$
|
|
245
|
+
var WellKnownSymbolsStore = shared$3('wks');
|
|
246
|
+
var Symbol$1 = global$h.Symbol;
|
|
246
247
|
var symbolFor = Symbol$1 && Symbol$1['for'];
|
|
247
248
|
var createWellKnownSymbol = USE_SYMBOL_AS_UID$1 ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
|
|
248
249
|
|
|
249
|
-
var wellKnownSymbol$
|
|
250
|
-
if (!hasOwn$
|
|
250
|
+
var wellKnownSymbol$i = function (name) {
|
|
251
|
+
if (!hasOwn$a(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
|
|
251
252
|
var description = 'Symbol.' + name;
|
|
252
|
-
if (NATIVE_SYMBOL && hasOwn$
|
|
253
|
+
if (NATIVE_SYMBOL && hasOwn$a(Symbol$1, name)) {
|
|
253
254
|
WellKnownSymbolsStore[name] = Symbol$1[name];
|
|
254
255
|
} else if (USE_SYMBOL_AS_UID$1 && symbolFor) {
|
|
255
256
|
WellKnownSymbolsStore[name] = symbolFor(description);
|
|
@@ -259,39 +260,39 @@ var wellKnownSymbol$6 = function (name) {
|
|
|
259
260
|
} return WellKnownSymbolsStore[name];
|
|
260
261
|
};
|
|
261
262
|
|
|
262
|
-
var isCallable$
|
|
263
|
+
var isCallable$l = isCallable$n;
|
|
263
264
|
|
|
264
|
-
var isObject$
|
|
265
|
-
return typeof it == 'object' ? it !== null : isCallable$
|
|
265
|
+
var isObject$8 = function (it) {
|
|
266
|
+
return typeof it == 'object' ? it !== null : isCallable$l(it);
|
|
266
267
|
};
|
|
267
268
|
|
|
268
|
-
var isObject$
|
|
269
|
+
var isObject$7 = isObject$8;
|
|
269
270
|
|
|
270
|
-
var $String$
|
|
271
|
-
var $TypeError$
|
|
271
|
+
var $String$3 = String;
|
|
272
|
+
var $TypeError$c = TypeError;
|
|
272
273
|
|
|
273
274
|
// `Assert: Type(argument) is Object`
|
|
274
|
-
var anObject$
|
|
275
|
-
if (isObject$
|
|
276
|
-
throw $TypeError$
|
|
275
|
+
var anObject$f = function (argument) {
|
|
276
|
+
if (isObject$7(argument)) return argument;
|
|
277
|
+
throw $TypeError$c($String$3(argument) + ' is not an object');
|
|
277
278
|
};
|
|
278
279
|
|
|
279
280
|
var objectDefineProperties = {};
|
|
280
281
|
|
|
281
|
-
var fails$
|
|
282
|
+
var fails$g = fails$k;
|
|
282
283
|
|
|
283
284
|
// Detect IE8's incomplete defineProperty implementation
|
|
284
|
-
var descriptors = !fails$
|
|
285
|
+
var descriptors = !fails$g(function () {
|
|
285
286
|
// eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
|
|
286
287
|
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
|
|
287
288
|
});
|
|
288
289
|
|
|
289
|
-
var DESCRIPTORS$
|
|
290
|
-
var fails$
|
|
290
|
+
var DESCRIPTORS$a = descriptors;
|
|
291
|
+
var fails$f = fails$k;
|
|
291
292
|
|
|
292
293
|
// V8 ~ Chrome 36-
|
|
293
294
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
|
|
294
|
-
var v8PrototypeDefineBug = DESCRIPTORS$
|
|
295
|
+
var v8PrototypeDefineBug = DESCRIPTORS$a && fails$f(function () {
|
|
295
296
|
// eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
|
|
296
297
|
return Object.defineProperty(function () { /* empty */ }, 'prototype', {
|
|
297
298
|
value: 42,
|
|
@@ -301,122 +302,122 @@ var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$6(function () {
|
|
|
301
302
|
|
|
302
303
|
var objectDefineProperty = {};
|
|
303
304
|
|
|
304
|
-
var global$
|
|
305
|
-
var isObject$
|
|
305
|
+
var global$g = global$m;
|
|
306
|
+
var isObject$6 = isObject$8;
|
|
306
307
|
|
|
307
|
-
var document$
|
|
308
|
+
var document$3 = global$g.document;
|
|
308
309
|
// typeof document.createElement is 'object' in old IE
|
|
309
|
-
var EXISTS$1 = isObject$
|
|
310
|
+
var EXISTS$1 = isObject$6(document$3) && isObject$6(document$3.createElement);
|
|
310
311
|
|
|
311
312
|
var documentCreateElement$2 = function (it) {
|
|
312
|
-
return EXISTS$1 ? document$
|
|
313
|
+
return EXISTS$1 ? document$3.createElement(it) : {};
|
|
313
314
|
};
|
|
314
315
|
|
|
315
|
-
var DESCRIPTORS$
|
|
316
|
-
var fails$
|
|
317
|
-
var createElement = documentCreateElement$2;
|
|
316
|
+
var DESCRIPTORS$9 = descriptors;
|
|
317
|
+
var fails$e = fails$k;
|
|
318
|
+
var createElement$1 = documentCreateElement$2;
|
|
318
319
|
|
|
319
320
|
// Thanks to IE8 for its funny defineProperty
|
|
320
|
-
var ie8DomDefine = !DESCRIPTORS$
|
|
321
|
+
var ie8DomDefine = !DESCRIPTORS$9 && !fails$e(function () {
|
|
321
322
|
// eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
|
|
322
|
-
return Object.defineProperty(createElement('div'), 'a', {
|
|
323
|
+
return Object.defineProperty(createElement$1('div'), 'a', {
|
|
323
324
|
get: function () { return 7; }
|
|
324
325
|
}).a != 7;
|
|
325
326
|
});
|
|
326
327
|
|
|
327
|
-
var NATIVE_BIND = functionBindNative;
|
|
328
|
+
var NATIVE_BIND$2 = functionBindNative;
|
|
328
329
|
|
|
329
|
-
var call$
|
|
330
|
+
var call$i = Function.prototype.call;
|
|
330
331
|
|
|
331
|
-
var functionCall = NATIVE_BIND ? call$
|
|
332
|
-
return call$
|
|
332
|
+
var functionCall = NATIVE_BIND$2 ? call$i.bind(call$i) : function () {
|
|
333
|
+
return call$i.apply(call$i, arguments);
|
|
333
334
|
};
|
|
334
335
|
|
|
335
|
-
var uncurryThis$
|
|
336
|
+
var uncurryThis$f = functionUncurryThis;
|
|
336
337
|
|
|
337
|
-
var objectIsPrototypeOf = uncurryThis$
|
|
338
|
+
var objectIsPrototypeOf = uncurryThis$f({}.isPrototypeOf);
|
|
338
339
|
|
|
339
|
-
var getBuiltIn$
|
|
340
|
-
var isCallable$
|
|
341
|
-
var isPrototypeOf = objectIsPrototypeOf;
|
|
340
|
+
var getBuiltIn$7 = getBuiltIn$9;
|
|
341
|
+
var isCallable$k = isCallable$n;
|
|
342
|
+
var isPrototypeOf$3 = objectIsPrototypeOf;
|
|
342
343
|
var USE_SYMBOL_AS_UID = useSymbolAsUid;
|
|
343
344
|
|
|
344
|
-
var $Object$
|
|
345
|
+
var $Object$2 = Object;
|
|
345
346
|
|
|
346
347
|
var isSymbol$2 = USE_SYMBOL_AS_UID ? function (it) {
|
|
347
348
|
return typeof it == 'symbol';
|
|
348
349
|
} : function (it) {
|
|
349
|
-
var $Symbol = getBuiltIn$
|
|
350
|
-
return isCallable$
|
|
350
|
+
var $Symbol = getBuiltIn$7('Symbol');
|
|
351
|
+
return isCallable$k($Symbol) && isPrototypeOf$3($Symbol.prototype, $Object$2(it));
|
|
351
352
|
};
|
|
352
353
|
|
|
353
|
-
var $String$
|
|
354
|
+
var $String$2 = String;
|
|
354
355
|
|
|
355
|
-
var tryToString$
|
|
356
|
+
var tryToString$4 = function (argument) {
|
|
356
357
|
try {
|
|
357
|
-
return $String$
|
|
358
|
+
return $String$2(argument);
|
|
358
359
|
} catch (error) {
|
|
359
360
|
return 'Object';
|
|
360
361
|
}
|
|
361
362
|
};
|
|
362
363
|
|
|
363
|
-
var isCallable$
|
|
364
|
-
var tryToString = tryToString$
|
|
364
|
+
var isCallable$j = isCallable$n;
|
|
365
|
+
var tryToString$3 = tryToString$4;
|
|
365
366
|
|
|
366
|
-
var $TypeError$
|
|
367
|
+
var $TypeError$b = TypeError;
|
|
367
368
|
|
|
368
369
|
// `Assert: IsCallable(argument) is true`
|
|
369
|
-
var aCallable$
|
|
370
|
-
if (isCallable$
|
|
371
|
-
throw $TypeError$
|
|
370
|
+
var aCallable$7 = function (argument) {
|
|
371
|
+
if (isCallable$j(argument)) return argument;
|
|
372
|
+
throw $TypeError$b(tryToString$3(argument) + ' is not a function');
|
|
372
373
|
};
|
|
373
374
|
|
|
374
|
-
var aCallable = aCallable$
|
|
375
|
+
var aCallable$6 = aCallable$7;
|
|
375
376
|
|
|
376
377
|
// `GetMethod` abstract operation
|
|
377
378
|
// https://tc39.es/ecma262/#sec-getmethod
|
|
378
|
-
var getMethod$
|
|
379
|
+
var getMethod$5 = function (V, P) {
|
|
379
380
|
var func = V[P];
|
|
380
|
-
return func == null ? undefined : aCallable(func);
|
|
381
|
+
return func == null ? undefined : aCallable$6(func);
|
|
381
382
|
};
|
|
382
383
|
|
|
383
|
-
var call$
|
|
384
|
-
var isCallable$
|
|
385
|
-
var isObject$
|
|
384
|
+
var call$h = functionCall;
|
|
385
|
+
var isCallable$i = isCallable$n;
|
|
386
|
+
var isObject$5 = isObject$8;
|
|
386
387
|
|
|
387
|
-
var $TypeError$
|
|
388
|
+
var $TypeError$a = TypeError;
|
|
388
389
|
|
|
389
390
|
// `OrdinaryToPrimitive` abstract operation
|
|
390
391
|
// https://tc39.es/ecma262/#sec-ordinarytoprimitive
|
|
391
392
|
var ordinaryToPrimitive$1 = function (input, pref) {
|
|
392
393
|
var fn, val;
|
|
393
|
-
if (pref === 'string' && isCallable$
|
|
394
|
-
if (isCallable$
|
|
395
|
-
if (pref !== 'string' && isCallable$
|
|
396
|
-
throw $TypeError$
|
|
394
|
+
if (pref === 'string' && isCallable$i(fn = input.toString) && !isObject$5(val = call$h(fn, input))) return val;
|
|
395
|
+
if (isCallable$i(fn = input.valueOf) && !isObject$5(val = call$h(fn, input))) return val;
|
|
396
|
+
if (pref !== 'string' && isCallable$i(fn = input.toString) && !isObject$5(val = call$h(fn, input))) return val;
|
|
397
|
+
throw $TypeError$a("Can't convert object to primitive value");
|
|
397
398
|
};
|
|
398
399
|
|
|
399
|
-
var call$
|
|
400
|
-
var isObject$
|
|
400
|
+
var call$g = functionCall;
|
|
401
|
+
var isObject$4 = isObject$8;
|
|
401
402
|
var isSymbol$1 = isSymbol$2;
|
|
402
|
-
var getMethod = getMethod$
|
|
403
|
+
var getMethod$4 = getMethod$5;
|
|
403
404
|
var ordinaryToPrimitive = ordinaryToPrimitive$1;
|
|
404
|
-
var wellKnownSymbol$
|
|
405
|
+
var wellKnownSymbol$h = wellKnownSymbol$i;
|
|
405
406
|
|
|
406
|
-
var $TypeError$
|
|
407
|
-
var TO_PRIMITIVE = wellKnownSymbol$
|
|
407
|
+
var $TypeError$9 = TypeError;
|
|
408
|
+
var TO_PRIMITIVE = wellKnownSymbol$h('toPrimitive');
|
|
408
409
|
|
|
409
410
|
// `ToPrimitive` abstract operation
|
|
410
411
|
// https://tc39.es/ecma262/#sec-toprimitive
|
|
411
412
|
var toPrimitive$1 = function (input, pref) {
|
|
412
|
-
if (!isObject$
|
|
413
|
-
var exoticToPrim = getMethod(input, TO_PRIMITIVE);
|
|
413
|
+
if (!isObject$4(input) || isSymbol$1(input)) return input;
|
|
414
|
+
var exoticToPrim = getMethod$4(input, TO_PRIMITIVE);
|
|
414
415
|
var result;
|
|
415
416
|
if (exoticToPrim) {
|
|
416
417
|
if (pref === undefined) pref = 'default';
|
|
417
|
-
result = call$
|
|
418
|
-
if (!isObject$
|
|
419
|
-
throw $TypeError$
|
|
418
|
+
result = call$g(exoticToPrim, input, pref);
|
|
419
|
+
if (!isObject$4(result) || isSymbol$1(result)) return result;
|
|
420
|
+
throw $TypeError$9("Can't convert object to primitive value");
|
|
420
421
|
}
|
|
421
422
|
if (pref === undefined) pref = 'number';
|
|
422
423
|
return ordinaryToPrimitive(input, pref);
|
|
@@ -432,13 +433,13 @@ var toPropertyKey$2 = function (argument) {
|
|
|
432
433
|
return isSymbol(key) ? key : key + '';
|
|
433
434
|
};
|
|
434
435
|
|
|
435
|
-
var DESCRIPTORS$
|
|
436
|
+
var DESCRIPTORS$8 = descriptors;
|
|
436
437
|
var IE8_DOM_DEFINE$1 = ie8DomDefine;
|
|
437
438
|
var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
|
|
438
|
-
var anObject$
|
|
439
|
+
var anObject$e = anObject$f;
|
|
439
440
|
var toPropertyKey$1 = toPropertyKey$2;
|
|
440
441
|
|
|
441
|
-
var $TypeError$
|
|
442
|
+
var $TypeError$8 = TypeError;
|
|
442
443
|
// eslint-disable-next-line es-x/no-object-defineproperty -- safe
|
|
443
444
|
var $defineProperty = Object.defineProperty;
|
|
444
445
|
// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
|
|
@@ -449,10 +450,10 @@ var WRITABLE = 'writable';
|
|
|
449
450
|
|
|
450
451
|
// `Object.defineProperty` method
|
|
451
452
|
// https://tc39.es/ecma262/#sec-object.defineproperty
|
|
452
|
-
objectDefineProperty.f = DESCRIPTORS$
|
|
453
|
-
anObject$
|
|
453
|
+
objectDefineProperty.f = DESCRIPTORS$8 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
|
|
454
|
+
anObject$e(O);
|
|
454
455
|
P = toPropertyKey$1(P);
|
|
455
|
-
anObject$
|
|
456
|
+
anObject$e(Attributes);
|
|
456
457
|
if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
|
|
457
458
|
var current = $getOwnPropertyDescriptor$1(O, P);
|
|
458
459
|
if (current && current[WRITABLE]) {
|
|
@@ -465,78 +466,78 @@ objectDefineProperty.f = DESCRIPTORS$7 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function de
|
|
|
465
466
|
}
|
|
466
467
|
} return $defineProperty(O, P, Attributes);
|
|
467
468
|
} : $defineProperty : function defineProperty(O, P, Attributes) {
|
|
468
|
-
anObject$
|
|
469
|
+
anObject$e(O);
|
|
469
470
|
P = toPropertyKey$1(P);
|
|
470
|
-
anObject$
|
|
471
|
+
anObject$e(Attributes);
|
|
471
472
|
if (IE8_DOM_DEFINE$1) try {
|
|
472
473
|
return $defineProperty(O, P, Attributes);
|
|
473
474
|
} catch (error) { /* empty */ }
|
|
474
|
-
if ('get' in Attributes || 'set' in Attributes) throw $TypeError$
|
|
475
|
+
if ('get' in Attributes || 'set' in Attributes) throw $TypeError$8('Accessors not supported');
|
|
475
476
|
if ('value' in Attributes) O[P] = Attributes.value;
|
|
476
477
|
return O;
|
|
477
478
|
};
|
|
478
479
|
|
|
479
480
|
var ceil = Math.ceil;
|
|
480
|
-
var floor = Math.floor;
|
|
481
|
+
var floor$1 = Math.floor;
|
|
481
482
|
|
|
482
483
|
// `Math.trunc` method
|
|
483
484
|
// https://tc39.es/ecma262/#sec-math.trunc
|
|
484
485
|
// eslint-disable-next-line es-x/no-math-trunc -- safe
|
|
485
486
|
var mathTrunc = Math.trunc || function trunc(x) {
|
|
486
487
|
var n = +x;
|
|
487
|
-
return (n > 0 ? floor : ceil)(n);
|
|
488
|
+
return (n > 0 ? floor$1 : ceil)(n);
|
|
488
489
|
};
|
|
489
490
|
|
|
490
491
|
var trunc = mathTrunc;
|
|
491
492
|
|
|
492
493
|
// `ToIntegerOrInfinity` abstract operation
|
|
493
494
|
// https://tc39.es/ecma262/#sec-tointegerorinfinity
|
|
494
|
-
var toIntegerOrInfinity$
|
|
495
|
+
var toIntegerOrInfinity$4 = function (argument) {
|
|
495
496
|
var number = +argument;
|
|
496
497
|
// eslint-disable-next-line no-self-compare -- NaN check
|
|
497
498
|
return number !== number || number === 0 ? 0 : trunc(number);
|
|
498
499
|
};
|
|
499
500
|
|
|
500
|
-
var toIntegerOrInfinity$
|
|
501
|
+
var toIntegerOrInfinity$3 = toIntegerOrInfinity$4;
|
|
501
502
|
|
|
502
|
-
var max = Math.max;
|
|
503
|
-
var min$
|
|
503
|
+
var max$1 = Math.max;
|
|
504
|
+
var min$2 = Math.min;
|
|
504
505
|
|
|
505
506
|
// Helper for a popular repeating case of the spec:
|
|
506
507
|
// Let integer be ? ToInteger(index).
|
|
507
508
|
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
|
|
508
509
|
var toAbsoluteIndex$1 = function (index, length) {
|
|
509
|
-
var integer = toIntegerOrInfinity$
|
|
510
|
-
return integer < 0 ? max(integer + length, 0) : min$
|
|
510
|
+
var integer = toIntegerOrInfinity$3(index);
|
|
511
|
+
return integer < 0 ? max$1(integer + length, 0) : min$2(integer, length);
|
|
511
512
|
};
|
|
512
513
|
|
|
513
|
-
var toIntegerOrInfinity = toIntegerOrInfinity$
|
|
514
|
+
var toIntegerOrInfinity$2 = toIntegerOrInfinity$4;
|
|
514
515
|
|
|
515
|
-
var min = Math.min;
|
|
516
|
+
var min$1 = Math.min;
|
|
516
517
|
|
|
517
518
|
// `ToLength` abstract operation
|
|
518
519
|
// https://tc39.es/ecma262/#sec-tolength
|
|
519
|
-
var toLength$
|
|
520
|
-
return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
|
|
520
|
+
var toLength$2 = function (argument) {
|
|
521
|
+
return argument > 0 ? min$1(toIntegerOrInfinity$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
|
|
521
522
|
};
|
|
522
523
|
|
|
523
|
-
var toLength = toLength$
|
|
524
|
+
var toLength$1 = toLength$2;
|
|
524
525
|
|
|
525
526
|
// `LengthOfArrayLike` abstract operation
|
|
526
527
|
// https://tc39.es/ecma262/#sec-lengthofarraylike
|
|
527
|
-
var lengthOfArrayLike$
|
|
528
|
-
return toLength(obj.length);
|
|
528
|
+
var lengthOfArrayLike$2 = function (obj) {
|
|
529
|
+
return toLength$1(obj.length);
|
|
529
530
|
};
|
|
530
531
|
|
|
531
532
|
var toIndexedObject$4 = toIndexedObject$5;
|
|
532
533
|
var toAbsoluteIndex = toAbsoluteIndex$1;
|
|
533
|
-
var lengthOfArrayLike = lengthOfArrayLike$
|
|
534
|
+
var lengthOfArrayLike$1 = lengthOfArrayLike$2;
|
|
534
535
|
|
|
535
536
|
// `Array.prototype.{ indexOf, includes }` methods implementation
|
|
536
|
-
var createMethod = function (IS_INCLUDES) {
|
|
537
|
+
var createMethod$1 = function (IS_INCLUDES) {
|
|
537
538
|
return function ($this, el, fromIndex) {
|
|
538
539
|
var O = toIndexedObject$4($this);
|
|
539
|
-
var length = lengthOfArrayLike(O);
|
|
540
|
+
var length = lengthOfArrayLike$1(O);
|
|
540
541
|
var index = toAbsoluteIndex(fromIndex, length);
|
|
541
542
|
var value;
|
|
542
543
|
// Array#includes uses SameValueZero equality algorithm
|
|
@@ -555,31 +556,31 @@ var createMethod = function (IS_INCLUDES) {
|
|
|
555
556
|
var arrayIncludes = {
|
|
556
557
|
// `Array.prototype.includes` method
|
|
557
558
|
// https://tc39.es/ecma262/#sec-array.prototype.includes
|
|
558
|
-
includes: createMethod(true),
|
|
559
|
+
includes: createMethod$1(true),
|
|
559
560
|
// `Array.prototype.indexOf` method
|
|
560
561
|
// https://tc39.es/ecma262/#sec-array.prototype.indexof
|
|
561
|
-
indexOf: createMethod(false)
|
|
562
|
+
indexOf: createMethod$1(false)
|
|
562
563
|
};
|
|
563
564
|
|
|
564
565
|
var hiddenKeys$4 = {};
|
|
565
566
|
|
|
566
|
-
var uncurryThis$
|
|
567
|
-
var hasOwn$
|
|
567
|
+
var uncurryThis$e = functionUncurryThis;
|
|
568
|
+
var hasOwn$9 = hasOwnProperty_1;
|
|
568
569
|
var toIndexedObject$3 = toIndexedObject$5;
|
|
569
|
-
var indexOf = arrayIncludes.indexOf;
|
|
570
|
+
var indexOf$1 = arrayIncludes.indexOf;
|
|
570
571
|
var hiddenKeys$3 = hiddenKeys$4;
|
|
571
572
|
|
|
572
|
-
var push = uncurryThis$
|
|
573
|
+
var push$1 = uncurryThis$e([].push);
|
|
573
574
|
|
|
574
575
|
var objectKeysInternal = function (object, names) {
|
|
575
576
|
var O = toIndexedObject$3(object);
|
|
576
577
|
var i = 0;
|
|
577
578
|
var result = [];
|
|
578
579
|
var key;
|
|
579
|
-
for (key in O) !hasOwn$
|
|
580
|
+
for (key in O) !hasOwn$9(hiddenKeys$3, key) && hasOwn$9(O, key) && push$1(result, key);
|
|
580
581
|
// Don't enum bug & hidden keys
|
|
581
|
-
while (names.length > i) if (hasOwn$
|
|
582
|
-
~indexOf(result, key) || push(result, key);
|
|
582
|
+
while (names.length > i) if (hasOwn$9(O, key = names[i++])) {
|
|
583
|
+
~indexOf$1(result, key) || push$1(result, key);
|
|
583
584
|
}
|
|
584
585
|
return result;
|
|
585
586
|
};
|
|
@@ -605,35 +606,35 @@ var objectKeys$2 = Object.keys || function keys(O) {
|
|
|
605
606
|
return internalObjectKeys$1(O, enumBugKeys$2);
|
|
606
607
|
};
|
|
607
608
|
|
|
608
|
-
var DESCRIPTORS$
|
|
609
|
+
var DESCRIPTORS$7 = descriptors;
|
|
609
610
|
var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
|
|
610
|
-
var definePropertyModule$
|
|
611
|
-
var anObject$
|
|
611
|
+
var definePropertyModule$4 = objectDefineProperty;
|
|
612
|
+
var anObject$d = anObject$f;
|
|
612
613
|
var toIndexedObject$2 = toIndexedObject$5;
|
|
613
614
|
var objectKeys$1 = objectKeys$2;
|
|
614
615
|
|
|
615
616
|
// `Object.defineProperties` method
|
|
616
617
|
// https://tc39.es/ecma262/#sec-object.defineproperties
|
|
617
618
|
// eslint-disable-next-line es-x/no-object-defineproperties -- safe
|
|
618
|
-
objectDefineProperties.f = DESCRIPTORS$
|
|
619
|
-
anObject$
|
|
619
|
+
objectDefineProperties.f = DESCRIPTORS$7 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
|
|
620
|
+
anObject$d(O);
|
|
620
621
|
var props = toIndexedObject$2(Properties);
|
|
621
622
|
var keys = objectKeys$1(Properties);
|
|
622
623
|
var length = keys.length;
|
|
623
624
|
var index = 0;
|
|
624
625
|
var key;
|
|
625
|
-
while (length > index) definePropertyModule$
|
|
626
|
+
while (length > index) definePropertyModule$4.f(O, key = keys[index++], props[key]);
|
|
626
627
|
return O;
|
|
627
628
|
};
|
|
628
629
|
|
|
629
|
-
var getBuiltIn$
|
|
630
|
+
var getBuiltIn$6 = getBuiltIn$9;
|
|
630
631
|
|
|
631
|
-
var html$
|
|
632
|
+
var html$2 = getBuiltIn$6('document', 'documentElement');
|
|
632
633
|
|
|
633
|
-
var shared$
|
|
634
|
+
var shared$2 = shared$4.exports;
|
|
634
635
|
var uid = uid$2;
|
|
635
636
|
|
|
636
|
-
var keys = shared$
|
|
637
|
+
var keys = shared$2('keys');
|
|
637
638
|
|
|
638
639
|
var sharedKey$3 = function (key) {
|
|
639
640
|
return keys[key] || (keys[key] = uid(key));
|
|
@@ -641,11 +642,11 @@ var sharedKey$3 = function (key) {
|
|
|
641
642
|
|
|
642
643
|
/* global ActiveXObject -- old IE, WSH */
|
|
643
644
|
|
|
644
|
-
var anObject$
|
|
645
|
+
var anObject$c = anObject$f;
|
|
645
646
|
var definePropertiesModule = objectDefineProperties;
|
|
646
647
|
var enumBugKeys$1 = enumBugKeys$3;
|
|
647
648
|
var hiddenKeys$2 = hiddenKeys$4;
|
|
648
|
-
var html = html$
|
|
649
|
+
var html$1 = html$2;
|
|
649
650
|
var documentCreateElement$1 = documentCreateElement$2;
|
|
650
651
|
var sharedKey$2 = sharedKey$3;
|
|
651
652
|
|
|
@@ -677,7 +678,7 @@ var NullProtoObjectViaIFrame = function () {
|
|
|
677
678
|
var JS = 'java' + SCRIPT + ':';
|
|
678
679
|
var iframeDocument;
|
|
679
680
|
iframe.style.display = 'none';
|
|
680
|
-
html.appendChild(iframe);
|
|
681
|
+
html$1.appendChild(iframe);
|
|
681
682
|
// https://github.com/zloirock/core-js/issues/475
|
|
682
683
|
iframe.src = String(JS);
|
|
683
684
|
iframeDocument = iframe.contentWindow.document;
|
|
@@ -715,7 +716,7 @@ hiddenKeys$2[IE_PROTO$1] = true;
|
|
|
715
716
|
var objectCreate = Object.create || function create(O, Properties) {
|
|
716
717
|
var result;
|
|
717
718
|
if (O !== null) {
|
|
718
|
-
EmptyConstructor[PROTOTYPE] = anObject$
|
|
719
|
+
EmptyConstructor[PROTOTYPE] = anObject$c(O);
|
|
719
720
|
result = new EmptyConstructor();
|
|
720
721
|
EmptyConstructor[PROTOTYPE] = null;
|
|
721
722
|
// add "__proto__" for Object.getPrototypeOf polyfill
|
|
@@ -724,51 +725,51 @@ var objectCreate = Object.create || function create(O, Properties) {
|
|
|
724
725
|
return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
|
|
725
726
|
};
|
|
726
727
|
|
|
727
|
-
var wellKnownSymbol$
|
|
728
|
-
var create$
|
|
728
|
+
var wellKnownSymbol$g = wellKnownSymbol$i;
|
|
729
|
+
var create$2 = objectCreate;
|
|
729
730
|
var defineProperty$4 = objectDefineProperty.f;
|
|
730
731
|
|
|
731
|
-
var UNSCOPABLES = wellKnownSymbol$
|
|
732
|
-
var ArrayPrototype = Array.prototype;
|
|
732
|
+
var UNSCOPABLES = wellKnownSymbol$g('unscopables');
|
|
733
|
+
var ArrayPrototype$1 = Array.prototype;
|
|
733
734
|
|
|
734
735
|
// Array.prototype[@@unscopables]
|
|
735
736
|
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
736
|
-
if (ArrayPrototype[UNSCOPABLES] == undefined) {
|
|
737
|
-
defineProperty$4(ArrayPrototype, UNSCOPABLES, {
|
|
737
|
+
if (ArrayPrototype$1[UNSCOPABLES] == undefined) {
|
|
738
|
+
defineProperty$4(ArrayPrototype$1, UNSCOPABLES, {
|
|
738
739
|
configurable: true,
|
|
739
|
-
value: create$
|
|
740
|
+
value: create$2(null)
|
|
740
741
|
});
|
|
741
742
|
}
|
|
742
743
|
|
|
743
744
|
// add a key to Array.prototype[@@unscopables]
|
|
744
745
|
var addToUnscopables$1 = function (key) {
|
|
745
|
-
ArrayPrototype[UNSCOPABLES][key] = true;
|
|
746
|
+
ArrayPrototype$1[UNSCOPABLES][key] = true;
|
|
746
747
|
};
|
|
747
748
|
|
|
748
749
|
var iterators = {};
|
|
749
750
|
|
|
750
|
-
var uncurryThis$
|
|
751
|
-
var isCallable$
|
|
751
|
+
var uncurryThis$d = functionUncurryThis;
|
|
752
|
+
var isCallable$h = isCallable$n;
|
|
752
753
|
var store$1 = sharedStore;
|
|
753
754
|
|
|
754
|
-
var functionToString = uncurryThis$
|
|
755
|
+
var functionToString = uncurryThis$d(Function.toString);
|
|
755
756
|
|
|
756
757
|
// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
|
|
757
|
-
if (!isCallable$
|
|
758
|
+
if (!isCallable$h(store$1.inspectSource)) {
|
|
758
759
|
store$1.inspectSource = function (it) {
|
|
759
760
|
return functionToString(it);
|
|
760
761
|
};
|
|
761
762
|
}
|
|
762
763
|
|
|
763
|
-
var inspectSource$
|
|
764
|
+
var inspectSource$4 = store$1.inspectSource;
|
|
764
765
|
|
|
765
|
-
var global$
|
|
766
|
-
var isCallable$
|
|
767
|
-
var inspectSource$
|
|
766
|
+
var global$f = global$m;
|
|
767
|
+
var isCallable$g = isCallable$n;
|
|
768
|
+
var inspectSource$3 = inspectSource$4;
|
|
768
769
|
|
|
769
|
-
var WeakMap$1 = global$
|
|
770
|
+
var WeakMap$1 = global$f.WeakMap;
|
|
770
771
|
|
|
771
|
-
var nativeWeakMap = isCallable$
|
|
772
|
+
var nativeWeakMap = isCallable$g(WeakMap$1) && /native code/.test(inspectSource$3(WeakMap$1));
|
|
772
773
|
|
|
773
774
|
var createPropertyDescriptor$3 = function (bitmap, value) {
|
|
774
775
|
return {
|
|
@@ -779,52 +780,52 @@ var createPropertyDescriptor$3 = function (bitmap, value) {
|
|
|
779
780
|
};
|
|
780
781
|
};
|
|
781
782
|
|
|
782
|
-
var DESCRIPTORS$
|
|
783
|
-
var definePropertyModule$
|
|
783
|
+
var DESCRIPTORS$6 = descriptors;
|
|
784
|
+
var definePropertyModule$3 = objectDefineProperty;
|
|
784
785
|
var createPropertyDescriptor$2 = createPropertyDescriptor$3;
|
|
785
786
|
|
|
786
|
-
var createNonEnumerableProperty$
|
|
787
|
-
return definePropertyModule$
|
|
787
|
+
var createNonEnumerableProperty$5 = DESCRIPTORS$6 ? function (object, key, value) {
|
|
788
|
+
return definePropertyModule$3.f(object, key, createPropertyDescriptor$2(1, value));
|
|
788
789
|
} : function (object, key, value) {
|
|
789
790
|
object[key] = value;
|
|
790
791
|
return object;
|
|
791
792
|
};
|
|
792
793
|
|
|
793
794
|
var NATIVE_WEAK_MAP = nativeWeakMap;
|
|
794
|
-
var global$
|
|
795
|
-
var uncurryThis$
|
|
796
|
-
var isObject = isObject$
|
|
797
|
-
var createNonEnumerableProperty$
|
|
798
|
-
var hasOwn$
|
|
799
|
-
var shared = sharedStore;
|
|
795
|
+
var global$e = global$m;
|
|
796
|
+
var uncurryThis$c = functionUncurryThis;
|
|
797
|
+
var isObject$3 = isObject$8;
|
|
798
|
+
var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
|
|
799
|
+
var hasOwn$8 = hasOwnProperty_1;
|
|
800
|
+
var shared$1 = sharedStore;
|
|
800
801
|
var sharedKey$1 = sharedKey$3;
|
|
801
802
|
var hiddenKeys$1 = hiddenKeys$4;
|
|
802
803
|
|
|
803
804
|
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
|
|
804
|
-
var TypeError$
|
|
805
|
-
var WeakMap = global$
|
|
806
|
-
var set, get, has;
|
|
805
|
+
var TypeError$2 = global$e.TypeError;
|
|
806
|
+
var WeakMap = global$e.WeakMap;
|
|
807
|
+
var set$1, get, has;
|
|
807
808
|
|
|
808
809
|
var enforce = function (it) {
|
|
809
|
-
return has(it) ? get(it) : set(it, {});
|
|
810
|
+
return has(it) ? get(it) : set$1(it, {});
|
|
810
811
|
};
|
|
811
812
|
|
|
812
813
|
var getterFor = function (TYPE) {
|
|
813
814
|
return function (it) {
|
|
814
815
|
var state;
|
|
815
|
-
if (!isObject(it) || (state = get(it)).type !== TYPE) {
|
|
816
|
-
throw TypeError$
|
|
816
|
+
if (!isObject$3(it) || (state = get(it)).type !== TYPE) {
|
|
817
|
+
throw TypeError$2('Incompatible receiver, ' + TYPE + ' required');
|
|
817
818
|
} return state;
|
|
818
819
|
};
|
|
819
820
|
};
|
|
820
821
|
|
|
821
|
-
if (NATIVE_WEAK_MAP || shared.state) {
|
|
822
|
-
var store = shared.state || (shared.state = new WeakMap());
|
|
823
|
-
var wmget = uncurryThis$
|
|
824
|
-
var wmhas = uncurryThis$
|
|
825
|
-
var wmset = uncurryThis$
|
|
826
|
-
set = function (it, metadata) {
|
|
827
|
-
if (wmhas(store, it)) throw new TypeError$
|
|
822
|
+
if (NATIVE_WEAK_MAP || shared$1.state) {
|
|
823
|
+
var store = shared$1.state || (shared$1.state = new WeakMap());
|
|
824
|
+
var wmget = uncurryThis$c(store.get);
|
|
825
|
+
var wmhas = uncurryThis$c(store.has);
|
|
826
|
+
var wmset = uncurryThis$c(store.set);
|
|
827
|
+
set$1 = function (it, metadata) {
|
|
828
|
+
if (wmhas(store, it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED);
|
|
828
829
|
metadata.facade = it;
|
|
829
830
|
wmset(store, it, metadata);
|
|
830
831
|
return metadata;
|
|
@@ -838,22 +839,22 @@ if (NATIVE_WEAK_MAP || shared.state) {
|
|
|
838
839
|
} else {
|
|
839
840
|
var STATE = sharedKey$1('state');
|
|
840
841
|
hiddenKeys$1[STATE] = true;
|
|
841
|
-
set = function (it, metadata) {
|
|
842
|
-
if (hasOwn$
|
|
842
|
+
set$1 = function (it, metadata) {
|
|
843
|
+
if (hasOwn$8(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED);
|
|
843
844
|
metadata.facade = it;
|
|
844
|
-
createNonEnumerableProperty$
|
|
845
|
+
createNonEnumerableProperty$4(it, STATE, metadata);
|
|
845
846
|
return metadata;
|
|
846
847
|
};
|
|
847
848
|
get = function (it) {
|
|
848
|
-
return hasOwn$
|
|
849
|
+
return hasOwn$8(it, STATE) ? it[STATE] : {};
|
|
849
850
|
};
|
|
850
851
|
has = function (it) {
|
|
851
|
-
return hasOwn$
|
|
852
|
+
return hasOwn$8(it, STATE);
|
|
852
853
|
};
|
|
853
854
|
}
|
|
854
855
|
|
|
855
856
|
var internalState = {
|
|
856
|
-
set: set,
|
|
857
|
+
set: set$1,
|
|
857
858
|
get: get,
|
|
858
859
|
has: has,
|
|
859
860
|
enforce: enforce,
|
|
@@ -866,25 +867,25 @@ var objectPropertyIsEnumerable = {};
|
|
|
866
867
|
|
|
867
868
|
var $propertyIsEnumerable = {}.propertyIsEnumerable;
|
|
868
869
|
// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
|
|
869
|
-
var getOwnPropertyDescriptor$
|
|
870
|
+
var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor;
|
|
870
871
|
|
|
871
872
|
// Nashorn ~ JDK8 bug
|
|
872
|
-
var NASHORN_BUG = getOwnPropertyDescriptor$
|
|
873
|
+
var NASHORN_BUG = getOwnPropertyDescriptor$2 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
|
|
873
874
|
|
|
874
875
|
// `Object.prototype.propertyIsEnumerable` method implementation
|
|
875
876
|
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
|
|
876
877
|
objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
|
|
877
|
-
var descriptor = getOwnPropertyDescriptor$
|
|
878
|
+
var descriptor = getOwnPropertyDescriptor$2(this, V);
|
|
878
879
|
return !!descriptor && descriptor.enumerable;
|
|
879
880
|
} : $propertyIsEnumerable;
|
|
880
881
|
|
|
881
|
-
var DESCRIPTORS$
|
|
882
|
-
var call$
|
|
882
|
+
var DESCRIPTORS$5 = descriptors;
|
|
883
|
+
var call$f = functionCall;
|
|
883
884
|
var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable;
|
|
884
885
|
var createPropertyDescriptor$1 = createPropertyDescriptor$3;
|
|
885
886
|
var toIndexedObject$1 = toIndexedObject$5;
|
|
886
887
|
var toPropertyKey = toPropertyKey$2;
|
|
887
|
-
var hasOwn$
|
|
888
|
+
var hasOwn$7 = hasOwnProperty_1;
|
|
888
889
|
var IE8_DOM_DEFINE = ie8DomDefine;
|
|
889
890
|
|
|
890
891
|
// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
|
|
@@ -892,28 +893,28 @@ var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
892
893
|
|
|
893
894
|
// `Object.getOwnPropertyDescriptor` method
|
|
894
895
|
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
|
|
895
|
-
objectGetOwnPropertyDescriptor.f = DESCRIPTORS$
|
|
896
|
+
objectGetOwnPropertyDescriptor.f = DESCRIPTORS$5 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
|
|
896
897
|
O = toIndexedObject$1(O);
|
|
897
898
|
P = toPropertyKey(P);
|
|
898
899
|
if (IE8_DOM_DEFINE) try {
|
|
899
900
|
return $getOwnPropertyDescriptor(O, P);
|
|
900
901
|
} catch (error) { /* empty */ }
|
|
901
|
-
if (hasOwn$
|
|
902
|
+
if (hasOwn$7(O, P)) return createPropertyDescriptor$1(!call$f(propertyIsEnumerableModule$1.f, O, P), O[P]);
|
|
902
903
|
};
|
|
903
904
|
|
|
904
905
|
var makeBuiltIn$2 = {exports: {}};
|
|
905
906
|
|
|
906
|
-
var DESCRIPTORS$
|
|
907
|
-
var hasOwn$
|
|
907
|
+
var DESCRIPTORS$4 = descriptors;
|
|
908
|
+
var hasOwn$6 = hasOwnProperty_1;
|
|
908
909
|
|
|
909
|
-
var FunctionPrototype = Function.prototype;
|
|
910
|
+
var FunctionPrototype$1 = Function.prototype;
|
|
910
911
|
// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
|
|
911
|
-
var getDescriptor = DESCRIPTORS$
|
|
912
|
+
var getDescriptor = DESCRIPTORS$4 && Object.getOwnPropertyDescriptor;
|
|
912
913
|
|
|
913
|
-
var EXISTS = hasOwn$
|
|
914
|
+
var EXISTS = hasOwn$6(FunctionPrototype$1, 'name');
|
|
914
915
|
// additional protection from minified / mangled / dropped function names
|
|
915
916
|
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
|
|
916
|
-
var CONFIGURABLE = EXISTS && (!DESCRIPTORS$
|
|
917
|
+
var CONFIGURABLE = EXISTS && (!DESCRIPTORS$4 || (DESCRIPTORS$4 && getDescriptor(FunctionPrototype$1, 'name').configurable));
|
|
917
918
|
|
|
918
919
|
var functionName = {
|
|
919
920
|
EXISTS: EXISTS,
|
|
@@ -921,20 +922,20 @@ var functionName = {
|
|
|
921
922
|
CONFIGURABLE: CONFIGURABLE
|
|
922
923
|
};
|
|
923
924
|
|
|
924
|
-
var fails$
|
|
925
|
-
var isCallable$
|
|
926
|
-
var hasOwn$
|
|
927
|
-
var DESCRIPTORS$
|
|
925
|
+
var fails$d = fails$k;
|
|
926
|
+
var isCallable$f = isCallable$n;
|
|
927
|
+
var hasOwn$5 = hasOwnProperty_1;
|
|
928
|
+
var DESCRIPTORS$3 = descriptors;
|
|
928
929
|
var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
|
|
929
|
-
var inspectSource = inspectSource$
|
|
930
|
-
var InternalStateModule$
|
|
930
|
+
var inspectSource$2 = inspectSource$4;
|
|
931
|
+
var InternalStateModule$2 = internalState;
|
|
931
932
|
|
|
932
|
-
var enforceInternalState = InternalStateModule$
|
|
933
|
-
var getInternalState$
|
|
933
|
+
var enforceInternalState = InternalStateModule$2.enforce;
|
|
934
|
+
var getInternalState$2 = InternalStateModule$2.get;
|
|
934
935
|
// eslint-disable-next-line es-x/no-object-defineproperty -- safe
|
|
935
936
|
var defineProperty$3 = Object.defineProperty;
|
|
936
937
|
|
|
937
|
-
var CONFIGURABLE_LENGTH = DESCRIPTORS$
|
|
938
|
+
var CONFIGURABLE_LENGTH = DESCRIPTORS$3 && !fails$d(function () {
|
|
938
939
|
return defineProperty$3(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
|
|
939
940
|
});
|
|
940
941
|
|
|
@@ -946,21 +947,21 @@ var makeBuiltIn$1 = makeBuiltIn$2.exports = function (value, name, options) {
|
|
|
946
947
|
}
|
|
947
948
|
if (options && options.getter) name = 'get ' + name;
|
|
948
949
|
if (options && options.setter) name = 'set ' + name;
|
|
949
|
-
if (!hasOwn$
|
|
950
|
-
if (DESCRIPTORS$
|
|
950
|
+
if (!hasOwn$5(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
|
|
951
|
+
if (DESCRIPTORS$3) defineProperty$3(value, 'name', { value: name, configurable: true });
|
|
951
952
|
else value.name = name;
|
|
952
953
|
}
|
|
953
|
-
if (CONFIGURABLE_LENGTH && options && hasOwn$
|
|
954
|
+
if (CONFIGURABLE_LENGTH && options && hasOwn$5(options, 'arity') && value.length !== options.arity) {
|
|
954
955
|
defineProperty$3(value, 'length', { value: options.arity });
|
|
955
956
|
}
|
|
956
957
|
try {
|
|
957
|
-
if (options && hasOwn$
|
|
958
|
-
if (DESCRIPTORS$
|
|
958
|
+
if (options && hasOwn$5(options, 'constructor') && options.constructor) {
|
|
959
|
+
if (DESCRIPTORS$3) defineProperty$3(value, 'prototype', { writable: false });
|
|
959
960
|
// in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
|
|
960
961
|
} else if (value.prototype) value.prototype = undefined;
|
|
961
962
|
} catch (error) { /* empty */ }
|
|
962
963
|
var state = enforceInternalState(value);
|
|
963
|
-
if (!hasOwn$
|
|
964
|
+
if (!hasOwn$5(state, 'source')) {
|
|
964
965
|
state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
|
|
965
966
|
} return value;
|
|
966
967
|
};
|
|
@@ -968,19 +969,19 @@ var makeBuiltIn$1 = makeBuiltIn$2.exports = function (value, name, options) {
|
|
|
968
969
|
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
|
|
969
970
|
// eslint-disable-next-line no-extend-native -- required
|
|
970
971
|
Function.prototype.toString = makeBuiltIn$1(function toString() {
|
|
971
|
-
return isCallable$
|
|
972
|
+
return isCallable$f(this) && getInternalState$2(this).source || inspectSource$2(this);
|
|
972
973
|
}, 'toString');
|
|
973
974
|
|
|
974
|
-
var isCallable$
|
|
975
|
-
var definePropertyModule$
|
|
975
|
+
var isCallable$e = isCallable$n;
|
|
976
|
+
var definePropertyModule$2 = objectDefineProperty;
|
|
976
977
|
var makeBuiltIn = makeBuiltIn$2.exports;
|
|
977
978
|
var defineGlobalProperty$1 = defineGlobalProperty$3;
|
|
978
979
|
|
|
979
|
-
var defineBuiltIn$
|
|
980
|
+
var defineBuiltIn$8 = function (O, key, value, options) {
|
|
980
981
|
if (!options) options = {};
|
|
981
982
|
var simple = options.enumerable;
|
|
982
983
|
var name = options.name !== undefined ? options.name : key;
|
|
983
|
-
if (isCallable$
|
|
984
|
+
if (isCallable$e(value)) makeBuiltIn(value, name, options);
|
|
984
985
|
if (options.global) {
|
|
985
986
|
if (simple) O[key] = value;
|
|
986
987
|
else defineGlobalProperty$1(key, value);
|
|
@@ -990,7 +991,7 @@ var defineBuiltIn$3 = function (O, key, value, options) {
|
|
|
990
991
|
else if (O[key]) simple = true;
|
|
991
992
|
} catch (error) { /* empty */ }
|
|
992
993
|
if (simple) O[key] = value;
|
|
993
|
-
else definePropertyModule$
|
|
994
|
+
else definePropertyModule$2.f(O, key, {
|
|
994
995
|
value: value,
|
|
995
996
|
enumerable: false,
|
|
996
997
|
configurable: !options.nonConfigurable,
|
|
@@ -1018,68 +1019,68 @@ var objectGetOwnPropertySymbols = {};
|
|
|
1018
1019
|
// eslint-disable-next-line es-x/no-object-getownpropertysymbols -- safe
|
|
1019
1020
|
objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
|
|
1020
1021
|
|
|
1021
|
-
var getBuiltIn = getBuiltIn$
|
|
1022
|
-
var uncurryThis$
|
|
1022
|
+
var getBuiltIn$5 = getBuiltIn$9;
|
|
1023
|
+
var uncurryThis$b = functionUncurryThis;
|
|
1023
1024
|
var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
|
|
1024
1025
|
var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols;
|
|
1025
|
-
var anObject$
|
|
1026
|
+
var anObject$b = anObject$f;
|
|
1026
1027
|
|
|
1027
|
-
var concat$
|
|
1028
|
+
var concat$2 = uncurryThis$b([].concat);
|
|
1028
1029
|
|
|
1029
1030
|
// all object keys, includes non-enumerable and symbols
|
|
1030
|
-
var ownKeys$1 = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
|
|
1031
|
-
var keys = getOwnPropertyNamesModule.f(anObject$
|
|
1031
|
+
var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) {
|
|
1032
|
+
var keys = getOwnPropertyNamesModule.f(anObject$b(it));
|
|
1032
1033
|
var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f;
|
|
1033
|
-
return getOwnPropertySymbols ? concat$
|
|
1034
|
+
return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys;
|
|
1034
1035
|
};
|
|
1035
1036
|
|
|
1036
|
-
var hasOwn$
|
|
1037
|
+
var hasOwn$4 = hasOwnProperty_1;
|
|
1037
1038
|
var ownKeys = ownKeys$1;
|
|
1038
1039
|
var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
|
|
1039
|
-
var definePropertyModule = objectDefineProperty;
|
|
1040
|
+
var definePropertyModule$1 = objectDefineProperty;
|
|
1040
1041
|
|
|
1041
1042
|
var copyConstructorProperties$1 = function (target, source, exceptions) {
|
|
1042
1043
|
var keys = ownKeys(source);
|
|
1043
|
-
var defineProperty = definePropertyModule.f;
|
|
1044
|
+
var defineProperty = definePropertyModule$1.f;
|
|
1044
1045
|
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
1045
1046
|
for (var i = 0; i < keys.length; i++) {
|
|
1046
1047
|
var key = keys[i];
|
|
1047
|
-
if (!hasOwn$
|
|
1048
|
+
if (!hasOwn$4(target, key) && !(exceptions && hasOwn$4(exceptions, key))) {
|
|
1048
1049
|
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
|
1049
1050
|
}
|
|
1050
1051
|
}
|
|
1051
1052
|
};
|
|
1052
1053
|
|
|
1053
|
-
var fails$
|
|
1054
|
-
var isCallable$
|
|
1054
|
+
var fails$c = fails$k;
|
|
1055
|
+
var isCallable$d = isCallable$n;
|
|
1055
1056
|
|
|
1056
1057
|
var replacement = /#|\.prototype\./;
|
|
1057
1058
|
|
|
1058
|
-
var isForced$
|
|
1059
|
+
var isForced$2 = function (feature, detection) {
|
|
1059
1060
|
var value = data[normalize(feature)];
|
|
1060
1061
|
return value == POLYFILL ? true
|
|
1061
1062
|
: value == NATIVE ? false
|
|
1062
|
-
: isCallable$
|
|
1063
|
+
: isCallable$d(detection) ? fails$c(detection)
|
|
1063
1064
|
: !!detection;
|
|
1064
1065
|
};
|
|
1065
1066
|
|
|
1066
|
-
var normalize = isForced$
|
|
1067
|
+
var normalize = isForced$2.normalize = function (string) {
|
|
1067
1068
|
return String(string).replace(replacement, '.').toLowerCase();
|
|
1068
1069
|
};
|
|
1069
1070
|
|
|
1070
|
-
var data = isForced$
|
|
1071
|
-
var NATIVE = isForced$
|
|
1072
|
-
var POLYFILL = isForced$
|
|
1071
|
+
var data = isForced$2.data = {};
|
|
1072
|
+
var NATIVE = isForced$2.NATIVE = 'N';
|
|
1073
|
+
var POLYFILL = isForced$2.POLYFILL = 'P';
|
|
1073
1074
|
|
|
1074
|
-
var isForced_1 = isForced$
|
|
1075
|
+
var isForced_1 = isForced$2;
|
|
1075
1076
|
|
|
1076
|
-
var global$
|
|
1077
|
-
var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
|
|
1078
|
-
var createNonEnumerableProperty$
|
|
1079
|
-
var defineBuiltIn$
|
|
1077
|
+
var global$d = global$m;
|
|
1078
|
+
var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
|
|
1079
|
+
var createNonEnumerableProperty$3 = createNonEnumerableProperty$5;
|
|
1080
|
+
var defineBuiltIn$7 = defineBuiltIn$8;
|
|
1080
1081
|
var defineGlobalProperty = defineGlobalProperty$3;
|
|
1081
1082
|
var copyConstructorProperties = copyConstructorProperties$1;
|
|
1082
|
-
var isForced = isForced_1;
|
|
1083
|
+
var isForced$1 = isForced_1;
|
|
1083
1084
|
|
|
1084
1085
|
/*
|
|
1085
1086
|
options.target - name of the target object
|
|
@@ -1102,19 +1103,19 @@ var _export = function (options, source) {
|
|
|
1102
1103
|
var STATIC = options.stat;
|
|
1103
1104
|
var FORCED, target, key, targetProperty, sourceProperty, descriptor;
|
|
1104
1105
|
if (GLOBAL) {
|
|
1105
|
-
target = global$
|
|
1106
|
+
target = global$d;
|
|
1106
1107
|
} else if (STATIC) {
|
|
1107
|
-
target = global$
|
|
1108
|
+
target = global$d[TARGET] || defineGlobalProperty(TARGET, {});
|
|
1108
1109
|
} else {
|
|
1109
|
-
target = (global$
|
|
1110
|
+
target = (global$d[TARGET] || {}).prototype;
|
|
1110
1111
|
}
|
|
1111
1112
|
if (target) for (key in source) {
|
|
1112
1113
|
sourceProperty = source[key];
|
|
1113
1114
|
if (options.dontCallGetSet) {
|
|
1114
|
-
descriptor = getOwnPropertyDescriptor(target, key);
|
|
1115
|
+
descriptor = getOwnPropertyDescriptor$1(target, key);
|
|
1115
1116
|
targetProperty = descriptor && descriptor.value;
|
|
1116
1117
|
} else targetProperty = target[key];
|
|
1117
|
-
FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
|
|
1118
|
+
FORCED = isForced$1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
|
|
1118
1119
|
// contained in target
|
|
1119
1120
|
if (!FORCED && targetProperty !== undefined) {
|
|
1120
1121
|
if (typeof sourceProperty == typeof targetProperty) continue;
|
|
@@ -1122,50 +1123,50 @@ var _export = function (options, source) {
|
|
|
1122
1123
|
}
|
|
1123
1124
|
// add a flag to not completely full polyfills
|
|
1124
1125
|
if (options.sham || (targetProperty && targetProperty.sham)) {
|
|
1125
|
-
createNonEnumerableProperty$
|
|
1126
|
+
createNonEnumerableProperty$3(sourceProperty, 'sham', true);
|
|
1126
1127
|
}
|
|
1127
|
-
defineBuiltIn$
|
|
1128
|
+
defineBuiltIn$7(target, key, sourceProperty, options);
|
|
1128
1129
|
}
|
|
1129
1130
|
};
|
|
1130
1131
|
|
|
1131
|
-
var fails$
|
|
1132
|
+
var fails$b = fails$k;
|
|
1132
1133
|
|
|
1133
|
-
var correctPrototypeGetter = !fails$
|
|
1134
|
+
var correctPrototypeGetter = !fails$b(function () {
|
|
1134
1135
|
function F() { /* empty */ }
|
|
1135
1136
|
F.prototype.constructor = null;
|
|
1136
1137
|
// eslint-disable-next-line es-x/no-object-getprototypeof -- required for testing
|
|
1137
1138
|
return Object.getPrototypeOf(new F()) !== F.prototype;
|
|
1138
1139
|
});
|
|
1139
1140
|
|
|
1140
|
-
var hasOwn$
|
|
1141
|
-
var isCallable$
|
|
1142
|
-
var toObject$
|
|
1141
|
+
var hasOwn$3 = hasOwnProperty_1;
|
|
1142
|
+
var isCallable$c = isCallable$n;
|
|
1143
|
+
var toObject$2 = toObject$4;
|
|
1143
1144
|
var sharedKey = sharedKey$3;
|
|
1144
1145
|
var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
|
|
1145
1146
|
|
|
1146
1147
|
var IE_PROTO = sharedKey('IE_PROTO');
|
|
1147
|
-
var $Object = Object;
|
|
1148
|
-
var ObjectPrototype = $Object.prototype;
|
|
1148
|
+
var $Object$1 = Object;
|
|
1149
|
+
var ObjectPrototype = $Object$1.prototype;
|
|
1149
1150
|
|
|
1150
1151
|
// `Object.getPrototypeOf` method
|
|
1151
1152
|
// https://tc39.es/ecma262/#sec-object.getprototypeof
|
|
1152
1153
|
// eslint-disable-next-line es-x/no-object-getprototypeof -- safe
|
|
1153
|
-
var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
|
|
1154
|
-
var object = toObject$
|
|
1155
|
-
if (hasOwn$
|
|
1154
|
+
var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object$1.getPrototypeOf : function (O) {
|
|
1155
|
+
var object = toObject$2(O);
|
|
1156
|
+
if (hasOwn$3(object, IE_PROTO)) return object[IE_PROTO];
|
|
1156
1157
|
var constructor = object.constructor;
|
|
1157
|
-
if (isCallable$
|
|
1158
|
+
if (isCallable$c(constructor) && object instanceof constructor) {
|
|
1158
1159
|
return constructor.prototype;
|
|
1159
|
-
} return object instanceof $Object ? ObjectPrototype : null;
|
|
1160
|
+
} return object instanceof $Object$1 ? ObjectPrototype : null;
|
|
1160
1161
|
};
|
|
1161
1162
|
|
|
1162
|
-
var fails$
|
|
1163
|
-
var isCallable$
|
|
1163
|
+
var fails$a = fails$k;
|
|
1164
|
+
var isCallable$b = isCallable$n;
|
|
1164
1165
|
var getPrototypeOf$1 = objectGetPrototypeOf;
|
|
1165
|
-
var defineBuiltIn$
|
|
1166
|
-
var wellKnownSymbol$
|
|
1166
|
+
var defineBuiltIn$6 = defineBuiltIn$8;
|
|
1167
|
+
var wellKnownSymbol$f = wellKnownSymbol$i;
|
|
1167
1168
|
|
|
1168
|
-
var ITERATOR$
|
|
1169
|
+
var ITERATOR$5 = wellKnownSymbol$f('iterator');
|
|
1169
1170
|
var BUGGY_SAFARI_ITERATORS$1 = false;
|
|
1170
1171
|
|
|
1171
1172
|
// `%IteratorPrototype%` object
|
|
@@ -1183,18 +1184,18 @@ if ([].keys) {
|
|
|
1183
1184
|
}
|
|
1184
1185
|
}
|
|
1185
1186
|
|
|
1186
|
-
var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$
|
|
1187
|
+
var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$a(function () {
|
|
1187
1188
|
var test = {};
|
|
1188
1189
|
// FF44- legacy iterators case
|
|
1189
|
-
return IteratorPrototype$2[ITERATOR$
|
|
1190
|
+
return IteratorPrototype$2[ITERATOR$5].call(test) !== test;
|
|
1190
1191
|
});
|
|
1191
1192
|
|
|
1192
1193
|
if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
|
|
1193
1194
|
|
|
1194
1195
|
// `%IteratorPrototype%[@@iterator]()` method
|
|
1195
1196
|
// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
|
|
1196
|
-
if (!isCallable$
|
|
1197
|
-
defineBuiltIn$
|
|
1197
|
+
if (!isCallable$b(IteratorPrototype$2[ITERATOR$5])) {
|
|
1198
|
+
defineBuiltIn$6(IteratorPrototype$2, ITERATOR$5, function () {
|
|
1198
1199
|
return this;
|
|
1199
1200
|
});
|
|
1200
1201
|
}
|
|
@@ -1205,48 +1206,48 @@ var iteratorsCore = {
|
|
|
1205
1206
|
};
|
|
1206
1207
|
|
|
1207
1208
|
var defineProperty$2 = objectDefineProperty.f;
|
|
1208
|
-
var hasOwn = hasOwnProperty_1;
|
|
1209
|
-
var wellKnownSymbol$
|
|
1209
|
+
var hasOwn$2 = hasOwnProperty_1;
|
|
1210
|
+
var wellKnownSymbol$e = wellKnownSymbol$i;
|
|
1210
1211
|
|
|
1211
|
-
var TO_STRING_TAG$
|
|
1212
|
+
var TO_STRING_TAG$3 = wellKnownSymbol$e('toStringTag');
|
|
1212
1213
|
|
|
1213
|
-
var setToStringTag$
|
|
1214
|
+
var setToStringTag$3 = function (target, TAG, STATIC) {
|
|
1214
1215
|
if (target && !STATIC) target = target.prototype;
|
|
1215
|
-
if (target && !hasOwn(target, TO_STRING_TAG$
|
|
1216
|
-
defineProperty$2(target, TO_STRING_TAG$
|
|
1216
|
+
if (target && !hasOwn$2(target, TO_STRING_TAG$3)) {
|
|
1217
|
+
defineProperty$2(target, TO_STRING_TAG$3, { configurable: true, value: TAG });
|
|
1217
1218
|
}
|
|
1218
1219
|
};
|
|
1219
1220
|
|
|
1220
1221
|
var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
|
|
1221
|
-
var create = objectCreate;
|
|
1222
|
+
var create$1 = objectCreate;
|
|
1222
1223
|
var createPropertyDescriptor = createPropertyDescriptor$3;
|
|
1223
|
-
var setToStringTag$
|
|
1224
|
-
var Iterators$
|
|
1224
|
+
var setToStringTag$2 = setToStringTag$3;
|
|
1225
|
+
var Iterators$4 = iterators;
|
|
1225
1226
|
|
|
1226
1227
|
var returnThis$1 = function () { return this; };
|
|
1227
1228
|
|
|
1228
1229
|
var createIteratorConstructor$1 = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
|
|
1229
1230
|
var TO_STRING_TAG = NAME + ' Iterator';
|
|
1230
|
-
IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
|
|
1231
|
-
setToStringTag$
|
|
1232
|
-
Iterators$
|
|
1231
|
+
IteratorConstructor.prototype = create$1(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
|
|
1232
|
+
setToStringTag$2(IteratorConstructor, TO_STRING_TAG, false);
|
|
1233
|
+
Iterators$4[TO_STRING_TAG] = returnThis$1;
|
|
1233
1234
|
return IteratorConstructor;
|
|
1234
1235
|
};
|
|
1235
1236
|
|
|
1236
|
-
var isCallable$
|
|
1237
|
+
var isCallable$a = isCallable$n;
|
|
1237
1238
|
|
|
1238
|
-
var $String = String;
|
|
1239
|
-
var $TypeError = TypeError;
|
|
1239
|
+
var $String$1 = String;
|
|
1240
|
+
var $TypeError$7 = TypeError;
|
|
1240
1241
|
|
|
1241
1242
|
var aPossiblePrototype$1 = function (argument) {
|
|
1242
|
-
if (typeof argument == 'object' || isCallable$
|
|
1243
|
-
throw $TypeError("Can't set " + $String(argument) + ' as a prototype');
|
|
1243
|
+
if (typeof argument == 'object' || isCallable$a(argument)) return argument;
|
|
1244
|
+
throw $TypeError$7("Can't set " + $String$1(argument) + ' as a prototype');
|
|
1244
1245
|
};
|
|
1245
1246
|
|
|
1246
1247
|
/* eslint-disable no-proto -- safe */
|
|
1247
1248
|
|
|
1248
|
-
var uncurryThis$
|
|
1249
|
-
var anObject = anObject$
|
|
1249
|
+
var uncurryThis$a = functionUncurryThis;
|
|
1250
|
+
var anObject$a = anObject$f;
|
|
1250
1251
|
var aPossiblePrototype = aPossiblePrototype$1;
|
|
1251
1252
|
|
|
1252
1253
|
// `Object.setPrototypeOf` method
|
|
@@ -1259,12 +1260,12 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
|
|
|
1259
1260
|
var setter;
|
|
1260
1261
|
try {
|
|
1261
1262
|
// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
|
|
1262
|
-
setter = uncurryThis$
|
|
1263
|
+
setter = uncurryThis$a(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
|
|
1263
1264
|
setter(test, []);
|
|
1264
1265
|
CORRECT_SETTER = test instanceof Array;
|
|
1265
1266
|
} catch (error) { /* empty */ }
|
|
1266
1267
|
return function setPrototypeOf(O, proto) {
|
|
1267
|
-
anObject(O);
|
|
1268
|
+
anObject$a(O);
|
|
1268
1269
|
aPossiblePrototype(proto);
|
|
1269
1270
|
if (CORRECT_SETTER) setter(O, proto);
|
|
1270
1271
|
else O.__proto__ = proto;
|
|
@@ -1272,25 +1273,25 @@ var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? functio
|
|
|
1272
1273
|
};
|
|
1273
1274
|
}() : undefined);
|
|
1274
1275
|
|
|
1275
|
-
var $$
|
|
1276
|
-
var call$
|
|
1276
|
+
var $$a = _export;
|
|
1277
|
+
var call$e = functionCall;
|
|
1277
1278
|
var FunctionName = functionName;
|
|
1278
|
-
var isCallable = isCallable$
|
|
1279
|
+
var isCallable$9 = isCallable$n;
|
|
1279
1280
|
var createIteratorConstructor = createIteratorConstructor$1;
|
|
1280
1281
|
var getPrototypeOf = objectGetPrototypeOf;
|
|
1281
|
-
var setPrototypeOf = objectSetPrototypeOf;
|
|
1282
|
-
var setToStringTag = setToStringTag$
|
|
1283
|
-
var createNonEnumerableProperty$
|
|
1284
|
-
var defineBuiltIn = defineBuiltIn$
|
|
1285
|
-
var wellKnownSymbol$
|
|
1286
|
-
var Iterators$
|
|
1282
|
+
var setPrototypeOf$1 = objectSetPrototypeOf;
|
|
1283
|
+
var setToStringTag$1 = setToStringTag$3;
|
|
1284
|
+
var createNonEnumerableProperty$2 = createNonEnumerableProperty$5;
|
|
1285
|
+
var defineBuiltIn$5 = defineBuiltIn$8;
|
|
1286
|
+
var wellKnownSymbol$d = wellKnownSymbol$i;
|
|
1287
|
+
var Iterators$3 = iterators;
|
|
1287
1288
|
var IteratorsCore = iteratorsCore;
|
|
1288
1289
|
|
|
1289
|
-
var PROPER_FUNCTION_NAME = FunctionName.PROPER;
|
|
1290
|
+
var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER;
|
|
1290
1291
|
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
|
|
1291
1292
|
var IteratorPrototype = IteratorsCore.IteratorPrototype;
|
|
1292
1293
|
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
|
|
1293
|
-
var ITERATOR$
|
|
1294
|
+
var ITERATOR$4 = wellKnownSymbol$d('iterator');
|
|
1294
1295
|
var KEYS = 'keys';
|
|
1295
1296
|
var VALUES = 'values';
|
|
1296
1297
|
var ENTRIES = 'entries';
|
|
@@ -1313,7 +1314,7 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
|
|
|
1313
1314
|
var TO_STRING_TAG = NAME + ' Iterator';
|
|
1314
1315
|
var INCORRECT_VALUES_NAME = false;
|
|
1315
1316
|
var IterablePrototype = Iterable.prototype;
|
|
1316
|
-
var nativeIterator = IterablePrototype[ITERATOR$
|
|
1317
|
+
var nativeIterator = IterablePrototype[ITERATOR$4]
|
|
1317
1318
|
|| IterablePrototype['@@iterator']
|
|
1318
1319
|
|| DEFAULT && IterablePrototype[DEFAULT];
|
|
1319
1320
|
var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
|
|
@@ -1325,24 +1326,24 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
|
|
|
1325
1326
|
CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
|
|
1326
1327
|
if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
|
|
1327
1328
|
if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
|
|
1328
|
-
if (setPrototypeOf) {
|
|
1329
|
-
setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
|
|
1330
|
-
} else if (!isCallable(CurrentIteratorPrototype[ITERATOR$
|
|
1331
|
-
defineBuiltIn(CurrentIteratorPrototype, ITERATOR$
|
|
1329
|
+
if (setPrototypeOf$1) {
|
|
1330
|
+
setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype);
|
|
1331
|
+
} else if (!isCallable$9(CurrentIteratorPrototype[ITERATOR$4])) {
|
|
1332
|
+
defineBuiltIn$5(CurrentIteratorPrototype, ITERATOR$4, returnThis);
|
|
1332
1333
|
}
|
|
1333
1334
|
}
|
|
1334
1335
|
// Set @@toStringTag to native iterators
|
|
1335
|
-
setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true);
|
|
1336
|
+
setToStringTag$1(CurrentIteratorPrototype, TO_STRING_TAG, true);
|
|
1336
1337
|
}
|
|
1337
1338
|
}
|
|
1338
1339
|
|
|
1339
1340
|
// fix Array.prototype.{ values, @@iterator }.name in V8 / FF
|
|
1340
|
-
if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
|
|
1341
|
+
if (PROPER_FUNCTION_NAME$1 && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
|
|
1341
1342
|
if (CONFIGURABLE_FUNCTION_NAME) {
|
|
1342
|
-
createNonEnumerableProperty$
|
|
1343
|
+
createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES);
|
|
1343
1344
|
} else {
|
|
1344
1345
|
INCORRECT_VALUES_NAME = true;
|
|
1345
|
-
defaultIterator = function values() { return call$
|
|
1346
|
+
defaultIterator = function values() { return call$e(nativeIterator, this); };
|
|
1346
1347
|
}
|
|
1347
1348
|
}
|
|
1348
1349
|
|
|
@@ -1355,31 +1356,31 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
|
|
|
1355
1356
|
};
|
|
1356
1357
|
if (FORCED) for (KEY in methods) {
|
|
1357
1358
|
if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
|
|
1358
|
-
defineBuiltIn(IterablePrototype, KEY, methods[KEY]);
|
|
1359
|
+
defineBuiltIn$5(IterablePrototype, KEY, methods[KEY]);
|
|
1359
1360
|
}
|
|
1360
|
-
} else $$
|
|
1361
|
+
} else $$a({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
|
|
1361
1362
|
}
|
|
1362
1363
|
|
|
1363
1364
|
// define iterator
|
|
1364
|
-
if (IterablePrototype[ITERATOR$
|
|
1365
|
-
defineBuiltIn(IterablePrototype, ITERATOR$
|
|
1365
|
+
if (IterablePrototype[ITERATOR$4] !== defaultIterator) {
|
|
1366
|
+
defineBuiltIn$5(IterablePrototype, ITERATOR$4, defaultIterator, { name: DEFAULT });
|
|
1366
1367
|
}
|
|
1367
|
-
Iterators$
|
|
1368
|
+
Iterators$3[NAME] = defaultIterator;
|
|
1368
1369
|
|
|
1369
1370
|
return methods;
|
|
1370
1371
|
};
|
|
1371
1372
|
|
|
1372
1373
|
var toIndexedObject = toIndexedObject$5;
|
|
1373
1374
|
var addToUnscopables = addToUnscopables$1;
|
|
1374
|
-
var Iterators = iterators;
|
|
1375
|
-
var InternalStateModule = internalState;
|
|
1375
|
+
var Iterators$2 = iterators;
|
|
1376
|
+
var InternalStateModule$1 = internalState;
|
|
1376
1377
|
var defineProperty$1 = objectDefineProperty.f;
|
|
1377
1378
|
var defineIterator = defineIterator$1;
|
|
1378
|
-
var DESCRIPTORS$
|
|
1379
|
+
var DESCRIPTORS$2 = descriptors;
|
|
1379
1380
|
|
|
1380
1381
|
var ARRAY_ITERATOR = 'Array Iterator';
|
|
1381
|
-
var setInternalState = InternalStateModule.set;
|
|
1382
|
-
var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
|
|
1382
|
+
var setInternalState$1 = InternalStateModule$1.set;
|
|
1383
|
+
var getInternalState$1 = InternalStateModule$1.getterFor(ARRAY_ITERATOR);
|
|
1383
1384
|
|
|
1384
1385
|
// `Array.prototype.entries` method
|
|
1385
1386
|
// https://tc39.es/ecma262/#sec-array.prototype.entries
|
|
@@ -1392,7 +1393,7 @@ var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
|
|
|
1392
1393
|
// `CreateArrayIterator` internal method
|
|
1393
1394
|
// https://tc39.es/ecma262/#sec-createarrayiterator
|
|
1394
1395
|
var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
|
|
1395
|
-
setInternalState(this, {
|
|
1396
|
+
setInternalState$1(this, {
|
|
1396
1397
|
type: ARRAY_ITERATOR,
|
|
1397
1398
|
target: toIndexedObject(iterated), // target
|
|
1398
1399
|
index: 0, // next index
|
|
@@ -1401,7 +1402,7 @@ var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind)
|
|
|
1401
1402
|
// `%ArrayIteratorPrototype%.next` method
|
|
1402
1403
|
// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
|
|
1403
1404
|
}, function () {
|
|
1404
|
-
var state = getInternalState(this);
|
|
1405
|
+
var state = getInternalState$1(this);
|
|
1405
1406
|
var target = state.target;
|
|
1406
1407
|
var kind = state.kind;
|
|
1407
1408
|
var index = state.index++;
|
|
@@ -1417,7 +1418,7 @@ var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind)
|
|
|
1417
1418
|
// argumentsList[@@iterator] is %ArrayProto_values%
|
|
1418
1419
|
// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
|
|
1419
1420
|
// https://tc39.es/ecma262/#sec-createmappedargumentsobject
|
|
1420
|
-
var values = Iterators.Arguments = Iterators.Array;
|
|
1421
|
+
var values = Iterators$2.Arguments = Iterators$2.Array;
|
|
1421
1422
|
|
|
1422
1423
|
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
1423
1424
|
addToUnscopables('keys');
|
|
@@ -1425,7 +1426,7 @@ addToUnscopables('values');
|
|
|
1425
1426
|
addToUnscopables('entries');
|
|
1426
1427
|
|
|
1427
1428
|
// V8 ~ Chrome 45- bug
|
|
1428
|
-
if (DESCRIPTORS$
|
|
1429
|
+
if (DESCRIPTORS$2 && values.name !== 'values') try {
|
|
1429
1430
|
defineProperty$1(values, 'name', { value: 'values' });
|
|
1430
1431
|
} catch (error) { /* empty */ }
|
|
1431
1432
|
|
|
@@ -1473,32 +1474,32 @@ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.co
|
|
|
1473
1474
|
|
|
1474
1475
|
var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
|
|
1475
1476
|
|
|
1476
|
-
var global$
|
|
1477
|
+
var global$c = global$m;
|
|
1477
1478
|
var DOMIterables = domIterables;
|
|
1478
1479
|
var DOMTokenListPrototype = domTokenListPrototype;
|
|
1479
1480
|
var ArrayIteratorMethods = es_array_iterator;
|
|
1480
|
-
var createNonEnumerableProperty = createNonEnumerableProperty$
|
|
1481
|
-
var wellKnownSymbol = wellKnownSymbol$
|
|
1481
|
+
var createNonEnumerableProperty$1 = createNonEnumerableProperty$5;
|
|
1482
|
+
var wellKnownSymbol$c = wellKnownSymbol$i;
|
|
1482
1483
|
|
|
1483
|
-
var ITERATOR = wellKnownSymbol('iterator');
|
|
1484
|
-
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
1484
|
+
var ITERATOR$3 = wellKnownSymbol$c('iterator');
|
|
1485
|
+
var TO_STRING_TAG$2 = wellKnownSymbol$c('toStringTag');
|
|
1485
1486
|
var ArrayValues = ArrayIteratorMethods.values;
|
|
1486
1487
|
|
|
1487
1488
|
var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
|
|
1488
1489
|
if (CollectionPrototype) {
|
|
1489
1490
|
// some Chrome versions have non-configurable methods on DOMTokenList
|
|
1490
|
-
if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
|
|
1491
|
-
createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
|
|
1491
|
+
if (CollectionPrototype[ITERATOR$3] !== ArrayValues) try {
|
|
1492
|
+
createNonEnumerableProperty$1(CollectionPrototype, ITERATOR$3, ArrayValues);
|
|
1492
1493
|
} catch (error) {
|
|
1493
|
-
CollectionPrototype[ITERATOR] = ArrayValues;
|
|
1494
|
+
CollectionPrototype[ITERATOR$3] = ArrayValues;
|
|
1494
1495
|
}
|
|
1495
|
-
if (!CollectionPrototype[TO_STRING_TAG]) {
|
|
1496
|
-
createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
|
|
1496
|
+
if (!CollectionPrototype[TO_STRING_TAG$2]) {
|
|
1497
|
+
createNonEnumerableProperty$1(CollectionPrototype, TO_STRING_TAG$2, COLLECTION_NAME);
|
|
1497
1498
|
}
|
|
1498
1499
|
if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
|
|
1499
1500
|
// some Chrome versions have non-configurable methods on DOMTokenList
|
|
1500
1501
|
if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
|
|
1501
|
-
createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
|
|
1502
|
+
createNonEnumerableProperty$1(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
|
|
1502
1503
|
} catch (error) {
|
|
1503
1504
|
CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
|
|
1504
1505
|
}
|
|
@@ -1507,32 +1508,32 @@ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
|
|
|
1507
1508
|
};
|
|
1508
1509
|
|
|
1509
1510
|
for (var COLLECTION_NAME in DOMIterables) {
|
|
1510
|
-
handlePrototype(global$
|
|
1511
|
+
handlePrototype(global$c[COLLECTION_NAME] && global$c[COLLECTION_NAME].prototype, COLLECTION_NAME);
|
|
1511
1512
|
}
|
|
1512
1513
|
|
|
1513
1514
|
handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
|
|
1514
1515
|
|
|
1515
|
-
var DESCRIPTORS = descriptors;
|
|
1516
|
-
var uncurryThis = functionUncurryThis;
|
|
1517
|
-
var call = functionCall;
|
|
1518
|
-
var fails = fails$
|
|
1516
|
+
var DESCRIPTORS$1 = descriptors;
|
|
1517
|
+
var uncurryThis$9 = functionUncurryThis;
|
|
1518
|
+
var call$d = functionCall;
|
|
1519
|
+
var fails$9 = fails$k;
|
|
1519
1520
|
var objectKeys = objectKeys$2;
|
|
1520
1521
|
var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
|
|
1521
1522
|
var propertyIsEnumerableModule = objectPropertyIsEnumerable;
|
|
1522
|
-
var toObject = toObject$
|
|
1523
|
+
var toObject$1 = toObject$4;
|
|
1523
1524
|
var IndexedObject = indexedObject;
|
|
1524
1525
|
|
|
1525
1526
|
// eslint-disable-next-line es-x/no-object-assign -- safe
|
|
1526
1527
|
var $assign = Object.assign;
|
|
1527
1528
|
// eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
|
|
1528
1529
|
var defineProperty = Object.defineProperty;
|
|
1529
|
-
var concat = uncurryThis([].concat);
|
|
1530
|
+
var concat$1 = uncurryThis$9([].concat);
|
|
1530
1531
|
|
|
1531
1532
|
// `Object.assign` method
|
|
1532
1533
|
// https://tc39.es/ecma262/#sec-object.assign
|
|
1533
|
-
var objectAssign = !$assign || fails(function () {
|
|
1534
|
+
var objectAssign = !$assign || fails$9(function () {
|
|
1534
1535
|
// should have correct order of operations (Edge bug)
|
|
1535
|
-
if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
|
|
1536
|
+
if (DESCRIPTORS$1 && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
|
|
1536
1537
|
enumerable: true,
|
|
1537
1538
|
get: function () {
|
|
1538
1539
|
defineProperty(this, 'b', {
|
|
@@ -1551,31 +1552,31 @@ var objectAssign = !$assign || fails(function () {
|
|
|
1551
1552
|
alphabet.split('').forEach(function (chr) { B[chr] = chr; });
|
|
1552
1553
|
return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;
|
|
1553
1554
|
}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
|
|
1554
|
-
var T = toObject(target);
|
|
1555
|
+
var T = toObject$1(target);
|
|
1555
1556
|
var argumentsLength = arguments.length;
|
|
1556
1557
|
var index = 1;
|
|
1557
1558
|
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
1558
1559
|
var propertyIsEnumerable = propertyIsEnumerableModule.f;
|
|
1559
1560
|
while (argumentsLength > index) {
|
|
1560
1561
|
var S = IndexedObject(arguments[index++]);
|
|
1561
|
-
var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
|
|
1562
|
+
var keys = getOwnPropertySymbols ? concat$1(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
|
|
1562
1563
|
var length = keys.length;
|
|
1563
1564
|
var j = 0;
|
|
1564
1565
|
var key;
|
|
1565
1566
|
while (length > j) {
|
|
1566
1567
|
key = keys[j++];
|
|
1567
|
-
if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];
|
|
1568
|
+
if (!DESCRIPTORS$1 || call$d(propertyIsEnumerable, S, key)) T[key] = S[key];
|
|
1568
1569
|
}
|
|
1569
1570
|
} return T;
|
|
1570
1571
|
} : $assign;
|
|
1571
1572
|
|
|
1572
|
-
var
|
|
1573
|
+
var $$9 = _export;
|
|
1573
1574
|
var assign = objectAssign;
|
|
1574
1575
|
|
|
1575
1576
|
// `Object.assign` method
|
|
1576
1577
|
// https://tc39.es/ecma262/#sec-object.assign
|
|
1577
1578
|
// eslint-disable-next-line es-x/no-object-assign -- required for testing
|
|
1578
|
-
|
|
1579
|
+
$$9({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
|
|
1579
1580
|
assign: assign
|
|
1580
1581
|
});
|
|
1581
1582
|
|
|
@@ -1630,6 +1631,1911 @@ const useEnvironment = () => {
|
|
|
1630
1631
|
return context;
|
|
1631
1632
|
};
|
|
1632
1633
|
|
|
1634
|
+
var classof$6 = classofRaw$1;
|
|
1635
|
+
var global$b = global$m;
|
|
1636
|
+
|
|
1637
|
+
var engineIsNode = classof$6(global$b.process) == 'process';
|
|
1638
|
+
|
|
1639
|
+
var getBuiltIn$4 = getBuiltIn$9;
|
|
1640
|
+
var definePropertyModule = objectDefineProperty;
|
|
1641
|
+
var wellKnownSymbol$b = wellKnownSymbol$i;
|
|
1642
|
+
var DESCRIPTORS = descriptors;
|
|
1643
|
+
|
|
1644
|
+
var SPECIES$3 = wellKnownSymbol$b('species');
|
|
1645
|
+
|
|
1646
|
+
var setSpecies$1 = function (CONSTRUCTOR_NAME) {
|
|
1647
|
+
var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME);
|
|
1648
|
+
var defineProperty = definePropertyModule.f;
|
|
1649
|
+
|
|
1650
|
+
if (DESCRIPTORS && Constructor && !Constructor[SPECIES$3]) {
|
|
1651
|
+
defineProperty(Constructor, SPECIES$3, {
|
|
1652
|
+
configurable: true,
|
|
1653
|
+
get: function () { return this; }
|
|
1654
|
+
});
|
|
1655
|
+
}
|
|
1656
|
+
};
|
|
1657
|
+
|
|
1658
|
+
var isPrototypeOf$2 = objectIsPrototypeOf;
|
|
1659
|
+
|
|
1660
|
+
var $TypeError$6 = TypeError;
|
|
1661
|
+
|
|
1662
|
+
var anInstance$1 = function (it, Prototype) {
|
|
1663
|
+
if (isPrototypeOf$2(Prototype, it)) return it;
|
|
1664
|
+
throw $TypeError$6('Incorrect invocation');
|
|
1665
|
+
};
|
|
1666
|
+
|
|
1667
|
+
var wellKnownSymbol$a = wellKnownSymbol$i;
|
|
1668
|
+
|
|
1669
|
+
var TO_STRING_TAG$1 = wellKnownSymbol$a('toStringTag');
|
|
1670
|
+
var test = {};
|
|
1671
|
+
|
|
1672
|
+
test[TO_STRING_TAG$1] = 'z';
|
|
1673
|
+
|
|
1674
|
+
var toStringTagSupport = String(test) === '[object z]';
|
|
1675
|
+
|
|
1676
|
+
var TO_STRING_TAG_SUPPORT = toStringTagSupport;
|
|
1677
|
+
var isCallable$8 = isCallable$n;
|
|
1678
|
+
var classofRaw = classofRaw$1;
|
|
1679
|
+
var wellKnownSymbol$9 = wellKnownSymbol$i;
|
|
1680
|
+
|
|
1681
|
+
var TO_STRING_TAG = wellKnownSymbol$9('toStringTag');
|
|
1682
|
+
var $Object = Object;
|
|
1683
|
+
|
|
1684
|
+
// ES3 wrong here
|
|
1685
|
+
var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
|
|
1686
|
+
|
|
1687
|
+
// fallback for IE11 Script Access Denied error
|
|
1688
|
+
var tryGet = function (it, key) {
|
|
1689
|
+
try {
|
|
1690
|
+
return it[key];
|
|
1691
|
+
} catch (error) { /* empty */ }
|
|
1692
|
+
};
|
|
1693
|
+
|
|
1694
|
+
// getting tag from ES6+ `Object.prototype.toString`
|
|
1695
|
+
var classof$5 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
|
|
1696
|
+
var O, tag, result;
|
|
1697
|
+
return it === undefined ? 'Undefined' : it === null ? 'Null'
|
|
1698
|
+
// @@toStringTag case
|
|
1699
|
+
: typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
|
|
1700
|
+
// builtinTag case
|
|
1701
|
+
: CORRECT_ARGUMENTS ? classofRaw(O)
|
|
1702
|
+
// ES3 arguments fallback
|
|
1703
|
+
: (result = classofRaw(O)) == 'Object' && isCallable$8(O.callee) ? 'Arguments' : result;
|
|
1704
|
+
};
|
|
1705
|
+
|
|
1706
|
+
var uncurryThis$8 = functionUncurryThis;
|
|
1707
|
+
var fails$8 = fails$k;
|
|
1708
|
+
var isCallable$7 = isCallable$n;
|
|
1709
|
+
var classof$4 = classof$5;
|
|
1710
|
+
var getBuiltIn$3 = getBuiltIn$9;
|
|
1711
|
+
var inspectSource$1 = inspectSource$4;
|
|
1712
|
+
|
|
1713
|
+
var noop = function () { /* empty */ };
|
|
1714
|
+
var empty = [];
|
|
1715
|
+
var construct = getBuiltIn$3('Reflect', 'construct');
|
|
1716
|
+
var constructorRegExp = /^\s*(?:class|function)\b/;
|
|
1717
|
+
var exec$1 = uncurryThis$8(constructorRegExp.exec);
|
|
1718
|
+
var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
|
|
1719
|
+
|
|
1720
|
+
var isConstructorModern = function isConstructor(argument) {
|
|
1721
|
+
if (!isCallable$7(argument)) return false;
|
|
1722
|
+
try {
|
|
1723
|
+
construct(noop, empty, argument);
|
|
1724
|
+
return true;
|
|
1725
|
+
} catch (error) {
|
|
1726
|
+
return false;
|
|
1727
|
+
}
|
|
1728
|
+
};
|
|
1729
|
+
|
|
1730
|
+
var isConstructorLegacy = function isConstructor(argument) {
|
|
1731
|
+
if (!isCallable$7(argument)) return false;
|
|
1732
|
+
switch (classof$4(argument)) {
|
|
1733
|
+
case 'AsyncFunction':
|
|
1734
|
+
case 'GeneratorFunction':
|
|
1735
|
+
case 'AsyncGeneratorFunction': return false;
|
|
1736
|
+
}
|
|
1737
|
+
try {
|
|
1738
|
+
// we can't check .prototype since constructors produced by .bind haven't it
|
|
1739
|
+
// `Function#toString` throws on some built-it function in some legacy engines
|
|
1740
|
+
// (for example, `DOMQuad` and similar in FF41-)
|
|
1741
|
+
return INCORRECT_TO_STRING || !!exec$1(constructorRegExp, inspectSource$1(argument));
|
|
1742
|
+
} catch (error) {
|
|
1743
|
+
return true;
|
|
1744
|
+
}
|
|
1745
|
+
};
|
|
1746
|
+
|
|
1747
|
+
isConstructorLegacy.sham = true;
|
|
1748
|
+
|
|
1749
|
+
// `IsConstructor` abstract operation
|
|
1750
|
+
// https://tc39.es/ecma262/#sec-isconstructor
|
|
1751
|
+
var isConstructor$1 = !construct || fails$8(function () {
|
|
1752
|
+
var called;
|
|
1753
|
+
return isConstructorModern(isConstructorModern.call)
|
|
1754
|
+
|| !isConstructorModern(Object)
|
|
1755
|
+
|| !isConstructorModern(function () { called = true; })
|
|
1756
|
+
|| called;
|
|
1757
|
+
}) ? isConstructorLegacy : isConstructorModern;
|
|
1758
|
+
|
|
1759
|
+
var isConstructor = isConstructor$1;
|
|
1760
|
+
var tryToString$2 = tryToString$4;
|
|
1761
|
+
|
|
1762
|
+
var $TypeError$5 = TypeError;
|
|
1763
|
+
|
|
1764
|
+
// `Assert: IsConstructor(argument) is true`
|
|
1765
|
+
var aConstructor$1 = function (argument) {
|
|
1766
|
+
if (isConstructor(argument)) return argument;
|
|
1767
|
+
throw $TypeError$5(tryToString$2(argument) + ' is not a constructor');
|
|
1768
|
+
};
|
|
1769
|
+
|
|
1770
|
+
var anObject$9 = anObject$f;
|
|
1771
|
+
var aConstructor = aConstructor$1;
|
|
1772
|
+
var wellKnownSymbol$8 = wellKnownSymbol$i;
|
|
1773
|
+
|
|
1774
|
+
var SPECIES$2 = wellKnownSymbol$8('species');
|
|
1775
|
+
|
|
1776
|
+
// `SpeciesConstructor` abstract operation
|
|
1777
|
+
// https://tc39.es/ecma262/#sec-speciesconstructor
|
|
1778
|
+
var speciesConstructor$2 = function (O, defaultConstructor) {
|
|
1779
|
+
var C = anObject$9(O).constructor;
|
|
1780
|
+
var S;
|
|
1781
|
+
return C === undefined || (S = anObject$9(C)[SPECIES$2]) == undefined ? defaultConstructor : aConstructor(S);
|
|
1782
|
+
};
|
|
1783
|
+
|
|
1784
|
+
var NATIVE_BIND$1 = functionBindNative;
|
|
1785
|
+
|
|
1786
|
+
var FunctionPrototype = Function.prototype;
|
|
1787
|
+
var apply$2 = FunctionPrototype.apply;
|
|
1788
|
+
var call$c = FunctionPrototype.call;
|
|
1789
|
+
|
|
1790
|
+
// eslint-disable-next-line es-x/no-reflect -- safe
|
|
1791
|
+
var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$c.bind(apply$2) : function () {
|
|
1792
|
+
return call$c.apply(apply$2, arguments);
|
|
1793
|
+
});
|
|
1794
|
+
|
|
1795
|
+
var uncurryThis$7 = functionUncurryThis;
|
|
1796
|
+
var aCallable$5 = aCallable$7;
|
|
1797
|
+
var NATIVE_BIND = functionBindNative;
|
|
1798
|
+
|
|
1799
|
+
var bind$4 = uncurryThis$7(uncurryThis$7.bind);
|
|
1800
|
+
|
|
1801
|
+
// optional / simple context binding
|
|
1802
|
+
var functionBindContext = function (fn, that) {
|
|
1803
|
+
aCallable$5(fn);
|
|
1804
|
+
return that === undefined ? fn : NATIVE_BIND ? bind$4(fn, that) : function (/* ...args */) {
|
|
1805
|
+
return fn.apply(that, arguments);
|
|
1806
|
+
};
|
|
1807
|
+
};
|
|
1808
|
+
|
|
1809
|
+
var uncurryThis$6 = functionUncurryThis;
|
|
1810
|
+
|
|
1811
|
+
var arraySlice$1 = uncurryThis$6([].slice);
|
|
1812
|
+
|
|
1813
|
+
var $TypeError$4 = TypeError;
|
|
1814
|
+
|
|
1815
|
+
var validateArgumentsLength$1 = function (passed, required) {
|
|
1816
|
+
if (passed < required) throw $TypeError$4('Not enough arguments');
|
|
1817
|
+
return passed;
|
|
1818
|
+
};
|
|
1819
|
+
|
|
1820
|
+
var userAgent$2 = engineUserAgent;
|
|
1821
|
+
|
|
1822
|
+
var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
|
|
1823
|
+
|
|
1824
|
+
var global$a = global$m;
|
|
1825
|
+
var apply$1 = functionApply;
|
|
1826
|
+
var bind$3 = functionBindContext;
|
|
1827
|
+
var isCallable$6 = isCallable$n;
|
|
1828
|
+
var hasOwn$1 = hasOwnProperty_1;
|
|
1829
|
+
var fails$7 = fails$k;
|
|
1830
|
+
var html = html$2;
|
|
1831
|
+
var arraySlice = arraySlice$1;
|
|
1832
|
+
var createElement = documentCreateElement$2;
|
|
1833
|
+
var validateArgumentsLength = validateArgumentsLength$1;
|
|
1834
|
+
var IS_IOS$1 = engineIsIos;
|
|
1835
|
+
var IS_NODE$3 = engineIsNode;
|
|
1836
|
+
|
|
1837
|
+
var set = global$a.setImmediate;
|
|
1838
|
+
var clear = global$a.clearImmediate;
|
|
1839
|
+
var process$2 = global$a.process;
|
|
1840
|
+
var Dispatch = global$a.Dispatch;
|
|
1841
|
+
var Function$1 = global$a.Function;
|
|
1842
|
+
var MessageChannel = global$a.MessageChannel;
|
|
1843
|
+
var String$1 = global$a.String;
|
|
1844
|
+
var counter = 0;
|
|
1845
|
+
var queue$1 = {};
|
|
1846
|
+
var ONREADYSTATECHANGE = 'onreadystatechange';
|
|
1847
|
+
var location, defer, channel, port;
|
|
1848
|
+
|
|
1849
|
+
try {
|
|
1850
|
+
// Deno throws a ReferenceError on `location` access without `--location` flag
|
|
1851
|
+
location = global$a.location;
|
|
1852
|
+
} catch (error) { /* empty */ }
|
|
1853
|
+
|
|
1854
|
+
var run = function (id) {
|
|
1855
|
+
if (hasOwn$1(queue$1, id)) {
|
|
1856
|
+
var fn = queue$1[id];
|
|
1857
|
+
delete queue$1[id];
|
|
1858
|
+
fn();
|
|
1859
|
+
}
|
|
1860
|
+
};
|
|
1861
|
+
|
|
1862
|
+
var runner = function (id) {
|
|
1863
|
+
return function () {
|
|
1864
|
+
run(id);
|
|
1865
|
+
};
|
|
1866
|
+
};
|
|
1867
|
+
|
|
1868
|
+
var listener = function (event) {
|
|
1869
|
+
run(event.data);
|
|
1870
|
+
};
|
|
1871
|
+
|
|
1872
|
+
var post = function (id) {
|
|
1873
|
+
// old engines have not location.origin
|
|
1874
|
+
global$a.postMessage(String$1(id), location.protocol + '//' + location.host);
|
|
1875
|
+
};
|
|
1876
|
+
|
|
1877
|
+
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
|
|
1878
|
+
if (!set || !clear) {
|
|
1879
|
+
set = function setImmediate(handler) {
|
|
1880
|
+
validateArgumentsLength(arguments.length, 1);
|
|
1881
|
+
var fn = isCallable$6(handler) ? handler : Function$1(handler);
|
|
1882
|
+
var args = arraySlice(arguments, 1);
|
|
1883
|
+
queue$1[++counter] = function () {
|
|
1884
|
+
apply$1(fn, undefined, args);
|
|
1885
|
+
};
|
|
1886
|
+
defer(counter);
|
|
1887
|
+
return counter;
|
|
1888
|
+
};
|
|
1889
|
+
clear = function clearImmediate(id) {
|
|
1890
|
+
delete queue$1[id];
|
|
1891
|
+
};
|
|
1892
|
+
// Node.js 0.8-
|
|
1893
|
+
if (IS_NODE$3) {
|
|
1894
|
+
defer = function (id) {
|
|
1895
|
+
process$2.nextTick(runner(id));
|
|
1896
|
+
};
|
|
1897
|
+
// Sphere (JS game engine) Dispatch API
|
|
1898
|
+
} else if (Dispatch && Dispatch.now) {
|
|
1899
|
+
defer = function (id) {
|
|
1900
|
+
Dispatch.now(runner(id));
|
|
1901
|
+
};
|
|
1902
|
+
// Browsers with MessageChannel, includes WebWorkers
|
|
1903
|
+
// except iOS - https://github.com/zloirock/core-js/issues/624
|
|
1904
|
+
} else if (MessageChannel && !IS_IOS$1) {
|
|
1905
|
+
channel = new MessageChannel();
|
|
1906
|
+
port = channel.port2;
|
|
1907
|
+
channel.port1.onmessage = listener;
|
|
1908
|
+
defer = bind$3(port.postMessage, port);
|
|
1909
|
+
// Browsers with postMessage, skip WebWorkers
|
|
1910
|
+
// IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
|
|
1911
|
+
} else if (
|
|
1912
|
+
global$a.addEventListener &&
|
|
1913
|
+
isCallable$6(global$a.postMessage) &&
|
|
1914
|
+
!global$a.importScripts &&
|
|
1915
|
+
location && location.protocol !== 'file:' &&
|
|
1916
|
+
!fails$7(post)
|
|
1917
|
+
) {
|
|
1918
|
+
defer = post;
|
|
1919
|
+
global$a.addEventListener('message', listener, false);
|
|
1920
|
+
// IE8-
|
|
1921
|
+
} else if (ONREADYSTATECHANGE in createElement('script')) {
|
|
1922
|
+
defer = function (id) {
|
|
1923
|
+
html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
|
|
1924
|
+
html.removeChild(this);
|
|
1925
|
+
run(id);
|
|
1926
|
+
};
|
|
1927
|
+
};
|
|
1928
|
+
// Rest old browsers
|
|
1929
|
+
} else {
|
|
1930
|
+
defer = function (id) {
|
|
1931
|
+
setTimeout(runner(id), 0);
|
|
1932
|
+
};
|
|
1933
|
+
}
|
|
1934
|
+
}
|
|
1935
|
+
|
|
1936
|
+
var task$1 = {
|
|
1937
|
+
set: set,
|
|
1938
|
+
clear: clear
|
|
1939
|
+
};
|
|
1940
|
+
|
|
1941
|
+
var userAgent$1 = engineUserAgent;
|
|
1942
|
+
var global$9 = global$m;
|
|
1943
|
+
|
|
1944
|
+
var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$9.Pebble !== undefined;
|
|
1945
|
+
|
|
1946
|
+
var userAgent = engineUserAgent;
|
|
1947
|
+
|
|
1948
|
+
var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
|
|
1949
|
+
|
|
1950
|
+
var global$8 = global$m;
|
|
1951
|
+
var bind$2 = functionBindContext;
|
|
1952
|
+
var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
|
|
1953
|
+
var macrotask = task$1.set;
|
|
1954
|
+
var IS_IOS = engineIsIos;
|
|
1955
|
+
var IS_IOS_PEBBLE = engineIsIosPebble;
|
|
1956
|
+
var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
|
|
1957
|
+
var IS_NODE$2 = engineIsNode;
|
|
1958
|
+
|
|
1959
|
+
var MutationObserver = global$8.MutationObserver || global$8.WebKitMutationObserver;
|
|
1960
|
+
var document$2 = global$8.document;
|
|
1961
|
+
var process$1 = global$8.process;
|
|
1962
|
+
var Promise$1 = global$8.Promise;
|
|
1963
|
+
// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
|
|
1964
|
+
var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$8, 'queueMicrotask');
|
|
1965
|
+
var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
|
|
1966
|
+
|
|
1967
|
+
var flush, head, last, notify$1, toggle, node, promise, then;
|
|
1968
|
+
|
|
1969
|
+
// modern engines have queueMicrotask method
|
|
1970
|
+
if (!queueMicrotask) {
|
|
1971
|
+
flush = function () {
|
|
1972
|
+
var parent, fn;
|
|
1973
|
+
if (IS_NODE$2 && (parent = process$1.domain)) parent.exit();
|
|
1974
|
+
while (head) {
|
|
1975
|
+
fn = head.fn;
|
|
1976
|
+
head = head.next;
|
|
1977
|
+
try {
|
|
1978
|
+
fn();
|
|
1979
|
+
} catch (error) {
|
|
1980
|
+
if (head) notify$1();
|
|
1981
|
+
else last = undefined;
|
|
1982
|
+
throw error;
|
|
1983
|
+
}
|
|
1984
|
+
} last = undefined;
|
|
1985
|
+
if (parent) parent.enter();
|
|
1986
|
+
};
|
|
1987
|
+
|
|
1988
|
+
// browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
|
|
1989
|
+
// also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
|
|
1990
|
+
if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
|
|
1991
|
+
toggle = true;
|
|
1992
|
+
node = document$2.createTextNode('');
|
|
1993
|
+
new MutationObserver(flush).observe(node, { characterData: true });
|
|
1994
|
+
notify$1 = function () {
|
|
1995
|
+
node.data = toggle = !toggle;
|
|
1996
|
+
};
|
|
1997
|
+
// environments with maybe non-completely correct, but existent Promise
|
|
1998
|
+
} else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) {
|
|
1999
|
+
// Promise.resolve without an argument throws an error in LG WebOS 2
|
|
2000
|
+
promise = Promise$1.resolve(undefined);
|
|
2001
|
+
// workaround of WebKit ~ iOS Safari 10.1 bug
|
|
2002
|
+
promise.constructor = Promise$1;
|
|
2003
|
+
then = bind$2(promise.then, promise);
|
|
2004
|
+
notify$1 = function () {
|
|
2005
|
+
then(flush);
|
|
2006
|
+
};
|
|
2007
|
+
// Node.js without promises
|
|
2008
|
+
} else if (IS_NODE$2) {
|
|
2009
|
+
notify$1 = function () {
|
|
2010
|
+
process$1.nextTick(flush);
|
|
2011
|
+
};
|
|
2012
|
+
// for other environments - macrotask based on:
|
|
2013
|
+
// - setImmediate
|
|
2014
|
+
// - MessageChannel
|
|
2015
|
+
// - window.postMessage
|
|
2016
|
+
// - onreadystatechange
|
|
2017
|
+
// - setTimeout
|
|
2018
|
+
} else {
|
|
2019
|
+
// strange IE + webpack dev server bug - use .bind(global)
|
|
2020
|
+
macrotask = bind$2(macrotask, global$8);
|
|
2021
|
+
notify$1 = function () {
|
|
2022
|
+
macrotask(flush);
|
|
2023
|
+
};
|
|
2024
|
+
}
|
|
2025
|
+
}
|
|
2026
|
+
|
|
2027
|
+
var microtask$1 = queueMicrotask || function (fn) {
|
|
2028
|
+
var task = { fn: fn, next: undefined };
|
|
2029
|
+
if (last) last.next = task;
|
|
2030
|
+
if (!head) {
|
|
2031
|
+
head = task;
|
|
2032
|
+
notify$1();
|
|
2033
|
+
} last = task;
|
|
2034
|
+
};
|
|
2035
|
+
|
|
2036
|
+
var global$7 = global$m;
|
|
2037
|
+
|
|
2038
|
+
var hostReportErrors$1 = function (a, b) {
|
|
2039
|
+
var console = global$7.console;
|
|
2040
|
+
if (console && console.error) {
|
|
2041
|
+
arguments.length == 1 ? console.error(a) : console.error(a, b);
|
|
2042
|
+
}
|
|
2043
|
+
};
|
|
2044
|
+
|
|
2045
|
+
var perform$3 = function (exec) {
|
|
2046
|
+
try {
|
|
2047
|
+
return { error: false, value: exec() };
|
|
2048
|
+
} catch (error) {
|
|
2049
|
+
return { error: true, value: error };
|
|
2050
|
+
}
|
|
2051
|
+
};
|
|
2052
|
+
|
|
2053
|
+
var Queue$1 = function () {
|
|
2054
|
+
this.head = null;
|
|
2055
|
+
this.tail = null;
|
|
2056
|
+
};
|
|
2057
|
+
|
|
2058
|
+
Queue$1.prototype = {
|
|
2059
|
+
add: function (item) {
|
|
2060
|
+
var entry = { item: item, next: null };
|
|
2061
|
+
if (this.head) this.tail.next = entry;
|
|
2062
|
+
else this.head = entry;
|
|
2063
|
+
this.tail = entry;
|
|
2064
|
+
},
|
|
2065
|
+
get: function () {
|
|
2066
|
+
var entry = this.head;
|
|
2067
|
+
if (entry) {
|
|
2068
|
+
this.head = entry.next;
|
|
2069
|
+
if (this.tail === entry) this.tail = null;
|
|
2070
|
+
return entry.item;
|
|
2071
|
+
}
|
|
2072
|
+
}
|
|
2073
|
+
};
|
|
2074
|
+
|
|
2075
|
+
var queue = Queue$1;
|
|
2076
|
+
|
|
2077
|
+
var global$6 = global$m;
|
|
2078
|
+
|
|
2079
|
+
var promiseNativeConstructor = global$6.Promise;
|
|
2080
|
+
|
|
2081
|
+
/* global Deno -- Deno case */
|
|
2082
|
+
|
|
2083
|
+
var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
|
|
2084
|
+
|
|
2085
|
+
var IS_DENO$1 = engineIsDeno;
|
|
2086
|
+
var IS_NODE$1 = engineIsNode;
|
|
2087
|
+
|
|
2088
|
+
var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1
|
|
2089
|
+
&& typeof window == 'object'
|
|
2090
|
+
&& typeof document == 'object';
|
|
2091
|
+
|
|
2092
|
+
var global$5 = global$m;
|
|
2093
|
+
var NativePromiseConstructor$4 = promiseNativeConstructor;
|
|
2094
|
+
var isCallable$5 = isCallable$n;
|
|
2095
|
+
var isForced = isForced_1;
|
|
2096
|
+
var inspectSource = inspectSource$4;
|
|
2097
|
+
var wellKnownSymbol$7 = wellKnownSymbol$i;
|
|
2098
|
+
var IS_BROWSER = engineIsBrowser;
|
|
2099
|
+
var IS_DENO = engineIsDeno;
|
|
2100
|
+
var V8_VERSION = engineV8Version;
|
|
2101
|
+
|
|
2102
|
+
NativePromiseConstructor$4 && NativePromiseConstructor$4.prototype;
|
|
2103
|
+
var SPECIES$1 = wellKnownSymbol$7('species');
|
|
2104
|
+
var SUBCLASSING = false;
|
|
2105
|
+
var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$5(global$5.PromiseRejectionEvent);
|
|
2106
|
+
|
|
2107
|
+
var FORCED_PROMISE_CONSTRUCTOR$5 = isForced('Promise', function () {
|
|
2108
|
+
var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$4);
|
|
2109
|
+
var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$4);
|
|
2110
|
+
// V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
|
|
2111
|
+
// https://bugs.chromium.org/p/chromium/issues/detail?id=830565
|
|
2112
|
+
// We can't detect it synchronously, so just check versions
|
|
2113
|
+
if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
|
|
2114
|
+
// We can't use @@species feature detection in V8 since it causes
|
|
2115
|
+
// deoptimization and performance degradation
|
|
2116
|
+
// https://github.com/zloirock/core-js/issues/679
|
|
2117
|
+
if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
|
|
2118
|
+
// Detect correctness of subclassing with @@species support
|
|
2119
|
+
var promise = new NativePromiseConstructor$4(function (resolve) { resolve(1); });
|
|
2120
|
+
var FakePromise = function (exec) {
|
|
2121
|
+
exec(function () { /* empty */ }, function () { /* empty */ });
|
|
2122
|
+
};
|
|
2123
|
+
var constructor = promise.constructor = {};
|
|
2124
|
+
constructor[SPECIES$1] = FakePromise;
|
|
2125
|
+
SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
|
|
2126
|
+
if (!SUBCLASSING) return true;
|
|
2127
|
+
// Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
|
|
2128
|
+
} return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1;
|
|
2129
|
+
});
|
|
2130
|
+
|
|
2131
|
+
var promiseConstructorDetection = {
|
|
2132
|
+
CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5,
|
|
2133
|
+
REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1,
|
|
2134
|
+
SUBCLASSING: SUBCLASSING
|
|
2135
|
+
};
|
|
2136
|
+
|
|
2137
|
+
var newPromiseCapability$2 = {};
|
|
2138
|
+
|
|
2139
|
+
var aCallable$4 = aCallable$7;
|
|
2140
|
+
|
|
2141
|
+
var PromiseCapability = function (C) {
|
|
2142
|
+
var resolve, reject;
|
|
2143
|
+
this.promise = new C(function ($$resolve, $$reject) {
|
|
2144
|
+
if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
|
|
2145
|
+
resolve = $$resolve;
|
|
2146
|
+
reject = $$reject;
|
|
2147
|
+
});
|
|
2148
|
+
this.resolve = aCallable$4(resolve);
|
|
2149
|
+
this.reject = aCallable$4(reject);
|
|
2150
|
+
};
|
|
2151
|
+
|
|
2152
|
+
// `NewPromiseCapability` abstract operation
|
|
2153
|
+
// https://tc39.es/ecma262/#sec-newpromisecapability
|
|
2154
|
+
newPromiseCapability$2.f = function (C) {
|
|
2155
|
+
return new PromiseCapability(C);
|
|
2156
|
+
};
|
|
2157
|
+
|
|
2158
|
+
var $$8 = _export;
|
|
2159
|
+
var IS_NODE = engineIsNode;
|
|
2160
|
+
var global$4 = global$m;
|
|
2161
|
+
var call$b = functionCall;
|
|
2162
|
+
var defineBuiltIn$4 = defineBuiltIn$8;
|
|
2163
|
+
var setPrototypeOf = objectSetPrototypeOf;
|
|
2164
|
+
var setToStringTag = setToStringTag$3;
|
|
2165
|
+
var setSpecies = setSpecies$1;
|
|
2166
|
+
var aCallable$3 = aCallable$7;
|
|
2167
|
+
var isCallable$4 = isCallable$n;
|
|
2168
|
+
var isObject$2 = isObject$8;
|
|
2169
|
+
var anInstance = anInstance$1;
|
|
2170
|
+
var speciesConstructor$1 = speciesConstructor$2;
|
|
2171
|
+
var task = task$1.set;
|
|
2172
|
+
var microtask = microtask$1;
|
|
2173
|
+
var hostReportErrors = hostReportErrors$1;
|
|
2174
|
+
var perform$2 = perform$3;
|
|
2175
|
+
var Queue = queue;
|
|
2176
|
+
var InternalStateModule = internalState;
|
|
2177
|
+
var NativePromiseConstructor$3 = promiseNativeConstructor;
|
|
2178
|
+
var PromiseConstructorDetection = promiseConstructorDetection;
|
|
2179
|
+
var newPromiseCapabilityModule$3 = newPromiseCapability$2;
|
|
2180
|
+
|
|
2181
|
+
var PROMISE = 'Promise';
|
|
2182
|
+
var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR;
|
|
2183
|
+
var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
|
|
2184
|
+
var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
|
|
2185
|
+
var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
|
|
2186
|
+
var setInternalState = InternalStateModule.set;
|
|
2187
|
+
var NativePromisePrototype$2 = NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype;
|
|
2188
|
+
var PromiseConstructor = NativePromiseConstructor$3;
|
|
2189
|
+
var PromisePrototype = NativePromisePrototype$2;
|
|
2190
|
+
var TypeError$1 = global$4.TypeError;
|
|
2191
|
+
var document$1 = global$4.document;
|
|
2192
|
+
var process = global$4.process;
|
|
2193
|
+
var newPromiseCapability$1 = newPromiseCapabilityModule$3.f;
|
|
2194
|
+
var newGenericPromiseCapability = newPromiseCapability$1;
|
|
2195
|
+
|
|
2196
|
+
var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$4.dispatchEvent);
|
|
2197
|
+
var UNHANDLED_REJECTION = 'unhandledrejection';
|
|
2198
|
+
var REJECTION_HANDLED = 'rejectionhandled';
|
|
2199
|
+
var PENDING = 0;
|
|
2200
|
+
var FULFILLED = 1;
|
|
2201
|
+
var REJECTED = 2;
|
|
2202
|
+
var HANDLED = 1;
|
|
2203
|
+
var UNHANDLED = 2;
|
|
2204
|
+
|
|
2205
|
+
var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
|
|
2206
|
+
|
|
2207
|
+
// helpers
|
|
2208
|
+
var isThenable = function (it) {
|
|
2209
|
+
var then;
|
|
2210
|
+
return isObject$2(it) && isCallable$4(then = it.then) ? then : false;
|
|
2211
|
+
};
|
|
2212
|
+
|
|
2213
|
+
var callReaction = function (reaction, state) {
|
|
2214
|
+
var value = state.value;
|
|
2215
|
+
var ok = state.state == FULFILLED;
|
|
2216
|
+
var handler = ok ? reaction.ok : reaction.fail;
|
|
2217
|
+
var resolve = reaction.resolve;
|
|
2218
|
+
var reject = reaction.reject;
|
|
2219
|
+
var domain = reaction.domain;
|
|
2220
|
+
var result, then, exited;
|
|
2221
|
+
try {
|
|
2222
|
+
if (handler) {
|
|
2223
|
+
if (!ok) {
|
|
2224
|
+
if (state.rejection === UNHANDLED) onHandleUnhandled(state);
|
|
2225
|
+
state.rejection = HANDLED;
|
|
2226
|
+
}
|
|
2227
|
+
if (handler === true) result = value;
|
|
2228
|
+
else {
|
|
2229
|
+
if (domain) domain.enter();
|
|
2230
|
+
result = handler(value); // can throw
|
|
2231
|
+
if (domain) {
|
|
2232
|
+
domain.exit();
|
|
2233
|
+
exited = true;
|
|
2234
|
+
}
|
|
2235
|
+
}
|
|
2236
|
+
if (result === reaction.promise) {
|
|
2237
|
+
reject(TypeError$1('Promise-chain cycle'));
|
|
2238
|
+
} else if (then = isThenable(result)) {
|
|
2239
|
+
call$b(then, result, resolve, reject);
|
|
2240
|
+
} else resolve(result);
|
|
2241
|
+
} else reject(value);
|
|
2242
|
+
} catch (error) {
|
|
2243
|
+
if (domain && !exited) domain.exit();
|
|
2244
|
+
reject(error);
|
|
2245
|
+
}
|
|
2246
|
+
};
|
|
2247
|
+
|
|
2248
|
+
var notify = function (state, isReject) {
|
|
2249
|
+
if (state.notified) return;
|
|
2250
|
+
state.notified = true;
|
|
2251
|
+
microtask(function () {
|
|
2252
|
+
var reactions = state.reactions;
|
|
2253
|
+
var reaction;
|
|
2254
|
+
while (reaction = reactions.get()) {
|
|
2255
|
+
callReaction(reaction, state);
|
|
2256
|
+
}
|
|
2257
|
+
state.notified = false;
|
|
2258
|
+
if (isReject && !state.rejection) onUnhandled(state);
|
|
2259
|
+
});
|
|
2260
|
+
};
|
|
2261
|
+
|
|
2262
|
+
var dispatchEvent = function (name, promise, reason) {
|
|
2263
|
+
var event, handler;
|
|
2264
|
+
if (DISPATCH_EVENT) {
|
|
2265
|
+
event = document$1.createEvent('Event');
|
|
2266
|
+
event.promise = promise;
|
|
2267
|
+
event.reason = reason;
|
|
2268
|
+
event.initEvent(name, false, true);
|
|
2269
|
+
global$4.dispatchEvent(event);
|
|
2270
|
+
} else event = { promise: promise, reason: reason };
|
|
2271
|
+
if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$4['on' + name])) handler(event);
|
|
2272
|
+
else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
|
|
2273
|
+
};
|
|
2274
|
+
|
|
2275
|
+
var onUnhandled = function (state) {
|
|
2276
|
+
call$b(task, global$4, function () {
|
|
2277
|
+
var promise = state.facade;
|
|
2278
|
+
var value = state.value;
|
|
2279
|
+
var IS_UNHANDLED = isUnhandled(state);
|
|
2280
|
+
var result;
|
|
2281
|
+
if (IS_UNHANDLED) {
|
|
2282
|
+
result = perform$2(function () {
|
|
2283
|
+
if (IS_NODE) {
|
|
2284
|
+
process.emit('unhandledRejection', value, promise);
|
|
2285
|
+
} else dispatchEvent(UNHANDLED_REJECTION, promise, value);
|
|
2286
|
+
});
|
|
2287
|
+
// Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
|
|
2288
|
+
state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
|
|
2289
|
+
if (result.error) throw result.value;
|
|
2290
|
+
}
|
|
2291
|
+
});
|
|
2292
|
+
};
|
|
2293
|
+
|
|
2294
|
+
var isUnhandled = function (state) {
|
|
2295
|
+
return state.rejection !== HANDLED && !state.parent;
|
|
2296
|
+
};
|
|
2297
|
+
|
|
2298
|
+
var onHandleUnhandled = function (state) {
|
|
2299
|
+
call$b(task, global$4, function () {
|
|
2300
|
+
var promise = state.facade;
|
|
2301
|
+
if (IS_NODE) {
|
|
2302
|
+
process.emit('rejectionHandled', promise);
|
|
2303
|
+
} else dispatchEvent(REJECTION_HANDLED, promise, state.value);
|
|
2304
|
+
});
|
|
2305
|
+
};
|
|
2306
|
+
|
|
2307
|
+
var bind$1 = function (fn, state, unwrap) {
|
|
2308
|
+
return function (value) {
|
|
2309
|
+
fn(state, value, unwrap);
|
|
2310
|
+
};
|
|
2311
|
+
};
|
|
2312
|
+
|
|
2313
|
+
var internalReject = function (state, value, unwrap) {
|
|
2314
|
+
if (state.done) return;
|
|
2315
|
+
state.done = true;
|
|
2316
|
+
if (unwrap) state = unwrap;
|
|
2317
|
+
state.value = value;
|
|
2318
|
+
state.state = REJECTED;
|
|
2319
|
+
notify(state, true);
|
|
2320
|
+
};
|
|
2321
|
+
|
|
2322
|
+
var internalResolve = function (state, value, unwrap) {
|
|
2323
|
+
if (state.done) return;
|
|
2324
|
+
state.done = true;
|
|
2325
|
+
if (unwrap) state = unwrap;
|
|
2326
|
+
try {
|
|
2327
|
+
if (state.facade === value) throw TypeError$1("Promise can't be resolved itself");
|
|
2328
|
+
var then = isThenable(value);
|
|
2329
|
+
if (then) {
|
|
2330
|
+
microtask(function () {
|
|
2331
|
+
var wrapper = { done: false };
|
|
2332
|
+
try {
|
|
2333
|
+
call$b(then, value,
|
|
2334
|
+
bind$1(internalResolve, wrapper, state),
|
|
2335
|
+
bind$1(internalReject, wrapper, state)
|
|
2336
|
+
);
|
|
2337
|
+
} catch (error) {
|
|
2338
|
+
internalReject(wrapper, error, state);
|
|
2339
|
+
}
|
|
2340
|
+
});
|
|
2341
|
+
} else {
|
|
2342
|
+
state.value = value;
|
|
2343
|
+
state.state = FULFILLED;
|
|
2344
|
+
notify(state, false);
|
|
2345
|
+
}
|
|
2346
|
+
} catch (error) {
|
|
2347
|
+
internalReject({ done: false }, error, state);
|
|
2348
|
+
}
|
|
2349
|
+
};
|
|
2350
|
+
|
|
2351
|
+
// constructor polyfill
|
|
2352
|
+
if (FORCED_PROMISE_CONSTRUCTOR$4) {
|
|
2353
|
+
// 25.4.3.1 Promise(executor)
|
|
2354
|
+
PromiseConstructor = function Promise(executor) {
|
|
2355
|
+
anInstance(this, PromisePrototype);
|
|
2356
|
+
aCallable$3(executor);
|
|
2357
|
+
call$b(Internal, this);
|
|
2358
|
+
var state = getInternalPromiseState(this);
|
|
2359
|
+
try {
|
|
2360
|
+
executor(bind$1(internalResolve, state), bind$1(internalReject, state));
|
|
2361
|
+
} catch (error) {
|
|
2362
|
+
internalReject(state, error);
|
|
2363
|
+
}
|
|
2364
|
+
};
|
|
2365
|
+
|
|
2366
|
+
PromisePrototype = PromiseConstructor.prototype;
|
|
2367
|
+
|
|
2368
|
+
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
2369
|
+
Internal = function Promise(executor) {
|
|
2370
|
+
setInternalState(this, {
|
|
2371
|
+
type: PROMISE,
|
|
2372
|
+
done: false,
|
|
2373
|
+
notified: false,
|
|
2374
|
+
parent: false,
|
|
2375
|
+
reactions: new Queue(),
|
|
2376
|
+
rejection: false,
|
|
2377
|
+
state: PENDING,
|
|
2378
|
+
value: undefined
|
|
2379
|
+
});
|
|
2380
|
+
};
|
|
2381
|
+
|
|
2382
|
+
// `Promise.prototype.then` method
|
|
2383
|
+
// https://tc39.es/ecma262/#sec-promise.prototype.then
|
|
2384
|
+
Internal.prototype = defineBuiltIn$4(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
|
|
2385
|
+
var state = getInternalPromiseState(this);
|
|
2386
|
+
var reaction = newPromiseCapability$1(speciesConstructor$1(this, PromiseConstructor));
|
|
2387
|
+
state.parent = true;
|
|
2388
|
+
reaction.ok = isCallable$4(onFulfilled) ? onFulfilled : true;
|
|
2389
|
+
reaction.fail = isCallable$4(onRejected) && onRejected;
|
|
2390
|
+
reaction.domain = IS_NODE ? process.domain : undefined;
|
|
2391
|
+
if (state.state == PENDING) state.reactions.add(reaction);
|
|
2392
|
+
else microtask(function () {
|
|
2393
|
+
callReaction(reaction, state);
|
|
2394
|
+
});
|
|
2395
|
+
return reaction.promise;
|
|
2396
|
+
});
|
|
2397
|
+
|
|
2398
|
+
OwnPromiseCapability = function () {
|
|
2399
|
+
var promise = new Internal();
|
|
2400
|
+
var state = getInternalPromiseState(promise);
|
|
2401
|
+
this.promise = promise;
|
|
2402
|
+
this.resolve = bind$1(internalResolve, state);
|
|
2403
|
+
this.reject = bind$1(internalReject, state);
|
|
2404
|
+
};
|
|
2405
|
+
|
|
2406
|
+
newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) {
|
|
2407
|
+
return C === PromiseConstructor || C === PromiseWrapper
|
|
2408
|
+
? new OwnPromiseCapability(C)
|
|
2409
|
+
: newGenericPromiseCapability(C);
|
|
2410
|
+
};
|
|
2411
|
+
|
|
2412
|
+
if (isCallable$4(NativePromiseConstructor$3) && NativePromisePrototype$2 !== Object.prototype) {
|
|
2413
|
+
nativeThen = NativePromisePrototype$2.then;
|
|
2414
|
+
|
|
2415
|
+
if (!NATIVE_PROMISE_SUBCLASSING) {
|
|
2416
|
+
// make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
|
|
2417
|
+
defineBuiltIn$4(NativePromisePrototype$2, 'then', function then(onFulfilled, onRejected) {
|
|
2418
|
+
var that = this;
|
|
2419
|
+
return new PromiseConstructor(function (resolve, reject) {
|
|
2420
|
+
call$b(nativeThen, that, resolve, reject);
|
|
2421
|
+
}).then(onFulfilled, onRejected);
|
|
2422
|
+
// https://github.com/zloirock/core-js/issues/640
|
|
2423
|
+
}, { unsafe: true });
|
|
2424
|
+
}
|
|
2425
|
+
|
|
2426
|
+
// make `.constructor === Promise` work for native promise-based APIs
|
|
2427
|
+
try {
|
|
2428
|
+
delete NativePromisePrototype$2.constructor;
|
|
2429
|
+
} catch (error) { /* empty */ }
|
|
2430
|
+
|
|
2431
|
+
// make `instanceof Promise` work for native promise-based APIs
|
|
2432
|
+
if (setPrototypeOf) {
|
|
2433
|
+
setPrototypeOf(NativePromisePrototype$2, PromisePrototype);
|
|
2434
|
+
}
|
|
2435
|
+
}
|
|
2436
|
+
}
|
|
2437
|
+
|
|
2438
|
+
$$8({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
|
|
2439
|
+
Promise: PromiseConstructor
|
|
2440
|
+
});
|
|
2441
|
+
|
|
2442
|
+
setToStringTag(PromiseConstructor, PROMISE, false);
|
|
2443
|
+
setSpecies(PROMISE);
|
|
2444
|
+
|
|
2445
|
+
var wellKnownSymbol$6 = wellKnownSymbol$i;
|
|
2446
|
+
var Iterators$1 = iterators;
|
|
2447
|
+
|
|
2448
|
+
var ITERATOR$2 = wellKnownSymbol$6('iterator');
|
|
2449
|
+
var ArrayPrototype = Array.prototype;
|
|
2450
|
+
|
|
2451
|
+
// check on default Array iterator
|
|
2452
|
+
var isArrayIteratorMethod$1 = function (it) {
|
|
2453
|
+
return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it);
|
|
2454
|
+
};
|
|
2455
|
+
|
|
2456
|
+
var classof$3 = classof$5;
|
|
2457
|
+
var getMethod$3 = getMethod$5;
|
|
2458
|
+
var Iterators = iterators;
|
|
2459
|
+
var wellKnownSymbol$5 = wellKnownSymbol$i;
|
|
2460
|
+
|
|
2461
|
+
var ITERATOR$1 = wellKnownSymbol$5('iterator');
|
|
2462
|
+
|
|
2463
|
+
var getIteratorMethod$2 = function (it) {
|
|
2464
|
+
if (it != undefined) return getMethod$3(it, ITERATOR$1)
|
|
2465
|
+
|| getMethod$3(it, '@@iterator')
|
|
2466
|
+
|| Iterators[classof$3(it)];
|
|
2467
|
+
};
|
|
2468
|
+
|
|
2469
|
+
var call$a = functionCall;
|
|
2470
|
+
var aCallable$2 = aCallable$7;
|
|
2471
|
+
var anObject$8 = anObject$f;
|
|
2472
|
+
var tryToString$1 = tryToString$4;
|
|
2473
|
+
var getIteratorMethod$1 = getIteratorMethod$2;
|
|
2474
|
+
|
|
2475
|
+
var $TypeError$3 = TypeError;
|
|
2476
|
+
|
|
2477
|
+
var getIterator$1 = function (argument, usingIterator) {
|
|
2478
|
+
var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
|
|
2479
|
+
if (aCallable$2(iteratorMethod)) return anObject$8(call$a(iteratorMethod, argument));
|
|
2480
|
+
throw $TypeError$3(tryToString$1(argument) + ' is not iterable');
|
|
2481
|
+
};
|
|
2482
|
+
|
|
2483
|
+
var call$9 = functionCall;
|
|
2484
|
+
var anObject$7 = anObject$f;
|
|
2485
|
+
var getMethod$2 = getMethod$5;
|
|
2486
|
+
|
|
2487
|
+
var iteratorClose$1 = function (iterator, kind, value) {
|
|
2488
|
+
var innerResult, innerError;
|
|
2489
|
+
anObject$7(iterator);
|
|
2490
|
+
try {
|
|
2491
|
+
innerResult = getMethod$2(iterator, 'return');
|
|
2492
|
+
if (!innerResult) {
|
|
2493
|
+
if (kind === 'throw') throw value;
|
|
2494
|
+
return value;
|
|
2495
|
+
}
|
|
2496
|
+
innerResult = call$9(innerResult, iterator);
|
|
2497
|
+
} catch (error) {
|
|
2498
|
+
innerError = true;
|
|
2499
|
+
innerResult = error;
|
|
2500
|
+
}
|
|
2501
|
+
if (kind === 'throw') throw value;
|
|
2502
|
+
if (innerError) throw innerResult;
|
|
2503
|
+
anObject$7(innerResult);
|
|
2504
|
+
return value;
|
|
2505
|
+
};
|
|
2506
|
+
|
|
2507
|
+
var bind = functionBindContext;
|
|
2508
|
+
var call$8 = functionCall;
|
|
2509
|
+
var anObject$6 = anObject$f;
|
|
2510
|
+
var tryToString = tryToString$4;
|
|
2511
|
+
var isArrayIteratorMethod = isArrayIteratorMethod$1;
|
|
2512
|
+
var lengthOfArrayLike = lengthOfArrayLike$2;
|
|
2513
|
+
var isPrototypeOf$1 = objectIsPrototypeOf;
|
|
2514
|
+
var getIterator = getIterator$1;
|
|
2515
|
+
var getIteratorMethod = getIteratorMethod$2;
|
|
2516
|
+
var iteratorClose = iteratorClose$1;
|
|
2517
|
+
|
|
2518
|
+
var $TypeError$2 = TypeError;
|
|
2519
|
+
|
|
2520
|
+
var Result = function (stopped, result) {
|
|
2521
|
+
this.stopped = stopped;
|
|
2522
|
+
this.result = result;
|
|
2523
|
+
};
|
|
2524
|
+
|
|
2525
|
+
var ResultPrototype = Result.prototype;
|
|
2526
|
+
|
|
2527
|
+
var iterate$2 = function (iterable, unboundFunction, options) {
|
|
2528
|
+
var that = options && options.that;
|
|
2529
|
+
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
|
|
2530
|
+
var IS_RECORD = !!(options && options.IS_RECORD);
|
|
2531
|
+
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
|
|
2532
|
+
var INTERRUPTED = !!(options && options.INTERRUPTED);
|
|
2533
|
+
var fn = bind(unboundFunction, that);
|
|
2534
|
+
var iterator, iterFn, index, length, result, next, step;
|
|
2535
|
+
|
|
2536
|
+
var stop = function (condition) {
|
|
2537
|
+
if (iterator) iteratorClose(iterator, 'normal', condition);
|
|
2538
|
+
return new Result(true, condition);
|
|
2539
|
+
};
|
|
2540
|
+
|
|
2541
|
+
var callFn = function (value) {
|
|
2542
|
+
if (AS_ENTRIES) {
|
|
2543
|
+
anObject$6(value);
|
|
2544
|
+
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
|
|
2545
|
+
} return INTERRUPTED ? fn(value, stop) : fn(value);
|
|
2546
|
+
};
|
|
2547
|
+
|
|
2548
|
+
if (IS_RECORD) {
|
|
2549
|
+
iterator = iterable.iterator;
|
|
2550
|
+
} else if (IS_ITERATOR) {
|
|
2551
|
+
iterator = iterable;
|
|
2552
|
+
} else {
|
|
2553
|
+
iterFn = getIteratorMethod(iterable);
|
|
2554
|
+
if (!iterFn) throw $TypeError$2(tryToString(iterable) + ' is not iterable');
|
|
2555
|
+
// optimisation for array iterators
|
|
2556
|
+
if (isArrayIteratorMethod(iterFn)) {
|
|
2557
|
+
for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
|
|
2558
|
+
result = callFn(iterable[index]);
|
|
2559
|
+
if (result && isPrototypeOf$1(ResultPrototype, result)) return result;
|
|
2560
|
+
} return new Result(false);
|
|
2561
|
+
}
|
|
2562
|
+
iterator = getIterator(iterable, iterFn);
|
|
2563
|
+
}
|
|
2564
|
+
|
|
2565
|
+
next = IS_RECORD ? iterable.next : iterator.next;
|
|
2566
|
+
while (!(step = call$8(next, iterator)).done) {
|
|
2567
|
+
try {
|
|
2568
|
+
result = callFn(step.value);
|
|
2569
|
+
} catch (error) {
|
|
2570
|
+
iteratorClose(iterator, 'throw', error);
|
|
2571
|
+
}
|
|
2572
|
+
if (typeof result == 'object' && result && isPrototypeOf$1(ResultPrototype, result)) return result;
|
|
2573
|
+
} return new Result(false);
|
|
2574
|
+
};
|
|
2575
|
+
|
|
2576
|
+
var wellKnownSymbol$4 = wellKnownSymbol$i;
|
|
2577
|
+
|
|
2578
|
+
var ITERATOR = wellKnownSymbol$4('iterator');
|
|
2579
|
+
var SAFE_CLOSING = false;
|
|
2580
|
+
|
|
2581
|
+
try {
|
|
2582
|
+
var called = 0;
|
|
2583
|
+
var iteratorWithReturn = {
|
|
2584
|
+
next: function () {
|
|
2585
|
+
return { done: !!called++ };
|
|
2586
|
+
},
|
|
2587
|
+
'return': function () {
|
|
2588
|
+
SAFE_CLOSING = true;
|
|
2589
|
+
}
|
|
2590
|
+
};
|
|
2591
|
+
iteratorWithReturn[ITERATOR] = function () {
|
|
2592
|
+
return this;
|
|
2593
|
+
};
|
|
2594
|
+
// eslint-disable-next-line es-x/no-array-from, no-throw-literal -- required for testing
|
|
2595
|
+
Array.from(iteratorWithReturn, function () { throw 2; });
|
|
2596
|
+
} catch (error) { /* empty */ }
|
|
2597
|
+
|
|
2598
|
+
var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
|
|
2599
|
+
if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
|
|
2600
|
+
var ITERATION_SUPPORT = false;
|
|
2601
|
+
try {
|
|
2602
|
+
var object = {};
|
|
2603
|
+
object[ITERATOR] = function () {
|
|
2604
|
+
return {
|
|
2605
|
+
next: function () {
|
|
2606
|
+
return { done: ITERATION_SUPPORT = true };
|
|
2607
|
+
}
|
|
2608
|
+
};
|
|
2609
|
+
};
|
|
2610
|
+
exec(object);
|
|
2611
|
+
} catch (error) { /* empty */ }
|
|
2612
|
+
return ITERATION_SUPPORT;
|
|
2613
|
+
};
|
|
2614
|
+
|
|
2615
|
+
var NativePromiseConstructor$2 = promiseNativeConstructor;
|
|
2616
|
+
var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
|
|
2617
|
+
var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR;
|
|
2618
|
+
|
|
2619
|
+
var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration(function (iterable) {
|
|
2620
|
+
NativePromiseConstructor$2.all(iterable).then(undefined, function () { /* empty */ });
|
|
2621
|
+
});
|
|
2622
|
+
|
|
2623
|
+
var $$7 = _export;
|
|
2624
|
+
var call$7 = functionCall;
|
|
2625
|
+
var aCallable$1 = aCallable$7;
|
|
2626
|
+
var newPromiseCapabilityModule$2 = newPromiseCapability$2;
|
|
2627
|
+
var perform$1 = perform$3;
|
|
2628
|
+
var iterate$1 = iterate$2;
|
|
2629
|
+
var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration;
|
|
2630
|
+
|
|
2631
|
+
// `Promise.all` method
|
|
2632
|
+
// https://tc39.es/ecma262/#sec-promise.all
|
|
2633
|
+
$$7({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
|
|
2634
|
+
all: function all(iterable) {
|
|
2635
|
+
var C = this;
|
|
2636
|
+
var capability = newPromiseCapabilityModule$2.f(C);
|
|
2637
|
+
var resolve = capability.resolve;
|
|
2638
|
+
var reject = capability.reject;
|
|
2639
|
+
var result = perform$1(function () {
|
|
2640
|
+
var $promiseResolve = aCallable$1(C.resolve);
|
|
2641
|
+
var values = [];
|
|
2642
|
+
var counter = 0;
|
|
2643
|
+
var remaining = 1;
|
|
2644
|
+
iterate$1(iterable, function (promise) {
|
|
2645
|
+
var index = counter++;
|
|
2646
|
+
var alreadyCalled = false;
|
|
2647
|
+
remaining++;
|
|
2648
|
+
call$7($promiseResolve, C, promise).then(function (value) {
|
|
2649
|
+
if (alreadyCalled) return;
|
|
2650
|
+
alreadyCalled = true;
|
|
2651
|
+
values[index] = value;
|
|
2652
|
+
--remaining || resolve(values);
|
|
2653
|
+
}, reject);
|
|
2654
|
+
});
|
|
2655
|
+
--remaining || resolve(values);
|
|
2656
|
+
});
|
|
2657
|
+
if (result.error) reject(result.value);
|
|
2658
|
+
return capability.promise;
|
|
2659
|
+
}
|
|
2660
|
+
});
|
|
2661
|
+
|
|
2662
|
+
var $$6 = _export;
|
|
2663
|
+
var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
|
|
2664
|
+
var NativePromiseConstructor$1 = promiseNativeConstructor;
|
|
2665
|
+
var getBuiltIn$2 = getBuiltIn$9;
|
|
2666
|
+
var isCallable$3 = isCallable$n;
|
|
2667
|
+
var defineBuiltIn$3 = defineBuiltIn$8;
|
|
2668
|
+
|
|
2669
|
+
var NativePromisePrototype$1 = NativePromiseConstructor$1 && NativePromiseConstructor$1.prototype;
|
|
2670
|
+
|
|
2671
|
+
// `Promise.prototype.catch` method
|
|
2672
|
+
// https://tc39.es/ecma262/#sec-promise.prototype.catch
|
|
2673
|
+
$$6({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
|
|
2674
|
+
'catch': function (onRejected) {
|
|
2675
|
+
return this.then(undefined, onRejected);
|
|
2676
|
+
}
|
|
2677
|
+
});
|
|
2678
|
+
|
|
2679
|
+
// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
|
|
2680
|
+
if (isCallable$3(NativePromiseConstructor$1)) {
|
|
2681
|
+
var method$1 = getBuiltIn$2('Promise').prototype['catch'];
|
|
2682
|
+
if (NativePromisePrototype$1['catch'] !== method$1) {
|
|
2683
|
+
defineBuiltIn$3(NativePromisePrototype$1, 'catch', method$1, { unsafe: true });
|
|
2684
|
+
}
|
|
2685
|
+
}
|
|
2686
|
+
|
|
2687
|
+
var $$5 = _export;
|
|
2688
|
+
var call$6 = functionCall;
|
|
2689
|
+
var aCallable = aCallable$7;
|
|
2690
|
+
var newPromiseCapabilityModule$1 = newPromiseCapability$2;
|
|
2691
|
+
var perform = perform$3;
|
|
2692
|
+
var iterate = iterate$2;
|
|
2693
|
+
var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration;
|
|
2694
|
+
|
|
2695
|
+
// `Promise.race` method
|
|
2696
|
+
// https://tc39.es/ecma262/#sec-promise.race
|
|
2697
|
+
$$5({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
|
|
2698
|
+
race: function race(iterable) {
|
|
2699
|
+
var C = this;
|
|
2700
|
+
var capability = newPromiseCapabilityModule$1.f(C);
|
|
2701
|
+
var reject = capability.reject;
|
|
2702
|
+
var result = perform(function () {
|
|
2703
|
+
var $promiseResolve = aCallable(C.resolve);
|
|
2704
|
+
iterate(iterable, function (promise) {
|
|
2705
|
+
call$6($promiseResolve, C, promise).then(capability.resolve, reject);
|
|
2706
|
+
});
|
|
2707
|
+
});
|
|
2708
|
+
if (result.error) reject(result.value);
|
|
2709
|
+
return capability.promise;
|
|
2710
|
+
}
|
|
2711
|
+
});
|
|
2712
|
+
|
|
2713
|
+
var $$4 = _export;
|
|
2714
|
+
var call$5 = functionCall;
|
|
2715
|
+
var newPromiseCapabilityModule = newPromiseCapability$2;
|
|
2716
|
+
var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
|
|
2717
|
+
|
|
2718
|
+
// `Promise.reject` method
|
|
2719
|
+
// https://tc39.es/ecma262/#sec-promise.reject
|
|
2720
|
+
$$4({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
|
|
2721
|
+
reject: function reject(r) {
|
|
2722
|
+
var capability = newPromiseCapabilityModule.f(this);
|
|
2723
|
+
call$5(capability.reject, undefined, r);
|
|
2724
|
+
return capability.promise;
|
|
2725
|
+
}
|
|
2726
|
+
});
|
|
2727
|
+
|
|
2728
|
+
var anObject$5 = anObject$f;
|
|
2729
|
+
var isObject$1 = isObject$8;
|
|
2730
|
+
var newPromiseCapability = newPromiseCapability$2;
|
|
2731
|
+
|
|
2732
|
+
var promiseResolve$2 = function (C, x) {
|
|
2733
|
+
anObject$5(C);
|
|
2734
|
+
if (isObject$1(x) && x.constructor === C) return x;
|
|
2735
|
+
var promiseCapability = newPromiseCapability.f(C);
|
|
2736
|
+
var resolve = promiseCapability.resolve;
|
|
2737
|
+
resolve(x);
|
|
2738
|
+
return promiseCapability.promise;
|
|
2739
|
+
};
|
|
2740
|
+
|
|
2741
|
+
var $$3 = _export;
|
|
2742
|
+
var getBuiltIn$1 = getBuiltIn$9;
|
|
2743
|
+
var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR;
|
|
2744
|
+
var promiseResolve$1 = promiseResolve$2;
|
|
2745
|
+
|
|
2746
|
+
getBuiltIn$1('Promise');
|
|
2747
|
+
|
|
2748
|
+
// `Promise.resolve` method
|
|
2749
|
+
// https://tc39.es/ecma262/#sec-promise.resolve
|
|
2750
|
+
$$3({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
|
|
2751
|
+
resolve: function resolve(x) {
|
|
2752
|
+
return promiseResolve$1(this, x);
|
|
2753
|
+
}
|
|
2754
|
+
});
|
|
2755
|
+
|
|
2756
|
+
var $$2 = _export;
|
|
2757
|
+
var NativePromiseConstructor = promiseNativeConstructor;
|
|
2758
|
+
var fails$6 = fails$k;
|
|
2759
|
+
var getBuiltIn = getBuiltIn$9;
|
|
2760
|
+
var isCallable$2 = isCallable$n;
|
|
2761
|
+
var speciesConstructor = speciesConstructor$2;
|
|
2762
|
+
var promiseResolve = promiseResolve$2;
|
|
2763
|
+
var defineBuiltIn$2 = defineBuiltIn$8;
|
|
2764
|
+
|
|
2765
|
+
var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
|
|
2766
|
+
|
|
2767
|
+
// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829
|
|
2768
|
+
var NON_GENERIC = !!NativePromiseConstructor && fails$6(function () {
|
|
2769
|
+
// eslint-disable-next-line unicorn/no-thenable -- required for testing
|
|
2770
|
+
NativePromisePrototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });
|
|
2771
|
+
});
|
|
2772
|
+
|
|
2773
|
+
// `Promise.prototype.finally` method
|
|
2774
|
+
// https://tc39.es/ecma262/#sec-promise.prototype.finally
|
|
2775
|
+
$$2({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {
|
|
2776
|
+
'finally': function (onFinally) {
|
|
2777
|
+
var C = speciesConstructor(this, getBuiltIn('Promise'));
|
|
2778
|
+
var isFunction = isCallable$2(onFinally);
|
|
2779
|
+
return this.then(
|
|
2780
|
+
isFunction ? function (x) {
|
|
2781
|
+
return promiseResolve(C, onFinally()).then(function () { return x; });
|
|
2782
|
+
} : onFinally,
|
|
2783
|
+
isFunction ? function (e) {
|
|
2784
|
+
return promiseResolve(C, onFinally()).then(function () { throw e; });
|
|
2785
|
+
} : onFinally
|
|
2786
|
+
);
|
|
2787
|
+
}
|
|
2788
|
+
});
|
|
2789
|
+
|
|
2790
|
+
// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`
|
|
2791
|
+
if (isCallable$2(NativePromiseConstructor)) {
|
|
2792
|
+
var method = getBuiltIn('Promise').prototype['finally'];
|
|
2793
|
+
if (NativePromisePrototype['finally'] !== method) {
|
|
2794
|
+
defineBuiltIn$2(NativePromisePrototype, 'finally', method, { unsafe: true });
|
|
2795
|
+
}
|
|
2796
|
+
}
|
|
2797
|
+
|
|
2798
|
+
var isObject = isObject$8;
|
|
2799
|
+
var classof$2 = classofRaw$1;
|
|
2800
|
+
var wellKnownSymbol$3 = wellKnownSymbol$i;
|
|
2801
|
+
|
|
2802
|
+
var MATCH$1 = wellKnownSymbol$3('match');
|
|
2803
|
+
|
|
2804
|
+
// `IsRegExp` abstract operation
|
|
2805
|
+
// https://tc39.es/ecma262/#sec-isregexp
|
|
2806
|
+
var isRegexp = function (it) {
|
|
2807
|
+
var isRegExp;
|
|
2808
|
+
return isObject(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$2(it) == 'RegExp');
|
|
2809
|
+
};
|
|
2810
|
+
|
|
2811
|
+
var isRegExp = isRegexp;
|
|
2812
|
+
|
|
2813
|
+
var $TypeError$1 = TypeError;
|
|
2814
|
+
|
|
2815
|
+
var notARegexp = function (it) {
|
|
2816
|
+
if (isRegExp(it)) {
|
|
2817
|
+
throw $TypeError$1("The method doesn't accept regular expressions");
|
|
2818
|
+
} return it;
|
|
2819
|
+
};
|
|
2820
|
+
|
|
2821
|
+
var classof$1 = classof$5;
|
|
2822
|
+
|
|
2823
|
+
var $String = String;
|
|
2824
|
+
|
|
2825
|
+
var toString$5 = function (argument) {
|
|
2826
|
+
if (classof$1(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
|
|
2827
|
+
return $String(argument);
|
|
2828
|
+
};
|
|
2829
|
+
|
|
2830
|
+
var wellKnownSymbol$2 = wellKnownSymbol$i;
|
|
2831
|
+
|
|
2832
|
+
var MATCH = wellKnownSymbol$2('match');
|
|
2833
|
+
|
|
2834
|
+
var correctIsRegexpLogic = function (METHOD_NAME) {
|
|
2835
|
+
var regexp = /./;
|
|
2836
|
+
try {
|
|
2837
|
+
'/./'[METHOD_NAME](regexp);
|
|
2838
|
+
} catch (error1) {
|
|
2839
|
+
try {
|
|
2840
|
+
regexp[MATCH] = false;
|
|
2841
|
+
return '/./'[METHOD_NAME](regexp);
|
|
2842
|
+
} catch (error2) { /* empty */ }
|
|
2843
|
+
} return false;
|
|
2844
|
+
};
|
|
2845
|
+
|
|
2846
|
+
var $$1 = _export;
|
|
2847
|
+
var uncurryThis$5 = functionUncurryThis;
|
|
2848
|
+
var notARegExp = notARegexp;
|
|
2849
|
+
var requireObjectCoercible$3 = requireObjectCoercible$6;
|
|
2850
|
+
var toString$4 = toString$5;
|
|
2851
|
+
var correctIsRegExpLogic = correctIsRegexpLogic;
|
|
2852
|
+
|
|
2853
|
+
var stringIndexOf$1 = uncurryThis$5(''.indexOf);
|
|
2854
|
+
|
|
2855
|
+
// `String.prototype.includes` method
|
|
2856
|
+
// https://tc39.es/ecma262/#sec-string.prototype.includes
|
|
2857
|
+
$$1({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {
|
|
2858
|
+
includes: function includes(searchString /* , position = 0 */) {
|
|
2859
|
+
return !!~stringIndexOf$1(
|
|
2860
|
+
toString$4(requireObjectCoercible$3(this)),
|
|
2861
|
+
toString$4(notARegExp(searchString)),
|
|
2862
|
+
arguments.length > 1 ? arguments[1] : undefined
|
|
2863
|
+
);
|
|
2864
|
+
}
|
|
2865
|
+
});
|
|
2866
|
+
|
|
2867
|
+
var anObject$4 = anObject$f;
|
|
2868
|
+
|
|
2869
|
+
// `RegExp.prototype.flags` getter implementation
|
|
2870
|
+
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
|
|
2871
|
+
var regexpFlags$1 = function () {
|
|
2872
|
+
var that = anObject$4(this);
|
|
2873
|
+
var result = '';
|
|
2874
|
+
if (that.hasIndices) result += 'd';
|
|
2875
|
+
if (that.global) result += 'g';
|
|
2876
|
+
if (that.ignoreCase) result += 'i';
|
|
2877
|
+
if (that.multiline) result += 'm';
|
|
2878
|
+
if (that.dotAll) result += 's';
|
|
2879
|
+
if (that.unicode) result += 'u';
|
|
2880
|
+
if (that.unicodeSets) result += 'v';
|
|
2881
|
+
if (that.sticky) result += 'y';
|
|
2882
|
+
return result;
|
|
2883
|
+
};
|
|
2884
|
+
|
|
2885
|
+
var fails$5 = fails$k;
|
|
2886
|
+
var global$3 = global$m;
|
|
2887
|
+
|
|
2888
|
+
// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
|
|
2889
|
+
var $RegExp$2 = global$3.RegExp;
|
|
2890
|
+
|
|
2891
|
+
var UNSUPPORTED_Y$1 = fails$5(function () {
|
|
2892
|
+
var re = $RegExp$2('a', 'y');
|
|
2893
|
+
re.lastIndex = 2;
|
|
2894
|
+
return re.exec('abcd') != null;
|
|
2895
|
+
});
|
|
2896
|
+
|
|
2897
|
+
// UC Browser bug
|
|
2898
|
+
// https://github.com/zloirock/core-js/issues/1008
|
|
2899
|
+
var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$5(function () {
|
|
2900
|
+
return !$RegExp$2('a', 'y').sticky;
|
|
2901
|
+
});
|
|
2902
|
+
|
|
2903
|
+
var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$5(function () {
|
|
2904
|
+
// https://bugzilla.mozilla.org/show_bug.cgi?id=773687
|
|
2905
|
+
var re = $RegExp$2('^r', 'gy');
|
|
2906
|
+
re.lastIndex = 2;
|
|
2907
|
+
return re.exec('str') != null;
|
|
2908
|
+
});
|
|
2909
|
+
|
|
2910
|
+
var regexpStickyHelpers = {
|
|
2911
|
+
BROKEN_CARET: BROKEN_CARET,
|
|
2912
|
+
MISSED_STICKY: MISSED_STICKY,
|
|
2913
|
+
UNSUPPORTED_Y: UNSUPPORTED_Y$1
|
|
2914
|
+
};
|
|
2915
|
+
|
|
2916
|
+
var fails$4 = fails$k;
|
|
2917
|
+
var global$2 = global$m;
|
|
2918
|
+
|
|
2919
|
+
// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
|
|
2920
|
+
var $RegExp$1 = global$2.RegExp;
|
|
2921
|
+
|
|
2922
|
+
var regexpUnsupportedDotAll = fails$4(function () {
|
|
2923
|
+
var re = $RegExp$1('.', 's');
|
|
2924
|
+
return !(re.dotAll && re.exec('\n') && re.flags === 's');
|
|
2925
|
+
});
|
|
2926
|
+
|
|
2927
|
+
var fails$3 = fails$k;
|
|
2928
|
+
var global$1 = global$m;
|
|
2929
|
+
|
|
2930
|
+
// babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
|
|
2931
|
+
var $RegExp = global$1.RegExp;
|
|
2932
|
+
|
|
2933
|
+
var regexpUnsupportedNcg = fails$3(function () {
|
|
2934
|
+
var re = $RegExp('(?<a>b)', 'g');
|
|
2935
|
+
return re.exec('b').groups.a !== 'b' ||
|
|
2936
|
+
'b'.replace(re, '$<a>c') !== 'bc';
|
|
2937
|
+
});
|
|
2938
|
+
|
|
2939
|
+
/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
|
|
2940
|
+
/* eslint-disable regexp/no-useless-quantifier -- testing */
|
|
2941
|
+
var call$4 = functionCall;
|
|
2942
|
+
var uncurryThis$4 = functionUncurryThis;
|
|
2943
|
+
var toString$3 = toString$5;
|
|
2944
|
+
var regexpFlags = regexpFlags$1;
|
|
2945
|
+
var stickyHelpers = regexpStickyHelpers;
|
|
2946
|
+
var shared = shared$4.exports;
|
|
2947
|
+
var create = objectCreate;
|
|
2948
|
+
var getInternalState = internalState.get;
|
|
2949
|
+
var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
|
|
2950
|
+
var UNSUPPORTED_NCG = regexpUnsupportedNcg;
|
|
2951
|
+
|
|
2952
|
+
var nativeReplace = shared('native-string-replace', String.prototype.replace);
|
|
2953
|
+
var nativeExec = RegExp.prototype.exec;
|
|
2954
|
+
var patchedExec = nativeExec;
|
|
2955
|
+
var charAt$3 = uncurryThis$4(''.charAt);
|
|
2956
|
+
var indexOf = uncurryThis$4(''.indexOf);
|
|
2957
|
+
var replace$1 = uncurryThis$4(''.replace);
|
|
2958
|
+
var stringSlice$3 = uncurryThis$4(''.slice);
|
|
2959
|
+
|
|
2960
|
+
var UPDATES_LAST_INDEX_WRONG = (function () {
|
|
2961
|
+
var re1 = /a/;
|
|
2962
|
+
var re2 = /b*/g;
|
|
2963
|
+
call$4(nativeExec, re1, 'a');
|
|
2964
|
+
call$4(nativeExec, re2, 'a');
|
|
2965
|
+
return re1.lastIndex !== 0 || re2.lastIndex !== 0;
|
|
2966
|
+
})();
|
|
2967
|
+
|
|
2968
|
+
var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
|
|
2969
|
+
|
|
2970
|
+
// nonparticipating capturing group, copied from es5-shim's String#split patch.
|
|
2971
|
+
var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
|
|
2972
|
+
|
|
2973
|
+
var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
|
|
2974
|
+
|
|
2975
|
+
if (PATCH) {
|
|
2976
|
+
patchedExec = function exec(string) {
|
|
2977
|
+
var re = this;
|
|
2978
|
+
var state = getInternalState(re);
|
|
2979
|
+
var str = toString$3(string);
|
|
2980
|
+
var raw = state.raw;
|
|
2981
|
+
var result, reCopy, lastIndex, match, i, object, group;
|
|
2982
|
+
|
|
2983
|
+
if (raw) {
|
|
2984
|
+
raw.lastIndex = re.lastIndex;
|
|
2985
|
+
result = call$4(patchedExec, raw, str);
|
|
2986
|
+
re.lastIndex = raw.lastIndex;
|
|
2987
|
+
return result;
|
|
2988
|
+
}
|
|
2989
|
+
|
|
2990
|
+
var groups = state.groups;
|
|
2991
|
+
var sticky = UNSUPPORTED_Y && re.sticky;
|
|
2992
|
+
var flags = call$4(regexpFlags, re);
|
|
2993
|
+
var source = re.source;
|
|
2994
|
+
var charsAdded = 0;
|
|
2995
|
+
var strCopy = str;
|
|
2996
|
+
|
|
2997
|
+
if (sticky) {
|
|
2998
|
+
flags = replace$1(flags, 'y', '');
|
|
2999
|
+
if (indexOf(flags, 'g') === -1) {
|
|
3000
|
+
flags += 'g';
|
|
3001
|
+
}
|
|
3002
|
+
|
|
3003
|
+
strCopy = stringSlice$3(str, re.lastIndex);
|
|
3004
|
+
// Support anchored sticky behavior.
|
|
3005
|
+
if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$3(str, re.lastIndex - 1) !== '\n')) {
|
|
3006
|
+
source = '(?: ' + source + ')';
|
|
3007
|
+
strCopy = ' ' + strCopy;
|
|
3008
|
+
charsAdded++;
|
|
3009
|
+
}
|
|
3010
|
+
// ^(? + rx + ) is needed, in combination with some str slicing, to
|
|
3011
|
+
// simulate the 'y' flag.
|
|
3012
|
+
reCopy = new RegExp('^(?:' + source + ')', flags);
|
|
3013
|
+
}
|
|
3014
|
+
|
|
3015
|
+
if (NPCG_INCLUDED) {
|
|
3016
|
+
reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
|
|
3017
|
+
}
|
|
3018
|
+
if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
|
|
3019
|
+
|
|
3020
|
+
match = call$4(nativeExec, sticky ? reCopy : re, strCopy);
|
|
3021
|
+
|
|
3022
|
+
if (sticky) {
|
|
3023
|
+
if (match) {
|
|
3024
|
+
match.input = stringSlice$3(match.input, charsAdded);
|
|
3025
|
+
match[0] = stringSlice$3(match[0], charsAdded);
|
|
3026
|
+
match.index = re.lastIndex;
|
|
3027
|
+
re.lastIndex += match[0].length;
|
|
3028
|
+
} else re.lastIndex = 0;
|
|
3029
|
+
} else if (UPDATES_LAST_INDEX_WRONG && match) {
|
|
3030
|
+
re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
|
|
3031
|
+
}
|
|
3032
|
+
if (NPCG_INCLUDED && match && match.length > 1) {
|
|
3033
|
+
// Fix browsers whose `exec` methods don't consistently return `undefined`
|
|
3034
|
+
// for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
|
|
3035
|
+
call$4(nativeReplace, match[0], reCopy, function () {
|
|
3036
|
+
for (i = 1; i < arguments.length - 2; i++) {
|
|
3037
|
+
if (arguments[i] === undefined) match[i] = undefined;
|
|
3038
|
+
}
|
|
3039
|
+
});
|
|
3040
|
+
}
|
|
3041
|
+
|
|
3042
|
+
if (match && groups) {
|
|
3043
|
+
match.groups = object = create(null);
|
|
3044
|
+
for (i = 0; i < groups.length; i++) {
|
|
3045
|
+
group = groups[i];
|
|
3046
|
+
object[group[0]] = match[group[1]];
|
|
3047
|
+
}
|
|
3048
|
+
}
|
|
3049
|
+
|
|
3050
|
+
return match;
|
|
3051
|
+
};
|
|
3052
|
+
}
|
|
3053
|
+
|
|
3054
|
+
var regexpExec$2 = patchedExec;
|
|
3055
|
+
|
|
3056
|
+
var $ = _export;
|
|
3057
|
+
var exec = regexpExec$2;
|
|
3058
|
+
|
|
3059
|
+
// `RegExp.prototype.exec` method
|
|
3060
|
+
// https://tc39.es/ecma262/#sec-regexp.prototype.exec
|
|
3061
|
+
$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
|
|
3062
|
+
exec: exec
|
|
3063
|
+
});
|
|
3064
|
+
|
|
3065
|
+
// TODO: Remove from `core-js@4` since it's moved to entry points
|
|
3066
|
+
|
|
3067
|
+
var uncurryThis$3 = functionUncurryThis;
|
|
3068
|
+
var defineBuiltIn$1 = defineBuiltIn$8;
|
|
3069
|
+
var regexpExec$1 = regexpExec$2;
|
|
3070
|
+
var fails$2 = fails$k;
|
|
3071
|
+
var wellKnownSymbol$1 = wellKnownSymbol$i;
|
|
3072
|
+
var createNonEnumerableProperty = createNonEnumerableProperty$5;
|
|
3073
|
+
|
|
3074
|
+
var SPECIES = wellKnownSymbol$1('species');
|
|
3075
|
+
var RegExpPrototype$2 = RegExp.prototype;
|
|
3076
|
+
|
|
3077
|
+
var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
|
|
3078
|
+
var SYMBOL = wellKnownSymbol$1(KEY);
|
|
3079
|
+
|
|
3080
|
+
var DELEGATES_TO_SYMBOL = !fails$2(function () {
|
|
3081
|
+
// String methods call symbol-named RegEp methods
|
|
3082
|
+
var O = {};
|
|
3083
|
+
O[SYMBOL] = function () { return 7; };
|
|
3084
|
+
return ''[KEY](O) != 7;
|
|
3085
|
+
});
|
|
3086
|
+
|
|
3087
|
+
var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$2(function () {
|
|
3088
|
+
// Symbol-named RegExp methods call .exec
|
|
3089
|
+
var execCalled = false;
|
|
3090
|
+
var re = /a/;
|
|
3091
|
+
|
|
3092
|
+
if (KEY === 'split') {
|
|
3093
|
+
// We can't use real regex here since it causes deoptimization
|
|
3094
|
+
// and serious performance degradation in V8
|
|
3095
|
+
// https://github.com/zloirock/core-js/issues/306
|
|
3096
|
+
re = {};
|
|
3097
|
+
// RegExp[@@split] doesn't call the regex's exec method, but first creates
|
|
3098
|
+
// a new one. We need to return the patched regex when creating the new one.
|
|
3099
|
+
re.constructor = {};
|
|
3100
|
+
re.constructor[SPECIES] = function () { return re; };
|
|
3101
|
+
re.flags = '';
|
|
3102
|
+
re[SYMBOL] = /./[SYMBOL];
|
|
3103
|
+
}
|
|
3104
|
+
|
|
3105
|
+
re.exec = function () { execCalled = true; return null; };
|
|
3106
|
+
|
|
3107
|
+
re[SYMBOL]('');
|
|
3108
|
+
return !execCalled;
|
|
3109
|
+
});
|
|
3110
|
+
|
|
3111
|
+
if (
|
|
3112
|
+
!DELEGATES_TO_SYMBOL ||
|
|
3113
|
+
!DELEGATES_TO_EXEC ||
|
|
3114
|
+
FORCED
|
|
3115
|
+
) {
|
|
3116
|
+
var uncurriedNativeRegExpMethod = uncurryThis$3(/./[SYMBOL]);
|
|
3117
|
+
var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
|
|
3118
|
+
var uncurriedNativeMethod = uncurryThis$3(nativeMethod);
|
|
3119
|
+
var $exec = regexp.exec;
|
|
3120
|
+
if ($exec === regexpExec$1 || $exec === RegExpPrototype$2.exec) {
|
|
3121
|
+
if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
|
|
3122
|
+
// The native String method already delegates to @@method (this
|
|
3123
|
+
// polyfilled function), leasing to infinite recursion.
|
|
3124
|
+
// We avoid it by directly calling the native @@method method.
|
|
3125
|
+
return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };
|
|
3126
|
+
}
|
|
3127
|
+
return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };
|
|
3128
|
+
}
|
|
3129
|
+
return { done: false };
|
|
3130
|
+
});
|
|
3131
|
+
|
|
3132
|
+
defineBuiltIn$1(String.prototype, KEY, methods[0]);
|
|
3133
|
+
defineBuiltIn$1(RegExpPrototype$2, SYMBOL, methods[1]);
|
|
3134
|
+
}
|
|
3135
|
+
|
|
3136
|
+
if (SHAM) createNonEnumerableProperty(RegExpPrototype$2[SYMBOL], 'sham', true);
|
|
3137
|
+
};
|
|
3138
|
+
|
|
3139
|
+
var uncurryThis$2 = functionUncurryThis;
|
|
3140
|
+
var toIntegerOrInfinity$1 = toIntegerOrInfinity$4;
|
|
3141
|
+
var toString$2 = toString$5;
|
|
3142
|
+
var requireObjectCoercible$2 = requireObjectCoercible$6;
|
|
3143
|
+
|
|
3144
|
+
var charAt$2 = uncurryThis$2(''.charAt);
|
|
3145
|
+
var charCodeAt = uncurryThis$2(''.charCodeAt);
|
|
3146
|
+
var stringSlice$2 = uncurryThis$2(''.slice);
|
|
3147
|
+
|
|
3148
|
+
var createMethod = function (CONVERT_TO_STRING) {
|
|
3149
|
+
return function ($this, pos) {
|
|
3150
|
+
var S = toString$2(requireObjectCoercible$2($this));
|
|
3151
|
+
var position = toIntegerOrInfinity$1(pos);
|
|
3152
|
+
var size = S.length;
|
|
3153
|
+
var first, second;
|
|
3154
|
+
if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
|
|
3155
|
+
first = charCodeAt(S, position);
|
|
3156
|
+
return first < 0xD800 || first > 0xDBFF || position + 1 === size
|
|
3157
|
+
|| (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
|
|
3158
|
+
? CONVERT_TO_STRING
|
|
3159
|
+
? charAt$2(S, position)
|
|
3160
|
+
: first
|
|
3161
|
+
: CONVERT_TO_STRING
|
|
3162
|
+
? stringSlice$2(S, position, position + 2)
|
|
3163
|
+
: (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
|
|
3164
|
+
};
|
|
3165
|
+
};
|
|
3166
|
+
|
|
3167
|
+
var stringMultibyte = {
|
|
3168
|
+
// `String.prototype.codePointAt` method
|
|
3169
|
+
// https://tc39.es/ecma262/#sec-string.prototype.codepointat
|
|
3170
|
+
codeAt: createMethod(false),
|
|
3171
|
+
// `String.prototype.at` method
|
|
3172
|
+
// https://github.com/mathiasbynens/String.prototype.at
|
|
3173
|
+
charAt: createMethod(true)
|
|
3174
|
+
};
|
|
3175
|
+
|
|
3176
|
+
var charAt$1 = stringMultibyte.charAt;
|
|
3177
|
+
|
|
3178
|
+
// `AdvanceStringIndex` abstract operation
|
|
3179
|
+
// https://tc39.es/ecma262/#sec-advancestringindex
|
|
3180
|
+
var advanceStringIndex$1 = function (S, index, unicode) {
|
|
3181
|
+
return index + (unicode ? charAt$1(S, index).length : 1);
|
|
3182
|
+
};
|
|
3183
|
+
|
|
3184
|
+
var uncurryThis$1 = functionUncurryThis;
|
|
3185
|
+
var toObject = toObject$4;
|
|
3186
|
+
|
|
3187
|
+
var floor = Math.floor;
|
|
3188
|
+
var charAt = uncurryThis$1(''.charAt);
|
|
3189
|
+
var replace = uncurryThis$1(''.replace);
|
|
3190
|
+
var stringSlice$1 = uncurryThis$1(''.slice);
|
|
3191
|
+
var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
|
|
3192
|
+
var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
|
|
3193
|
+
|
|
3194
|
+
// `GetSubstitution` abstract operation
|
|
3195
|
+
// https://tc39.es/ecma262/#sec-getsubstitution
|
|
3196
|
+
var getSubstitution$1 = function (matched, str, position, captures, namedCaptures, replacement) {
|
|
3197
|
+
var tailPos = position + matched.length;
|
|
3198
|
+
var m = captures.length;
|
|
3199
|
+
var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
|
|
3200
|
+
if (namedCaptures !== undefined) {
|
|
3201
|
+
namedCaptures = toObject(namedCaptures);
|
|
3202
|
+
symbols = SUBSTITUTION_SYMBOLS;
|
|
3203
|
+
}
|
|
3204
|
+
return replace(replacement, symbols, function (match, ch) {
|
|
3205
|
+
var capture;
|
|
3206
|
+
switch (charAt(ch, 0)) {
|
|
3207
|
+
case '$': return '$';
|
|
3208
|
+
case '&': return matched;
|
|
3209
|
+
case '`': return stringSlice$1(str, 0, position);
|
|
3210
|
+
case "'": return stringSlice$1(str, tailPos);
|
|
3211
|
+
case '<':
|
|
3212
|
+
capture = namedCaptures[stringSlice$1(ch, 1, -1)];
|
|
3213
|
+
break;
|
|
3214
|
+
default: // \d\d?
|
|
3215
|
+
var n = +ch;
|
|
3216
|
+
if (n === 0) return match;
|
|
3217
|
+
if (n > m) {
|
|
3218
|
+
var f = floor(n / 10);
|
|
3219
|
+
if (f === 0) return match;
|
|
3220
|
+
if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);
|
|
3221
|
+
return match;
|
|
3222
|
+
}
|
|
3223
|
+
capture = captures[n - 1];
|
|
3224
|
+
}
|
|
3225
|
+
return capture === undefined ? '' : capture;
|
|
3226
|
+
});
|
|
3227
|
+
};
|
|
3228
|
+
|
|
3229
|
+
var call$3 = functionCall;
|
|
3230
|
+
var anObject$3 = anObject$f;
|
|
3231
|
+
var isCallable$1 = isCallable$n;
|
|
3232
|
+
var classof = classofRaw$1;
|
|
3233
|
+
var regexpExec = regexpExec$2;
|
|
3234
|
+
|
|
3235
|
+
var $TypeError = TypeError;
|
|
3236
|
+
|
|
3237
|
+
// `RegExpExec` abstract operation
|
|
3238
|
+
// https://tc39.es/ecma262/#sec-regexpexec
|
|
3239
|
+
var regexpExecAbstract = function (R, S) {
|
|
3240
|
+
var exec = R.exec;
|
|
3241
|
+
if (isCallable$1(exec)) {
|
|
3242
|
+
var result = call$3(exec, R, S);
|
|
3243
|
+
if (result !== null) anObject$3(result);
|
|
3244
|
+
return result;
|
|
3245
|
+
}
|
|
3246
|
+
if (classof(R) === 'RegExp') return call$3(regexpExec, R, S);
|
|
3247
|
+
throw $TypeError('RegExp#exec called on incompatible receiver');
|
|
3248
|
+
};
|
|
3249
|
+
|
|
3250
|
+
var apply = functionApply;
|
|
3251
|
+
var call$2 = functionCall;
|
|
3252
|
+
var uncurryThis = functionUncurryThis;
|
|
3253
|
+
var fixRegExpWellKnownSymbolLogic$1 = fixRegexpWellKnownSymbolLogic;
|
|
3254
|
+
var fails$1 = fails$k;
|
|
3255
|
+
var anObject$2 = anObject$f;
|
|
3256
|
+
var isCallable = isCallable$n;
|
|
3257
|
+
var toIntegerOrInfinity = toIntegerOrInfinity$4;
|
|
3258
|
+
var toLength = toLength$2;
|
|
3259
|
+
var toString$1 = toString$5;
|
|
3260
|
+
var requireObjectCoercible$1 = requireObjectCoercible$6;
|
|
3261
|
+
var advanceStringIndex = advanceStringIndex$1;
|
|
3262
|
+
var getMethod$1 = getMethod$5;
|
|
3263
|
+
var getSubstitution = getSubstitution$1;
|
|
3264
|
+
var regExpExec$1 = regexpExecAbstract;
|
|
3265
|
+
var wellKnownSymbol = wellKnownSymbol$i;
|
|
3266
|
+
|
|
3267
|
+
var REPLACE = wellKnownSymbol('replace');
|
|
3268
|
+
var max = Math.max;
|
|
3269
|
+
var min = Math.min;
|
|
3270
|
+
var concat = uncurryThis([].concat);
|
|
3271
|
+
var push = uncurryThis([].push);
|
|
3272
|
+
var stringIndexOf = uncurryThis(''.indexOf);
|
|
3273
|
+
var stringSlice = uncurryThis(''.slice);
|
|
3274
|
+
|
|
3275
|
+
var maybeToString = function (it) {
|
|
3276
|
+
return it === undefined ? it : String(it);
|
|
3277
|
+
};
|
|
3278
|
+
|
|
3279
|
+
// IE <= 11 replaces $0 with the whole match, as if it was $&
|
|
3280
|
+
// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
|
|
3281
|
+
var REPLACE_KEEPS_$0 = (function () {
|
|
3282
|
+
// eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
|
|
3283
|
+
return 'a'.replace(/./, '$0') === '$0';
|
|
3284
|
+
})();
|
|
3285
|
+
|
|
3286
|
+
// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
|
|
3287
|
+
var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
|
|
3288
|
+
if (/./[REPLACE]) {
|
|
3289
|
+
return /./[REPLACE]('a', '$0') === '';
|
|
3290
|
+
}
|
|
3291
|
+
return false;
|
|
3292
|
+
})();
|
|
3293
|
+
|
|
3294
|
+
var REPLACE_SUPPORTS_NAMED_GROUPS = !fails$1(function () {
|
|
3295
|
+
var re = /./;
|
|
3296
|
+
re.exec = function () {
|
|
3297
|
+
var result = [];
|
|
3298
|
+
result.groups = { a: '7' };
|
|
3299
|
+
return result;
|
|
3300
|
+
};
|
|
3301
|
+
// eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive
|
|
3302
|
+
return ''.replace(re, '$<a>') !== '7';
|
|
3303
|
+
});
|
|
3304
|
+
|
|
3305
|
+
// @@replace logic
|
|
3306
|
+
fixRegExpWellKnownSymbolLogic$1('replace', function (_, nativeReplace, maybeCallNative) {
|
|
3307
|
+
var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
|
|
3308
|
+
|
|
3309
|
+
return [
|
|
3310
|
+
// `String.prototype.replace` method
|
|
3311
|
+
// https://tc39.es/ecma262/#sec-string.prototype.replace
|
|
3312
|
+
function replace(searchValue, replaceValue) {
|
|
3313
|
+
var O = requireObjectCoercible$1(this);
|
|
3314
|
+
var replacer = searchValue == undefined ? undefined : getMethod$1(searchValue, REPLACE);
|
|
3315
|
+
return replacer
|
|
3316
|
+
? call$2(replacer, searchValue, O, replaceValue)
|
|
3317
|
+
: call$2(nativeReplace, toString$1(O), searchValue, replaceValue);
|
|
3318
|
+
},
|
|
3319
|
+
// `RegExp.prototype[@@replace]` method
|
|
3320
|
+
// https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
|
|
3321
|
+
function (string, replaceValue) {
|
|
3322
|
+
var rx = anObject$2(this);
|
|
3323
|
+
var S = toString$1(string);
|
|
3324
|
+
|
|
3325
|
+
if (
|
|
3326
|
+
typeof replaceValue == 'string' &&
|
|
3327
|
+
stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 &&
|
|
3328
|
+
stringIndexOf(replaceValue, '$<') === -1
|
|
3329
|
+
) {
|
|
3330
|
+
var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
|
|
3331
|
+
if (res.done) return res.value;
|
|
3332
|
+
}
|
|
3333
|
+
|
|
3334
|
+
var functionalReplace = isCallable(replaceValue);
|
|
3335
|
+
if (!functionalReplace) replaceValue = toString$1(replaceValue);
|
|
3336
|
+
|
|
3337
|
+
var global = rx.global;
|
|
3338
|
+
if (global) {
|
|
3339
|
+
var fullUnicode = rx.unicode;
|
|
3340
|
+
rx.lastIndex = 0;
|
|
3341
|
+
}
|
|
3342
|
+
var results = [];
|
|
3343
|
+
while (true) {
|
|
3344
|
+
var result = regExpExec$1(rx, S);
|
|
3345
|
+
if (result === null) break;
|
|
3346
|
+
|
|
3347
|
+
push(results, result);
|
|
3348
|
+
if (!global) break;
|
|
3349
|
+
|
|
3350
|
+
var matchStr = toString$1(result[0]);
|
|
3351
|
+
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
|
|
3352
|
+
}
|
|
3353
|
+
|
|
3354
|
+
var accumulatedResult = '';
|
|
3355
|
+
var nextSourcePosition = 0;
|
|
3356
|
+
for (var i = 0; i < results.length; i++) {
|
|
3357
|
+
result = results[i];
|
|
3358
|
+
|
|
3359
|
+
var matched = toString$1(result[0]);
|
|
3360
|
+
var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
|
|
3361
|
+
var captures = [];
|
|
3362
|
+
// NOTE: This is equivalent to
|
|
3363
|
+
// captures = result.slice(1).map(maybeToString)
|
|
3364
|
+
// but for some reason `nativeSlice.call(result, 1, result.length)` (called in
|
|
3365
|
+
// the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
|
|
3366
|
+
// causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
|
|
3367
|
+
for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
|
|
3368
|
+
var namedCaptures = result.groups;
|
|
3369
|
+
if (functionalReplace) {
|
|
3370
|
+
var replacerArgs = concat([matched], captures, position, S);
|
|
3371
|
+
if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
|
|
3372
|
+
var replacement = toString$1(apply(replaceValue, undefined, replacerArgs));
|
|
3373
|
+
} else {
|
|
3374
|
+
replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
|
|
3375
|
+
}
|
|
3376
|
+
if (position >= nextSourcePosition) {
|
|
3377
|
+
accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
|
|
3378
|
+
nextSourcePosition = position + matched.length;
|
|
3379
|
+
}
|
|
3380
|
+
}
|
|
3381
|
+
return accumulatedResult + stringSlice(S, nextSourcePosition);
|
|
3382
|
+
}
|
|
3383
|
+
];
|
|
3384
|
+
}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
|
|
3385
|
+
|
|
3386
|
+
var call$1 = functionCall;
|
|
3387
|
+
var hasOwn = hasOwnProperty_1;
|
|
3388
|
+
var isPrototypeOf = objectIsPrototypeOf;
|
|
3389
|
+
var regExpFlags = regexpFlags$1;
|
|
3390
|
+
|
|
3391
|
+
var RegExpPrototype$1 = RegExp.prototype;
|
|
3392
|
+
|
|
3393
|
+
var regexpGetFlags = function (R) {
|
|
3394
|
+
var flags = R.flags;
|
|
3395
|
+
return flags === undefined && !('flags' in RegExpPrototype$1) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype$1, R)
|
|
3396
|
+
? call$1(regExpFlags, R) : flags;
|
|
3397
|
+
};
|
|
3398
|
+
|
|
3399
|
+
var PROPER_FUNCTION_NAME = functionName.PROPER;
|
|
3400
|
+
var defineBuiltIn = defineBuiltIn$8;
|
|
3401
|
+
var anObject$1 = anObject$f;
|
|
3402
|
+
var $toString = toString$5;
|
|
3403
|
+
var fails = fails$k;
|
|
3404
|
+
var getRegExpFlags = regexpGetFlags;
|
|
3405
|
+
|
|
3406
|
+
var TO_STRING = 'toString';
|
|
3407
|
+
var RegExpPrototype = RegExp.prototype;
|
|
3408
|
+
var n$ToString = RegExpPrototype[TO_STRING];
|
|
3409
|
+
|
|
3410
|
+
var NOT_GENERIC = fails(function () { return n$ToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
|
|
3411
|
+
// FF44- RegExp#toString has a wrong name
|
|
3412
|
+
var INCORRECT_NAME = PROPER_FUNCTION_NAME && n$ToString.name != TO_STRING;
|
|
3413
|
+
|
|
3414
|
+
// `RegExp.prototype.toString` method
|
|
3415
|
+
// https://tc39.es/ecma262/#sec-regexp.prototype.tostring
|
|
3416
|
+
if (NOT_GENERIC || INCORRECT_NAME) {
|
|
3417
|
+
defineBuiltIn(RegExp.prototype, TO_STRING, function toString() {
|
|
3418
|
+
var R = anObject$1(this);
|
|
3419
|
+
var pattern = $toString(R.source);
|
|
3420
|
+
var flags = $toString(getRegExpFlags(R));
|
|
3421
|
+
return '/' + pattern + '/' + flags;
|
|
3422
|
+
}, { unsafe: true });
|
|
3423
|
+
}
|
|
3424
|
+
|
|
3425
|
+
// `SameValue` abstract operation
|
|
3426
|
+
// https://tc39.es/ecma262/#sec-samevalue
|
|
3427
|
+
// eslint-disable-next-line es-x/no-object-is -- safe
|
|
3428
|
+
var sameValue$1 = Object.is || function is(x, y) {
|
|
3429
|
+
// eslint-disable-next-line no-self-compare -- NaN check
|
|
3430
|
+
return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
|
|
3431
|
+
};
|
|
3432
|
+
|
|
3433
|
+
var call = functionCall;
|
|
3434
|
+
var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
|
|
3435
|
+
var anObject = anObject$f;
|
|
3436
|
+
var requireObjectCoercible = requireObjectCoercible$6;
|
|
3437
|
+
var sameValue = sameValue$1;
|
|
3438
|
+
var toString = toString$5;
|
|
3439
|
+
var getMethod = getMethod$5;
|
|
3440
|
+
var regExpExec = regexpExecAbstract;
|
|
3441
|
+
|
|
3442
|
+
// @@search logic
|
|
3443
|
+
fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCallNative) {
|
|
3444
|
+
return [
|
|
3445
|
+
// `String.prototype.search` method
|
|
3446
|
+
// https://tc39.es/ecma262/#sec-string.prototype.search
|
|
3447
|
+
function search(regexp) {
|
|
3448
|
+
var O = requireObjectCoercible(this);
|
|
3449
|
+
var searcher = regexp == undefined ? undefined : getMethod(regexp, SEARCH);
|
|
3450
|
+
return searcher ? call(searcher, regexp, O) : new RegExp(regexp)[SEARCH](toString(O));
|
|
3451
|
+
},
|
|
3452
|
+
// `RegExp.prototype[@@search]` method
|
|
3453
|
+
// https://tc39.es/ecma262/#sec-regexp.prototype-@@search
|
|
3454
|
+
function (string) {
|
|
3455
|
+
var rx = anObject(this);
|
|
3456
|
+
var S = toString(string);
|
|
3457
|
+
var res = maybeCallNative(nativeSearch, rx, S);
|
|
3458
|
+
|
|
3459
|
+
if (res.done) return res.value;
|
|
3460
|
+
|
|
3461
|
+
var previousLastIndex = rx.lastIndex;
|
|
3462
|
+
if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0;
|
|
3463
|
+
var result = regExpExec(rx, S);
|
|
3464
|
+
if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex;
|
|
3465
|
+
return result === null ? -1 : result.index;
|
|
3466
|
+
}
|
|
3467
|
+
];
|
|
3468
|
+
});
|
|
3469
|
+
|
|
3470
|
+
/**
|
|
3471
|
+
* A hook to allow your Iris App to render specific url passed from host
|
|
3472
|
+
*/
|
|
3473
|
+
|
|
3474
|
+
const useDeepLink = () => {
|
|
3475
|
+
const [loading, setLoading] = React__default.useState(true);
|
|
3476
|
+
const [synced, setSynced] = React__default.useState(false);
|
|
3477
|
+
const {
|
|
3478
|
+
pathname
|
|
3479
|
+
} = useLocation();
|
|
3480
|
+
const navigate = useNavigate();
|
|
3481
|
+
NavigationRuntime.getDeepLink().then(deepLink => {
|
|
3482
|
+
if (!pathname.includes(deepLink.pathname) && !synced) {
|
|
3483
|
+
setSynced(true);
|
|
3484
|
+
const newPath = generatePath(":url?:queryString#:hashParams", {
|
|
3485
|
+
url: deepLink.path,
|
|
3486
|
+
queryString: createSearchParams(deepLink.search).toString(),
|
|
3487
|
+
hashParams: createSearchParams(deepLink.hash.slice(1)).toString()
|
|
3488
|
+
}).replace("runLocal=", "runLocal");
|
|
3489
|
+
navigate(newPath);
|
|
3490
|
+
}
|
|
3491
|
+
}).finally(() => {
|
|
3492
|
+
setLoading(false);
|
|
3493
|
+
});
|
|
3494
|
+
return {
|
|
3495
|
+
loading
|
|
3496
|
+
};
|
|
3497
|
+
};
|
|
3498
|
+
|
|
3499
|
+
/**
|
|
3500
|
+
* A react hook for notifying host about location change
|
|
3501
|
+
*
|
|
3502
|
+
*/
|
|
3503
|
+
|
|
3504
|
+
const useURLSynchronization = () => {
|
|
3505
|
+
const location = useLocation();
|
|
3506
|
+
React__default.useEffect(() => {
|
|
3507
|
+
NavigationRuntime.setDeepLink({
|
|
3508
|
+
path: location.pathname,
|
|
3509
|
+
search: location.search,
|
|
3510
|
+
hash: location.hash,
|
|
3511
|
+
pathname: ""
|
|
3512
|
+
});
|
|
3513
|
+
}, [location]);
|
|
3514
|
+
};
|
|
3515
|
+
|
|
3516
|
+
const HostNavigator = ({
|
|
3517
|
+
children
|
|
3518
|
+
}) => {
|
|
3519
|
+
const {
|
|
3520
|
+
loading
|
|
3521
|
+
} = useDeepLink();
|
|
3522
|
+
useURLSynchronization(); // eslint-disable-next-line react/jsx-no-useless-fragment
|
|
3523
|
+
|
|
3524
|
+
return loading ? null : jsx(Fragment, {
|
|
3525
|
+
children: children
|
|
3526
|
+
});
|
|
3527
|
+
};
|
|
3528
|
+
|
|
3529
|
+
const TrackunitRouter = ({
|
|
3530
|
+
children
|
|
3531
|
+
}) => {
|
|
3532
|
+
return jsx(BrowserRouter, {
|
|
3533
|
+
children: jsx(HostNavigator, {
|
|
3534
|
+
children: children
|
|
3535
|
+
})
|
|
3536
|
+
});
|
|
3537
|
+
};
|
|
3538
|
+
|
|
1633
3539
|
/**
|
|
1634
3540
|
* A hook to expose asset runtime for React components
|
|
1635
3541
|
*
|
|
@@ -1714,4 +3620,4 @@ const useCurrentUser = () => {
|
|
|
1714
3620
|
return context;
|
|
1715
3621
|
};
|
|
1716
3622
|
|
|
1717
|
-
export { CurrentUserProvider, DeveloperSettingsContext, DeveloperSettingsProvider, EnvironmentContextProvider, ToastProvider, TokenProvider, UserSubscriptionProvider, useAssetRuntime, useCurrentUser, useCustomFieldRuntime, useDeveloperSettings, useEnvironment, useRestRuntime, useToast, useToken, useUserSubscription };
|
|
3623
|
+
export { CurrentUserProvider, DeveloperSettingsContext, DeveloperSettingsProvider, EnvironmentContextProvider, ToastProvider, TokenProvider, TrackunitRouter, UserSubscriptionProvider, useAssetRuntime, useCurrentUser, useCustomFieldRuntime, useDeepLink, useDeveloperSettings, useEnvironment, useRestRuntime, useToast, useToken, useURLSynchronization, useUserSubscription };
|