@fluxo-dev/shell-printing 0.0.33 → 0.0.35

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/index.esm.js +2328 -1700
  2. package/package.json +3 -2
package/index.esm.js CHANGED
@@ -7,7 +7,29 @@ import { showNotification } from '@mantine/notifications';
7
7
 
8
8
  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
9
9
 
10
- var fails$7 = function (exec) {
10
+ function getDefaultExportFromCjs (x) {
11
+ return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
12
+ }
13
+
14
+ var check = function (it) {
15
+ return it && it.Math === Math && it;
16
+ };
17
+
18
+ // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
19
+ var global$d =
20
+ // eslint-disable-next-line es/no-global-this -- safe
21
+ check(typeof globalThis == 'object' && globalThis) ||
22
+ check(typeof window == 'object' && window) ||
23
+ // eslint-disable-next-line no-restricted-globals -- safe
24
+ check(typeof self == 'object' && self) ||
25
+ check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
26
+ check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
27
+ // eslint-disable-next-line no-new-func -- fallback
28
+ (function () { return this; })() || Function('return this')();
29
+
30
+ var objectGetOwnPropertyDescriptor = {};
31
+
32
+ var fails$c = function (exec) {
11
33
  try {
12
34
  return !!exec();
13
35
  } catch (error) {
@@ -15,695 +37,908 @@ var fails$7 = function (exec) {
15
37
  }
16
38
  };
17
39
 
18
- var toString = {}.toString;
40
+ var fails$b = fails$c;
19
41
 
20
- var classofRaw = function (it) {
21
- return toString.call(it).slice(8, -1);
22
- };
23
-
24
- var fails$6 = fails$7;
25
- var classof = classofRaw;
42
+ // Detect IE8's incomplete defineProperty implementation
43
+ var descriptors = !fails$b(function () {
44
+ // eslint-disable-next-line es/no-object-defineproperty -- required for testing
45
+ return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
46
+ });
26
47
 
27
- var split = ''.split;
48
+ var fails$a = fails$c;
28
49
 
29
- // fallback for non-array-like ES3 and non-enumerable old V8 strings
30
- var indexedObject = fails$6(function () {
31
- // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
32
- // eslint-disable-next-line no-prototype-builtins
33
- return !Object('z').propertyIsEnumerable(0);
34
- }) ? function (it) {
35
- return classof(it) == 'String' ? split.call(it, '') : Object(it);
36
- } : Object;
50
+ var functionBindNative = !fails$a(function () {
51
+ // eslint-disable-next-line es/no-function-prototype-bind -- safe
52
+ var test = (function () { /* empty */ }).bind();
53
+ // eslint-disable-next-line no-prototype-builtins -- safe
54
+ return typeof test != 'function' || test.hasOwnProperty('prototype');
55
+ });
37
56
 
38
- // `RequireObjectCoercible` abstract operation
39
- // https://tc39.github.io/ecma262/#sec-requireobjectcoercible
40
- var requireObjectCoercible$3 = function (it) {
41
- if (it == undefined) throw TypeError("Can't call method on " + it);
42
- return it;
43
- };
57
+ var NATIVE_BIND$1 = functionBindNative;
44
58
 
45
- // toObject with fallback for non-array-like ES3 strings
46
- var IndexedObject = indexedObject;
47
- var requireObjectCoercible$2 = requireObjectCoercible$3;
59
+ var call$6 = Function.prototype.call;
48
60
 
49
- var toIndexedObject$4 = function (it) {
50
- return IndexedObject(requireObjectCoercible$2(it));
61
+ var functionCall = NATIVE_BIND$1 ? call$6.bind(call$6) : function () {
62
+ return call$6.apply(call$6, arguments);
51
63
  };
52
64
 
53
- var check = function (it) {
54
- return it && it.Math == Math && it;
55
- };
65
+ var objectPropertyIsEnumerable = {};
56
66
 
57
- // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
58
- var global$e =
59
- // eslint-disable-next-line no-undef
60
- check(typeof globalThis == 'object' && globalThis) ||
61
- check(typeof window == 'object' && window) ||
62
- check(typeof self == 'object' && self) ||
63
- check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
64
- // eslint-disable-next-line no-new-func
65
- Function('return this')();
67
+ var $propertyIsEnumerable = {}.propertyIsEnumerable;
68
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
69
+ var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
66
70
 
67
- var shared$2 = {exports: {}};
71
+ // Nashorn ~ JDK8 bug
72
+ var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
68
73
 
69
- var fails$5 = fails$7;
74
+ // `Object.prototype.propertyIsEnumerable` method implementation
75
+ // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
76
+ objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
77
+ var descriptor = getOwnPropertyDescriptor$1(this, V);
78
+ return !!descriptor && descriptor.enumerable;
79
+ } : $propertyIsEnumerable;
70
80
 
71
- // Thank's IE8 for his funny defineProperty
72
- var descriptors = !fails$5(function () {
73
- return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
74
- });
81
+ var createPropertyDescriptor$3 = function (bitmap, value) {
82
+ return {
83
+ enumerable: !(bitmap & 1),
84
+ configurable: !(bitmap & 2),
85
+ writable: !(bitmap & 4),
86
+ value: value
87
+ };
88
+ };
75
89
 
76
- var objectDefineProperty = {};
90
+ var NATIVE_BIND = functionBindNative;
91
+
92
+ var FunctionPrototype$1 = Function.prototype;
93
+ var call$5 = FunctionPrototype$1.call;
94
+ var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype$1.bind.bind(call$5, call$5);
77
95
 
78
- var isObject$6 = function (it) {
79
- return typeof it === 'object' ? it !== null : typeof it === 'function';
96
+ var functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
97
+ return function () {
98
+ return call$5.apply(fn, arguments);
99
+ };
80
100
  };
81
101
 
82
- var global$d = global$e;
83
- var isObject$5 = isObject$6;
102
+ var uncurryThis$c = functionUncurryThis;
84
103
 
85
- var document$1 = global$d.document;
86
- // typeof document.createElement is 'object' in old IE
87
- var EXISTS = isObject$5(document$1) && isObject$5(document$1.createElement);
104
+ var toString$5 = uncurryThis$c({}.toString);
105
+ var stringSlice$2 = uncurryThis$c(''.slice);
88
106
 
89
- var documentCreateElement$1 = function (it) {
90
- return EXISTS ? document$1.createElement(it) : {};
107
+ var classofRaw$1 = function (it) {
108
+ return stringSlice$2(toString$5(it), 8, -1);
91
109
  };
92
110
 
93
- var DESCRIPTORS$5 = descriptors;
94
- var fails$4 = fails$7;
95
- var createElement = documentCreateElement$1;
111
+ var uncurryThis$b = functionUncurryThis;
112
+ var fails$9 = fails$c;
113
+ var classof$2 = classofRaw$1;
96
114
 
97
- // Thank's IE8 for his funny defineProperty
98
- var ie8DomDefine = !DESCRIPTORS$5 && !fails$4(function () {
99
- return Object.defineProperty(createElement('div'), 'a', {
100
- get: function () { return 7; }
101
- }).a != 7;
102
- });
115
+ var $Object$4 = Object;
116
+ var split = uncurryThis$b(''.split);
103
117
 
104
- var isObject$4 = isObject$6;
118
+ // fallback for non-array-like ES3 and non-enumerable old V8 strings
119
+ var indexedObject = fails$9(function () {
120
+ // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
121
+ // eslint-disable-next-line no-prototype-builtins -- safe
122
+ return !$Object$4('z').propertyIsEnumerable(0);
123
+ }) ? function (it) {
124
+ return classof$2(it) === 'String' ? split(it, '') : $Object$4(it);
125
+ } : $Object$4;
105
126
 
106
- var anObject$7 = function (it) {
107
- if (!isObject$4(it)) {
108
- throw TypeError(String(it) + ' is not an object');
109
- } return it;
127
+ // we can't use just `it == null` since of `document.all` special case
128
+ // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
129
+ var isNullOrUndefined$2 = function (it) {
130
+ return it === null || it === undefined;
110
131
  };
111
132
 
112
- var isObject$3 = isObject$6;
133
+ var isNullOrUndefined$1 = isNullOrUndefined$2;
113
134
 
114
- // `ToPrimitive` abstract operation
115
- // https://tc39.github.io/ecma262/#sec-toprimitive
116
- // instead of the ES6 spec version, we didn't implement @@toPrimitive case
117
- // and the second argument - flag - preferred type is a string
118
- var toPrimitive$2 = function (input, PREFERRED_STRING) {
119
- if (!isObject$3(input)) return input;
120
- var fn, val;
121
- if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject$3(val = fn.call(input))) return val;
122
- if (typeof (fn = input.valueOf) == 'function' && !isObject$3(val = fn.call(input))) return val;
123
- if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject$3(val = fn.call(input))) return val;
124
- throw TypeError("Can't convert object to primitive value");
125
- };
135
+ var $TypeError$6 = TypeError;
126
136
 
127
- var DESCRIPTORS$4 = descriptors;
128
- var IE8_DOM_DEFINE$1 = ie8DomDefine;
129
- var anObject$6 = anObject$7;
130
- var toPrimitive$1 = toPrimitive$2;
137
+ // `RequireObjectCoercible` abstract operation
138
+ // https://tc39.es/ecma262/#sec-requireobjectcoercible
139
+ var requireObjectCoercible$4 = function (it) {
140
+ if (isNullOrUndefined$1(it)) throw new $TypeError$6("Can't call method on " + it);
141
+ return it;
142
+ };
131
143
 
132
- var nativeDefineProperty = Object.defineProperty;
144
+ // toObject with fallback for non-array-like ES3 strings
145
+ var IndexedObject = indexedObject;
146
+ var requireObjectCoercible$3 = requireObjectCoercible$4;
133
147
 
134
- // `Object.defineProperty` method
135
- // https://tc39.github.io/ecma262/#sec-object.defineproperty
136
- objectDefineProperty.f = DESCRIPTORS$4 ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
137
- anObject$6(O);
138
- P = toPrimitive$1(P, true);
139
- anObject$6(Attributes);
140
- if (IE8_DOM_DEFINE$1) try {
141
- return nativeDefineProperty(O, P, Attributes);
142
- } catch (error) { /* empty */ }
143
- if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
144
- if ('value' in Attributes) O[P] = Attributes.value;
145
- return O;
148
+ var toIndexedObject$5 = function (it) {
149
+ return IndexedObject(requireObjectCoercible$3(it));
146
150
  };
147
151
 
148
- var createPropertyDescriptor$3 = function (bitmap, value) {
149
- return {
150
- enumerable: !(bitmap & 1),
151
- configurable: !(bitmap & 2),
152
- writable: !(bitmap & 4),
153
- value: value
154
- };
152
+ // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
153
+ var documentAll = typeof document == 'object' && document.all;
154
+
155
+ // `IsCallable` abstract operation
156
+ // https://tc39.es/ecma262/#sec-iscallable
157
+ // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
158
+ var isCallable$f = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
159
+ return typeof argument == 'function' || argument === documentAll;
160
+ } : function (argument) {
161
+ return typeof argument == 'function';
155
162
  };
156
163
 
157
- var DESCRIPTORS$3 = descriptors;
158
- var definePropertyModule$3 = objectDefineProperty;
159
- var createPropertyDescriptor$2 = createPropertyDescriptor$3;
164
+ var isCallable$e = isCallable$f;
160
165
 
161
- var createNonEnumerableProperty$7 = DESCRIPTORS$3 ? function (object, key, value) {
162
- return definePropertyModule$3.f(object, key, createPropertyDescriptor$2(1, value));
163
- } : function (object, key, value) {
164
- object[key] = value;
165
- return object;
166
+ var isObject$8 = function (it) {
167
+ return typeof it == 'object' ? it !== null : isCallable$e(it);
166
168
  };
167
169
 
168
- var global$c = global$e;
169
- var createNonEnumerableProperty$6 = createNonEnumerableProperty$7;
170
+ var global$c = global$d;
171
+ var isCallable$d = isCallable$f;
170
172
 
171
- var setGlobal$3 = function (key, value) {
172
- try {
173
- createNonEnumerableProperty$6(global$c, key, value);
174
- } catch (error) {
175
- global$c[key] = value;
176
- } return value;
173
+ var aFunction = function (argument) {
174
+ return isCallable$d(argument) ? argument : undefined;
177
175
  };
178
176
 
179
- var global$b = global$e;
180
- var setGlobal$2 = setGlobal$3;
177
+ var getBuiltIn$3 = function (namespace, method) {
178
+ return arguments.length < 2 ? aFunction(global$c[namespace]) : global$c[namespace] && global$c[namespace][method];
179
+ };
181
180
 
182
- var SHARED = '__core-js_shared__';
183
- var store$3 = global$b[SHARED] || setGlobal$2(SHARED, {});
181
+ var uncurryThis$a = functionUncurryThis;
184
182
 
185
- var sharedStore = store$3;
183
+ var objectIsPrototypeOf = uncurryThis$a({}.isPrototypeOf);
186
184
 
187
- var store$2 = sharedStore;
185
+ var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
188
186
 
189
- (shared$2.exports = function (key, value) {
190
- return store$2[key] || (store$2[key] = value !== undefined ? value : {});
191
- })('versions', []).push({
192
- version: '3.6.5',
193
- mode: 'global',
194
- copyright: '© 2020 Denis Pushkarev (zloirock.ru)'
195
- });
187
+ var global$b = global$d;
188
+ var userAgent = engineUserAgent;
196
189
 
197
- var hasOwnProperty$1 = {}.hasOwnProperty;
190
+ var process$1 = global$b.process;
191
+ var Deno = global$b.Deno;
192
+ var versions = process$1 && process$1.versions || Deno && Deno.version;
193
+ var v8 = versions && versions.v8;
194
+ var match, version;
198
195
 
199
- var has$d = function (it, key) {
200
- return hasOwnProperty$1.call(it, key);
201
- };
196
+ if (v8) {
197
+ match = v8.split('.');
198
+ // in old Chrome, versions of V8 isn't V8 = Chrome / 10
199
+ // but their correct versions are not interesting for us
200
+ version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
201
+ }
202
202
 
203
- var id = 0;
204
- var postfix = Math.random();
203
+ // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
204
+ // so check `userAgent` even if `.v8` exists, but 0
205
+ if (!version && userAgent) {
206
+ match = userAgent.match(/Edge\/(\d+)/);
207
+ if (!match || match[1] >= 74) {
208
+ match = userAgent.match(/Chrome\/(\d+)/);
209
+ if (match) version = +match[1];
210
+ }
211
+ }
205
212
 
206
- var uid$2 = function (key) {
207
- return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
208
- };
213
+ var engineV8Version = version;
214
+
215
+ /* eslint-disable es/no-symbol -- required for testing */
216
+ var V8_VERSION = engineV8Version;
217
+ var fails$8 = fails$c;
218
+ var global$a = global$d;
209
219
 
210
- var fails$3 = fails$7;
220
+ var $String$5 = global$a.String;
211
221
 
212
- var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$3(function () {
222
+ // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
223
+ var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$8(function () {
224
+ var symbol = Symbol('symbol detection');
213
225
  // Chrome 38 Symbol has incorrect toString conversion
214
- // eslint-disable-next-line no-undef
215
- return !String(Symbol());
226
+ // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
227
+ // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
228
+ // of course, fail.
229
+ return !$String$5(symbol) || !(Object(symbol) instanceof Symbol) ||
230
+ // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
231
+ !Symbol.sham && V8_VERSION && V8_VERSION < 41;
216
232
  });
217
233
 
218
- var NATIVE_SYMBOL$1 = nativeSymbol;
234
+ /* eslint-disable es/no-symbol -- required for testing */
235
+ var NATIVE_SYMBOL$2 = symbolConstructorDetection;
219
236
 
220
- var useSymbolAsUid = NATIVE_SYMBOL$1
221
- // eslint-disable-next-line no-undef
237
+ var useSymbolAsUid = NATIVE_SYMBOL$2
222
238
  && !Symbol.sham
223
- // eslint-disable-next-line no-undef
224
239
  && typeof Symbol.iterator == 'symbol';
225
240
 
226
- var global$a = global$e;
227
- var shared$1 = shared$2.exports;
228
- var has$c = has$d;
229
- var uid$1 = uid$2;
230
- var NATIVE_SYMBOL = nativeSymbol;
231
- var USE_SYMBOL_AS_UID = useSymbolAsUid;
241
+ var getBuiltIn$2 = getBuiltIn$3;
242
+ var isCallable$c = isCallable$f;
243
+ var isPrototypeOf$2 = objectIsPrototypeOf;
244
+ var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
232
245
 
233
- var WellKnownSymbolsStore = shared$1('wks');
234
- var Symbol$1 = global$a.Symbol;
235
- var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
246
+ var $Object$3 = Object;
236
247
 
237
- var wellKnownSymbol$5 = function (name) {
238
- if (!has$c(WellKnownSymbolsStore, name)) {
239
- if (NATIVE_SYMBOL && has$c(Symbol$1, name)) WellKnownSymbolsStore[name] = Symbol$1[name];
240
- else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
241
- } return WellKnownSymbolsStore[name];
248
+ var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
249
+ return typeof it == 'symbol';
250
+ } : function (it) {
251
+ var $Symbol = getBuiltIn$2('Symbol');
252
+ return isCallable$c($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it));
242
253
  };
243
254
 
244
- var ceil = Math.ceil;
245
- var floor = Math.floor;
255
+ var $String$4 = String;
246
256
 
247
- // `ToInteger` abstract operation
248
- // https://tc39.github.io/ecma262/#sec-tointeger
249
- var toInteger$2 = function (argument) {
250
- return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
257
+ var tryToString$1 = function (argument) {
258
+ try {
259
+ return $String$4(argument);
260
+ } catch (error) {
261
+ return 'Object';
262
+ }
251
263
  };
252
264
 
253
- var toInteger$1 = toInteger$2;
265
+ var isCallable$b = isCallable$f;
266
+ var tryToString = tryToString$1;
254
267
 
255
- var min$1 = Math.min;
268
+ var $TypeError$5 = TypeError;
256
269
 
257
- // `ToLength` abstract operation
258
- // https://tc39.github.io/ecma262/#sec-tolength
259
- var toLength$1 = function (argument) {
260
- return argument > 0 ? min$1(toInteger$1(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
270
+ // `Assert: IsCallable(argument) is true`
271
+ var aCallable$2 = function (argument) {
272
+ if (isCallable$b(argument)) return argument;
273
+ throw new $TypeError$5(tryToString(argument) + ' is not a function');
261
274
  };
262
275
 
263
- var toInteger = toInteger$2;
276
+ var aCallable$1 = aCallable$2;
277
+ var isNullOrUndefined = isNullOrUndefined$2;
264
278
 
265
- var max = Math.max;
266
- var min = Math.min;
267
-
268
- // Helper for a popular repeating case of the spec:
269
- // Let integer be ? ToInteger(index).
270
- // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
271
- var toAbsoluteIndex$1 = function (index, length) {
272
- var integer = toInteger(index);
273
- return integer < 0 ? max(integer + length, 0) : min(integer, length);
279
+ // `GetMethod` abstract operation
280
+ // https://tc39.es/ecma262/#sec-getmethod
281
+ var getMethod$1 = function (V, P) {
282
+ var func = V[P];
283
+ return isNullOrUndefined(func) ? undefined : aCallable$1(func);
274
284
  };
275
285
 
276
- var toIndexedObject$3 = toIndexedObject$4;
277
- var toLength = toLength$1;
278
- var toAbsoluteIndex = toAbsoluteIndex$1;
286
+ var call$4 = functionCall;
287
+ var isCallable$a = isCallable$f;
288
+ var isObject$7 = isObject$8;
279
289
 
280
- // `Array.prototype.{ indexOf, includes }` methods implementation
281
- var createMethod$1 = function (IS_INCLUDES) {
282
- return function ($this, el, fromIndex) {
283
- var O = toIndexedObject$3($this);
284
- var length = toLength(O.length);
285
- var index = toAbsoluteIndex(fromIndex, length);
286
- var value;
287
- // Array#includes uses SameValueZero equality algorithm
288
- // eslint-disable-next-line no-self-compare
289
- if (IS_INCLUDES && el != el) while (length > index) {
290
- value = O[index++];
291
- // eslint-disable-next-line no-self-compare
292
- if (value != value) return true;
293
- // Array#indexOf ignores holes, Array#includes - not
294
- } else for (;length > index; index++) {
295
- if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
296
- } return !IS_INCLUDES && -1;
297
- };
290
+ var $TypeError$4 = TypeError;
291
+
292
+ // `OrdinaryToPrimitive` abstract operation
293
+ // https://tc39.es/ecma262/#sec-ordinarytoprimitive
294
+ var ordinaryToPrimitive$1 = function (input, pref) {
295
+ var fn, val;
296
+ if (pref === 'string' && isCallable$a(fn = input.toString) && !isObject$7(val = call$4(fn, input))) return val;
297
+ if (isCallable$a(fn = input.valueOf) && !isObject$7(val = call$4(fn, input))) return val;
298
+ if (pref !== 'string' && isCallable$a(fn = input.toString) && !isObject$7(val = call$4(fn, input))) return val;
299
+ throw new $TypeError$4("Can't convert object to primitive value");
298
300
  };
299
301
 
300
- var arrayIncludes = {
301
- // `Array.prototype.includes` method
302
- // https://tc39.github.io/ecma262/#sec-array.prototype.includes
303
- includes: createMethod$1(true),
304
- // `Array.prototype.indexOf` method
305
- // https://tc39.github.io/ecma262/#sec-array.prototype.indexof
306
- indexOf: createMethod$1(false)
302
+ var sharedStore = {exports: {}};
303
+
304
+ var global$9 = global$d;
305
+
306
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
307
+ var defineProperty$5 = Object.defineProperty;
308
+
309
+ var defineGlobalProperty$3 = function (key, value) {
310
+ try {
311
+ defineProperty$5(global$9, key, { value: value, configurable: true, writable: true });
312
+ } catch (error) {
313
+ global$9[key] = value;
314
+ } return value;
307
315
  };
308
316
 
309
- var hiddenKeys$4 = {};
317
+ var globalThis$1 = global$d;
318
+ var defineGlobalProperty$2 = defineGlobalProperty$3;
310
319
 
311
- var has$b = has$d;
312
- var toIndexedObject$2 = toIndexedObject$4;
313
- var indexOf = arrayIncludes.indexOf;
314
- var hiddenKeys$3 = hiddenKeys$4;
320
+ var SHARED = '__core-js_shared__';
321
+ var store$3 = sharedStore.exports = globalThis$1[SHARED] || defineGlobalProperty$2(SHARED, {});
315
322
 
316
- var objectKeysInternal = function (object, names) {
317
- var O = toIndexedObject$2(object);
318
- var i = 0;
319
- var result = [];
320
- var key;
321
- for (key in O) !has$b(hiddenKeys$3, key) && has$b(O, key) && result.push(key);
322
- // Don't enum bug & hidden keys
323
- while (names.length > i) if (has$b(O, key = names[i++])) {
324
- ~indexOf(result, key) || result.push(key);
325
- }
326
- return result;
323
+ (store$3.versions || (store$3.versions = [])).push({
324
+ version: '3.36.1',
325
+ mode: 'global',
326
+ copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
327
+ license: 'https://github.com/zloirock/core-js/blob/v3.36.1/LICENSE',
328
+ source: 'https://github.com/zloirock/core-js'
329
+ });
330
+
331
+ var sharedStoreExports = sharedStore.exports;
332
+
333
+ var store$2 = sharedStoreExports;
334
+
335
+ var shared$3 = function (key, value) {
336
+ return store$2[key] || (store$2[key] = value || {});
327
337
  };
328
338
 
329
- // IE8- don't enum bug keys
330
- var enumBugKeys$3 = [
331
- 'constructor',
332
- 'hasOwnProperty',
333
- 'isPrototypeOf',
334
- 'propertyIsEnumerable',
335
- 'toLocaleString',
336
- 'toString',
337
- 'valueOf'
338
- ];
339
+ var requireObjectCoercible$2 = requireObjectCoercible$4;
339
340
 
340
- var internalObjectKeys$1 = objectKeysInternal;
341
- var enumBugKeys$2 = enumBugKeys$3;
341
+ var $Object$2 = Object;
342
342
 
343
- // `Object.keys` method
344
- // https://tc39.github.io/ecma262/#sec-object.keys
345
- var objectKeys$1 = Object.keys || function keys(O) {
346
- return internalObjectKeys$1(O, enumBugKeys$2);
343
+ // `ToObject` abstract operation
344
+ // https://tc39.es/ecma262/#sec-toobject
345
+ var toObject$2 = function (argument) {
346
+ return $Object$2(requireObjectCoercible$2(argument));
347
347
  };
348
348
 
349
- var DESCRIPTORS$2 = descriptors;
350
- var definePropertyModule$2 = objectDefineProperty;
351
- var anObject$5 = anObject$7;
352
- var objectKeys = objectKeys$1;
349
+ var uncurryThis$9 = functionUncurryThis;
350
+ var toObject$1 = toObject$2;
353
351
 
354
- // `Object.defineProperties` method
355
- // https://tc39.github.io/ecma262/#sec-object.defineproperties
356
- var objectDefineProperties = DESCRIPTORS$2 ? Object.defineProperties : function defineProperties(O, Properties) {
357
- anObject$5(O);
358
- var keys = objectKeys(Properties);
359
- var length = keys.length;
360
- var index = 0;
361
- var key;
362
- while (length > index) definePropertyModule$2.f(O, key = keys[index++], Properties[key]);
363
- return O;
352
+ var hasOwnProperty = uncurryThis$9({}.hasOwnProperty);
353
+
354
+ // `HasOwnProperty` abstract operation
355
+ // https://tc39.es/ecma262/#sec-hasownproperty
356
+ // eslint-disable-next-line es/no-object-hasown -- safe
357
+ var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
358
+ return hasOwnProperty(toObject$1(it), key);
364
359
  };
365
360
 
366
- var global$9 = global$e;
361
+ var uncurryThis$8 = functionUncurryThis;
362
+
363
+ var id = 0;
364
+ var postfix = Math.random();
365
+ var toString$4 = uncurryThis$8(1.0.toString);
366
+
367
+ var uid$2 = function (key) {
368
+ return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$4(++id + postfix, 36);
369
+ };
367
370
 
368
- var path$1 = global$9;
371
+ var global$8 = global$d;
372
+ var shared$2 = shared$3;
373
+ var hasOwn$a = hasOwnProperty_1;
374
+ var uid$1 = uid$2;
375
+ var NATIVE_SYMBOL$1 = symbolConstructorDetection;
376
+ var USE_SYMBOL_AS_UID = useSymbolAsUid;
369
377
 
370
- var path = path$1;
371
- var global$8 = global$e;
378
+ var Symbol$2 = global$8.Symbol;
379
+ var WellKnownSymbolsStore = shared$2('wks');
380
+ var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$2['for'] || Symbol$2 : Symbol$2 && Symbol$2.withoutSetter || uid$1;
372
381
 
373
- var aFunction = function (variable) {
374
- return typeof variable == 'function' ? variable : undefined;
382
+ var wellKnownSymbol$8 = function (name) {
383
+ if (!hasOwn$a(WellKnownSymbolsStore, name)) {
384
+ WellKnownSymbolsStore[name] = NATIVE_SYMBOL$1 && hasOwn$a(Symbol$2, name)
385
+ ? Symbol$2[name]
386
+ : createWellKnownSymbol('Symbol.' + name);
387
+ } return WellKnownSymbolsStore[name];
375
388
  };
376
389
 
377
- var getBuiltIn$2 = function (namespace, method) {
378
- return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global$8[namespace])
379
- : path[namespace] && path[namespace][method] || global$8[namespace] && global$8[namespace][method];
390
+ var call$3 = functionCall;
391
+ var isObject$6 = isObject$8;
392
+ var isSymbol$1 = isSymbol$2;
393
+ var getMethod = getMethod$1;
394
+ var ordinaryToPrimitive = ordinaryToPrimitive$1;
395
+ var wellKnownSymbol$7 = wellKnownSymbol$8;
396
+
397
+ var $TypeError$3 = TypeError;
398
+ var TO_PRIMITIVE = wellKnownSymbol$7('toPrimitive');
399
+
400
+ // `ToPrimitive` abstract operation
401
+ // https://tc39.es/ecma262/#sec-toprimitive
402
+ var toPrimitive$1 = function (input, pref) {
403
+ if (!isObject$6(input) || isSymbol$1(input)) return input;
404
+ var exoticToPrim = getMethod(input, TO_PRIMITIVE);
405
+ var result;
406
+ if (exoticToPrim) {
407
+ if (pref === undefined) pref = 'default';
408
+ result = call$3(exoticToPrim, input, pref);
409
+ if (!isObject$6(result) || isSymbol$1(result)) return result;
410
+ throw new $TypeError$3("Can't convert object to primitive value");
411
+ }
412
+ if (pref === undefined) pref = 'number';
413
+ return ordinaryToPrimitive(input, pref);
380
414
  };
381
415
 
382
- var getBuiltIn$1 = getBuiltIn$2;
416
+ var toPrimitive = toPrimitive$1;
417
+ var isSymbol = isSymbol$2;
383
418
 
384
- var html$1 = getBuiltIn$1('document', 'documentElement');
419
+ // `ToPropertyKey` abstract operation
420
+ // https://tc39.es/ecma262/#sec-topropertykey
421
+ var toPropertyKey$2 = function (argument) {
422
+ var key = toPrimitive(argument, 'string');
423
+ return isSymbol(key) ? key : key + '';
424
+ };
385
425
 
386
- var shared = shared$2.exports;
387
- var uid = uid$2;
426
+ var global$7 = global$d;
427
+ var isObject$5 = isObject$8;
388
428
 
389
- var keys = shared('keys');
429
+ var document$1 = global$7.document;
430
+ // typeof document.createElement is 'object' in old IE
431
+ var EXISTS$1 = isObject$5(document$1) && isObject$5(document$1.createElement);
390
432
 
391
- var sharedKey$3 = function (key) {
392
- return keys[key] || (keys[key] = uid(key));
433
+ var documentCreateElement$2 = function (it) {
434
+ return EXISTS$1 ? document$1.createElement(it) : {};
393
435
  };
394
436
 
395
- var anObject$4 = anObject$7;
396
- var defineProperties = objectDefineProperties;
397
- var enumBugKeys$1 = enumBugKeys$3;
398
- var hiddenKeys$2 = hiddenKeys$4;
399
- var html = html$1;
400
- var documentCreateElement = documentCreateElement$1;
401
- var sharedKey$2 = sharedKey$3;
437
+ var DESCRIPTORS$9 = descriptors;
438
+ var fails$7 = fails$c;
439
+ var createElement = documentCreateElement$2;
402
440
 
403
- var GT = '>';
404
- var LT = '<';
405
- var PROTOTYPE = 'prototype';
406
- var SCRIPT = 'script';
407
- var IE_PROTO$1 = sharedKey$2('IE_PROTO');
441
+ // Thanks to IE8 for its funny defineProperty
442
+ var ie8DomDefine = !DESCRIPTORS$9 && !fails$7(function () {
443
+ // eslint-disable-next-line es/no-object-defineproperty -- required for testing
444
+ return Object.defineProperty(createElement('div'), 'a', {
445
+ get: function () { return 7; }
446
+ }).a !== 7;
447
+ });
408
448
 
409
- var EmptyConstructor = function () { /* empty */ };
449
+ var DESCRIPTORS$8 = descriptors;
450
+ var call$2 = functionCall;
451
+ var propertyIsEnumerableModule = objectPropertyIsEnumerable;
452
+ var createPropertyDescriptor$2 = createPropertyDescriptor$3;
453
+ var toIndexedObject$4 = toIndexedObject$5;
454
+ var toPropertyKey$1 = toPropertyKey$2;
455
+ var hasOwn$9 = hasOwnProperty_1;
456
+ var IE8_DOM_DEFINE$1 = ie8DomDefine;
410
457
 
411
- var scriptTag = function (content) {
412
- return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
413
- };
458
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
459
+ var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
414
460
 
415
- // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
416
- var NullProtoObjectViaActiveX = function (activeXDocument) {
417
- activeXDocument.write(scriptTag(''));
418
- activeXDocument.close();
419
- var temp = activeXDocument.parentWindow.Object;
420
- activeXDocument = null; // avoid memory leak
421
- return temp;
461
+ // `Object.getOwnPropertyDescriptor` method
462
+ // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
463
+ objectGetOwnPropertyDescriptor.f = DESCRIPTORS$8 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
464
+ O = toIndexedObject$4(O);
465
+ P = toPropertyKey$1(P);
466
+ if (IE8_DOM_DEFINE$1) try {
467
+ return $getOwnPropertyDescriptor$1(O, P);
468
+ } catch (error) { /* empty */ }
469
+ if (hasOwn$9(O, P)) return createPropertyDescriptor$2(!call$2(propertyIsEnumerableModule.f, O, P), O[P]);
422
470
  };
423
471
 
424
- // Create object with fake `null` prototype: use iframe Object with cleared prototype
425
- var NullProtoObjectViaIFrame = function () {
426
- // Thrash, waste and sodomy: IE GC bug
427
- var iframe = documentCreateElement('iframe');
428
- var JS = 'java' + SCRIPT + ':';
429
- var iframeDocument;
430
- iframe.style.display = 'none';
431
- html.appendChild(iframe);
432
- // https://github.com/zloirock/core-js/issues/475
433
- iframe.src = String(JS);
434
- iframeDocument = iframe.contentWindow.document;
435
- iframeDocument.open();
436
- iframeDocument.write(scriptTag('document.F=Object'));
437
- iframeDocument.close();
438
- return iframeDocument.F;
472
+ var objectDefineProperty = {};
473
+
474
+ var DESCRIPTORS$7 = descriptors;
475
+ var fails$6 = fails$c;
476
+
477
+ // V8 ~ Chrome 36-
478
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3334
479
+ var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$6(function () {
480
+ // eslint-disable-next-line es/no-object-defineproperty -- required for testing
481
+ return Object.defineProperty(function () { /* empty */ }, 'prototype', {
482
+ value: 42,
483
+ writable: false
484
+ }).prototype !== 42;
485
+ });
486
+
487
+ var isObject$4 = isObject$8;
488
+
489
+ var $String$3 = String;
490
+ var $TypeError$2 = TypeError;
491
+
492
+ // `Assert: Type(argument) is Object`
493
+ var anObject$6 = function (argument) {
494
+ if (isObject$4(argument)) return argument;
495
+ throw new $TypeError$2($String$3(argument) + ' is not an object');
439
496
  };
440
497
 
441
- // Check for document.domain and active x support
442
- // No need to use active x approach when document.domain is not set
443
- // see https://github.com/es-shims/es5-shim/issues/150
444
- // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
445
- // avoid IE GC bug
446
- var activeXDocument;
447
- var NullProtoObject = function () {
448
- try {
449
- /* global ActiveXObject */
450
- activeXDocument = document.domain && new ActiveXObject('htmlfile');
451
- } catch (error) { /* ignore */ }
452
- NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();
453
- var length = enumBugKeys$1.length;
454
- while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys$1[length]];
455
- return NullProtoObject();
498
+ var DESCRIPTORS$6 = descriptors;
499
+ var IE8_DOM_DEFINE = ie8DomDefine;
500
+ var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
501
+ var anObject$5 = anObject$6;
502
+ var toPropertyKey = toPropertyKey$2;
503
+
504
+ var $TypeError$1 = TypeError;
505
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
506
+ var $defineProperty = Object.defineProperty;
507
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
508
+ var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
509
+ var ENUMERABLE = 'enumerable';
510
+ var CONFIGURABLE$1 = 'configurable';
511
+ var WRITABLE = 'writable';
512
+
513
+ // `Object.defineProperty` method
514
+ // https://tc39.es/ecma262/#sec-object.defineproperty
515
+ objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
516
+ anObject$5(O);
517
+ P = toPropertyKey(P);
518
+ anObject$5(Attributes);
519
+ if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
520
+ var current = $getOwnPropertyDescriptor(O, P);
521
+ if (current && current[WRITABLE]) {
522
+ O[P] = Attributes.value;
523
+ Attributes = {
524
+ configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
525
+ enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
526
+ writable: false
527
+ };
528
+ }
529
+ } return $defineProperty(O, P, Attributes);
530
+ } : $defineProperty : function defineProperty(O, P, Attributes) {
531
+ anObject$5(O);
532
+ P = toPropertyKey(P);
533
+ anObject$5(Attributes);
534
+ if (IE8_DOM_DEFINE) try {
535
+ return $defineProperty(O, P, Attributes);
536
+ } catch (error) { /* empty */ }
537
+ if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$1('Accessors not supported');
538
+ if ('value' in Attributes) O[P] = Attributes.value;
539
+ return O;
456
540
  };
457
541
 
458
- hiddenKeys$2[IE_PROTO$1] = true;
542
+ var DESCRIPTORS$5 = descriptors;
543
+ var definePropertyModule$3 = objectDefineProperty;
544
+ var createPropertyDescriptor$1 = createPropertyDescriptor$3;
459
545
 
460
- // `Object.create` method
461
- // https://tc39.github.io/ecma262/#sec-object.create
462
- var objectCreate = Object.create || function create(O, Properties) {
463
- var result;
464
- if (O !== null) {
465
- EmptyConstructor[PROTOTYPE] = anObject$4(O);
466
- result = new EmptyConstructor();
467
- EmptyConstructor[PROTOTYPE] = null;
468
- // add "__proto__" for Object.getPrototypeOf polyfill
469
- result[IE_PROTO$1] = O;
470
- } else result = NullProtoObject();
471
- return Properties === undefined ? result : defineProperties(result, Properties);
546
+ var createNonEnumerableProperty$4 = DESCRIPTORS$5 ? function (object, key, value) {
547
+ return definePropertyModule$3.f(object, key, createPropertyDescriptor$1(1, value));
548
+ } : function (object, key, value) {
549
+ object[key] = value;
550
+ return object;
472
551
  };
473
552
 
474
- var wellKnownSymbol$4 = wellKnownSymbol$5;
475
- var create$1 = objectCreate;
476
- var definePropertyModule$1 = objectDefineProperty;
553
+ var makeBuiltIn$3 = {exports: {}};
477
554
 
478
- var UNSCOPABLES = wellKnownSymbol$4('unscopables');
479
- var ArrayPrototype = Array.prototype;
555
+ var DESCRIPTORS$4 = descriptors;
556
+ var hasOwn$8 = hasOwnProperty_1;
480
557
 
481
- // Array.prototype[@@unscopables]
482
- // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
483
- if (ArrayPrototype[UNSCOPABLES] == undefined) {
484
- definePropertyModule$1.f(ArrayPrototype, UNSCOPABLES, {
485
- configurable: true,
486
- value: create$1(null)
487
- });
488
- }
558
+ var FunctionPrototype = Function.prototype;
559
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
560
+ var getDescriptor = DESCRIPTORS$4 && Object.getOwnPropertyDescriptor;
489
561
 
490
- // add a key to Array.prototype[@@unscopables]
491
- var addToUnscopables$1 = function (key) {
492
- ArrayPrototype[UNSCOPABLES][key] = true;
493
- };
562
+ var EXISTS = hasOwn$8(FunctionPrototype, 'name');
563
+ // additional protection from minified / mangled / dropped function names
564
+ var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
565
+ var CONFIGURABLE = EXISTS && (!DESCRIPTORS$4 || (DESCRIPTORS$4 && getDescriptor(FunctionPrototype, 'name').configurable));
494
566
 
495
- var iterators = {};
567
+ var functionName = {
568
+ EXISTS: EXISTS,
569
+ PROPER: PROPER,
570
+ CONFIGURABLE: CONFIGURABLE
571
+ };
496
572
 
497
- var store$1 = sharedStore;
573
+ var uncurryThis$7 = functionUncurryThis;
574
+ var isCallable$9 = isCallable$f;
575
+ var store$1 = sharedStoreExports;
498
576
 
499
- var functionToString = Function.toString;
577
+ var functionToString = uncurryThis$7(Function.toString);
500
578
 
501
- // this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper
502
- if (typeof store$1.inspectSource != 'function') {
579
+ // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
580
+ if (!isCallable$9(store$1.inspectSource)) {
503
581
  store$1.inspectSource = function (it) {
504
- return functionToString.call(it);
582
+ return functionToString(it);
505
583
  };
506
584
  }
507
585
 
508
- var inspectSource$2 = store$1.inspectSource;
586
+ var inspectSource$1 = store$1.inspectSource;
509
587
 
510
- var global$7 = global$e;
511
- var inspectSource$1 = inspectSource$2;
588
+ var global$6 = global$d;
589
+ var isCallable$8 = isCallable$f;
512
590
 
513
- var WeakMap$1 = global$7.WeakMap;
591
+ var WeakMap$1 = global$6.WeakMap;
514
592
 
515
- var nativeWeakMap = typeof WeakMap$1 === 'function' && /native code/.test(inspectSource$1(WeakMap$1));
593
+ var weakMapBasicDetection = isCallable$8(WeakMap$1) && /native code/.test(String(WeakMap$1));
516
594
 
517
- var NATIVE_WEAK_MAP = nativeWeakMap;
518
- var global$6 = global$e;
519
- var isObject$2 = isObject$6;
520
- var createNonEnumerableProperty$5 = createNonEnumerableProperty$7;
521
- var objectHas = has$d;
522
- var sharedKey$1 = sharedKey$3;
523
- var hiddenKeys$1 = hiddenKeys$4;
595
+ var shared$1 = shared$3;
596
+ var uid = uid$2;
597
+
598
+ var keys = shared$1('keys');
599
+
600
+ var sharedKey$3 = function (key) {
601
+ return keys[key] || (keys[key] = uid(key));
602
+ };
603
+
604
+ var hiddenKeys$4 = {};
605
+
606
+ var NATIVE_WEAK_MAP = weakMapBasicDetection;
607
+ var global$5 = global$d;
608
+ var isObject$3 = isObject$8;
609
+ var createNonEnumerableProperty$3 = createNonEnumerableProperty$4;
610
+ var hasOwn$7 = hasOwnProperty_1;
611
+ var shared = sharedStoreExports;
612
+ var sharedKey$2 = sharedKey$3;
613
+ var hiddenKeys$3 = hiddenKeys$4;
524
614
 
525
- var WeakMap = global$6.WeakMap;
526
- var set, get, has$a;
615
+ var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
616
+ var TypeError$1 = global$5.TypeError;
617
+ var WeakMap = global$5.WeakMap;
618
+ var set, get, has$1;
527
619
 
528
620
  var enforce = function (it) {
529
- return has$a(it) ? get(it) : set(it, {});
621
+ return has$1(it) ? get(it) : set(it, {});
530
622
  };
531
623
 
532
624
  var getterFor = function (TYPE) {
533
625
  return function (it) {
534
626
  var state;
535
- if (!isObject$2(it) || (state = get(it)).type !== TYPE) {
536
- throw TypeError('Incompatible receiver, ' + TYPE + ' required');
627
+ if (!isObject$3(it) || (state = get(it)).type !== TYPE) {
628
+ throw new TypeError$1('Incompatible receiver, ' + TYPE + ' required');
537
629
  } return state;
538
630
  };
539
631
  };
540
632
 
541
- if (NATIVE_WEAK_MAP) {
542
- var store = new WeakMap();
543
- var wmget = store.get;
544
- var wmhas = store.has;
545
- var wmset = store.set;
633
+ if (NATIVE_WEAK_MAP || shared.state) {
634
+ var store = shared.state || (shared.state = new WeakMap());
635
+ /* eslint-disable no-self-assign -- prototype methods protection */
636
+ store.get = store.get;
637
+ store.has = store.has;
638
+ store.set = store.set;
639
+ /* eslint-enable no-self-assign -- prototype methods protection */
546
640
  set = function (it, metadata) {
547
- wmset.call(store, it, metadata);
641
+ if (store.has(it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
642
+ metadata.facade = it;
643
+ store.set(it, metadata);
548
644
  return metadata;
549
645
  };
550
646
  get = function (it) {
551
- return wmget.call(store, it) || {};
647
+ return store.get(it) || {};
552
648
  };
553
- has$a = function (it) {
554
- return wmhas.call(store, it);
649
+ has$1 = function (it) {
650
+ return store.has(it);
555
651
  };
556
652
  } else {
557
- var STATE = sharedKey$1('state');
558
- hiddenKeys$1[STATE] = true;
653
+ var STATE = sharedKey$2('state');
654
+ hiddenKeys$3[STATE] = true;
559
655
  set = function (it, metadata) {
560
- createNonEnumerableProperty$5(it, STATE, metadata);
656
+ if (hasOwn$7(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
657
+ metadata.facade = it;
658
+ createNonEnumerableProperty$3(it, STATE, metadata);
561
659
  return metadata;
562
660
  };
563
661
  get = function (it) {
564
- return objectHas(it, STATE) ? it[STATE] : {};
662
+ return hasOwn$7(it, STATE) ? it[STATE] : {};
565
663
  };
566
- has$a = function (it) {
567
- return objectHas(it, STATE);
664
+ has$1 = function (it) {
665
+ return hasOwn$7(it, STATE);
568
666
  };
569
667
  }
570
668
 
571
669
  var internalState = {
572
670
  set: set,
573
671
  get: get,
574
- has: has$a,
672
+ has: has$1,
575
673
  enforce: enforce,
576
674
  getterFor: getterFor
577
675
  };
578
676
 
579
- var objectGetOwnPropertyDescriptor = {};
677
+ var uncurryThis$6 = functionUncurryThis;
678
+ var fails$5 = fails$c;
679
+ var isCallable$7 = isCallable$f;
680
+ var hasOwn$6 = hasOwnProperty_1;
681
+ var DESCRIPTORS$3 = descriptors;
682
+ var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
683
+ var inspectSource = inspectSource$1;
684
+ var InternalStateModule$1 = internalState;
580
685
 
581
- var objectPropertyIsEnumerable = {};
686
+ var enforceInternalState = InternalStateModule$1.enforce;
687
+ var getInternalState$1 = InternalStateModule$1.get;
688
+ var $String$2 = String;
689
+ // eslint-disable-next-line es/no-object-defineproperty -- safe
690
+ var defineProperty$4 = Object.defineProperty;
691
+ var stringSlice$1 = uncurryThis$6(''.slice);
692
+ var replace$2 = uncurryThis$6(''.replace);
693
+ var join = uncurryThis$6([].join);
694
+
695
+ var CONFIGURABLE_LENGTH = DESCRIPTORS$3 && !fails$5(function () {
696
+ return defineProperty$4(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
697
+ });
582
698
 
583
- var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
584
- var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
699
+ var TEMPLATE = String(String).split('String');
585
700
 
586
- // Nashorn ~ JDK8 bug
587
- var NASHORN_BUG = getOwnPropertyDescriptor$1 && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
701
+ var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
702
+ if (stringSlice$1($String$2(name), 0, 7) === 'Symbol(') {
703
+ name = '[' + replace$2($String$2(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
704
+ }
705
+ if (options && options.getter) name = 'get ' + name;
706
+ if (options && options.setter) name = 'set ' + name;
707
+ if (!hasOwn$6(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) {
708
+ if (DESCRIPTORS$3) defineProperty$4(value, 'name', { value: name, configurable: true });
709
+ else value.name = name;
710
+ }
711
+ if (CONFIGURABLE_LENGTH && options && hasOwn$6(options, 'arity') && value.length !== options.arity) {
712
+ defineProperty$4(value, 'length', { value: options.arity });
713
+ }
714
+ try {
715
+ if (options && hasOwn$6(options, 'constructor') && options.constructor) {
716
+ if (DESCRIPTORS$3) defineProperty$4(value, 'prototype', { writable: false });
717
+ // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
718
+ } else if (value.prototype) value.prototype = undefined;
719
+ } catch (error) { /* empty */ }
720
+ var state = enforceInternalState(value);
721
+ if (!hasOwn$6(state, 'source')) {
722
+ state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
723
+ } return value;
724
+ };
588
725
 
589
- // `Object.prototype.propertyIsEnumerable` method implementation
590
- // https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable
591
- objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
592
- var descriptor = getOwnPropertyDescriptor$1(this, V);
593
- return !!descriptor && descriptor.enumerable;
594
- } : nativePropertyIsEnumerable;
726
+ // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
727
+ // eslint-disable-next-line no-extend-native -- required
728
+ Function.prototype.toString = makeBuiltIn$2(function toString() {
729
+ return isCallable$7(this) && getInternalState$1(this).source || inspectSource(this);
730
+ }, 'toString');
595
731
 
596
- var DESCRIPTORS$1 = descriptors;
597
- var propertyIsEnumerableModule = objectPropertyIsEnumerable;
598
- var createPropertyDescriptor$1 = createPropertyDescriptor$3;
599
- var toIndexedObject$1 = toIndexedObject$4;
600
- var toPrimitive = toPrimitive$2;
601
- var has$9 = has$d;
602
- var IE8_DOM_DEFINE = ie8DomDefine;
732
+ var makeBuiltInExports = makeBuiltIn$3.exports;
603
733
 
604
- var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
734
+ var isCallable$6 = isCallable$f;
735
+ var definePropertyModule$2 = objectDefineProperty;
736
+ var makeBuiltIn$1 = makeBuiltInExports;
737
+ var defineGlobalProperty$1 = defineGlobalProperty$3;
738
+
739
+ var defineBuiltIn$4 = function (O, key, value, options) {
740
+ if (!options) options = {};
741
+ var simple = options.enumerable;
742
+ var name = options.name !== undefined ? options.name : key;
743
+ if (isCallable$6(value)) makeBuiltIn$1(value, name, options);
744
+ if (options.global) {
745
+ if (simple) O[key] = value;
746
+ else defineGlobalProperty$1(key, value);
747
+ } else {
748
+ try {
749
+ if (!options.unsafe) delete O[key];
750
+ else if (O[key]) simple = true;
751
+ } catch (error) { /* empty */ }
752
+ if (simple) O[key] = value;
753
+ else definePropertyModule$2.f(O, key, {
754
+ value: value,
755
+ enumerable: false,
756
+ configurable: !options.nonConfigurable,
757
+ writable: !options.nonWritable
758
+ });
759
+ } return O;
760
+ };
605
761
 
606
- // `Object.getOwnPropertyDescriptor` method
607
- // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor
608
- objectGetOwnPropertyDescriptor.f = DESCRIPTORS$1 ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
609
- O = toIndexedObject$1(O);
610
- P = toPrimitive(P, true);
611
- if (IE8_DOM_DEFINE) try {
612
- return nativeGetOwnPropertyDescriptor(O, P);
613
- } catch (error) { /* empty */ }
614
- if (has$9(O, P)) return createPropertyDescriptor$1(!propertyIsEnumerableModule.f.call(O, P), O[P]);
762
+ var objectGetOwnPropertyNames = {};
763
+
764
+ var ceil = Math.ceil;
765
+ var floor = Math.floor;
766
+
767
+ // `Math.trunc` method
768
+ // https://tc39.es/ecma262/#sec-math.trunc
769
+ // eslint-disable-next-line es/no-math-trunc -- safe
770
+ var mathTrunc = Math.trunc || function trunc(x) {
771
+ var n = +x;
772
+ return (n > 0 ? floor : ceil)(n);
615
773
  };
616
774
 
617
- var redefine$3 = {exports: {}};
775
+ var trunc = mathTrunc;
618
776
 
619
- var global$5 = global$e;
620
- var createNonEnumerableProperty$4 = createNonEnumerableProperty$7;
621
- var has$8 = has$d;
622
- var setGlobal$1 = setGlobal$3;
623
- var inspectSource = inspectSource$2;
624
- var InternalStateModule$1 = internalState;
777
+ // `ToIntegerOrInfinity` abstract operation
778
+ // https://tc39.es/ecma262/#sec-tointegerorinfinity
779
+ var toIntegerOrInfinity$2 = function (argument) {
780
+ var number = +argument;
781
+ // eslint-disable-next-line no-self-compare -- NaN check
782
+ return number !== number || number === 0 ? 0 : trunc(number);
783
+ };
625
784
 
626
- var getInternalState$1 = InternalStateModule$1.get;
627
- var enforceInternalState = InternalStateModule$1.enforce;
628
- var TEMPLATE = String(String).split('String');
785
+ var toIntegerOrInfinity$1 = toIntegerOrInfinity$2;
629
786
 
630
- (redefine$3.exports = function (O, key, value, options) {
631
- var unsafe = options ? !!options.unsafe : false;
632
- var simple = options ? !!options.enumerable : false;
633
- var noTargetGet = options ? !!options.noTargetGet : false;
634
- if (typeof value == 'function') {
635
- if (typeof key == 'string' && !has$8(value, 'name')) createNonEnumerableProperty$4(value, 'name', key);
636
- enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
637
- }
638
- if (O === global$5) {
639
- if (simple) O[key] = value;
640
- else setGlobal$1(key, value);
641
- return;
642
- } else if (!unsafe) {
643
- delete O[key];
644
- } else if (!noTargetGet && O[key]) {
645
- simple = true;
787
+ var max = Math.max;
788
+ var min$1 = Math.min;
789
+
790
+ // Helper for a popular repeating case of the spec:
791
+ // Let integer be ? ToInteger(index).
792
+ // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
793
+ var toAbsoluteIndex$1 = function (index, length) {
794
+ var integer = toIntegerOrInfinity$1(index);
795
+ return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
796
+ };
797
+
798
+ var toIntegerOrInfinity = toIntegerOrInfinity$2;
799
+
800
+ var min = Math.min;
801
+
802
+ // `ToLength` abstract operation
803
+ // https://tc39.es/ecma262/#sec-tolength
804
+ var toLength$1 = function (argument) {
805
+ var len = toIntegerOrInfinity(argument);
806
+ return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
807
+ };
808
+
809
+ var toLength = toLength$1;
810
+
811
+ // `LengthOfArrayLike` abstract operation
812
+ // https://tc39.es/ecma262/#sec-lengthofarraylike
813
+ var lengthOfArrayLike$1 = function (obj) {
814
+ return toLength(obj.length);
815
+ };
816
+
817
+ var toIndexedObject$3 = toIndexedObject$5;
818
+ var toAbsoluteIndex = toAbsoluteIndex$1;
819
+ var lengthOfArrayLike = lengthOfArrayLike$1;
820
+
821
+ // `Array.prototype.{ indexOf, includes }` methods implementation
822
+ var createMethod$1 = function (IS_INCLUDES) {
823
+ return function ($this, el, fromIndex) {
824
+ var O = toIndexedObject$3($this);
825
+ var length = lengthOfArrayLike(O);
826
+ if (length === 0) return !IS_INCLUDES && -1;
827
+ var index = toAbsoluteIndex(fromIndex, length);
828
+ var value;
829
+ // Array#includes uses SameValueZero equality algorithm
830
+ // eslint-disable-next-line no-self-compare -- NaN check
831
+ if (IS_INCLUDES && el !== el) while (length > index) {
832
+ value = O[index++];
833
+ // eslint-disable-next-line no-self-compare -- NaN check
834
+ if (value !== value) return true;
835
+ // Array#indexOf ignores holes, Array#includes - not
836
+ } else for (;length > index; index++) {
837
+ if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
838
+ } return !IS_INCLUDES && -1;
839
+ };
840
+ };
841
+
842
+ var arrayIncludes = {
843
+ // `Array.prototype.includes` method
844
+ // https://tc39.es/ecma262/#sec-array.prototype.includes
845
+ includes: createMethod$1(true),
846
+ // `Array.prototype.indexOf` method
847
+ // https://tc39.es/ecma262/#sec-array.prototype.indexof
848
+ indexOf: createMethod$1(false)
849
+ };
850
+
851
+ var uncurryThis$5 = functionUncurryThis;
852
+ var hasOwn$5 = hasOwnProperty_1;
853
+ var toIndexedObject$2 = toIndexedObject$5;
854
+ var indexOf = arrayIncludes.indexOf;
855
+ var hiddenKeys$2 = hiddenKeys$4;
856
+
857
+ var push = uncurryThis$5([].push);
858
+
859
+ var objectKeysInternal = function (object, names) {
860
+ var O = toIndexedObject$2(object);
861
+ var i = 0;
862
+ var result = [];
863
+ var key;
864
+ for (key in O) !hasOwn$5(hiddenKeys$2, key) && hasOwn$5(O, key) && push(result, key);
865
+ // Don't enum bug & hidden keys
866
+ while (names.length > i) if (hasOwn$5(O, key = names[i++])) {
867
+ ~indexOf(result, key) || push(result, key);
646
868
  }
647
- if (simple) O[key] = value;
648
- else createNonEnumerableProperty$4(O, key, value);
649
- // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
650
- })(Function.prototype, 'toString', function toString() {
651
- return typeof this == 'function' && getInternalState$1(this).source || inspectSource(this);
652
- });
869
+ return result;
870
+ };
653
871
 
654
- var objectGetOwnPropertyNames = {};
872
+ // IE8- don't enum bug keys
873
+ var enumBugKeys$3 = [
874
+ 'constructor',
875
+ 'hasOwnProperty',
876
+ 'isPrototypeOf',
877
+ 'propertyIsEnumerable',
878
+ 'toLocaleString',
879
+ 'toString',
880
+ 'valueOf'
881
+ ];
655
882
 
656
- var internalObjectKeys = objectKeysInternal;
657
- var enumBugKeys = enumBugKeys$3;
883
+ var internalObjectKeys$1 = objectKeysInternal;
884
+ var enumBugKeys$2 = enumBugKeys$3;
658
885
 
659
- var hiddenKeys = enumBugKeys.concat('length', 'prototype');
886
+ var hiddenKeys$1 = enumBugKeys$2.concat('length', 'prototype');
660
887
 
661
888
  // `Object.getOwnPropertyNames` method
662
- // https://tc39.github.io/ecma262/#sec-object.getownpropertynames
889
+ // https://tc39.es/ecma262/#sec-object.getownpropertynames
890
+ // eslint-disable-next-line es/no-object-getownpropertynames -- safe
663
891
  objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
664
- return internalObjectKeys(O, hiddenKeys);
892
+ return internalObjectKeys$1(O, hiddenKeys$1);
665
893
  };
666
894
 
667
895
  var objectGetOwnPropertySymbols = {};
668
896
 
897
+ // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
669
898
  objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
670
899
 
671
- var getBuiltIn = getBuiltIn$2;
900
+ var getBuiltIn$1 = getBuiltIn$3;
901
+ var uncurryThis$4 = functionUncurryThis;
672
902
  var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
673
903
  var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
674
- var anObject$3 = anObject$7;
904
+ var anObject$4 = anObject$6;
905
+
906
+ var concat = uncurryThis$4([].concat);
675
907
 
676
908
  // all object keys, includes non-enumerable and symbols
677
- var ownKeys$1 = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
678
- var keys = getOwnPropertyNamesModule.f(anObject$3(it));
909
+ var ownKeys$1 = getBuiltIn$1('Reflect', 'ownKeys') || function ownKeys(it) {
910
+ var keys = getOwnPropertyNamesModule.f(anObject$4(it));
679
911
  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
680
- return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
912
+ return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
681
913
  };
682
914
 
683
- var has$7 = has$d;
915
+ var hasOwn$4 = hasOwnProperty_1;
684
916
  var ownKeys = ownKeys$1;
685
917
  var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
686
- var definePropertyModule = objectDefineProperty;
918
+ var definePropertyModule$1 = objectDefineProperty;
687
919
 
688
- var copyConstructorProperties$2 = function (target, source) {
920
+ var copyConstructorProperties$2 = function (target, source, exceptions) {
689
921
  var keys = ownKeys(source);
690
- var defineProperty = definePropertyModule.f;
922
+ var defineProperty = definePropertyModule$1.f;
691
923
  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
692
924
  for (var i = 0; i < keys.length; i++) {
693
925
  var key = keys[i];
694
- if (!has$7(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
926
+ if (!hasOwn$4(target, key) && !(exceptions && hasOwn$4(exceptions, key))) {
927
+ defineProperty(target, key, getOwnPropertyDescriptor(source, key));
928
+ }
695
929
  }
696
930
  };
697
931
 
698
- var fails$2 = fails$7;
932
+ var fails$4 = fails$c;
933
+ var isCallable$5 = isCallable$f;
699
934
 
700
935
  var replacement = /#|\.prototype\./;
701
936
 
702
937
  var isForced$1 = function (feature, detection) {
703
938
  var value = data[normalize(feature)];
704
- return value == POLYFILL ? true
705
- : value == NATIVE ? false
706
- : typeof detection == 'function' ? fails$2(detection)
939
+ return value === POLYFILL ? true
940
+ : value === NATIVE ? false
941
+ : isCallable$5(detection) ? fails$4(detection)
707
942
  : !!detection;
708
943
  };
709
944
 
@@ -717,27 +952,28 @@ var POLYFILL = isForced$1.POLYFILL = 'P';
717
952
 
718
953
  var isForced_1 = isForced$1;
719
954
 
720
- var global$4 = global$e;
955
+ var global$4 = global$d;
721
956
  var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
722
- var createNonEnumerableProperty$3 = createNonEnumerableProperty$7;
723
- var redefine$2 = redefine$3.exports;
724
- var setGlobal = setGlobal$3;
957
+ var createNonEnumerableProperty$2 = createNonEnumerableProperty$4;
958
+ var defineBuiltIn$3 = defineBuiltIn$4;
959
+ var defineGlobalProperty = defineGlobalProperty$3;
725
960
  var copyConstructorProperties$1 = copyConstructorProperties$2;
726
961
  var isForced = isForced_1;
727
962
 
728
963
  /*
729
- options.target - name of the target object
730
- options.global - target is the global object
731
- options.stat - export as static methods of target
732
- options.proto - export as prototype methods of target
733
- options.real - real prototype method for the `pure` version
734
- options.forced - export even if the native feature is available
735
- options.bind - bind methods to the target, required for the `pure` version
736
- options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
737
- options.unsafe - use the simple assignment of property instead of delete + defineProperty
738
- options.sham - add a flag to not completely full polyfills
739
- options.enumerable - export as enumerable property
740
- options.noTargetGet - prevent calling a getter on target
964
+ options.target - name of the target object
965
+ options.global - target is the global object
966
+ options.stat - export as static methods of target
967
+ options.proto - export as prototype methods of target
968
+ options.real - real prototype method for the `pure` version
969
+ options.forced - export even if the native feature is available
970
+ options.bind - bind methods to the target, required for the `pure` version
971
+ options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
972
+ options.unsafe - use the simple assignment of property instead of delete + defineProperty
973
+ options.sham - add a flag to not completely full polyfills
974
+ options.enumerable - export as enumerable property
975
+ options.dontCallGetSet - prevent calling a getter on target
976
+ options.name - the .name of the function if it does not match the key
741
977
  */
742
978
  var _export = function (options, source) {
743
979
  var TARGET = options.target;
@@ -747,79 +983,334 @@ var _export = function (options, source) {
747
983
  if (GLOBAL) {
748
984
  target = global$4;
749
985
  } else if (STATIC) {
750
- target = global$4[TARGET] || setGlobal(TARGET, {});
986
+ target = global$4[TARGET] || defineGlobalProperty(TARGET, {});
751
987
  } else {
752
- target = (global$4[TARGET] || {}).prototype;
988
+ target = global$4[TARGET] && global$4[TARGET].prototype;
753
989
  }
754
990
  if (target) for (key in source) {
755
991
  sourceProperty = source[key];
756
- if (options.noTargetGet) {
992
+ if (options.dontCallGetSet) {
757
993
  descriptor = getOwnPropertyDescriptor(target, key);
758
994
  targetProperty = descriptor && descriptor.value;
759
995
  } else targetProperty = target[key];
760
996
  FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
761
997
  // contained in target
762
998
  if (!FORCED && targetProperty !== undefined) {
763
- if (typeof sourceProperty === typeof targetProperty) continue;
999
+ if (typeof sourceProperty == typeof targetProperty) continue;
764
1000
  copyConstructorProperties$1(sourceProperty, targetProperty);
765
1001
  }
766
1002
  // add a flag to not completely full polyfills
767
1003
  if (options.sham || (targetProperty && targetProperty.sham)) {
768
- createNonEnumerableProperty$3(sourceProperty, 'sham', true);
1004
+ createNonEnumerableProperty$2(sourceProperty, 'sham', true);
769
1005
  }
770
- // extend global
771
- redefine$2(target, key, sourceProperty, options);
1006
+ defineBuiltIn$3(target, key, sourceProperty, options);
772
1007
  }
773
1008
  };
774
1009
 
775
- var requireObjectCoercible$1 = requireObjectCoercible$3;
1010
+ var wellKnownSymbol$6 = wellKnownSymbol$8;
776
1011
 
777
- // `ToObject` abstract operation
778
- // https://tc39.github.io/ecma262/#sec-toobject
779
- var toObject$2 = function (argument) {
780
- return Object(requireObjectCoercible$1(argument));
1012
+ var TO_STRING_TAG$2 = wellKnownSymbol$6('toStringTag');
1013
+ var test = {};
1014
+
1015
+ test[TO_STRING_TAG$2] = 'z';
1016
+
1017
+ var toStringTagSupport = String(test) === '[object z]';
1018
+
1019
+ var TO_STRING_TAG_SUPPORT = toStringTagSupport;
1020
+ var isCallable$4 = isCallable$f;
1021
+ var classofRaw = classofRaw$1;
1022
+ var wellKnownSymbol$5 = wellKnownSymbol$8;
1023
+
1024
+ var TO_STRING_TAG$1 = wellKnownSymbol$5('toStringTag');
1025
+ var $Object$1 = Object;
1026
+
1027
+ // ES3 wrong here
1028
+ var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
1029
+
1030
+ // fallback for IE11 Script Access Denied error
1031
+ var tryGet = function (it, key) {
1032
+ try {
1033
+ return it[key];
1034
+ } catch (error) { /* empty */ }
1035
+ };
1036
+
1037
+ // getting tag from ES6+ `Object.prototype.toString`
1038
+ var classof$1 = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
1039
+ var O, tag, result;
1040
+ return it === undefined ? 'Undefined' : it === null ? 'Null'
1041
+ // @@toStringTag case
1042
+ : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$1)) == 'string' ? tag
1043
+ // builtinTag case
1044
+ : CORRECT_ARGUMENTS ? classofRaw(O)
1045
+ // ES3 arguments fallback
1046
+ : (result = classofRaw(O)) === 'Object' && isCallable$4(O.callee) ? 'Arguments' : result;
1047
+ };
1048
+
1049
+ var classof = classof$1;
1050
+
1051
+ var $String$1 = String;
1052
+
1053
+ var toString$3 = function (argument) {
1054
+ if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
1055
+ return $String$1(argument);
1056
+ };
1057
+
1058
+ var makeBuiltIn = makeBuiltInExports;
1059
+ var defineProperty$3 = objectDefineProperty;
1060
+
1061
+ var defineBuiltInAccessor$1 = function (target, name, descriptor) {
1062
+ if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
1063
+ if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
1064
+ return defineProperty$3.f(target, name, descriptor);
1065
+ };
1066
+
1067
+ var $$2 = _export;
1068
+ var DESCRIPTORS$2 = descriptors;
1069
+ var global$3 = global$d;
1070
+ var uncurryThis$3 = functionUncurryThis;
1071
+ var hasOwn$3 = hasOwnProperty_1;
1072
+ var isCallable$3 = isCallable$f;
1073
+ var isPrototypeOf$1 = objectIsPrototypeOf;
1074
+ var toString$2 = toString$3;
1075
+ var defineBuiltInAccessor = defineBuiltInAccessor$1;
1076
+ var copyConstructorProperties = copyConstructorProperties$2;
1077
+
1078
+ var NativeSymbol = global$3.Symbol;
1079
+ var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
1080
+
1081
+ if (DESCRIPTORS$2 && isCallable$3(NativeSymbol) && (!('description' in SymbolPrototype) ||
1082
+ // Safari 12 bug
1083
+ NativeSymbol().description !== undefined
1084
+ )) {
1085
+ var EmptyStringDescriptionStore = {};
1086
+ // wrap Symbol constructor for correct work with undefined description
1087
+ var SymbolWrapper = function Symbol() {
1088
+ var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString$2(arguments[0]);
1089
+ var result = isPrototypeOf$1(SymbolPrototype, this)
1090
+ ? new NativeSymbol(description)
1091
+ // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
1092
+ : description === undefined ? NativeSymbol() : NativeSymbol(description);
1093
+ if (description === '') EmptyStringDescriptionStore[result] = true;
1094
+ return result;
1095
+ };
1096
+
1097
+ copyConstructorProperties(SymbolWrapper, NativeSymbol);
1098
+ SymbolWrapper.prototype = SymbolPrototype;
1099
+ SymbolPrototype.constructor = SymbolWrapper;
1100
+
1101
+ var NATIVE_SYMBOL = String(NativeSymbol('description detection')) === 'Symbol(description detection)';
1102
+ var thisSymbolValue = uncurryThis$3(SymbolPrototype.valueOf);
1103
+ var symbolDescriptiveString = uncurryThis$3(SymbolPrototype.toString);
1104
+ var regexp = /^Symbol\((.*)\)[^)]+$/;
1105
+ var replace$1 = uncurryThis$3(''.replace);
1106
+ var stringSlice = uncurryThis$3(''.slice);
1107
+
1108
+ defineBuiltInAccessor(SymbolPrototype, 'description', {
1109
+ configurable: true,
1110
+ get: function description() {
1111
+ var symbol = thisSymbolValue(this);
1112
+ if (hasOwn$3(EmptyStringDescriptionStore, symbol)) return '';
1113
+ var string = symbolDescriptiveString(symbol);
1114
+ var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace$1(string, regexp, '$1');
1115
+ return desc === '' ? undefined : desc;
1116
+ }
1117
+ });
1118
+
1119
+ $$2({ global: true, constructor: true, forced: true }, {
1120
+ Symbol: SymbolWrapper
1121
+ });
1122
+ }
1123
+
1124
+ var objectDefineProperties = {};
1125
+
1126
+ var internalObjectKeys = objectKeysInternal;
1127
+ var enumBugKeys$1 = enumBugKeys$3;
1128
+
1129
+ // `Object.keys` method
1130
+ // https://tc39.es/ecma262/#sec-object.keys
1131
+ // eslint-disable-next-line es/no-object-keys -- safe
1132
+ var objectKeys$1 = Object.keys || function keys(O) {
1133
+ return internalObjectKeys(O, enumBugKeys$1);
1134
+ };
1135
+
1136
+ var DESCRIPTORS$1 = descriptors;
1137
+ var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
1138
+ var definePropertyModule = objectDefineProperty;
1139
+ var anObject$3 = anObject$6;
1140
+ var toIndexedObject$1 = toIndexedObject$5;
1141
+ var objectKeys = objectKeys$1;
1142
+
1143
+ // `Object.defineProperties` method
1144
+ // https://tc39.es/ecma262/#sec-object.defineproperties
1145
+ // eslint-disable-next-line es/no-object-defineproperties -- safe
1146
+ objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
1147
+ anObject$3(O);
1148
+ var props = toIndexedObject$1(Properties);
1149
+ var keys = objectKeys(Properties);
1150
+ var length = keys.length;
1151
+ var index = 0;
1152
+ var key;
1153
+ while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
1154
+ return O;
1155
+ };
1156
+
1157
+ var getBuiltIn = getBuiltIn$3;
1158
+
1159
+ var html$1 = getBuiltIn('document', 'documentElement');
1160
+
1161
+ /* global ActiveXObject -- old IE, WSH */
1162
+ var anObject$2 = anObject$6;
1163
+ var definePropertiesModule = objectDefineProperties;
1164
+ var enumBugKeys = enumBugKeys$3;
1165
+ var hiddenKeys = hiddenKeys$4;
1166
+ var html = html$1;
1167
+ var documentCreateElement$1 = documentCreateElement$2;
1168
+ var sharedKey$1 = sharedKey$3;
1169
+
1170
+ var GT = '>';
1171
+ var LT = '<';
1172
+ var PROTOTYPE = 'prototype';
1173
+ var SCRIPT = 'script';
1174
+ var IE_PROTO$1 = sharedKey$1('IE_PROTO');
1175
+
1176
+ var EmptyConstructor = function () { /* empty */ };
1177
+
1178
+ var scriptTag = function (content) {
1179
+ return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
1180
+ };
1181
+
1182
+ // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
1183
+ var NullProtoObjectViaActiveX = function (activeXDocument) {
1184
+ activeXDocument.write(scriptTag(''));
1185
+ activeXDocument.close();
1186
+ var temp = activeXDocument.parentWindow.Object;
1187
+ activeXDocument = null; // avoid memory leak
1188
+ return temp;
1189
+ };
1190
+
1191
+ // Create object with fake `null` prototype: use iframe Object with cleared prototype
1192
+ var NullProtoObjectViaIFrame = function () {
1193
+ // Thrash, waste and sodomy: IE GC bug
1194
+ var iframe = documentCreateElement$1('iframe');
1195
+ var JS = 'java' + SCRIPT + ':';
1196
+ var iframeDocument;
1197
+ iframe.style.display = 'none';
1198
+ html.appendChild(iframe);
1199
+ // https://github.com/zloirock/core-js/issues/475
1200
+ iframe.src = String(JS);
1201
+ iframeDocument = iframe.contentWindow.document;
1202
+ iframeDocument.open();
1203
+ iframeDocument.write(scriptTag('document.F=Object'));
1204
+ iframeDocument.close();
1205
+ return iframeDocument.F;
1206
+ };
1207
+
1208
+ // Check for document.domain and active x support
1209
+ // No need to use active x approach when document.domain is not set
1210
+ // see https://github.com/es-shims/es5-shim/issues/150
1211
+ // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
1212
+ // avoid IE GC bug
1213
+ var activeXDocument;
1214
+ var NullProtoObject = function () {
1215
+ try {
1216
+ activeXDocument = new ActiveXObject('htmlfile');
1217
+ } catch (error) { /* ignore */ }
1218
+ NullProtoObject = typeof document != 'undefined'
1219
+ ? document.domain && activeXDocument
1220
+ ? NullProtoObjectViaActiveX(activeXDocument) // old IE
1221
+ : NullProtoObjectViaIFrame()
1222
+ : NullProtoObjectViaActiveX(activeXDocument); // WSH
1223
+ var length = enumBugKeys.length;
1224
+ while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
1225
+ return NullProtoObject();
1226
+ };
1227
+
1228
+ hiddenKeys[IE_PROTO$1] = true;
1229
+
1230
+ // `Object.create` method
1231
+ // https://tc39.es/ecma262/#sec-object.create
1232
+ // eslint-disable-next-line es/no-object-create -- safe
1233
+ var objectCreate = Object.create || function create(O, Properties) {
1234
+ var result;
1235
+ if (O !== null) {
1236
+ EmptyConstructor[PROTOTYPE] = anObject$2(O);
1237
+ result = new EmptyConstructor();
1238
+ EmptyConstructor[PROTOTYPE] = null;
1239
+ // add "__proto__" for Object.getPrototypeOf polyfill
1240
+ result[IE_PROTO$1] = O;
1241
+ } else result = NullProtoObject();
1242
+ return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
1243
+ };
1244
+
1245
+ var wellKnownSymbol$4 = wellKnownSymbol$8;
1246
+ var create$1 = objectCreate;
1247
+ var defineProperty$2 = objectDefineProperty.f;
1248
+
1249
+ var UNSCOPABLES = wellKnownSymbol$4('unscopables');
1250
+ var ArrayPrototype = Array.prototype;
1251
+
1252
+ // Array.prototype[@@unscopables]
1253
+ // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1254
+ if (ArrayPrototype[UNSCOPABLES] === undefined) {
1255
+ defineProperty$2(ArrayPrototype, UNSCOPABLES, {
1256
+ configurable: true,
1257
+ value: create$1(null)
1258
+ });
1259
+ }
1260
+
1261
+ // add a key to Array.prototype[@@unscopables]
1262
+ var addToUnscopables$1 = function (key) {
1263
+ ArrayPrototype[UNSCOPABLES][key] = true;
781
1264
  };
782
1265
 
783
- var fails$1 = fails$7;
1266
+ var iterators = {};
1267
+
1268
+ var fails$3 = fails$c;
784
1269
 
785
- var correctPrototypeGetter = !fails$1(function () {
1270
+ var correctPrototypeGetter = !fails$3(function () {
786
1271
  function F() { /* empty */ }
787
1272
  F.prototype.constructor = null;
1273
+ // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
788
1274
  return Object.getPrototypeOf(new F()) !== F.prototype;
789
1275
  });
790
1276
 
791
- var has$6 = has$d;
792
- var toObject$1 = toObject$2;
1277
+ var hasOwn$2 = hasOwnProperty_1;
1278
+ var isCallable$2 = isCallable$f;
1279
+ var toObject = toObject$2;
793
1280
  var sharedKey = sharedKey$3;
794
1281
  var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
795
1282
 
796
1283
  var IE_PROTO = sharedKey('IE_PROTO');
797
- var ObjectPrototype = Object.prototype;
1284
+ var $Object = Object;
1285
+ var ObjectPrototype = $Object.prototype;
798
1286
 
799
1287
  // `Object.getPrototypeOf` method
800
- // https://tc39.github.io/ecma262/#sec-object.getprototypeof
801
- var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {
802
- O = toObject$1(O);
803
- if (has$6(O, IE_PROTO)) return O[IE_PROTO];
804
- if (typeof O.constructor == 'function' && O instanceof O.constructor) {
805
- return O.constructor.prototype;
806
- } return O instanceof Object ? ObjectPrototype : null;
1288
+ // https://tc39.es/ecma262/#sec-object.getprototypeof
1289
+ // eslint-disable-next-line es/no-object-getprototypeof -- safe
1290
+ var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
1291
+ var object = toObject(O);
1292
+ if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO];
1293
+ var constructor = object.constructor;
1294
+ if (isCallable$2(constructor) && object instanceof constructor) {
1295
+ return constructor.prototype;
1296
+ } return object instanceof $Object ? ObjectPrototype : null;
807
1297
  };
808
1298
 
1299
+ var fails$2 = fails$c;
1300
+ var isCallable$1 = isCallable$f;
1301
+ var isObject$2 = isObject$8;
809
1302
  var getPrototypeOf$1 = objectGetPrototypeOf;
810
- var createNonEnumerableProperty$2 = createNonEnumerableProperty$7;
811
- var has$5 = has$d;
812
- var wellKnownSymbol$3 = wellKnownSymbol$5;
1303
+ var defineBuiltIn$2 = defineBuiltIn$4;
1304
+ var wellKnownSymbol$3 = wellKnownSymbol$8;
813
1305
 
814
- var ITERATOR$2 = wellKnownSymbol$3('iterator');
1306
+ var ITERATOR$3 = wellKnownSymbol$3('iterator');
815
1307
  var BUGGY_SAFARI_ITERATORS$1 = false;
816
1308
 
817
- var returnThis$2 = function () { return this; };
818
-
819
1309
  // `%IteratorPrototype%` object
820
- // https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
1310
+ // https://tc39.es/ecma262/#sec-%iteratorprototype%-object
821
1311
  var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator;
822
1312
 
1313
+ /* eslint-disable es/no-array-prototype-keys -- safe */
823
1314
  if ([].keys) {
824
1315
  arrayIterator = [].keys();
825
1316
  // Safari 8 has buggy iterators w/o `next`
@@ -830,11 +1321,20 @@ if ([].keys) {
830
1321
  }
831
1322
  }
832
1323
 
833
- if (IteratorPrototype$2 == undefined) IteratorPrototype$2 = {};
1324
+ var NEW_ITERATOR_PROTOTYPE = !isObject$2(IteratorPrototype$2) || fails$2(function () {
1325
+ var test = {};
1326
+ // FF44- legacy iterators case
1327
+ return IteratorPrototype$2[ITERATOR$3].call(test) !== test;
1328
+ });
1329
+
1330
+ if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
834
1331
 
835
- // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
836
- if (!has$5(IteratorPrototype$2, ITERATOR$2)) {
837
- createNonEnumerableProperty$2(IteratorPrototype$2, ITERATOR$2, returnThis$2);
1332
+ // `%IteratorPrototype%[@@iterator]()` method
1333
+ // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
1334
+ if (!isCallable$1(IteratorPrototype$2[ITERATOR$3])) {
1335
+ defineBuiltIn$2(IteratorPrototype$2, ITERATOR$3, function () {
1336
+ return this;
1337
+ });
838
1338
  }
839
1339
 
840
1340
  var iteratorsCore = {
@@ -843,136 +1343,165 @@ var iteratorsCore = {
843
1343
  };
844
1344
 
845
1345
  var defineProperty$1 = objectDefineProperty.f;
846
- var has$4 = has$d;
847
- var wellKnownSymbol$2 = wellKnownSymbol$5;
1346
+ var hasOwn$1 = hasOwnProperty_1;
1347
+ var wellKnownSymbol$2 = wellKnownSymbol$8;
848
1348
 
849
- var TO_STRING_TAG$1 = wellKnownSymbol$2('toStringTag');
1349
+ var TO_STRING_TAG = wellKnownSymbol$2('toStringTag');
850
1350
 
851
- var setToStringTag$2 = function (it, TAG, STATIC) {
852
- if (it && !has$4(it = STATIC ? it : it.prototype, TO_STRING_TAG$1)) {
853
- defineProperty$1(it, TO_STRING_TAG$1, { configurable: true, value: TAG });
1351
+ var setToStringTag$3 = function (target, TAG, STATIC) {
1352
+ if (target && !STATIC) target = target.prototype;
1353
+ if (target && !hasOwn$1(target, TO_STRING_TAG)) {
1354
+ defineProperty$1(target, TO_STRING_TAG, { configurable: true, value: TAG });
854
1355
  }
855
1356
  };
856
1357
 
857
1358
  var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
858
1359
  var create = objectCreate;
859
1360
  var createPropertyDescriptor = createPropertyDescriptor$3;
860
- var setToStringTag$1 = setToStringTag$2;
1361
+ var setToStringTag$2 = setToStringTag$3;
861
1362
  var Iterators$2 = iterators;
862
1363
 
863
1364
  var returnThis$1 = function () { return this; };
864
1365
 
865
- var createIteratorConstructor$1 = function (IteratorConstructor, NAME, next) {
1366
+ var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
866
1367
  var TO_STRING_TAG = NAME + ' Iterator';
867
- IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(1, next) });
868
- setToStringTag$1(IteratorConstructor, TO_STRING_TAG, false);
1368
+ IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
1369
+ setToStringTag$2(IteratorConstructor, TO_STRING_TAG, false);
869
1370
  Iterators$2[TO_STRING_TAG] = returnThis$1;
870
1371
  return IteratorConstructor;
871
1372
  };
872
1373
 
873
- var isObject$1 = isObject$6;
1374
+ var uncurryThis$2 = functionUncurryThis;
1375
+ var aCallable = aCallable$2;
1376
+
1377
+ var functionUncurryThisAccessor = function (object, key, method) {
1378
+ try {
1379
+ // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
1380
+ return uncurryThis$2(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
1381
+ } catch (error) { /* empty */ }
1382
+ };
1383
+
1384
+ var isObject$1 = isObject$8;
1385
+
1386
+ var isPossiblePrototype$1 = function (argument) {
1387
+ return isObject$1(argument) || argument === null;
1388
+ };
1389
+
1390
+ var isPossiblePrototype = isPossiblePrototype$1;
1391
+
1392
+ var $String = String;
1393
+ var $TypeError = TypeError;
874
1394
 
875
- var aPossiblePrototype$1 = function (it) {
876
- if (!isObject$1(it) && it !== null) {
877
- throw TypeError("Can't set " + String(it) + ' as a prototype');
878
- } return it;
1395
+ var aPossiblePrototype$1 = function (argument) {
1396
+ if (isPossiblePrototype(argument)) return argument;
1397
+ throw new $TypeError("Can't set " + $String(argument) + ' as a prototype');
879
1398
  };
880
1399
 
881
- var anObject$2 = anObject$7;
1400
+ /* eslint-disable no-proto -- safe */
1401
+ var uncurryThisAccessor = functionUncurryThisAccessor;
1402
+ var isObject = isObject$8;
1403
+ var requireObjectCoercible$1 = requireObjectCoercible$4;
882
1404
  var aPossiblePrototype = aPossiblePrototype$1;
883
1405
 
884
1406
  // `Object.setPrototypeOf` method
885
- // https://tc39.github.io/ecma262/#sec-object.setprototypeof
1407
+ // https://tc39.es/ecma262/#sec-object.setprototypeof
886
1408
  // Works with __proto__ only. Old v8 can't work with null proto objects.
887
- /* eslint-disable no-proto */
1409
+ // eslint-disable-next-line es/no-object-setprototypeof -- safe
888
1410
  var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
889
1411
  var CORRECT_SETTER = false;
890
1412
  var test = {};
891
1413
  var setter;
892
1414
  try {
893
- setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
894
- setter.call(test, []);
1415
+ setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
1416
+ setter(test, []);
895
1417
  CORRECT_SETTER = test instanceof Array;
896
1418
  } catch (error) { /* empty */ }
897
1419
  return function setPrototypeOf(O, proto) {
898
- anObject$2(O);
1420
+ requireObjectCoercible$1(O);
899
1421
  aPossiblePrototype(proto);
900
- if (CORRECT_SETTER) setter.call(O, proto);
1422
+ if (!isObject(O)) return O;
1423
+ if (CORRECT_SETTER) setter(O, proto);
901
1424
  else O.__proto__ = proto;
902
1425
  return O;
903
1426
  };
904
1427
  }() : undefined);
905
1428
 
906
- var $$2 = _export;
907
- var createIteratorConstructor = createIteratorConstructor$1;
1429
+ var $$1 = _export;
1430
+ var call$1 = functionCall;
1431
+ var FunctionName = functionName;
1432
+ var isCallable = isCallable$f;
1433
+ var createIteratorConstructor = iteratorCreateConstructor;
908
1434
  var getPrototypeOf = objectGetPrototypeOf;
909
1435
  var setPrototypeOf = objectSetPrototypeOf;
910
- var setToStringTag = setToStringTag$2;
911
- var createNonEnumerableProperty$1 = createNonEnumerableProperty$7;
912
- var redefine$1 = redefine$3.exports;
913
- var wellKnownSymbol$1 = wellKnownSymbol$5;
1436
+ var setToStringTag$1 = setToStringTag$3;
1437
+ var createNonEnumerableProperty$1 = createNonEnumerableProperty$4;
1438
+ var defineBuiltIn$1 = defineBuiltIn$4;
1439
+ var wellKnownSymbol$1 = wellKnownSymbol$8;
914
1440
  var Iterators$1 = iterators;
915
1441
  var IteratorsCore = iteratorsCore;
916
1442
 
1443
+ var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER;
1444
+ var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
917
1445
  var IteratorPrototype = IteratorsCore.IteratorPrototype;
918
1446
  var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
919
- var ITERATOR$1 = wellKnownSymbol$1('iterator');
1447
+ var ITERATOR$2 = wellKnownSymbol$1('iterator');
920
1448
  var KEYS = 'keys';
921
1449
  var VALUES = 'values';
922
1450
  var ENTRIES = 'entries';
923
1451
 
924
1452
  var returnThis = function () { return this; };
925
1453
 
926
- var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
1454
+ var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
927
1455
  createIteratorConstructor(IteratorConstructor, NAME, next);
928
1456
 
929
1457
  var getIterationMethod = function (KIND) {
930
1458
  if (KIND === DEFAULT && defaultIterator) return defaultIterator;
931
- if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
1459
+ if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];
1460
+
932
1461
  switch (KIND) {
933
1462
  case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
934
1463
  case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
935
1464
  case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
936
- } return function () { return new IteratorConstructor(this); };
1465
+ }
1466
+
1467
+ return function () { return new IteratorConstructor(this); };
937
1468
  };
938
1469
 
939
1470
  var TO_STRING_TAG = NAME + ' Iterator';
940
1471
  var INCORRECT_VALUES_NAME = false;
941
1472
  var IterablePrototype = Iterable.prototype;
942
- var nativeIterator = IterablePrototype[ITERATOR$1]
1473
+ var nativeIterator = IterablePrototype[ITERATOR$2]
943
1474
  || IterablePrototype['@@iterator']
944
1475
  || DEFAULT && IterablePrototype[DEFAULT];
945
1476
  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
946
- var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
1477
+ var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
947
1478
  var CurrentIteratorPrototype, methods, KEY;
948
1479
 
949
1480
  // fix native
950
1481
  if (anyNativeIterator) {
951
1482
  CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
952
- if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
1483
+ if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
953
1484
  if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
954
1485
  if (setPrototypeOf) {
955
1486
  setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
956
- } else if (typeof CurrentIteratorPrototype[ITERATOR$1] != 'function') {
957
- createNonEnumerableProperty$1(CurrentIteratorPrototype, ITERATOR$1, returnThis);
1487
+ } else if (!isCallable(CurrentIteratorPrototype[ITERATOR$2])) {
1488
+ defineBuiltIn$1(CurrentIteratorPrototype, ITERATOR$2, returnThis);
958
1489
  }
959
1490
  }
960
1491
  // Set @@toStringTag to native iterators
961
- setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true);
1492
+ setToStringTag$1(CurrentIteratorPrototype, TO_STRING_TAG, true);
962
1493
  }
963
1494
  }
964
1495
 
965
- // fix Array#{values, @@iterator}.name in V8 / FF
966
- if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
967
- INCORRECT_VALUES_NAME = true;
968
- defaultIterator = function values() { return nativeIterator.call(this); };
969
- }
970
-
971
- // define iterator
972
- if (IterablePrototype[ITERATOR$1] !== defaultIterator) {
973
- createNonEnumerableProperty$1(IterablePrototype, ITERATOR$1, defaultIterator);
1496
+ // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
1497
+ if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
1498
+ if (CONFIGURABLE_FUNCTION_NAME) {
1499
+ createNonEnumerableProperty$1(IterablePrototype, 'name', VALUES);
1500
+ } else {
1501
+ INCORRECT_VALUES_NAME = true;
1502
+ defaultIterator = function values() { return call$1(nativeIterator, this); };
1503
+ }
974
1504
  }
975
- Iterators$1[NAME] = defaultIterator;
976
1505
 
977
1506
  // export additional methods
978
1507
  if (DEFAULT) {
@@ -983,34 +1512,49 @@ var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFA
983
1512
  };
984
1513
  if (FORCED) for (KEY in methods) {
985
1514
  if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
986
- redefine$1(IterablePrototype, KEY, methods[KEY]);
1515
+ defineBuiltIn$1(IterablePrototype, KEY, methods[KEY]);
987
1516
  }
988
- } else $$2({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
1517
+ } else $$1({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
1518
+ }
1519
+
1520
+ // define iterator
1521
+ if (IterablePrototype[ITERATOR$2] !== defaultIterator) {
1522
+ defineBuiltIn$1(IterablePrototype, ITERATOR$2, defaultIterator, { name: DEFAULT });
989
1523
  }
1524
+ Iterators$1[NAME] = defaultIterator;
990
1525
 
991
1526
  return methods;
992
1527
  };
993
1528
 
994
- var toIndexedObject = toIndexedObject$4;
1529
+ // `CreateIterResultObject` abstract operation
1530
+ // https://tc39.es/ecma262/#sec-createiterresultobject
1531
+ var createIterResultObject$1 = function (value, done) {
1532
+ return { value: value, done: done };
1533
+ };
1534
+
1535
+ var toIndexedObject = toIndexedObject$5;
995
1536
  var addToUnscopables = addToUnscopables$1;
996
1537
  var Iterators = iterators;
997
1538
  var InternalStateModule = internalState;
998
- var defineIterator = defineIterator$1;
1539
+ var defineProperty = objectDefineProperty.f;
1540
+ var defineIterator = iteratorDefine;
1541
+ var createIterResultObject = createIterResultObject$1;
1542
+ var DESCRIPTORS = descriptors;
999
1543
 
1000
1544
  var ARRAY_ITERATOR = 'Array Iterator';
1001
1545
  var setInternalState = InternalStateModule.set;
1002
1546
  var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
1003
1547
 
1004
1548
  // `Array.prototype.entries` method
1005
- // https://tc39.github.io/ecma262/#sec-array.prototype.entries
1549
+ // https://tc39.es/ecma262/#sec-array.prototype.entries
1006
1550
  // `Array.prototype.keys` method
1007
- // https://tc39.github.io/ecma262/#sec-array.prototype.keys
1551
+ // https://tc39.es/ecma262/#sec-array.prototype.keys
1008
1552
  // `Array.prototype.values` method
1009
- // https://tc39.github.io/ecma262/#sec-array.prototype.values
1553
+ // https://tc39.es/ecma262/#sec-array.prototype.values
1010
1554
  // `Array.prototype[@@iterator]` method
1011
- // https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator
1555
+ // https://tc39.es/ecma262/#sec-array.prototype-@@iterator
1012
1556
  // `CreateArrayIterator` internal method
1013
- // https://tc39.github.io/ecma262/#sec-createarrayiterator
1557
+ // https://tc39.es/ecma262/#sec-createarrayiterator
1014
1558
  var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
1015
1559
  setInternalState(this, {
1016
1560
  type: ARRAY_ITERATOR,
@@ -1019,31 +1563,36 @@ var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind)
1019
1563
  kind: kind // kind
1020
1564
  });
1021
1565
  // `%ArrayIteratorPrototype%.next` method
1022
- // https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next
1566
+ // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
1023
1567
  }, function () {
1024
1568
  var state = getInternalState(this);
1025
1569
  var target = state.target;
1026
- var kind = state.kind;
1027
1570
  var index = state.index++;
1028
1571
  if (!target || index >= target.length) {
1029
1572
  state.target = undefined;
1030
- return { value: undefined, done: true };
1573
+ return createIterResultObject(undefined, true);
1031
1574
  }
1032
- if (kind == 'keys') return { value: index, done: false };
1033
- if (kind == 'values') return { value: target[index], done: false };
1034
- return { value: [index, target[index]], done: false };
1575
+ switch (state.kind) {
1576
+ case 'keys': return createIterResultObject(index, false);
1577
+ case 'values': return createIterResultObject(target[index], false);
1578
+ } return createIterResultObject([index, target[index]], false);
1035
1579
  }, 'values');
1036
1580
 
1037
1581
  // argumentsList[@@iterator] is %ArrayProto_values%
1038
- // https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject
1039
- // https://tc39.github.io/ecma262/#sec-createmappedargumentsobject
1040
- Iterators.Arguments = Iterators.Array;
1582
+ // https://tc39.es/ecma262/#sec-createunmappedargumentsobject
1583
+ // https://tc39.es/ecma262/#sec-createmappedargumentsobject
1584
+ var values = Iterators.Arguments = Iterators.Array;
1041
1585
 
1042
- // https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
1586
+ // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
1043
1587
  addToUnscopables('keys');
1044
1588
  addToUnscopables('values');
1045
1589
  addToUnscopables('entries');
1046
1590
 
1591
+ // V8 ~ Chrome 45- bug
1592
+ if (DESCRIPTORS && values.name !== 'values') try {
1593
+ defineProperty(values, 'name', { value: 'values' });
1594
+ } catch (error) { /* empty */ }
1595
+
1047
1596
  // iterable DOM collections
1048
1597
  // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
1049
1598
  var domIterables = {
@@ -1080,29 +1629,34 @@ var domIterables = {
1080
1629
  TouchList: 0
1081
1630
  };
1082
1631
 
1083
- var global$3 = global$e;
1632
+ // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
1633
+ var documentCreateElement = documentCreateElement$2;
1634
+
1635
+ var classList = documentCreateElement('span').classList;
1636
+ var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
1637
+
1638
+ var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
1639
+
1640
+ var global$2 = global$d;
1084
1641
  var DOMIterables = domIterables;
1642
+ var DOMTokenListPrototype = domTokenListPrototype;
1085
1643
  var ArrayIteratorMethods = es_array_iterator;
1086
- var createNonEnumerableProperty = createNonEnumerableProperty$7;
1087
- var wellKnownSymbol = wellKnownSymbol$5;
1644
+ var createNonEnumerableProperty = createNonEnumerableProperty$4;
1645
+ var setToStringTag = setToStringTag$3;
1646
+ var wellKnownSymbol = wellKnownSymbol$8;
1088
1647
 
1089
- var ITERATOR = wellKnownSymbol('iterator');
1090
- var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1648
+ var ITERATOR$1 = wellKnownSymbol('iterator');
1091
1649
  var ArrayValues = ArrayIteratorMethods.values;
1092
1650
 
1093
- for (var COLLECTION_NAME in DOMIterables) {
1094
- var Collection = global$3[COLLECTION_NAME];
1095
- var CollectionPrototype = Collection && Collection.prototype;
1651
+ var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
1096
1652
  if (CollectionPrototype) {
1097
1653
  // some Chrome versions have non-configurable methods on DOMTokenList
1098
- if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
1099
- createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
1654
+ if (CollectionPrototype[ITERATOR$1] !== ArrayValues) try {
1655
+ createNonEnumerableProperty(CollectionPrototype, ITERATOR$1, ArrayValues);
1100
1656
  } catch (error) {
1101
- CollectionPrototype[ITERATOR] = ArrayValues;
1102
- }
1103
- if (!CollectionPrototype[TO_STRING_TAG]) {
1104
- createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
1657
+ CollectionPrototype[ITERATOR$1] = ArrayValues;
1105
1658
  }
1659
+ setToStringTag(CollectionPrototype, COLLECTION_NAME, true);
1106
1660
  if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
1107
1661
  // some Chrome versions have non-configurable methods on DOMTokenList
1108
1662
  if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
@@ -1112,56 +1666,14 @@ for (var COLLECTION_NAME in DOMIterables) {
1112
1666
  }
1113
1667
  }
1114
1668
  }
1115
- }
1116
-
1117
- var $$1 = _export;
1118
- var DESCRIPTORS = descriptors;
1119
- var global$2 = global$e;
1120
- var has$3 = has$d;
1121
- var isObject = isObject$6;
1122
- var defineProperty = objectDefineProperty.f;
1123
- var copyConstructorProperties = copyConstructorProperties$2;
1124
-
1125
- var NativeSymbol = global$2.Symbol;
1126
-
1127
- if (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||
1128
- // Safari 12 bug
1129
- NativeSymbol().description !== undefined
1130
- )) {
1131
- var EmptyStringDescriptionStore = {};
1132
- // wrap Symbol constructor for correct work with undefined description
1133
- var SymbolWrapper = function Symbol() {
1134
- var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);
1135
- var result = this instanceof SymbolWrapper
1136
- ? new NativeSymbol(description)
1137
- // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
1138
- : description === undefined ? NativeSymbol() : NativeSymbol(description);
1139
- if (description === '') EmptyStringDescriptionStore[result] = true;
1140
- return result;
1141
- };
1142
- copyConstructorProperties(SymbolWrapper, NativeSymbol);
1143
- var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;
1144
- symbolPrototype.constructor = SymbolWrapper;
1145
-
1146
- var symbolToString = symbolPrototype.toString;
1147
- var native = String(NativeSymbol('test')) == 'Symbol(test)';
1148
- var regexp = /^Symbol\((.*)\)[^)]+$/;
1149
- defineProperty(symbolPrototype, 'description', {
1150
- configurable: true,
1151
- get: function description() {
1152
- var symbol = isObject(this) ? this.valueOf() : this;
1153
- var string = symbolToString.call(symbol);
1154
- if (has$3(EmptyStringDescriptionStore, symbol)) return '';
1155
- var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');
1156
- return desc === '' ? undefined : desc;
1157
- }
1158
- });
1669
+ };
1159
1670
 
1160
- $$1({ global: true, forced: true }, {
1161
- Symbol: SymbolWrapper
1162
- });
1671
+ for (var COLLECTION_NAME in DOMIterables) {
1672
+ handlePrototype(global$2[COLLECTION_NAME] && global$2[COLLECTION_NAME].prototype, COLLECTION_NAME);
1163
1673
  }
1164
1674
 
1675
+ handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
1676
+
1165
1677
  var propTypes = {exports: {}};
1166
1678
 
1167
1679
  var reactIs = {exports: {}};
@@ -1176,12 +1688,20 @@ var reactIs_production_min = {};
1176
1688
  * This source code is licensed under the MIT license found in the
1177
1689
  * LICENSE file in the root directory of this source tree.
1178
1690
  */
1691
+
1692
+ var hasRequiredReactIs_production_min;
1693
+
1694
+ function requireReactIs_production_min () {
1695
+ if (hasRequiredReactIs_production_min) return reactIs_production_min;
1696
+ hasRequiredReactIs_production_min = 1;
1179
1697
  var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
1180
- Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
1181
- function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}reactIs_production_min.AsyncMode=l;reactIs_production_min.ConcurrentMode=m;reactIs_production_min.ContextConsumer=k;reactIs_production_min.ContextProvider=h;reactIs_production_min.Element=c;reactIs_production_min.ForwardRef=n;reactIs_production_min.Fragment=e;reactIs_production_min.Lazy=t;reactIs_production_min.Memo=r;reactIs_production_min.Portal=d;
1182
- reactIs_production_min.Profiler=g;reactIs_production_min.StrictMode=f;reactIs_production_min.Suspense=p;reactIs_production_min.isAsyncMode=function(a){return A(a)||z(a)===l};reactIs_production_min.isConcurrentMode=A;reactIs_production_min.isContextConsumer=function(a){return z(a)===k};reactIs_production_min.isContextProvider=function(a){return z(a)===h};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};reactIs_production_min.isForwardRef=function(a){return z(a)===n};reactIs_production_min.isFragment=function(a){return z(a)===e};reactIs_production_min.isLazy=function(a){return z(a)===t};
1183
- reactIs_production_min.isMemo=function(a){return z(a)===r};reactIs_production_min.isPortal=function(a){return z(a)===d};reactIs_production_min.isProfiler=function(a){return z(a)===g};reactIs_production_min.isStrictMode=function(a){return z(a)===f};reactIs_production_min.isSuspense=function(a){return z(a)===p};
1184
- reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};reactIs_production_min.typeOf=z;
1698
+ Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
1699
+ function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}reactIs_production_min.AsyncMode=l;reactIs_production_min.ConcurrentMode=m;reactIs_production_min.ContextConsumer=k;reactIs_production_min.ContextProvider=h;reactIs_production_min.Element=c;reactIs_production_min.ForwardRef=n;reactIs_production_min.Fragment=e;reactIs_production_min.Lazy=t;reactIs_production_min.Memo=r;reactIs_production_min.Portal=d;
1700
+ reactIs_production_min.Profiler=g;reactIs_production_min.StrictMode=f;reactIs_production_min.Suspense=p;reactIs_production_min.isAsyncMode=function(a){return A(a)||z(a)===l};reactIs_production_min.isConcurrentMode=A;reactIs_production_min.isContextConsumer=function(a){return z(a)===k};reactIs_production_min.isContextProvider=function(a){return z(a)===h};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};reactIs_production_min.isForwardRef=function(a){return z(a)===n};reactIs_production_min.isFragment=function(a){return z(a)===e};reactIs_production_min.isLazy=function(a){return z(a)===t};
1701
+ reactIs_production_min.isMemo=function(a){return z(a)===r};reactIs_production_min.isPortal=function(a){return z(a)===d};reactIs_production_min.isProfiler=function(a){return z(a)===g};reactIs_production_min.isStrictMode=function(a){return z(a)===f};reactIs_production_min.isSuspense=function(a){return z(a)===p};
1702
+ reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};reactIs_production_min.typeOf=z;
1703
+ return reactIs_production_min;
1704
+ }
1185
1705
 
1186
1706
  var reactIs_development = {};
1187
1707
 
@@ -1194,180 +1714,196 @@ var reactIs_development = {};
1194
1714
  * LICENSE file in the root directory of this source tree.
1195
1715
  */
1196
1716
 
1717
+ var hasRequiredReactIs_development;
1718
+
1719
+ function requireReactIs_development () {
1720
+ if (hasRequiredReactIs_development) return reactIs_development;
1721
+ hasRequiredReactIs_development = 1;
1722
+
1723
+
1724
+
1725
+ if (process.env.NODE_ENV !== "production") {
1726
+ (function() {
1727
+
1728
+ // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
1729
+ // nor polyfill, then a plain number is used for performance.
1730
+ var hasSymbol = typeof Symbol === 'function' && Symbol.for;
1731
+ var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
1732
+ var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
1733
+ var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
1734
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
1735
+ var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
1736
+ var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
1737
+ var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
1738
+ // (unstable) APIs that have been removed. Can we remove the symbols?
1739
+
1740
+ var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
1741
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
1742
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
1743
+ var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
1744
+ var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
1745
+ var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
1746
+ var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
1747
+ var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
1748
+ var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
1749
+ var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
1750
+ var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
1751
+
1752
+ function isValidElementType(type) {
1753
+ return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
1754
+ type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
1755
+ }
1197
1756
 
1757
+ function typeOf(object) {
1758
+ if (typeof object === 'object' && object !== null) {
1759
+ var $$typeof = object.$$typeof;
1760
+
1761
+ switch ($$typeof) {
1762
+ case REACT_ELEMENT_TYPE:
1763
+ var type = object.type;
1764
+
1765
+ switch (type) {
1766
+ case REACT_ASYNC_MODE_TYPE:
1767
+ case REACT_CONCURRENT_MODE_TYPE:
1768
+ case REACT_FRAGMENT_TYPE:
1769
+ case REACT_PROFILER_TYPE:
1770
+ case REACT_STRICT_MODE_TYPE:
1771
+ case REACT_SUSPENSE_TYPE:
1772
+ return type;
1773
+
1774
+ default:
1775
+ var $$typeofType = type && type.$$typeof;
1776
+
1777
+ switch ($$typeofType) {
1778
+ case REACT_CONTEXT_TYPE:
1779
+ case REACT_FORWARD_REF_TYPE:
1780
+ case REACT_LAZY_TYPE:
1781
+ case REACT_MEMO_TYPE:
1782
+ case REACT_PROVIDER_TYPE:
1783
+ return $$typeofType;
1784
+
1785
+ default:
1786
+ return $$typeof;
1787
+ }
1788
+
1789
+ }
1790
+
1791
+ case REACT_PORTAL_TYPE:
1792
+ return $$typeof;
1793
+ }
1794
+ }
1795
+
1796
+ return undefined;
1797
+ } // AsyncMode is deprecated along with isAsyncMode
1798
+
1799
+ var AsyncMode = REACT_ASYNC_MODE_TYPE;
1800
+ var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
1801
+ var ContextConsumer = REACT_CONTEXT_TYPE;
1802
+ var ContextProvider = REACT_PROVIDER_TYPE;
1803
+ var Element = REACT_ELEMENT_TYPE;
1804
+ var ForwardRef = REACT_FORWARD_REF_TYPE;
1805
+ var Fragment = REACT_FRAGMENT_TYPE;
1806
+ var Lazy = REACT_LAZY_TYPE;
1807
+ var Memo = REACT_MEMO_TYPE;
1808
+ var Portal = REACT_PORTAL_TYPE;
1809
+ var Profiler = REACT_PROFILER_TYPE;
1810
+ var StrictMode = REACT_STRICT_MODE_TYPE;
1811
+ var Suspense = REACT_SUSPENSE_TYPE;
1812
+ var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
1813
+
1814
+ function isAsyncMode(object) {
1815
+ {
1816
+ if (!hasWarnedAboutDeprecatedIsAsyncMode) {
1817
+ hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
1818
+
1819
+ console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
1820
+ }
1821
+ }
1822
+
1823
+ return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
1824
+ }
1825
+ function isConcurrentMode(object) {
1826
+ return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
1827
+ }
1828
+ function isContextConsumer(object) {
1829
+ return typeOf(object) === REACT_CONTEXT_TYPE;
1830
+ }
1831
+ function isContextProvider(object) {
1832
+ return typeOf(object) === REACT_PROVIDER_TYPE;
1833
+ }
1834
+ function isElement(object) {
1835
+ return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
1836
+ }
1837
+ function isForwardRef(object) {
1838
+ return typeOf(object) === REACT_FORWARD_REF_TYPE;
1839
+ }
1840
+ function isFragment(object) {
1841
+ return typeOf(object) === REACT_FRAGMENT_TYPE;
1842
+ }
1843
+ function isLazy(object) {
1844
+ return typeOf(object) === REACT_LAZY_TYPE;
1845
+ }
1846
+ function isMemo(object) {
1847
+ return typeOf(object) === REACT_MEMO_TYPE;
1848
+ }
1849
+ function isPortal(object) {
1850
+ return typeOf(object) === REACT_PORTAL_TYPE;
1851
+ }
1852
+ function isProfiler(object) {
1853
+ return typeOf(object) === REACT_PROFILER_TYPE;
1854
+ }
1855
+ function isStrictMode(object) {
1856
+ return typeOf(object) === REACT_STRICT_MODE_TYPE;
1857
+ }
1858
+ function isSuspense(object) {
1859
+ return typeOf(object) === REACT_SUSPENSE_TYPE;
1860
+ }
1198
1861
 
1199
- if (process.env.NODE_ENV !== "production") {
1200
- (function() {
1201
-
1202
- // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
1203
- // nor polyfill, then a plain number is used for performance.
1204
- var hasSymbol = typeof Symbol === 'function' && Symbol.for;
1205
- var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
1206
- var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
1207
- var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
1208
- var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
1209
- var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
1210
- var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
1211
- var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
1212
- // (unstable) APIs that have been removed. Can we remove the symbols?
1213
-
1214
- var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
1215
- var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
1216
- var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
1217
- var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
1218
- var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
1219
- var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
1220
- var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
1221
- var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
1222
- var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
1223
- var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
1224
- var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
1225
-
1226
- function isValidElementType(type) {
1227
- return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
1228
- type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
1229
- }
1230
-
1231
- function typeOf(object) {
1232
- if (typeof object === 'object' && object !== null) {
1233
- var $$typeof = object.$$typeof;
1234
-
1235
- switch ($$typeof) {
1236
- case REACT_ELEMENT_TYPE:
1237
- var type = object.type;
1238
-
1239
- switch (type) {
1240
- case REACT_ASYNC_MODE_TYPE:
1241
- case REACT_CONCURRENT_MODE_TYPE:
1242
- case REACT_FRAGMENT_TYPE:
1243
- case REACT_PROFILER_TYPE:
1244
- case REACT_STRICT_MODE_TYPE:
1245
- case REACT_SUSPENSE_TYPE:
1246
- return type;
1247
-
1248
- default:
1249
- var $$typeofType = type && type.$$typeof;
1250
-
1251
- switch ($$typeofType) {
1252
- case REACT_CONTEXT_TYPE:
1253
- case REACT_FORWARD_REF_TYPE:
1254
- case REACT_LAZY_TYPE:
1255
- case REACT_MEMO_TYPE:
1256
- case REACT_PROVIDER_TYPE:
1257
- return $$typeofType;
1258
-
1259
- default:
1260
- return $$typeof;
1261
- }
1262
-
1263
- }
1264
-
1265
- case REACT_PORTAL_TYPE:
1266
- return $$typeof;
1267
- }
1268
- }
1269
-
1270
- return undefined;
1271
- } // AsyncMode is deprecated along with isAsyncMode
1272
-
1273
- var AsyncMode = REACT_ASYNC_MODE_TYPE;
1274
- var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
1275
- var ContextConsumer = REACT_CONTEXT_TYPE;
1276
- var ContextProvider = REACT_PROVIDER_TYPE;
1277
- var Element = REACT_ELEMENT_TYPE;
1278
- var ForwardRef = REACT_FORWARD_REF_TYPE;
1279
- var Fragment = REACT_FRAGMENT_TYPE;
1280
- var Lazy = REACT_LAZY_TYPE;
1281
- var Memo = REACT_MEMO_TYPE;
1282
- var Portal = REACT_PORTAL_TYPE;
1283
- var Profiler = REACT_PROFILER_TYPE;
1284
- var StrictMode = REACT_STRICT_MODE_TYPE;
1285
- var Suspense = REACT_SUSPENSE_TYPE;
1286
- var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
1287
-
1288
- function isAsyncMode(object) {
1289
- {
1290
- if (!hasWarnedAboutDeprecatedIsAsyncMode) {
1291
- hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
1292
-
1293
- console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
1294
- }
1295
- }
1296
-
1297
- return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
1298
- }
1299
- function isConcurrentMode(object) {
1300
- return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
1301
- }
1302
- function isContextConsumer(object) {
1303
- return typeOf(object) === REACT_CONTEXT_TYPE;
1304
- }
1305
- function isContextProvider(object) {
1306
- return typeOf(object) === REACT_PROVIDER_TYPE;
1307
- }
1308
- function isElement(object) {
1309
- return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
1310
- }
1311
- function isForwardRef(object) {
1312
- return typeOf(object) === REACT_FORWARD_REF_TYPE;
1313
- }
1314
- function isFragment(object) {
1315
- return typeOf(object) === REACT_FRAGMENT_TYPE;
1316
- }
1317
- function isLazy(object) {
1318
- return typeOf(object) === REACT_LAZY_TYPE;
1319
- }
1320
- function isMemo(object) {
1321
- return typeOf(object) === REACT_MEMO_TYPE;
1322
- }
1323
- function isPortal(object) {
1324
- return typeOf(object) === REACT_PORTAL_TYPE;
1325
- }
1326
- function isProfiler(object) {
1327
- return typeOf(object) === REACT_PROFILER_TYPE;
1328
- }
1329
- function isStrictMode(object) {
1330
- return typeOf(object) === REACT_STRICT_MODE_TYPE;
1331
- }
1332
- function isSuspense(object) {
1333
- return typeOf(object) === REACT_SUSPENSE_TYPE;
1862
+ reactIs_development.AsyncMode = AsyncMode;
1863
+ reactIs_development.ConcurrentMode = ConcurrentMode;
1864
+ reactIs_development.ContextConsumer = ContextConsumer;
1865
+ reactIs_development.ContextProvider = ContextProvider;
1866
+ reactIs_development.Element = Element;
1867
+ reactIs_development.ForwardRef = ForwardRef;
1868
+ reactIs_development.Fragment = Fragment;
1869
+ reactIs_development.Lazy = Lazy;
1870
+ reactIs_development.Memo = Memo;
1871
+ reactIs_development.Portal = Portal;
1872
+ reactIs_development.Profiler = Profiler;
1873
+ reactIs_development.StrictMode = StrictMode;
1874
+ reactIs_development.Suspense = Suspense;
1875
+ reactIs_development.isAsyncMode = isAsyncMode;
1876
+ reactIs_development.isConcurrentMode = isConcurrentMode;
1877
+ reactIs_development.isContextConsumer = isContextConsumer;
1878
+ reactIs_development.isContextProvider = isContextProvider;
1879
+ reactIs_development.isElement = isElement;
1880
+ reactIs_development.isForwardRef = isForwardRef;
1881
+ reactIs_development.isFragment = isFragment;
1882
+ reactIs_development.isLazy = isLazy;
1883
+ reactIs_development.isMemo = isMemo;
1884
+ reactIs_development.isPortal = isPortal;
1885
+ reactIs_development.isProfiler = isProfiler;
1886
+ reactIs_development.isStrictMode = isStrictMode;
1887
+ reactIs_development.isSuspense = isSuspense;
1888
+ reactIs_development.isValidElementType = isValidElementType;
1889
+ reactIs_development.typeOf = typeOf;
1890
+ })();
1891
+ }
1892
+ return reactIs_development;
1334
1893
  }
1335
1894
 
1336
- reactIs_development.AsyncMode = AsyncMode;
1337
- reactIs_development.ConcurrentMode = ConcurrentMode;
1338
- reactIs_development.ContextConsumer = ContextConsumer;
1339
- reactIs_development.ContextProvider = ContextProvider;
1340
- reactIs_development.Element = Element;
1341
- reactIs_development.ForwardRef = ForwardRef;
1342
- reactIs_development.Fragment = Fragment;
1343
- reactIs_development.Lazy = Lazy;
1344
- reactIs_development.Memo = Memo;
1345
- reactIs_development.Portal = Portal;
1346
- reactIs_development.Profiler = Profiler;
1347
- reactIs_development.StrictMode = StrictMode;
1348
- reactIs_development.Suspense = Suspense;
1349
- reactIs_development.isAsyncMode = isAsyncMode;
1350
- reactIs_development.isConcurrentMode = isConcurrentMode;
1351
- reactIs_development.isContextConsumer = isContextConsumer;
1352
- reactIs_development.isContextProvider = isContextProvider;
1353
- reactIs_development.isElement = isElement;
1354
- reactIs_development.isForwardRef = isForwardRef;
1355
- reactIs_development.isFragment = isFragment;
1356
- reactIs_development.isLazy = isLazy;
1357
- reactIs_development.isMemo = isMemo;
1358
- reactIs_development.isPortal = isPortal;
1359
- reactIs_development.isProfiler = isProfiler;
1360
- reactIs_development.isStrictMode = isStrictMode;
1361
- reactIs_development.isSuspense = isSuspense;
1362
- reactIs_development.isValidElementType = isValidElementType;
1363
- reactIs_development.typeOf = typeOf;
1364
- })();
1365
- }
1895
+ var hasRequiredReactIs;
1366
1896
 
1367
- if (process.env.NODE_ENV === 'production') {
1368
- reactIs.exports = reactIs_production_min;
1369
- } else {
1370
- reactIs.exports = reactIs_development;
1897
+ function requireReactIs () {
1898
+ if (hasRequiredReactIs) return reactIs.exports;
1899
+ hasRequiredReactIs = 1;
1900
+
1901
+ if (process.env.NODE_ENV === 'production') {
1902
+ reactIs.exports = requireReactIs_production_min();
1903
+ } else {
1904
+ reactIs.exports = requireReactIs_development();
1905
+ }
1906
+ return reactIs.exports;
1371
1907
  }
1372
1908
 
1373
1909
  /*
@@ -1375,89 +1911,98 @@ object-assign
1375
1911
  (c) Sindre Sorhus
1376
1912
  @license MIT
1377
1913
  */
1378
- /* eslint-disable no-unused-vars */
1379
- var getOwnPropertySymbols = Object.getOwnPropertySymbols;
1380
- var hasOwnProperty = Object.prototype.hasOwnProperty;
1381
- var propIsEnumerable = Object.prototype.propertyIsEnumerable;
1382
-
1383
- function toObject(val) {
1384
- if (val === null || val === undefined) {
1385
- throw new TypeError('Object.assign cannot be called with null or undefined');
1386
- }
1387
1914
 
1388
- return Object(val);
1389
- }
1915
+ var objectAssign;
1916
+ var hasRequiredObjectAssign;
1390
1917
 
1391
- function shouldUseNative() {
1392
- try {
1393
- if (!Object.assign) {
1394
- return false;
1918
+ function requireObjectAssign () {
1919
+ if (hasRequiredObjectAssign) return objectAssign;
1920
+ hasRequiredObjectAssign = 1;
1921
+ /* eslint-disable no-unused-vars */
1922
+ var getOwnPropertySymbols = Object.getOwnPropertySymbols;
1923
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
1924
+ var propIsEnumerable = Object.prototype.propertyIsEnumerable;
1925
+
1926
+ function toObject(val) {
1927
+ if (val === null || val === undefined) {
1928
+ throw new TypeError('Object.assign cannot be called with null or undefined');
1395
1929
  }
1396
1930
 
1397
- // Detect buggy property enumeration order in older V8 versions.
1931
+ return Object(val);
1932
+ }
1398
1933
 
1399
- // https://bugs.chromium.org/p/v8/issues/detail?id=4118
1400
- var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
1401
- test1[5] = 'de';
1402
- if (Object.getOwnPropertyNames(test1)[0] === '5') {
1403
- return false;
1404
- }
1934
+ function shouldUseNative() {
1935
+ try {
1936
+ if (!Object.assign) {
1937
+ return false;
1938
+ }
1405
1939
 
1406
- // https://bugs.chromium.org/p/v8/issues/detail?id=3056
1407
- var test2 = {};
1408
- for (var i = 0; i < 10; i++) {
1409
- test2['_' + String.fromCharCode(i)] = i;
1410
- }
1411
- var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
1412
- return test2[n];
1413
- });
1414
- if (order2.join('') !== '0123456789') {
1415
- return false;
1416
- }
1940
+ // Detect buggy property enumeration order in older V8 versions.
1941
+
1942
+ // https://bugs.chromium.org/p/v8/issues/detail?id=4118
1943
+ var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
1944
+ test1[5] = 'de';
1945
+ if (Object.getOwnPropertyNames(test1)[0] === '5') {
1946
+ return false;
1947
+ }
1948
+
1949
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
1950
+ var test2 = {};
1951
+ for (var i = 0; i < 10; i++) {
1952
+ test2['_' + String.fromCharCode(i)] = i;
1953
+ }
1954
+ var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
1955
+ return test2[n];
1956
+ });
1957
+ if (order2.join('') !== '0123456789') {
1958
+ return false;
1959
+ }
1960
+
1961
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
1962
+ var test3 = {};
1963
+ 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
1964
+ test3[letter] = letter;
1965
+ });
1966
+ if (Object.keys(Object.assign({}, test3)).join('') !==
1967
+ 'abcdefghijklmnopqrst') {
1968
+ return false;
1969
+ }
1417
1970
 
1418
- // https://bugs.chromium.org/p/v8/issues/detail?id=3056
1419
- var test3 = {};
1420
- 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
1421
- test3[letter] = letter;
1422
- });
1423
- if (Object.keys(Object.assign({}, test3)).join('') !==
1424
- 'abcdefghijklmnopqrst') {
1971
+ return true;
1972
+ } catch (err) {
1973
+ // We don't expect any of the above to throw, but better to be safe.
1425
1974
  return false;
1426
1975
  }
1427
-
1428
- return true;
1429
- } catch (err) {
1430
- // We don't expect any of the above to throw, but better to be safe.
1431
- return false;
1432
1976
  }
1433
- }
1434
1977
 
1435
- var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
1436
- var from;
1437
- var to = toObject(target);
1438
- var symbols;
1978
+ objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
1979
+ var from;
1980
+ var to = toObject(target);
1981
+ var symbols;
1439
1982
 
1440
- for (var s = 1; s < arguments.length; s++) {
1441
- from = Object(arguments[s]);
1983
+ for (var s = 1; s < arguments.length; s++) {
1984
+ from = Object(arguments[s]);
1442
1985
 
1443
- for (var key in from) {
1444
- if (hasOwnProperty.call(from, key)) {
1445
- to[key] = from[key];
1986
+ for (var key in from) {
1987
+ if (hasOwnProperty.call(from, key)) {
1988
+ to[key] = from[key];
1989
+ }
1446
1990
  }
1447
- }
1448
1991
 
1449
- if (getOwnPropertySymbols) {
1450
- symbols = getOwnPropertySymbols(from);
1451
- for (var i = 0; i < symbols.length; i++) {
1452
- if (propIsEnumerable.call(from, symbols[i])) {
1453
- to[symbols[i]] = from[symbols[i]];
1992
+ if (getOwnPropertySymbols) {
1993
+ symbols = getOwnPropertySymbols(from);
1994
+ for (var i = 0; i < symbols.length; i++) {
1995
+ if (propIsEnumerable.call(from, symbols[i])) {
1996
+ to[symbols[i]] = from[symbols[i]];
1997
+ }
1454
1998
  }
1455
1999
  }
1456
2000
  }
1457
- }
1458
2001
 
1459
- return to;
1460
- };
2002
+ return to;
2003
+ };
2004
+ return objectAssign;
2005
+ }
1461
2006
 
1462
2007
  /**
1463
2008
  * Copyright (c) 2013-present, Facebook, Inc.
@@ -1466,113 +2011,139 @@ var objectAssign = shouldUseNative() ? Object.assign : function (target, source)
1466
2011
  * LICENSE file in the root directory of this source tree.
1467
2012
  */
1468
2013
 
1469
- var ReactPropTypesSecret$3 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
2014
+ var ReactPropTypesSecret_1;
2015
+ var hasRequiredReactPropTypesSecret;
1470
2016
 
1471
- var ReactPropTypesSecret_1 = ReactPropTypesSecret$3;
2017
+ function requireReactPropTypesSecret () {
2018
+ if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
2019
+ hasRequiredReactPropTypesSecret = 1;
1472
2020
 
1473
- var has$2 = Function.call.bind(Object.prototype.hasOwnProperty);
2021
+ var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
1474
2022
 
1475
- /**
1476
- * Copyright (c) 2013-present, Facebook, Inc.
1477
- *
1478
- * This source code is licensed under the MIT license found in the
1479
- * LICENSE file in the root directory of this source tree.
1480
- */
2023
+ ReactPropTypesSecret_1 = ReactPropTypesSecret;
2024
+ return ReactPropTypesSecret_1;
2025
+ }
1481
2026
 
1482
- var printWarning$1 = function() {};
2027
+ var has;
2028
+ var hasRequiredHas;
1483
2029
 
1484
- if (process.env.NODE_ENV !== 'production') {
1485
- var ReactPropTypesSecret$2 = ReactPropTypesSecret_1;
1486
- var loggedTypeFailures = {};
1487
- var has$1 = has$2;
1488
-
1489
- printWarning$1 = function(text) {
1490
- var message = 'Warning: ' + text;
1491
- if (typeof console !== 'undefined') {
1492
- console.error(message);
1493
- }
1494
- try {
1495
- // --- Welcome to debugging React ---
1496
- // This error was thrown as a convenience so that you can use this stack
1497
- // to find the callsite that caused this warning to fire.
1498
- throw new Error(message);
1499
- } catch (x) { /**/ }
1500
- };
2030
+ function requireHas () {
2031
+ if (hasRequiredHas) return has;
2032
+ hasRequiredHas = 1;
2033
+ has = Function.call.bind(Object.prototype.hasOwnProperty);
2034
+ return has;
1501
2035
  }
1502
2036
 
1503
2037
  /**
1504
- * Assert that the values match with the type specs.
1505
- * Error messages are memorized and will only be shown once.
2038
+ * Copyright (c) 2013-present, Facebook, Inc.
1506
2039
  *
1507
- * @param {object} typeSpecs Map of name to a ReactPropType
1508
- * @param {object} values Runtime values that need to be type-checked
1509
- * @param {string} location e.g. "prop", "context", "child context"
1510
- * @param {string} componentName Name of the component for error messages.
1511
- * @param {?Function} getStack Returns the component stack.
1512
- * @private
2040
+ * This source code is licensed under the MIT license found in the
2041
+ * LICENSE file in the root directory of this source tree.
1513
2042
  */
1514
- function checkPropTypes$1(typeSpecs, values, location, componentName, getStack) {
1515
- if (process.env.NODE_ENV !== 'production') {
1516
- for (var typeSpecName in typeSpecs) {
1517
- if (has$1(typeSpecs, typeSpecName)) {
1518
- var error;
1519
- // Prop type validation may throw. In case they do, we don't want to
1520
- // fail the render phase where it didn't fail before. So we log it.
1521
- // After these have been cleaned up, we'll let them throw.
1522
- try {
1523
- // This is intentionally an invariant that gets caught. It's the same
1524
- // behavior as without this statement except with a better message.
1525
- if (typeof typeSpecs[typeSpecName] !== 'function') {
1526
- var err = Error(
1527
- (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
1528
- 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
1529
- 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
1530
- );
1531
- err.name = 'Invariant Violation';
1532
- throw err;
1533
- }
1534
- error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$2);
1535
- } catch (ex) {
1536
- error = ex;
1537
- }
1538
- if (error && !(error instanceof Error)) {
1539
- printWarning$1(
1540
- (componentName || 'React class') + ': type specification of ' +
1541
- location + ' `' + typeSpecName + '` is invalid; the type checker ' +
1542
- 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
1543
- 'You may have forgotten to pass an argument to the type checker ' +
1544
- 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
1545
- 'shape all require an argument).'
1546
- );
1547
- }
1548
- if (error instanceof Error && !(error.message in loggedTypeFailures)) {
1549
- // Only monitor this failure once because there tends to be a lot of the
1550
- // same error.
1551
- loggedTypeFailures[error.message] = true;
1552
2043
 
1553
- var stack = getStack ? getStack() : '';
1554
-
1555
- printWarning$1(
1556
- 'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
1557
- );
1558
- }
1559
- }
1560
- }
1561
- }
1562
- }
2044
+ var checkPropTypes_1;
2045
+ var hasRequiredCheckPropTypes;
2046
+
2047
+ function requireCheckPropTypes () {
2048
+ if (hasRequiredCheckPropTypes) return checkPropTypes_1;
2049
+ hasRequiredCheckPropTypes = 1;
2050
+
2051
+ var printWarning = function() {};
2052
+
2053
+ if (process.env.NODE_ENV !== 'production') {
2054
+ var ReactPropTypesSecret = requireReactPropTypesSecret();
2055
+ var loggedTypeFailures = {};
2056
+ var has = requireHas();
2057
+
2058
+ printWarning = function(text) {
2059
+ var message = 'Warning: ' + text;
2060
+ if (typeof console !== 'undefined') {
2061
+ console.error(message);
2062
+ }
2063
+ try {
2064
+ // --- Welcome to debugging React ---
2065
+ // This error was thrown as a convenience so that you can use this stack
2066
+ // to find the callsite that caused this warning to fire.
2067
+ throw new Error(message);
2068
+ } catch (x) { /**/ }
2069
+ };
2070
+ }
1563
2071
 
1564
- /**
1565
- * Resets warning cache when testing.
1566
- *
1567
- * @private
1568
- */
1569
- checkPropTypes$1.resetWarningCache = function() {
1570
- if (process.env.NODE_ENV !== 'production') {
1571
- loggedTypeFailures = {};
1572
- }
1573
- };
2072
+ /**
2073
+ * Assert that the values match with the type specs.
2074
+ * Error messages are memorized and will only be shown once.
2075
+ *
2076
+ * @param {object} typeSpecs Map of name to a ReactPropType
2077
+ * @param {object} values Runtime values that need to be type-checked
2078
+ * @param {string} location e.g. "prop", "context", "child context"
2079
+ * @param {string} componentName Name of the component for error messages.
2080
+ * @param {?Function} getStack Returns the component stack.
2081
+ * @private
2082
+ */
2083
+ function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
2084
+ if (process.env.NODE_ENV !== 'production') {
2085
+ for (var typeSpecName in typeSpecs) {
2086
+ if (has(typeSpecs, typeSpecName)) {
2087
+ var error;
2088
+ // Prop type validation may throw. In case they do, we don't want to
2089
+ // fail the render phase where it didn't fail before. So we log it.
2090
+ // After these have been cleaned up, we'll let them throw.
2091
+ try {
2092
+ // This is intentionally an invariant that gets caught. It's the same
2093
+ // behavior as without this statement except with a better message.
2094
+ if (typeof typeSpecs[typeSpecName] !== 'function') {
2095
+ var err = Error(
2096
+ (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
2097
+ 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
2098
+ 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
2099
+ );
2100
+ err.name = 'Invariant Violation';
2101
+ throw err;
2102
+ }
2103
+ error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
2104
+ } catch (ex) {
2105
+ error = ex;
2106
+ }
2107
+ if (error && !(error instanceof Error)) {
2108
+ printWarning(
2109
+ (componentName || 'React class') + ': type specification of ' +
2110
+ location + ' `' + typeSpecName + '` is invalid; the type checker ' +
2111
+ 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
2112
+ 'You may have forgotten to pass an argument to the type checker ' +
2113
+ 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
2114
+ 'shape all require an argument).'
2115
+ );
2116
+ }
2117
+ if (error instanceof Error && !(error.message in loggedTypeFailures)) {
2118
+ // Only monitor this failure once because there tends to be a lot of the
2119
+ // same error.
2120
+ loggedTypeFailures[error.message] = true;
2121
+
2122
+ var stack = getStack ? getStack() : '';
2123
+
2124
+ printWarning(
2125
+ 'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
2126
+ );
2127
+ }
2128
+ }
2129
+ }
2130
+ }
2131
+ }
1574
2132
 
1575
- var checkPropTypes_1 = checkPropTypes$1;
2133
+ /**
2134
+ * Resets warning cache when testing.
2135
+ *
2136
+ * @private
2137
+ */
2138
+ checkPropTypes.resetWarningCache = function() {
2139
+ if (process.env.NODE_ENV !== 'production') {
2140
+ loggedTypeFailures = {};
2141
+ }
2142
+ };
2143
+
2144
+ checkPropTypes_1 = checkPropTypes;
2145
+ return checkPropTypes_1;
2146
+ }
1576
2147
 
1577
2148
  /**
1578
2149
  * Copyright (c) 2013-present, Facebook, Inc.
@@ -1581,608 +2152,617 @@ var checkPropTypes_1 = checkPropTypes$1;
1581
2152
  * LICENSE file in the root directory of this source tree.
1582
2153
  */
1583
2154
 
1584
- var ReactIs$1 = reactIs.exports;
1585
- var assign = objectAssign;
1586
-
1587
- var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
1588
- var has = has$2;
1589
- var checkPropTypes = checkPropTypes_1;
1590
-
1591
- var printWarning = function() {};
2155
+ var factoryWithTypeCheckers;
2156
+ var hasRequiredFactoryWithTypeCheckers;
2157
+
2158
+ function requireFactoryWithTypeCheckers () {
2159
+ if (hasRequiredFactoryWithTypeCheckers) return factoryWithTypeCheckers;
2160
+ hasRequiredFactoryWithTypeCheckers = 1;
2161
+
2162
+ var ReactIs = requireReactIs();
2163
+ var assign = requireObjectAssign();
2164
+
2165
+ var ReactPropTypesSecret = requireReactPropTypesSecret();
2166
+ var has = requireHas();
2167
+ var checkPropTypes = requireCheckPropTypes();
2168
+
2169
+ var printWarning = function() {};
2170
+
2171
+ if (process.env.NODE_ENV !== 'production') {
2172
+ printWarning = function(text) {
2173
+ var message = 'Warning: ' + text;
2174
+ if (typeof console !== 'undefined') {
2175
+ console.error(message);
2176
+ }
2177
+ try {
2178
+ // --- Welcome to debugging React ---
2179
+ // This error was thrown as a convenience so that you can use this stack
2180
+ // to find the callsite that caused this warning to fire.
2181
+ throw new Error(message);
2182
+ } catch (x) {}
2183
+ };
2184
+ }
1592
2185
 
1593
- if (process.env.NODE_ENV !== 'production') {
1594
- printWarning = function(text) {
1595
- var message = 'Warning: ' + text;
1596
- if (typeof console !== 'undefined') {
1597
- console.error(message);
1598
- }
1599
- try {
1600
- // --- Welcome to debugging React ---
1601
- // This error was thrown as a convenience so that you can use this stack
1602
- // to find the callsite that caused this warning to fire.
1603
- throw new Error(message);
1604
- } catch (x) {}
1605
- };
1606
- }
2186
+ function emptyFunctionThatReturnsNull() {
2187
+ return null;
2188
+ }
1607
2189
 
1608
- function emptyFunctionThatReturnsNull() {
1609
- return null;
2190
+ factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
2191
+ /* global Symbol */
2192
+ var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
2193
+ var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
2194
+
2195
+ /**
2196
+ * Returns the iterator method function contained on the iterable object.
2197
+ *
2198
+ * Be sure to invoke the function with the iterable as context:
2199
+ *
2200
+ * var iteratorFn = getIteratorFn(myIterable);
2201
+ * if (iteratorFn) {
2202
+ * var iterator = iteratorFn.call(myIterable);
2203
+ * ...
2204
+ * }
2205
+ *
2206
+ * @param {?object} maybeIterable
2207
+ * @return {?function}
2208
+ */
2209
+ function getIteratorFn(maybeIterable) {
2210
+ var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
2211
+ if (typeof iteratorFn === 'function') {
2212
+ return iteratorFn;
2213
+ }
2214
+ }
2215
+
2216
+ /**
2217
+ * Collection of methods that allow declaration and validation of props that are
2218
+ * supplied to React components. Example usage:
2219
+ *
2220
+ * var Props = require('ReactPropTypes');
2221
+ * var MyArticle = React.createClass({
2222
+ * propTypes: {
2223
+ * // An optional string prop named "description".
2224
+ * description: Props.string,
2225
+ *
2226
+ * // A required enum prop named "category".
2227
+ * category: Props.oneOf(['News','Photos']).isRequired,
2228
+ *
2229
+ * // A prop named "dialog" that requires an instance of Dialog.
2230
+ * dialog: Props.instanceOf(Dialog).isRequired
2231
+ * },
2232
+ * render: function() { ... }
2233
+ * });
2234
+ *
2235
+ * A more formal specification of how these methods are used:
2236
+ *
2237
+ * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
2238
+ * decl := ReactPropTypes.{type}(.isRequired)?
2239
+ *
2240
+ * Each and every declaration produces a function with the same signature. This
2241
+ * allows the creation of custom validation functions. For example:
2242
+ *
2243
+ * var MyLink = React.createClass({
2244
+ * propTypes: {
2245
+ * // An optional string or URI prop named "href".
2246
+ * href: function(props, propName, componentName) {
2247
+ * var propValue = props[propName];
2248
+ * if (propValue != null && typeof propValue !== 'string' &&
2249
+ * !(propValue instanceof URI)) {
2250
+ * return new Error(
2251
+ * 'Expected a string or an URI for ' + propName + ' in ' +
2252
+ * componentName
2253
+ * );
2254
+ * }
2255
+ * }
2256
+ * },
2257
+ * render: function() {...}
2258
+ * });
2259
+ *
2260
+ * @internal
2261
+ */
2262
+
2263
+ var ANONYMOUS = '<<anonymous>>';
2264
+
2265
+ // Important!
2266
+ // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
2267
+ var ReactPropTypes = {
2268
+ array: createPrimitiveTypeChecker('array'),
2269
+ bigint: createPrimitiveTypeChecker('bigint'),
2270
+ bool: createPrimitiveTypeChecker('boolean'),
2271
+ func: createPrimitiveTypeChecker('function'),
2272
+ number: createPrimitiveTypeChecker('number'),
2273
+ object: createPrimitiveTypeChecker('object'),
2274
+ string: createPrimitiveTypeChecker('string'),
2275
+ symbol: createPrimitiveTypeChecker('symbol'),
2276
+
2277
+ any: createAnyTypeChecker(),
2278
+ arrayOf: createArrayOfTypeChecker,
2279
+ element: createElementTypeChecker(),
2280
+ elementType: createElementTypeTypeChecker(),
2281
+ instanceOf: createInstanceTypeChecker,
2282
+ node: createNodeChecker(),
2283
+ objectOf: createObjectOfTypeChecker,
2284
+ oneOf: createEnumTypeChecker,
2285
+ oneOfType: createUnionTypeChecker,
2286
+ shape: createShapeTypeChecker,
2287
+ exact: createStrictShapeTypeChecker,
2288
+ };
2289
+
2290
+ /**
2291
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
2292
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
2293
+ */
2294
+ /*eslint-disable no-self-compare*/
2295
+ function is(x, y) {
2296
+ // SameValue algorithm
2297
+ if (x === y) {
2298
+ // Steps 1-5, 7-10
2299
+ // Steps 6.b-6.e: +0 != -0
2300
+ return x !== 0 || 1 / x === 1 / y;
2301
+ } else {
2302
+ // Step 6.a: NaN == NaN
2303
+ return x !== x && y !== y;
2304
+ }
2305
+ }
2306
+ /*eslint-enable no-self-compare*/
2307
+
2308
+ /**
2309
+ * We use an Error-like object for backward compatibility as people may call
2310
+ * PropTypes directly and inspect their output. However, we don't use real
2311
+ * Errors anymore. We don't inspect their stack anyway, and creating them
2312
+ * is prohibitively expensive if they are created too often, such as what
2313
+ * happens in oneOfType() for any type before the one that matched.
2314
+ */
2315
+ function PropTypeError(message, data) {
2316
+ this.message = message;
2317
+ this.data = data && typeof data === 'object' ? data: {};
2318
+ this.stack = '';
2319
+ }
2320
+ // Make `instanceof Error` still work for returned errors.
2321
+ PropTypeError.prototype = Error.prototype;
2322
+
2323
+ function createChainableTypeChecker(validate) {
2324
+ if (process.env.NODE_ENV !== 'production') {
2325
+ var manualPropTypeCallCache = {};
2326
+ var manualPropTypeWarningCount = 0;
2327
+ }
2328
+ function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
2329
+ componentName = componentName || ANONYMOUS;
2330
+ propFullName = propFullName || propName;
2331
+
2332
+ if (secret !== ReactPropTypesSecret) {
2333
+ if (throwOnDirectAccess) {
2334
+ // New behavior only for users of `prop-types` package
2335
+ var err = new Error(
2336
+ 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
2337
+ 'Use `PropTypes.checkPropTypes()` to call them. ' +
2338
+ 'Read more at http://fb.me/use-check-prop-types'
2339
+ );
2340
+ err.name = 'Invariant Violation';
2341
+ throw err;
2342
+ } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
2343
+ // Old behavior for people using React.PropTypes
2344
+ var cacheKey = componentName + ':' + propName;
2345
+ if (
2346
+ !manualPropTypeCallCache[cacheKey] &&
2347
+ // Avoid spamming the console because they are often not actionable except for lib authors
2348
+ manualPropTypeWarningCount < 3
2349
+ ) {
2350
+ printWarning(
2351
+ 'You are manually calling a React.PropTypes validation ' +
2352
+ 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +
2353
+ 'and will throw in the standalone `prop-types` package. ' +
2354
+ 'You may be seeing this warning due to a third-party PropTypes ' +
2355
+ 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
2356
+ );
2357
+ manualPropTypeCallCache[cacheKey] = true;
2358
+ manualPropTypeWarningCount++;
2359
+ }
2360
+ }
2361
+ }
2362
+ if (props[propName] == null) {
2363
+ if (isRequired) {
2364
+ if (props[propName] === null) {
2365
+ return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
2366
+ }
2367
+ return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
2368
+ }
2369
+ return null;
2370
+ } else {
2371
+ return validate(props, propName, componentName, location, propFullName);
2372
+ }
2373
+ }
2374
+
2375
+ var chainedCheckType = checkType.bind(null, false);
2376
+ chainedCheckType.isRequired = checkType.bind(null, true);
2377
+
2378
+ return chainedCheckType;
2379
+ }
2380
+
2381
+ function createPrimitiveTypeChecker(expectedType) {
2382
+ function validate(props, propName, componentName, location, propFullName, secret) {
2383
+ var propValue = props[propName];
2384
+ var propType = getPropType(propValue);
2385
+ if (propType !== expectedType) {
2386
+ // `propValue` being instance of, say, date/regexp, pass the 'object'
2387
+ // check, but we can offer a more precise error message here rather than
2388
+ // 'of type `object`'.
2389
+ var preciseType = getPreciseType(propValue);
2390
+
2391
+ return new PropTypeError(
2392
+ 'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),
2393
+ {expectedType: expectedType}
2394
+ );
2395
+ }
2396
+ return null;
2397
+ }
2398
+ return createChainableTypeChecker(validate);
2399
+ }
2400
+
2401
+ function createAnyTypeChecker() {
2402
+ return createChainableTypeChecker(emptyFunctionThatReturnsNull);
2403
+ }
2404
+
2405
+ function createArrayOfTypeChecker(typeChecker) {
2406
+ function validate(props, propName, componentName, location, propFullName) {
2407
+ if (typeof typeChecker !== 'function') {
2408
+ return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
2409
+ }
2410
+ var propValue = props[propName];
2411
+ if (!Array.isArray(propValue)) {
2412
+ var propType = getPropType(propValue);
2413
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
2414
+ }
2415
+ for (var i = 0; i < propValue.length; i++) {
2416
+ var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
2417
+ if (error instanceof Error) {
2418
+ return error;
2419
+ }
2420
+ }
2421
+ return null;
2422
+ }
2423
+ return createChainableTypeChecker(validate);
2424
+ }
2425
+
2426
+ function createElementTypeChecker() {
2427
+ function validate(props, propName, componentName, location, propFullName) {
2428
+ var propValue = props[propName];
2429
+ if (!isValidElement(propValue)) {
2430
+ var propType = getPropType(propValue);
2431
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
2432
+ }
2433
+ return null;
2434
+ }
2435
+ return createChainableTypeChecker(validate);
2436
+ }
2437
+
2438
+ function createElementTypeTypeChecker() {
2439
+ function validate(props, propName, componentName, location, propFullName) {
2440
+ var propValue = props[propName];
2441
+ if (!ReactIs.isValidElementType(propValue)) {
2442
+ var propType = getPropType(propValue);
2443
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
2444
+ }
2445
+ return null;
2446
+ }
2447
+ return createChainableTypeChecker(validate);
2448
+ }
2449
+
2450
+ function createInstanceTypeChecker(expectedClass) {
2451
+ function validate(props, propName, componentName, location, propFullName) {
2452
+ if (!(props[propName] instanceof expectedClass)) {
2453
+ var expectedClassName = expectedClass.name || ANONYMOUS;
2454
+ var actualClassName = getClassName(props[propName]);
2455
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
2456
+ }
2457
+ return null;
2458
+ }
2459
+ return createChainableTypeChecker(validate);
2460
+ }
2461
+
2462
+ function createEnumTypeChecker(expectedValues) {
2463
+ if (!Array.isArray(expectedValues)) {
2464
+ if (process.env.NODE_ENV !== 'production') {
2465
+ if (arguments.length > 1) {
2466
+ printWarning(
2467
+ 'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
2468
+ 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
2469
+ );
2470
+ } else {
2471
+ printWarning('Invalid argument supplied to oneOf, expected an array.');
2472
+ }
2473
+ }
2474
+ return emptyFunctionThatReturnsNull;
2475
+ }
2476
+
2477
+ function validate(props, propName, componentName, location, propFullName) {
2478
+ var propValue = props[propName];
2479
+ for (var i = 0; i < expectedValues.length; i++) {
2480
+ if (is(propValue, expectedValues[i])) {
2481
+ return null;
2482
+ }
2483
+ }
2484
+
2485
+ var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
2486
+ var type = getPreciseType(value);
2487
+ if (type === 'symbol') {
2488
+ return String(value);
2489
+ }
2490
+ return value;
2491
+ });
2492
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
2493
+ }
2494
+ return createChainableTypeChecker(validate);
2495
+ }
2496
+
2497
+ function createObjectOfTypeChecker(typeChecker) {
2498
+ function validate(props, propName, componentName, location, propFullName) {
2499
+ if (typeof typeChecker !== 'function') {
2500
+ return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
2501
+ }
2502
+ var propValue = props[propName];
2503
+ var propType = getPropType(propValue);
2504
+ if (propType !== 'object') {
2505
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
2506
+ }
2507
+ for (var key in propValue) {
2508
+ if (has(propValue, key)) {
2509
+ var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
2510
+ if (error instanceof Error) {
2511
+ return error;
2512
+ }
2513
+ }
2514
+ }
2515
+ return null;
2516
+ }
2517
+ return createChainableTypeChecker(validate);
2518
+ }
2519
+
2520
+ function createUnionTypeChecker(arrayOfTypeCheckers) {
2521
+ if (!Array.isArray(arrayOfTypeCheckers)) {
2522
+ process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
2523
+ return emptyFunctionThatReturnsNull;
2524
+ }
2525
+
2526
+ for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
2527
+ var checker = arrayOfTypeCheckers[i];
2528
+ if (typeof checker !== 'function') {
2529
+ printWarning(
2530
+ 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
2531
+ 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
2532
+ );
2533
+ return emptyFunctionThatReturnsNull;
2534
+ }
2535
+ }
2536
+
2537
+ function validate(props, propName, componentName, location, propFullName) {
2538
+ var expectedTypes = [];
2539
+ for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
2540
+ var checker = arrayOfTypeCheckers[i];
2541
+ var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
2542
+ if (checkerResult == null) {
2543
+ return null;
2544
+ }
2545
+ if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
2546
+ expectedTypes.push(checkerResult.data.expectedType);
2547
+ }
2548
+ }
2549
+ var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';
2550
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
2551
+ }
2552
+ return createChainableTypeChecker(validate);
2553
+ }
2554
+
2555
+ function createNodeChecker() {
2556
+ function validate(props, propName, componentName, location, propFullName) {
2557
+ if (!isNode(props[propName])) {
2558
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
2559
+ }
2560
+ return null;
2561
+ }
2562
+ return createChainableTypeChecker(validate);
2563
+ }
2564
+
2565
+ function invalidValidatorError(componentName, location, propFullName, key, type) {
2566
+ return new PropTypeError(
2567
+ (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +
2568
+ 'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'
2569
+ );
2570
+ }
2571
+
2572
+ function createShapeTypeChecker(shapeTypes) {
2573
+ function validate(props, propName, componentName, location, propFullName) {
2574
+ var propValue = props[propName];
2575
+ var propType = getPropType(propValue);
2576
+ if (propType !== 'object') {
2577
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
2578
+ }
2579
+ for (var key in shapeTypes) {
2580
+ var checker = shapeTypes[key];
2581
+ if (typeof checker !== 'function') {
2582
+ return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
2583
+ }
2584
+ var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
2585
+ if (error) {
2586
+ return error;
2587
+ }
2588
+ }
2589
+ return null;
2590
+ }
2591
+ return createChainableTypeChecker(validate);
2592
+ }
2593
+
2594
+ function createStrictShapeTypeChecker(shapeTypes) {
2595
+ function validate(props, propName, componentName, location, propFullName) {
2596
+ var propValue = props[propName];
2597
+ var propType = getPropType(propValue);
2598
+ if (propType !== 'object') {
2599
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
2600
+ }
2601
+ // We need to check all keys in case some are required but missing from props.
2602
+ var allKeys = assign({}, props[propName], shapeTypes);
2603
+ for (var key in allKeys) {
2604
+ var checker = shapeTypes[key];
2605
+ if (has(shapeTypes, key) && typeof checker !== 'function') {
2606
+ return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
2607
+ }
2608
+ if (!checker) {
2609
+ return new PropTypeError(
2610
+ 'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
2611
+ '\nBad object: ' + JSON.stringify(props[propName], null, ' ') +
2612
+ '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')
2613
+ );
2614
+ }
2615
+ var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
2616
+ if (error) {
2617
+ return error;
2618
+ }
2619
+ }
2620
+ return null;
2621
+ }
2622
+
2623
+ return createChainableTypeChecker(validate);
2624
+ }
2625
+
2626
+ function isNode(propValue) {
2627
+ switch (typeof propValue) {
2628
+ case 'number':
2629
+ case 'string':
2630
+ case 'undefined':
2631
+ return true;
2632
+ case 'boolean':
2633
+ return !propValue;
2634
+ case 'object':
2635
+ if (Array.isArray(propValue)) {
2636
+ return propValue.every(isNode);
2637
+ }
2638
+ if (propValue === null || isValidElement(propValue)) {
2639
+ return true;
2640
+ }
2641
+
2642
+ var iteratorFn = getIteratorFn(propValue);
2643
+ if (iteratorFn) {
2644
+ var iterator = iteratorFn.call(propValue);
2645
+ var step;
2646
+ if (iteratorFn !== propValue.entries) {
2647
+ while (!(step = iterator.next()).done) {
2648
+ if (!isNode(step.value)) {
2649
+ return false;
2650
+ }
2651
+ }
2652
+ } else {
2653
+ // Iterator will provide entry [k,v] tuples rather than values.
2654
+ while (!(step = iterator.next()).done) {
2655
+ var entry = step.value;
2656
+ if (entry) {
2657
+ if (!isNode(entry[1])) {
2658
+ return false;
2659
+ }
2660
+ }
2661
+ }
2662
+ }
2663
+ } else {
2664
+ return false;
2665
+ }
2666
+
2667
+ return true;
2668
+ default:
2669
+ return false;
2670
+ }
2671
+ }
2672
+
2673
+ function isSymbol(propType, propValue) {
2674
+ // Native Symbol.
2675
+ if (propType === 'symbol') {
2676
+ return true;
2677
+ }
2678
+
2679
+ // falsy value can't be a Symbol
2680
+ if (!propValue) {
2681
+ return false;
2682
+ }
2683
+
2684
+ // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
2685
+ if (propValue['@@toStringTag'] === 'Symbol') {
2686
+ return true;
2687
+ }
2688
+
2689
+ // Fallback for non-spec compliant Symbols which are polyfilled.
2690
+ if (typeof Symbol === 'function' && propValue instanceof Symbol) {
2691
+ return true;
2692
+ }
2693
+
2694
+ return false;
2695
+ }
2696
+
2697
+ // Equivalent of `typeof` but with special handling for array and regexp.
2698
+ function getPropType(propValue) {
2699
+ var propType = typeof propValue;
2700
+ if (Array.isArray(propValue)) {
2701
+ return 'array';
2702
+ }
2703
+ if (propValue instanceof RegExp) {
2704
+ // Old webkits (at least until Android 4.0) return 'function' rather than
2705
+ // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
2706
+ // passes PropTypes.object.
2707
+ return 'object';
2708
+ }
2709
+ if (isSymbol(propType, propValue)) {
2710
+ return 'symbol';
2711
+ }
2712
+ return propType;
2713
+ }
2714
+
2715
+ // This handles more types than `getPropType`. Only used for error messages.
2716
+ // See `createPrimitiveTypeChecker`.
2717
+ function getPreciseType(propValue) {
2718
+ if (typeof propValue === 'undefined' || propValue === null) {
2719
+ return '' + propValue;
2720
+ }
2721
+ var propType = getPropType(propValue);
2722
+ if (propType === 'object') {
2723
+ if (propValue instanceof Date) {
2724
+ return 'date';
2725
+ } else if (propValue instanceof RegExp) {
2726
+ return 'regexp';
2727
+ }
2728
+ }
2729
+ return propType;
2730
+ }
2731
+
2732
+ // Returns a string that is postfixed to a warning about an invalid type.
2733
+ // For example, "undefined" or "of type array"
2734
+ function getPostfixForTypeWarning(value) {
2735
+ var type = getPreciseType(value);
2736
+ switch (type) {
2737
+ case 'array':
2738
+ case 'object':
2739
+ return 'an ' + type;
2740
+ case 'boolean':
2741
+ case 'date':
2742
+ case 'regexp':
2743
+ return 'a ' + type;
2744
+ default:
2745
+ return type;
2746
+ }
2747
+ }
2748
+
2749
+ // Returns class name of the object, if any.
2750
+ function getClassName(propValue) {
2751
+ if (!propValue.constructor || !propValue.constructor.name) {
2752
+ return ANONYMOUS;
2753
+ }
2754
+ return propValue.constructor.name;
2755
+ }
2756
+
2757
+ ReactPropTypes.checkPropTypes = checkPropTypes;
2758
+ ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
2759
+ ReactPropTypes.PropTypes = ReactPropTypes;
2760
+
2761
+ return ReactPropTypes;
2762
+ };
2763
+ return factoryWithTypeCheckers;
1610
2764
  }
1611
2765
 
1612
- var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
1613
- /* global Symbol */
1614
- var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
1615
- var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
1616
-
1617
- /**
1618
- * Returns the iterator method function contained on the iterable object.
1619
- *
1620
- * Be sure to invoke the function with the iterable as context:
1621
- *
1622
- * var iteratorFn = getIteratorFn(myIterable);
1623
- * if (iteratorFn) {
1624
- * var iterator = iteratorFn.call(myIterable);
1625
- * ...
1626
- * }
1627
- *
1628
- * @param {?object} maybeIterable
1629
- * @return {?function}
1630
- */
1631
- function getIteratorFn(maybeIterable) {
1632
- var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
1633
- if (typeof iteratorFn === 'function') {
1634
- return iteratorFn;
1635
- }
1636
- }
1637
-
1638
- /**
1639
- * Collection of methods that allow declaration and validation of props that are
1640
- * supplied to React components. Example usage:
1641
- *
1642
- * var Props = require('ReactPropTypes');
1643
- * var MyArticle = React.createClass({
1644
- * propTypes: {
1645
- * // An optional string prop named "description".
1646
- * description: Props.string,
1647
- *
1648
- * // A required enum prop named "category".
1649
- * category: Props.oneOf(['News','Photos']).isRequired,
1650
- *
1651
- * // A prop named "dialog" that requires an instance of Dialog.
1652
- * dialog: Props.instanceOf(Dialog).isRequired
1653
- * },
1654
- * render: function() { ... }
1655
- * });
1656
- *
1657
- * A more formal specification of how these methods are used:
1658
- *
1659
- * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
1660
- * decl := ReactPropTypes.{type}(.isRequired)?
1661
- *
1662
- * Each and every declaration produces a function with the same signature. This
1663
- * allows the creation of custom validation functions. For example:
1664
- *
1665
- * var MyLink = React.createClass({
1666
- * propTypes: {
1667
- * // An optional string or URI prop named "href".
1668
- * href: function(props, propName, componentName) {
1669
- * var propValue = props[propName];
1670
- * if (propValue != null && typeof propValue !== 'string' &&
1671
- * !(propValue instanceof URI)) {
1672
- * return new Error(
1673
- * 'Expected a string or an URI for ' + propName + ' in ' +
1674
- * componentName
1675
- * );
1676
- * }
1677
- * }
1678
- * },
1679
- * render: function() {...}
1680
- * });
1681
- *
1682
- * @internal
1683
- */
1684
-
1685
- var ANONYMOUS = '<<anonymous>>';
1686
-
1687
- // Important!
1688
- // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
1689
- var ReactPropTypes = {
1690
- array: createPrimitiveTypeChecker('array'),
1691
- bigint: createPrimitiveTypeChecker('bigint'),
1692
- bool: createPrimitiveTypeChecker('boolean'),
1693
- func: createPrimitiveTypeChecker('function'),
1694
- number: createPrimitiveTypeChecker('number'),
1695
- object: createPrimitiveTypeChecker('object'),
1696
- string: createPrimitiveTypeChecker('string'),
1697
- symbol: createPrimitiveTypeChecker('symbol'),
1698
-
1699
- any: createAnyTypeChecker(),
1700
- arrayOf: createArrayOfTypeChecker,
1701
- element: createElementTypeChecker(),
1702
- elementType: createElementTypeTypeChecker(),
1703
- instanceOf: createInstanceTypeChecker,
1704
- node: createNodeChecker(),
1705
- objectOf: createObjectOfTypeChecker,
1706
- oneOf: createEnumTypeChecker,
1707
- oneOfType: createUnionTypeChecker,
1708
- shape: createShapeTypeChecker,
1709
- exact: createStrictShapeTypeChecker,
1710
- };
1711
-
1712
- /**
1713
- * inlined Object.is polyfill to avoid requiring consumers ship their own
1714
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
1715
- */
1716
- /*eslint-disable no-self-compare*/
1717
- function is(x, y) {
1718
- // SameValue algorithm
1719
- if (x === y) {
1720
- // Steps 1-5, 7-10
1721
- // Steps 6.b-6.e: +0 != -0
1722
- return x !== 0 || 1 / x === 1 / y;
1723
- } else {
1724
- // Step 6.a: NaN == NaN
1725
- return x !== x && y !== y;
1726
- }
1727
- }
1728
- /*eslint-enable no-self-compare*/
1729
-
1730
- /**
1731
- * We use an Error-like object for backward compatibility as people may call
1732
- * PropTypes directly and inspect their output. However, we don't use real
1733
- * Errors anymore. We don't inspect their stack anyway, and creating them
1734
- * is prohibitively expensive if they are created too often, such as what
1735
- * happens in oneOfType() for any type before the one that matched.
1736
- */
1737
- function PropTypeError(message, data) {
1738
- this.message = message;
1739
- this.data = data && typeof data === 'object' ? data: {};
1740
- this.stack = '';
1741
- }
1742
- // Make `instanceof Error` still work for returned errors.
1743
- PropTypeError.prototype = Error.prototype;
1744
-
1745
- function createChainableTypeChecker(validate) {
1746
- if (process.env.NODE_ENV !== 'production') {
1747
- var manualPropTypeCallCache = {};
1748
- var manualPropTypeWarningCount = 0;
1749
- }
1750
- function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
1751
- componentName = componentName || ANONYMOUS;
1752
- propFullName = propFullName || propName;
1753
-
1754
- if (secret !== ReactPropTypesSecret$1) {
1755
- if (throwOnDirectAccess) {
1756
- // New behavior only for users of `prop-types` package
1757
- var err = new Error(
1758
- 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
1759
- 'Use `PropTypes.checkPropTypes()` to call them. ' +
1760
- 'Read more at http://fb.me/use-check-prop-types'
1761
- );
1762
- err.name = 'Invariant Violation';
1763
- throw err;
1764
- } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
1765
- // Old behavior for people using React.PropTypes
1766
- var cacheKey = componentName + ':' + propName;
1767
- if (
1768
- !manualPropTypeCallCache[cacheKey] &&
1769
- // Avoid spamming the console because they are often not actionable except for lib authors
1770
- manualPropTypeWarningCount < 3
1771
- ) {
1772
- printWarning(
1773
- 'You are manually calling a React.PropTypes validation ' +
1774
- 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +
1775
- 'and will throw in the standalone `prop-types` package. ' +
1776
- 'You may be seeing this warning due to a third-party PropTypes ' +
1777
- 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
1778
- );
1779
- manualPropTypeCallCache[cacheKey] = true;
1780
- manualPropTypeWarningCount++;
1781
- }
1782
- }
1783
- }
1784
- if (props[propName] == null) {
1785
- if (isRequired) {
1786
- if (props[propName] === null) {
1787
- return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
1788
- }
1789
- return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
1790
- }
1791
- return null;
1792
- } else {
1793
- return validate(props, propName, componentName, location, propFullName);
1794
- }
1795
- }
1796
-
1797
- var chainedCheckType = checkType.bind(null, false);
1798
- chainedCheckType.isRequired = checkType.bind(null, true);
1799
-
1800
- return chainedCheckType;
1801
- }
1802
-
1803
- function createPrimitiveTypeChecker(expectedType) {
1804
- function validate(props, propName, componentName, location, propFullName, secret) {
1805
- var propValue = props[propName];
1806
- var propType = getPropType(propValue);
1807
- if (propType !== expectedType) {
1808
- // `propValue` being instance of, say, date/regexp, pass the 'object'
1809
- // check, but we can offer a more precise error message here rather than
1810
- // 'of type `object`'.
1811
- var preciseType = getPreciseType(propValue);
1812
-
1813
- return new PropTypeError(
1814
- 'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),
1815
- {expectedType: expectedType}
1816
- );
1817
- }
1818
- return null;
1819
- }
1820
- return createChainableTypeChecker(validate);
1821
- }
1822
-
1823
- function createAnyTypeChecker() {
1824
- return createChainableTypeChecker(emptyFunctionThatReturnsNull);
1825
- }
1826
-
1827
- function createArrayOfTypeChecker(typeChecker) {
1828
- function validate(props, propName, componentName, location, propFullName) {
1829
- if (typeof typeChecker !== 'function') {
1830
- return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
1831
- }
1832
- var propValue = props[propName];
1833
- if (!Array.isArray(propValue)) {
1834
- var propType = getPropType(propValue);
1835
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
1836
- }
1837
- for (var i = 0; i < propValue.length; i++) {
1838
- var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret$1);
1839
- if (error instanceof Error) {
1840
- return error;
1841
- }
1842
- }
1843
- return null;
1844
- }
1845
- return createChainableTypeChecker(validate);
1846
- }
1847
-
1848
- function createElementTypeChecker() {
1849
- function validate(props, propName, componentName, location, propFullName) {
1850
- var propValue = props[propName];
1851
- if (!isValidElement(propValue)) {
1852
- var propType = getPropType(propValue);
1853
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
1854
- }
1855
- return null;
1856
- }
1857
- return createChainableTypeChecker(validate);
1858
- }
1859
-
1860
- function createElementTypeTypeChecker() {
1861
- function validate(props, propName, componentName, location, propFullName) {
1862
- var propValue = props[propName];
1863
- if (!ReactIs$1.isValidElementType(propValue)) {
1864
- var propType = getPropType(propValue);
1865
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
1866
- }
1867
- return null;
1868
- }
1869
- return createChainableTypeChecker(validate);
1870
- }
1871
-
1872
- function createInstanceTypeChecker(expectedClass) {
1873
- function validate(props, propName, componentName, location, propFullName) {
1874
- if (!(props[propName] instanceof expectedClass)) {
1875
- var expectedClassName = expectedClass.name || ANONYMOUS;
1876
- var actualClassName = getClassName(props[propName]);
1877
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
1878
- }
1879
- return null;
1880
- }
1881
- return createChainableTypeChecker(validate);
1882
- }
1883
-
1884
- function createEnumTypeChecker(expectedValues) {
1885
- if (!Array.isArray(expectedValues)) {
1886
- if (process.env.NODE_ENV !== 'production') {
1887
- if (arguments.length > 1) {
1888
- printWarning(
1889
- 'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
1890
- 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
1891
- );
1892
- } else {
1893
- printWarning('Invalid argument supplied to oneOf, expected an array.');
1894
- }
1895
- }
1896
- return emptyFunctionThatReturnsNull;
1897
- }
1898
-
1899
- function validate(props, propName, componentName, location, propFullName) {
1900
- var propValue = props[propName];
1901
- for (var i = 0; i < expectedValues.length; i++) {
1902
- if (is(propValue, expectedValues[i])) {
1903
- return null;
1904
- }
1905
- }
1906
-
1907
- var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
1908
- var type = getPreciseType(value);
1909
- if (type === 'symbol') {
1910
- return String(value);
1911
- }
1912
- return value;
1913
- });
1914
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
1915
- }
1916
- return createChainableTypeChecker(validate);
1917
- }
1918
-
1919
- function createObjectOfTypeChecker(typeChecker) {
1920
- function validate(props, propName, componentName, location, propFullName) {
1921
- if (typeof typeChecker !== 'function') {
1922
- return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
1923
- }
1924
- var propValue = props[propName];
1925
- var propType = getPropType(propValue);
1926
- if (propType !== 'object') {
1927
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
1928
- }
1929
- for (var key in propValue) {
1930
- if (has(propValue, key)) {
1931
- var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret$1);
1932
- if (error instanceof Error) {
1933
- return error;
1934
- }
1935
- }
1936
- }
1937
- return null;
1938
- }
1939
- return createChainableTypeChecker(validate);
1940
- }
1941
-
1942
- function createUnionTypeChecker(arrayOfTypeCheckers) {
1943
- if (!Array.isArray(arrayOfTypeCheckers)) {
1944
- process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
1945
- return emptyFunctionThatReturnsNull;
1946
- }
1947
-
1948
- for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
1949
- var checker = arrayOfTypeCheckers[i];
1950
- if (typeof checker !== 'function') {
1951
- printWarning(
1952
- 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
1953
- 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
1954
- );
1955
- return emptyFunctionThatReturnsNull;
1956
- }
1957
- }
1958
-
1959
- function validate(props, propName, componentName, location, propFullName) {
1960
- var expectedTypes = [];
1961
- for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
1962
- var checker = arrayOfTypeCheckers[i];
1963
- var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret$1);
1964
- if (checkerResult == null) {
1965
- return null;
1966
- }
1967
- if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
1968
- expectedTypes.push(checkerResult.data.expectedType);
1969
- }
1970
- }
1971
- var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';
1972
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
1973
- }
1974
- return createChainableTypeChecker(validate);
1975
- }
1976
-
1977
- function createNodeChecker() {
1978
- function validate(props, propName, componentName, location, propFullName) {
1979
- if (!isNode(props[propName])) {
1980
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
1981
- }
1982
- return null;
1983
- }
1984
- return createChainableTypeChecker(validate);
1985
- }
1986
-
1987
- function invalidValidatorError(componentName, location, propFullName, key, type) {
1988
- return new PropTypeError(
1989
- (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +
1990
- 'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'
1991
- );
1992
- }
1993
-
1994
- function createShapeTypeChecker(shapeTypes) {
1995
- function validate(props, propName, componentName, location, propFullName) {
1996
- var propValue = props[propName];
1997
- var propType = getPropType(propValue);
1998
- if (propType !== 'object') {
1999
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
2000
- }
2001
- for (var key in shapeTypes) {
2002
- var checker = shapeTypes[key];
2003
- if (typeof checker !== 'function') {
2004
- return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
2005
- }
2006
- var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret$1);
2007
- if (error) {
2008
- return error;
2009
- }
2010
- }
2011
- return null;
2012
- }
2013
- return createChainableTypeChecker(validate);
2014
- }
2015
-
2016
- function createStrictShapeTypeChecker(shapeTypes) {
2017
- function validate(props, propName, componentName, location, propFullName) {
2018
- var propValue = props[propName];
2019
- var propType = getPropType(propValue);
2020
- if (propType !== 'object') {
2021
- return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
2022
- }
2023
- // We need to check all keys in case some are required but missing from props.
2024
- var allKeys = assign({}, props[propName], shapeTypes);
2025
- for (var key in allKeys) {
2026
- var checker = shapeTypes[key];
2027
- if (has(shapeTypes, key) && typeof checker !== 'function') {
2028
- return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
2029
- }
2030
- if (!checker) {
2031
- return new PropTypeError(
2032
- 'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
2033
- '\nBad object: ' + JSON.stringify(props[propName], null, ' ') +
2034
- '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')
2035
- );
2036
- }
2037
- var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret$1);
2038
- if (error) {
2039
- return error;
2040
- }
2041
- }
2042
- return null;
2043
- }
2044
-
2045
- return createChainableTypeChecker(validate);
2046
- }
2047
-
2048
- function isNode(propValue) {
2049
- switch (typeof propValue) {
2050
- case 'number':
2051
- case 'string':
2052
- case 'undefined':
2053
- return true;
2054
- case 'boolean':
2055
- return !propValue;
2056
- case 'object':
2057
- if (Array.isArray(propValue)) {
2058
- return propValue.every(isNode);
2059
- }
2060
- if (propValue === null || isValidElement(propValue)) {
2061
- return true;
2062
- }
2063
-
2064
- var iteratorFn = getIteratorFn(propValue);
2065
- if (iteratorFn) {
2066
- var iterator = iteratorFn.call(propValue);
2067
- var step;
2068
- if (iteratorFn !== propValue.entries) {
2069
- while (!(step = iterator.next()).done) {
2070
- if (!isNode(step.value)) {
2071
- return false;
2072
- }
2073
- }
2074
- } else {
2075
- // Iterator will provide entry [k,v] tuples rather than values.
2076
- while (!(step = iterator.next()).done) {
2077
- var entry = step.value;
2078
- if (entry) {
2079
- if (!isNode(entry[1])) {
2080
- return false;
2081
- }
2082
- }
2083
- }
2084
- }
2085
- } else {
2086
- return false;
2087
- }
2088
-
2089
- return true;
2090
- default:
2091
- return false;
2092
- }
2093
- }
2094
-
2095
- function isSymbol(propType, propValue) {
2096
- // Native Symbol.
2097
- if (propType === 'symbol') {
2098
- return true;
2099
- }
2100
-
2101
- // falsy value can't be a Symbol
2102
- if (!propValue) {
2103
- return false;
2104
- }
2105
-
2106
- // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
2107
- if (propValue['@@toStringTag'] === 'Symbol') {
2108
- return true;
2109
- }
2110
-
2111
- // Fallback for non-spec compliant Symbols which are polyfilled.
2112
- if (typeof Symbol === 'function' && propValue instanceof Symbol) {
2113
- return true;
2114
- }
2115
-
2116
- return false;
2117
- }
2118
-
2119
- // Equivalent of `typeof` but with special handling for array and regexp.
2120
- function getPropType(propValue) {
2121
- var propType = typeof propValue;
2122
- if (Array.isArray(propValue)) {
2123
- return 'array';
2124
- }
2125
- if (propValue instanceof RegExp) {
2126
- // Old webkits (at least until Android 4.0) return 'function' rather than
2127
- // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
2128
- // passes PropTypes.object.
2129
- return 'object';
2130
- }
2131
- if (isSymbol(propType, propValue)) {
2132
- return 'symbol';
2133
- }
2134
- return propType;
2135
- }
2136
-
2137
- // This handles more types than `getPropType`. Only used for error messages.
2138
- // See `createPrimitiveTypeChecker`.
2139
- function getPreciseType(propValue) {
2140
- if (typeof propValue === 'undefined' || propValue === null) {
2141
- return '' + propValue;
2142
- }
2143
- var propType = getPropType(propValue);
2144
- if (propType === 'object') {
2145
- if (propValue instanceof Date) {
2146
- return 'date';
2147
- } else if (propValue instanceof RegExp) {
2148
- return 'regexp';
2149
- }
2150
- }
2151
- return propType;
2152
- }
2153
-
2154
- // Returns a string that is postfixed to a warning about an invalid type.
2155
- // For example, "undefined" or "of type array"
2156
- function getPostfixForTypeWarning(value) {
2157
- var type = getPreciseType(value);
2158
- switch (type) {
2159
- case 'array':
2160
- case 'object':
2161
- return 'an ' + type;
2162
- case 'boolean':
2163
- case 'date':
2164
- case 'regexp':
2165
- return 'a ' + type;
2166
- default:
2167
- return type;
2168
- }
2169
- }
2170
-
2171
- // Returns class name of the object, if any.
2172
- function getClassName(propValue) {
2173
- if (!propValue.constructor || !propValue.constructor.name) {
2174
- return ANONYMOUS;
2175
- }
2176
- return propValue.constructor.name;
2177
- }
2178
-
2179
- ReactPropTypes.checkPropTypes = checkPropTypes;
2180
- ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
2181
- ReactPropTypes.PropTypes = ReactPropTypes;
2182
-
2183
- return ReactPropTypes;
2184
- };
2185
-
2186
2766
  /**
2187
2767
  * Copyright (c) 2013-present, Facebook, Inc.
2188
2768
  *
@@ -2190,60 +2770,69 @@ var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
2190
2770
  * LICENSE file in the root directory of this source tree.
2191
2771
  */
2192
2772
 
2193
- var ReactPropTypesSecret = ReactPropTypesSecret_1;
2194
-
2195
- function emptyFunction() {}
2196
- function emptyFunctionWithReset() {}
2197
- emptyFunctionWithReset.resetWarningCache = emptyFunction;
2198
-
2199
- var factoryWithThrowingShims = function() {
2200
- function shim(props, propName, componentName, location, propFullName, secret) {
2201
- if (secret === ReactPropTypesSecret) {
2202
- // It is still safe when called from React.
2203
- return;
2204
- }
2205
- var err = new Error(
2206
- 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
2207
- 'Use PropTypes.checkPropTypes() to call them. ' +
2208
- 'Read more at http://fb.me/use-check-prop-types'
2209
- );
2210
- err.name = 'Invariant Violation';
2211
- throw err;
2212
- } shim.isRequired = shim;
2213
- function getShim() {
2214
- return shim;
2215
- } // Important!
2216
- // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
2217
- var ReactPropTypes = {
2218
- array: shim,
2219
- bigint: shim,
2220
- bool: shim,
2221
- func: shim,
2222
- number: shim,
2223
- object: shim,
2224
- string: shim,
2225
- symbol: shim,
2226
-
2227
- any: shim,
2228
- arrayOf: getShim,
2229
- element: shim,
2230
- elementType: shim,
2231
- instanceOf: getShim,
2232
- node: shim,
2233
- objectOf: getShim,
2234
- oneOf: getShim,
2235
- oneOfType: getShim,
2236
- shape: getShim,
2237
- exact: getShim,
2238
-
2239
- checkPropTypes: emptyFunctionWithReset,
2240
- resetWarningCache: emptyFunction
2241
- };
2242
-
2243
- ReactPropTypes.PropTypes = ReactPropTypes;
2244
-
2245
- return ReactPropTypes;
2246
- };
2773
+ var factoryWithThrowingShims;
2774
+ var hasRequiredFactoryWithThrowingShims;
2775
+
2776
+ function requireFactoryWithThrowingShims () {
2777
+ if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
2778
+ hasRequiredFactoryWithThrowingShims = 1;
2779
+
2780
+ var ReactPropTypesSecret = requireReactPropTypesSecret();
2781
+
2782
+ function emptyFunction() {}
2783
+ function emptyFunctionWithReset() {}
2784
+ emptyFunctionWithReset.resetWarningCache = emptyFunction;
2785
+
2786
+ factoryWithThrowingShims = function() {
2787
+ function shim(props, propName, componentName, location, propFullName, secret) {
2788
+ if (secret === ReactPropTypesSecret) {
2789
+ // It is still safe when called from React.
2790
+ return;
2791
+ }
2792
+ var err = new Error(
2793
+ 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
2794
+ 'Use PropTypes.checkPropTypes() to call them. ' +
2795
+ 'Read more at http://fb.me/use-check-prop-types'
2796
+ );
2797
+ err.name = 'Invariant Violation';
2798
+ throw err;
2799
+ } shim.isRequired = shim;
2800
+ function getShim() {
2801
+ return shim;
2802
+ } // Important!
2803
+ // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
2804
+ var ReactPropTypes = {
2805
+ array: shim,
2806
+ bigint: shim,
2807
+ bool: shim,
2808
+ func: shim,
2809
+ number: shim,
2810
+ object: shim,
2811
+ string: shim,
2812
+ symbol: shim,
2813
+
2814
+ any: shim,
2815
+ arrayOf: getShim,
2816
+ element: shim,
2817
+ elementType: shim,
2818
+ instanceOf: getShim,
2819
+ node: shim,
2820
+ objectOf: getShim,
2821
+ oneOf: getShim,
2822
+ oneOfType: getShim,
2823
+ shape: getShim,
2824
+ exact: getShim,
2825
+
2826
+ checkPropTypes: emptyFunctionWithReset,
2827
+ resetWarningCache: emptyFunction
2828
+ };
2829
+
2830
+ ReactPropTypes.PropTypes = ReactPropTypes;
2831
+
2832
+ return ReactPropTypes;
2833
+ };
2834
+ return factoryWithThrowingShims;
2835
+ }
2247
2836
 
2248
2837
  /**
2249
2838
  * Copyright (c) 2013-present, Facebook, Inc.
@@ -2253,22 +2842,23 @@ var factoryWithThrowingShims = function() {
2253
2842
  */
2254
2843
 
2255
2844
  if (process.env.NODE_ENV !== 'production') {
2256
- var ReactIs = reactIs.exports;
2845
+ var ReactIs = requireReactIs();
2257
2846
 
2258
2847
  // By explicitly using `prop-types` you are opting into new development behavior.
2259
2848
  // http://fb.me/prop-types-in-prod
2260
2849
  var throwOnDirectAccess = true;
2261
- propTypes.exports = factoryWithTypeCheckers(ReactIs.isElement, throwOnDirectAccess);
2850
+ propTypes.exports = requireFactoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
2262
2851
  } else {
2263
2852
  // By explicitly using `prop-types` you are opting into new production behavior.
2264
2853
  // http://fb.me/prop-types-in-prod
2265
- propTypes.exports = factoryWithThrowingShims();
2854
+ propTypes.exports = requireFactoryWithThrowingShims()();
2266
2855
  }
2267
2856
 
2268
- var PropTypes = propTypes.exports;
2857
+ var propTypesExports = propTypes.exports;
2858
+ var PropTypes = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports);
2269
2859
 
2270
2860
  /**
2271
- * @tabler/icons-react v2.42.0 - MIT
2861
+ * @tabler/icons-react v2.47.0 - MIT
2272
2862
  */
2273
2863
 
2274
2864
  var defaultAttributes = {
@@ -2284,9 +2874,10 @@ var defaultAttributes = {
2284
2874
  };
2285
2875
 
2286
2876
  /**
2287
- * @tabler/icons-react v2.42.0 - MIT
2877
+ * @tabler/icons-react v2.47.0 - MIT
2288
2878
  */
2289
2879
 
2880
+
2290
2881
  var __defProp = Object.defineProperty;
2291
2882
  var __defProps = Object.defineProperties;
2292
2883
  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -2347,9 +2938,10 @@ var createReactComponent = (iconName, iconNamePascal, iconNode) => {
2347
2938
  };
2348
2939
 
2349
2940
  /**
2350
- * @tabler/icons-react v2.42.0 - MIT
2941
+ * @tabler/icons-react v2.47.0 - MIT
2351
2942
  */
2352
2943
 
2944
+
2353
2945
  var IconBrandWindows = createReactComponent("brand-windows", "IconBrandWindows", [
2354
2946
  [
2355
2947
  "path",
@@ -2363,9 +2955,10 @@ var IconBrandWindows = createReactComponent("brand-windows", "IconBrandWindows",
2363
2955
  ]);
2364
2956
 
2365
2957
  /**
2366
- * @tabler/icons-react v2.42.0 - MIT
2958
+ * @tabler/icons-react v2.47.0 - MIT
2367
2959
  */
2368
2960
 
2961
+
2369
2962
  var IconBuildingBridge = createReactComponent("building-bridge", "IconBuildingBridge", [
2370
2963
  ["path", { d: "M6 5l0 14", key: "svg-0" }],
2371
2964
  ["path", { d: "M18 5l0 14", key: "svg-1" }],
@@ -2381,17 +2974,19 @@ var IconBuildingBridge = createReactComponent("building-bridge", "IconBuildingBr
2381
2974
  ]);
2382
2975
 
2383
2976
  /**
2384
- * @tabler/icons-react v2.42.0 - MIT
2977
+ * @tabler/icons-react v2.47.0 - MIT
2385
2978
  */
2386
2979
 
2980
+
2387
2981
  var IconCircle = createReactComponent("circle", "IconCircle", [
2388
2982
  ["path", { d: "M12 12m-9 0a9 9 0 1 0 18 0a9 9 0 1 0 -18 0", key: "svg-0" }]
2389
2983
  ]);
2390
2984
 
2391
2985
  /**
2392
- * @tabler/icons-react v2.42.0 - MIT
2986
+ * @tabler/icons-react v2.47.0 - MIT
2393
2987
  */
2394
2988
 
2989
+
2395
2990
  var IconDotsVertical = createReactComponent("dots-vertical", "IconDotsVertical", [
2396
2991
  ["path", { d: "M12 12m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0", key: "svg-0" }],
2397
2992
  ["path", { d: "M12 19m-1 0a1 1 0 1 0 2 0a1 1 0 1 0 -2 0", key: "svg-1" }],
@@ -2399,9 +2994,10 @@ var IconDotsVertical = createReactComponent("dots-vertical", "IconDotsVertical",
2399
2994
  ]);
2400
2995
 
2401
2996
  /**
2402
- * @tabler/icons-react v2.42.0 - MIT
2997
+ * @tabler/icons-react v2.47.0 - MIT
2403
2998
  */
2404
2999
 
3000
+
2405
3001
  var IconExternalLink = createReactComponent("external-link", "IconExternalLink", [
2406
3002
  [
2407
3003
  "path",
@@ -2415,9 +3011,10 @@ var IconExternalLink = createReactComponent("external-link", "IconExternalLink",
2415
3011
  ]);
2416
3012
 
2417
3013
  /**
2418
- * @tabler/icons-react v2.42.0 - MIT
3014
+ * @tabler/icons-react v2.47.0 - MIT
2419
3015
  */
2420
3016
 
3017
+
2421
3018
  var IconLine = createReactComponent("line", "IconLine", [
2422
3019
  ["path", { d: "M6 18m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-0" }],
2423
3020
  ["path", { d: "M18 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-1" }],
@@ -2425,9 +3022,10 @@ var IconLine = createReactComponent("line", "IconLine", [
2425
3022
  ]);
2426
3023
 
2427
3024
  /**
2428
- * @tabler/icons-react v2.42.0 - MIT
3025
+ * @tabler/icons-react v2.47.0 - MIT
2429
3026
  */
2430
3027
 
3028
+
2431
3029
  var IconManualGearbox = createReactComponent("manual-gearbox", "IconManualGearbox", [
2432
3030
  ["path", { d: "M5 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-0" }],
2433
3031
  ["path", { d: "M12 6m-2 0a2 2 0 1 0 4 0a2 2 0 1 0 -4 0", key: "svg-1" }],
@@ -2440,18 +3038,20 @@ var IconManualGearbox = createReactComponent("manual-gearbox", "IconManualGearbo
2440
3038
  ]);
2441
3039
 
2442
3040
  /**
2443
- * @tabler/icons-react v2.42.0 - MIT
3041
+ * @tabler/icons-react v2.47.0 - MIT
2444
3042
  */
2445
3043
 
3044
+
2446
3045
  var IconPlus = createReactComponent("plus", "IconPlus", [
2447
3046
  ["path", { d: "M12 5l0 14", key: "svg-0" }],
2448
3047
  ["path", { d: "M5 12l14 0", key: "svg-1" }]
2449
3048
  ]);
2450
3049
 
2451
3050
  /**
2452
- * @tabler/icons-react v2.42.0 - MIT
3051
+ * @tabler/icons-react v2.47.0 - MIT
2453
3052
  */
2454
3053
 
3054
+
2455
3055
  var IconPrinter = createReactComponent("printer", "IconPrinter", [
2456
3056
  [
2457
3057
  "path",
@@ -2471,18 +3071,20 @@ var IconPrinter = createReactComponent("printer", "IconPrinter", [
2471
3071
  ]);
2472
3072
 
2473
3073
  /**
2474
- * @tabler/icons-react v2.42.0 - MIT
3074
+ * @tabler/icons-react v2.47.0 - MIT
2475
3075
  */
2476
3076
 
3077
+
2477
3078
  var IconRefresh = createReactComponent("refresh", "IconRefresh", [
2478
3079
  ["path", { d: "M20 11a8.1 8.1 0 0 0 -15.5 -2m-.5 -4v4h4", key: "svg-0" }],
2479
3080
  ["path", { d: "M4 13a8.1 8.1 0 0 0 15.5 2m.5 4v-4h-4", key: "svg-1" }]
2480
3081
  ]);
2481
3082
 
2482
3083
  /**
2483
- * @tabler/icons-react v2.42.0 - MIT
3084
+ * @tabler/icons-react v2.47.0 - MIT
2484
3085
  */
2485
3086
 
3087
+
2486
3088
  var IconTrash = createReactComponent("trash", "IconTrash", [
2487
3089
  ["path", { d: "M4 7l16 0", key: "svg-0" }],
2488
3090
  ["path", { d: "M10 11l0 6", key: "svg-1" }],
@@ -2604,100 +3206,126 @@ function AddPrintServer(props) {
2604
3206
  }
2605
3207
 
2606
3208
  // a string of all valid unicode whitespaces
2607
- // eslint-disable-next-line max-len
2608
- var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
3209
+ var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
3210
+ '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
2609
3211
 
2610
- var requireObjectCoercible = requireObjectCoercible$3;
3212
+ var uncurryThis$1 = functionUncurryThis;
3213
+ var requireObjectCoercible = requireObjectCoercible$4;
3214
+ var toString$1 = toString$3;
2611
3215
  var whitespaces$1 = whitespaces$2;
2612
3216
 
2613
- var whitespace = '[' + whitespaces$1 + ']';
2614
- var ltrim = RegExp('^' + whitespace + whitespace + '*');
2615
- var rtrim = RegExp(whitespace + whitespace + '*$');
3217
+ var replace = uncurryThis$1(''.replace);
3218
+ var ltrim = RegExp('^[' + whitespaces$1 + ']+');
3219
+ var rtrim = RegExp('(^|[^' + whitespaces$1 + '])[' + whitespaces$1 + ']+$');
2616
3220
 
2617
3221
  // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
2618
3222
  var createMethod = function (TYPE) {
2619
3223
  return function ($this) {
2620
- var string = String(requireObjectCoercible($this));
2621
- if (TYPE & 1) string = string.replace(ltrim, '');
2622
- if (TYPE & 2) string = string.replace(rtrim, '');
3224
+ var string = toString$1(requireObjectCoercible($this));
3225
+ if (TYPE & 1) string = replace(string, ltrim, '');
3226
+ if (TYPE & 2) string = replace(string, rtrim, '$1');
2623
3227
  return string;
2624
3228
  };
2625
3229
  };
2626
3230
 
2627
3231
  var stringTrim = {
2628
3232
  // `String.prototype.{ trimLeft, trimStart }` methods
2629
- // https://tc39.github.io/ecma262/#sec-string.prototype.trimstart
3233
+ // https://tc39.es/ecma262/#sec-string.prototype.trimstart
2630
3234
  start: createMethod(1),
2631
3235
  // `String.prototype.{ trimRight, trimEnd }` methods
2632
- // https://tc39.github.io/ecma262/#sec-string.prototype.trimend
3236
+ // https://tc39.es/ecma262/#sec-string.prototype.trimend
2633
3237
  end: createMethod(2),
2634
3238
  // `String.prototype.trim` method
2635
- // https://tc39.github.io/ecma262/#sec-string.prototype.trim
3239
+ // https://tc39.es/ecma262/#sec-string.prototype.trim
2636
3240
  trim: createMethod(3)
2637
3241
  };
2638
3242
 
2639
- var global$1 = global$e;
3243
+ var global$1 = global$d;
3244
+ var fails$1 = fails$c;
3245
+ var uncurryThis = functionUncurryThis;
3246
+ var toString = toString$3;
2640
3247
  var trim = stringTrim.trim;
2641
3248
  var whitespaces = whitespaces$2;
2642
3249
 
2643
- var $parseInt = global$1.parseInt;
2644
- var hex = /^[+-]?0[Xx]/;
2645
- var FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22;
3250
+ var $parseInt$1 = global$1.parseInt;
3251
+ var Symbol$1 = global$1.Symbol;
3252
+ var ITERATOR = Symbol$1 && Symbol$1.iterator;
3253
+ var hex = /^[+-]?0x/i;
3254
+ var exec = uncurryThis(hex.exec);
3255
+ var FORCED = $parseInt$1(whitespaces + '08') !== 8 || $parseInt$1(whitespaces + '0x16') !== 22
3256
+ // MS Edge 18- broken with boxed symbols
3257
+ || (ITERATOR && !fails$1(function () { $parseInt$1(Object(ITERATOR)); }));
2646
3258
 
2647
3259
  // `parseInt` method
2648
- // https://tc39.github.io/ecma262/#sec-parseint-string-radix
3260
+ // https://tc39.es/ecma262/#sec-parseint-string-radix
2649
3261
  var numberParseInt = FORCED ? function parseInt(string, radix) {
2650
- var S = trim(String(string));
2651
- return $parseInt(S, (radix >>> 0) || (hex.test(S) ? 16 : 10));
2652
- } : $parseInt;
3262
+ var S = trim(toString(string));
3263
+ return $parseInt$1(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));
3264
+ } : $parseInt$1;
2653
3265
 
2654
3266
  var $ = _export;
2655
- var parseIntImplementation = numberParseInt;
3267
+ var $parseInt = numberParseInt;
2656
3268
 
2657
3269
  // `parseInt` method
2658
- // https://tc39.github.io/ecma262/#sec-parseint-string-radix
2659
- $({ global: true, forced: parseInt != parseIntImplementation }, {
2660
- parseInt: parseIntImplementation
3270
+ // https://tc39.es/ecma262/#sec-parseint-string-radix
3271
+ $({ global: true, forced: parseInt !== $parseInt }, {
3272
+ parseInt: $parseInt
2661
3273
  });
2662
3274
 
2663
- var anObject$1 = anObject$7;
3275
+ var anObject$1 = anObject$6;
2664
3276
 
2665
3277
  // `RegExp.prototype.flags` getter implementation
2666
- // https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags
3278
+ // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
2667
3279
  var regexpFlags = function () {
2668
3280
  var that = anObject$1(this);
2669
3281
  var result = '';
3282
+ if (that.hasIndices) result += 'd';
2670
3283
  if (that.global) result += 'g';
2671
3284
  if (that.ignoreCase) result += 'i';
2672
3285
  if (that.multiline) result += 'm';
2673
3286
  if (that.dotAll) result += 's';
2674
3287
  if (that.unicode) result += 'u';
3288
+ if (that.unicodeSets) result += 'v';
2675
3289
  if (that.sticky) result += 'y';
2676
3290
  return result;
2677
3291
  };
2678
3292
 
2679
- var redefine = redefine$3.exports;
2680
- var anObject = anObject$7;
2681
- var fails = fails$7;
2682
- var flags = regexpFlags;
3293
+ var call = functionCall;
3294
+ var hasOwn = hasOwnProperty_1;
3295
+ var isPrototypeOf = objectIsPrototypeOf;
3296
+ var regExpFlags = regexpFlags;
3297
+
3298
+ var RegExpPrototype$1 = RegExp.prototype;
3299
+
3300
+ var regexpGetFlags = function (R) {
3301
+ var flags = R.flags;
3302
+ return flags === undefined && !('flags' in RegExpPrototype$1) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype$1, R)
3303
+ ? call(regExpFlags, R) : flags;
3304
+ };
3305
+
3306
+ var PROPER_FUNCTION_NAME = functionName.PROPER;
3307
+ var defineBuiltIn = defineBuiltIn$4;
3308
+ var anObject = anObject$6;
3309
+ var $toString = toString$3;
3310
+ var fails = fails$c;
3311
+ var getRegExpFlags = regexpGetFlags;
2683
3312
 
2684
3313
  var TO_STRING = 'toString';
2685
3314
  var RegExpPrototype = RegExp.prototype;
2686
3315
  var nativeToString = RegExpPrototype[TO_STRING];
2687
3316
 
2688
- var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
3317
+ var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
2689
3318
  // FF44- RegExp#toString has a wrong name
2690
- var INCORRECT_NAME = nativeToString.name != TO_STRING;
3319
+ var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING;
2691
3320
 
2692
3321
  // `RegExp.prototype.toString` method
2693
- // https://tc39.github.io/ecma262/#sec-regexp.prototype.tostring
3322
+ // https://tc39.es/ecma262/#sec-regexp.prototype.tostring
2694
3323
  if (NOT_GENERIC || INCORRECT_NAME) {
2695
- redefine(RegExp.prototype, TO_STRING, function toString() {
3324
+ defineBuiltIn(RegExpPrototype, TO_STRING, function toString() {
2696
3325
  var R = anObject(this);
2697
- var p = String(R.source);
2698
- var rf = R.flags;
2699
- var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype) ? flags.call(R) : rf);
2700
- return '/' + p + '/' + f;
3326
+ var pattern = $toString(R.source);
3327
+ var flags = $toString(getRegExpFlags(R));
3328
+ return '/' + pattern + '/' + flags;
2701
3329
  }, { unsafe: true });
2702
3330
  }
2703
3331