Elementor Website Builder – more than just a page builder / 3.26.1

Elementor Website Builder – more than just a page builder v3.26.1

elementor / assets / js / 056b8f3bbbcabf026cd1.bundle.js

056b8f3bbbcabf026cd1.bundle.js in Elementor Website Builder – more than just a page builder 3.26.1, at assets/js/056b8f3bbbcabf026cd1.bundle.js

1,221 lines 43.8 KB

Raw Download Zip

1	/! elementor - v3.26.0 - 19-12-2024 /
2	(self["webpackChunkelementor"] = self["webpackChunkelementor"] \|\| []).push([["vendors-node_modules_prop-types_index_js-node_modules_babel_runtime_helpers_slicedToArray_js"],{
3
4	/***/ "../node_modules/object-assign/index.js":
5	/!********************************************!\
6	!* ../node_modules/object-assign/index.js *!
7	\**********************************************/
8	/***/ ((module) => {
9
10	"use strict";
11	/*
12	object-assign
13	(c) Sindre Sorhus
14	@license MIT
15	*/
16
17
18	/* eslint-disable no-unused-vars */
19	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
20	var hasOwnProperty = Object.prototype.hasOwnProperty;
21	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
22
23	function toObject(val) {
24	if (val === null \|\| val === undefined) {
25	throw new TypeError('Object.assign cannot be called with null or undefined');
26	}
27
28	return Object(val);
29	}
30
31	function shouldUseNative() {
32	try {
33	if (!Object.assign) {
34	return false;
35	}
36
37	// Detect buggy property enumeration order in older V8 versions.
38
39	// https://bugs.chromium.org/p/v8/issues/detail?id=4118
40	var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
41	test1[5] = 'de';
42	if (Object.getOwnPropertyNames(test1)[0] === '5') {
43	return false;
44	}
45
46	// https://bugs.chromium.org/p/v8/issues/detail?id=3056
47	var test2 = {};
48	for (var i = 0; i < 10; i++) {
49	test2['_' + String.fromCharCode(i)] = i;
50	}
51	var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
52	return test2[n];
53	});
54	if (order2.join('') !== '0123456789') {
55	return false;
56	}
57
58	// https://bugs.chromium.org/p/v8/issues/detail?id=3056
59	var test3 = {};
60	'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
61	test3[letter] = letter;
62	});
63	if (Object.keys(Object.assign({}, test3)).join('') !==
64	'abcdefghijklmnopqrst') {
65	return false;
66	}
67
68	return true;
69	} catch (err) {
70	// We don't expect any of the above to throw, but better to be safe.
71	return false;
72	}
73	}
74
75	module.exports = shouldUseNative() ? Object.assign : function (target, source) {
76	var from;
77	var to = toObject(target);
78	var symbols;
79
80	for (var s = 1; s < arguments.length; s++) {
81	from = Object(arguments[s]);
82
83	for (var key in from) {
84	if (hasOwnProperty.call(from, key)) {
85	to[key] = from[key];
86	}
87	}
88
89	if (getOwnPropertySymbols) {
90	symbols = getOwnPropertySymbols(from);
91	for (var i = 0; i < symbols.length; i++) {
92	if (propIsEnumerable.call(from, symbols[i])) {
93	to[symbols[i]] = from[symbols[i]];
94	}
95	}
96	}
97	}
98
99	return to;
100	};
101
102
103	/***/ }),
104
105	/***/ "../node_modules/prop-types/checkPropTypes.js":
106	/!**************************************************!\
107	!* ../node_modules/prop-types/checkPropTypes.js *!
108	\****************************************************/
109	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
110
111	"use strict";
112	/**
113	* Copyright (c) 2013-present, Facebook, Inc.
114	*
115	* This source code is licensed under the MIT license found in the
116	* LICENSE file in the root directory of this source tree.
117	*/
118
119
120
121	var printWarning = function() {};
122
123	if (true) {
124	var ReactPropTypesSecret = __webpack_require__(/! ./lib/ReactPropTypesSecret / "../node_modules/prop-types/lib/ReactPropTypesSecret.js");
125	var loggedTypeFailures = {};
126	var has = __webpack_require__(/! ./lib/has / "../node_modules/prop-types/lib/has.js");
127
128	printWarning = function(text) {
129	var message = 'Warning: ' + text;
130	if (typeof console !== 'undefined') {
131	console.error(message);
132	}
133	try {
134	// --- Welcome to debugging React ---
135	// This error was thrown as a convenience so that you can use this stack
136	// to find the callsite that caused this warning to fire.
137	throw new Error(message);
138	} catch (x) { /**/ }
139	};
140	}
141
142	/**
143	* Assert that the values match with the type specs.
144	* Error messages are memorized and will only be shown once.
145	*
146	* @param {object} typeSpecs Map of name to a ReactPropType
147	* @param {object} values Runtime values that need to be type-checked
148	* @param {string} location e.g. "prop", "context", "child context"
149	* @param {string} componentName Name of the component for error messages.
150	* @param {?Function} getStack Returns the component stack.
151	* @private
152	*/
153	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
154	if (true) {
155	for (var typeSpecName in typeSpecs) {
156	if (has(typeSpecs, typeSpecName)) {
157	var error;
158	// Prop type validation may throw. In case they do, we don't want to
159	// fail the render phase where it didn't fail before. So we log it.
160	// After these have been cleaned up, we'll let them throw.
161	try {
162	// This is intentionally an invariant that gets caught. It's the same
163	// behavior as without this statement except with a better message.
164	if (typeof typeSpecs[typeSpecName] !== 'function') {
165	var err = Error(
166	(componentName \|\| 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
167	'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
168	'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
169	);
170	err.name = 'Invariant Violation';
171	throw err;
172	}
173	error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
174	} catch (ex) {
175	error = ex;
176	}
177	if (error && !(error instanceof Error)) {
178	printWarning(
179	(componentName \|\| 'React class') + ': type specification of ' +
180	location + ' `' + typeSpecName + '` is invalid; the type checker ' +
181	'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
182	'You may have forgotten to pass an argument to the type checker ' +
183	'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
184	'shape all require an argument).'
185	);
186	}
187	if (error instanceof Error && !(error.message in loggedTypeFailures)) {
188	// Only monitor this failure once because there tends to be a lot of the
189	// same error.
190	loggedTypeFailures[error.message] = true;
191
192	var stack = getStack ? getStack() : '';
193
194	printWarning(
195	'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
196	);
197	}
198	}
199	}
200	}
201	}
202
203	/**
204	* Resets warning cache when testing.
205	*
206	* @private
207	*/
208	checkPropTypes.resetWarningCache = function() {
209	if (true) {
210	loggedTypeFailures = {};
211	}
212	}
213
214	module.exports = checkPropTypes;
215
216
217	/***/ }),
218
219	/***/ "../node_modules/prop-types/factoryWithTypeCheckers.js":
220	/!***********************************************************!\
221	!* ../node_modules/prop-types/factoryWithTypeCheckers.js *!
222	\*************************************************************/
223	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
224
225	"use strict";
226	/**
227	* Copyright (c) 2013-present, Facebook, Inc.
228	*
229	* This source code is licensed under the MIT license found in the
230	* LICENSE file in the root directory of this source tree.
231	*/
232
233
234
235	var ReactIs = __webpack_require__(/! react-is / "../node_modules/prop-types/node_modules/react-is/index.js");
236	var assign = __webpack_require__(/! object-assign / "../node_modules/object-assign/index.js");
237
238	var ReactPropTypesSecret = __webpack_require__(/! ./lib/ReactPropTypesSecret / "../node_modules/prop-types/lib/ReactPropTypesSecret.js");
239	var has = __webpack_require__(/! ./lib/has / "../node_modules/prop-types/lib/has.js");
240	var checkPropTypes = __webpack_require__(/! ./checkPropTypes / "../node_modules/prop-types/checkPropTypes.js");
241
242	var printWarning = function() {};
243
244	if (true) {
245	printWarning = function(text) {
246	var message = 'Warning: ' + text;
247	if (typeof console !== 'undefined') {
248	console.error(message);
249	}
250	try {
251	// --- Welcome to debugging React ---
252	// This error was thrown as a convenience so that you can use this stack
253	// to find the callsite that caused this warning to fire.
254	throw new Error(message);
255	} catch (x) {}
256	};
257	}
258
259	function emptyFunctionThatReturnsNull() {
260	return null;
261	}
262
263	module.exports = function(isValidElement, throwOnDirectAccess) {
264	/* global Symbol */
265	var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
266	var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
267
268	/**
269	* Returns the iterator method function contained on the iterable object.
270	*
271	* Be sure to invoke the function with the iterable as context:
272	*
273	* var iteratorFn = getIteratorFn(myIterable);
274	* if (iteratorFn) {
275	* var iterator = iteratorFn.call(myIterable);
276	* ...
277	* }
278	*
279	* @param {?object} maybeIterable
280	* @return {?function}
281	*/
282	function getIteratorFn(maybeIterable) {
283	var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] \|\| maybeIterable[FAUX_ITERATOR_SYMBOL]);
284	if (typeof iteratorFn === 'function') {
285	return iteratorFn;
286	}
287	}
288
289	/**
290	* Collection of methods that allow declaration and validation of props that are
291	* supplied to React components. Example usage:
292	*
293	* var Props = require('ReactPropTypes');
294	* var MyArticle = React.createClass({
295	* propTypes: {
296	* // An optional string prop named "description".
297	* description: Props.string,
298	*
299	* // A required enum prop named "category".
300	* category: Props.oneOf(['News','Photos']).isRequired,
301	*
302	* // A prop named "dialog" that requires an instance of Dialog.
303	* dialog: Props.instanceOf(Dialog).isRequired
304	* },
305	* render: function() { ... }
306	* });
307	*
308	* A more formal specification of how these methods are used:
309	*
310	* type := array\|bool\|func\|object\|number\|string\|oneOf([...])\|instanceOf(...)
311	* decl := ReactPropTypes.{type}(.isRequired)?
312	*
313	* Each and every declaration produces a function with the same signature. This
314	* allows the creation of custom validation functions. For example:
315	*
316	* var MyLink = React.createClass({
317	* propTypes: {
318	* // An optional string or URI prop named "href".
319	* href: function(props, propName, componentName) {
320	* var propValue = props[propName];
321	* if (propValue != null && typeof propValue !== 'string' &&
322	* !(propValue instanceof URI)) {
323	* return new Error(
324	* 'Expected a string or an URI for ' + propName + ' in ' +
325	* componentName
326	* );
327	* }
328	* }
329	* },
330	* render: function() {...}
331	* });
332	*
333	* @internal
334	*/
335
336	var ANONYMOUS = '<<anonymous>>';
337
338	// Important!
339	// Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
340	var ReactPropTypes = {
341	array: createPrimitiveTypeChecker('array'),
342	bigint: createPrimitiveTypeChecker('bigint'),
343	bool: createPrimitiveTypeChecker('boolean'),
344	func: createPrimitiveTypeChecker('function'),
345	number: createPrimitiveTypeChecker('number'),
346	object: createPrimitiveTypeChecker('object'),
347	string: createPrimitiveTypeChecker('string'),
348	symbol: createPrimitiveTypeChecker('symbol'),
349
350	any: createAnyTypeChecker(),
351	arrayOf: createArrayOfTypeChecker,
352	element: createElementTypeChecker(),
353	elementType: createElementTypeTypeChecker(),
354	instanceOf: createInstanceTypeChecker,
355	node: createNodeChecker(),
356	objectOf: createObjectOfTypeChecker,
357	oneOf: createEnumTypeChecker,
358	oneOfType: createUnionTypeChecker,
359	shape: createShapeTypeChecker,
360	exact: createStrictShapeTypeChecker,
361	};
362
363	/**
364	* inlined Object.is polyfill to avoid requiring consumers ship their own
365	* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
366	*/
367	/eslint-disable no-self-compare/
368	function is(x, y) {
369	// SameValue algorithm
370	if (x === y) {
371	// Steps 1-5, 7-10
372	// Steps 6.b-6.e: +0 != -0
373	return x !== 0 \|\| 1 / x === 1 / y;
374	} else {
375	// Step 6.a: NaN == NaN
376	return x !== x && y !== y;
377	}
378	}
379	/eslint-enable no-self-compare/
380
381	/**
382	* We use an Error-like object for backward compatibility as people may call
383	* PropTypes directly and inspect their output. However, we don't use real
384	* Errors anymore. We don't inspect their stack anyway, and creating them
385	* is prohibitively expensive if they are created too often, such as what
386	* happens in oneOfType() for any type before the one that matched.
387	*/
388	function PropTypeError(message, data) {
389	this.message = message;
390	this.data = data && typeof data === 'object' ? data: {};
391	this.stack = '';
392	}
393	// Make `instanceof Error` still work for returned errors.
394	PropTypeError.prototype = Error.prototype;
395
396	function createChainableTypeChecker(validate) {
397	if (true) {
398	var manualPropTypeCallCache = {};
399	var manualPropTypeWarningCount = 0;
400	}
401	function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
402	componentName = componentName \|\| ANONYMOUS;
403	propFullName = propFullName \|\| propName;
404
405	if (secret !== ReactPropTypesSecret) {
406	if (throwOnDirectAccess) {
407	// New behavior only for users of `prop-types` package
408	var err = new Error(
409	'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
410	'Use `PropTypes.checkPropTypes()` to call them. ' +
411	'Read more at http://fb.me/use-check-prop-types'
412	);
413	err.name = 'Invariant Violation';
414	throw err;
415	} else if ( true && typeof console !== 'undefined') {
416	// Old behavior for people using React.PropTypes
417	var cacheKey = componentName + ':' + propName;
418	if (
419	!manualPropTypeCallCache[cacheKey] &&
420	// Avoid spamming the console because they are often not actionable except for lib authors
421	manualPropTypeWarningCount < 3
422	) {
423	printWarning(
424	'You are manually calling a React.PropTypes validation ' +
425	'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +
426	'and will throw in the standalone `prop-types` package. ' +
427	'You may be seeing this warning due to a third-party PropTypes ' +
428	'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
429	);
430	manualPropTypeCallCache[cacheKey] = true;
431	manualPropTypeWarningCount++;
432	}
433	}
434	}
435	if (props[propName] == null) {
436	if (isRequired) {
437	if (props[propName] === null) {
438	return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
439	}
440	return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
441	}
442	return null;
443	} else {
444	return validate(props, propName, componentName, location, propFullName);
445	}
446	}
447
448	var chainedCheckType = checkType.bind(null, false);
449	chainedCheckType.isRequired = checkType.bind(null, true);
450
451	return chainedCheckType;
452	}
453
454	function createPrimitiveTypeChecker(expectedType) {
455	function validate(props, propName, componentName, location, propFullName, secret) {
456	var propValue = props[propName];
457	var propType = getPropType(propValue);
458	if (propType !== expectedType) {
459	// `propValue` being instance of, say, date/regexp, pass the 'object'
460	// check, but we can offer a more precise error message here rather than
461	// 'of type `object`'.
462	var preciseType = getPreciseType(propValue);
463
464	return new PropTypeError(
465	'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),
466	{expectedType: expectedType}
467	);
468	}
469	return null;
470	}
471	return createChainableTypeChecker(validate);
472	}
473
474	function createAnyTypeChecker() {
475	return createChainableTypeChecker(emptyFunctionThatReturnsNull);
476	}
477
478	function createArrayOfTypeChecker(typeChecker) {
479	function validate(props, propName, componentName, location, propFullName) {
480	if (typeof typeChecker !== 'function') {
481	return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
482	}
483	var propValue = props[propName];
484	if (!Array.isArray(propValue)) {
485	var propType = getPropType(propValue);
486	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
487	}
488	for (var i = 0; i < propValue.length; i++) {
489	var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
490	if (error instanceof Error) {
491	return error;
492	}
493	}
494	return null;
495	}
496	return createChainableTypeChecker(validate);
497	}
498
499	function createElementTypeChecker() {
500	function validate(props, propName, componentName, location, propFullName) {
501	var propValue = props[propName];
502	if (!isValidElement(propValue)) {
503	var propType = getPropType(propValue);
504	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
505	}
506	return null;
507	}
508	return createChainableTypeChecker(validate);
509	}
510
511	function createElementTypeTypeChecker() {
512	function validate(props, propName, componentName, location, propFullName) {
513	var propValue = props[propName];
514	if (!ReactIs.isValidElementType(propValue)) {
515	var propType = getPropType(propValue);
516	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
517	}
518	return null;
519	}
520	return createChainableTypeChecker(validate);
521	}
522
523	function createInstanceTypeChecker(expectedClass) {
524	function validate(props, propName, componentName, location, propFullName) {
525	if (!(props[propName] instanceof expectedClass)) {
526	var expectedClassName = expectedClass.name \|\| ANONYMOUS;
527	var actualClassName = getClassName(props[propName]);
528	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
529	}
530	return null;
531	}
532	return createChainableTypeChecker(validate);
533	}
534
535	function createEnumTypeChecker(expectedValues) {
536	if (!Array.isArray(expectedValues)) {
537	if (true) {
538	if (arguments.length > 1) {
539	printWarning(
540	'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
541	'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
542	);
543	} else {
544	printWarning('Invalid argument supplied to oneOf, expected an array.');
545	}
546	}
547	return emptyFunctionThatReturnsNull;
548	}
549
550	function validate(props, propName, componentName, location, propFullName) {
551	var propValue = props[propName];
552	for (var i = 0; i < expectedValues.length; i++) {
553	if (is(propValue, expectedValues[i])) {
554	return null;
555	}
556	}
557
558	var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
559	var type = getPreciseType(value);
560	if (type === 'symbol') {
561	return String(value);
562	}
563	return value;
564	});
565	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
566	}
567	return createChainableTypeChecker(validate);
568	}
569
570	function createObjectOfTypeChecker(typeChecker) {
571	function validate(props, propName, componentName, location, propFullName) {
572	if (typeof typeChecker !== 'function') {
573	return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
574	}
575	var propValue = props[propName];
576	var propType = getPropType(propValue);
577	if (propType !== 'object') {
578	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
579	}
580	for (var key in propValue) {
581	if (has(propValue, key)) {
582	var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
583	if (error instanceof Error) {
584	return error;
585	}
586	}
587	}
588	return null;
589	}
590	return createChainableTypeChecker(validate);
591	}
592
593	function createUnionTypeChecker(arrayOfTypeCheckers) {
594	if (!Array.isArray(arrayOfTypeCheckers)) {
595	true ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : 0;
596	return emptyFunctionThatReturnsNull;
597	}
598
599	for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
600	var checker = arrayOfTypeCheckers[i];
601	if (typeof checker !== 'function') {
602	printWarning(
603	'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
604	'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
605	);
606	return emptyFunctionThatReturnsNull;
607	}
608	}
609
610	function validate(props, propName, componentName, location, propFullName) {
611	var expectedTypes = [];
612	for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
613	var checker = arrayOfTypeCheckers[i];
614	var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
615	if (checkerResult == null) {
616	return null;
617	}
618	if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
619	expectedTypes.push(checkerResult.data.expectedType);
620	}
621	}
622	var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';
623	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
624	}
625	return createChainableTypeChecker(validate);
626	}
627
628	function createNodeChecker() {
629	function validate(props, propName, componentName, location, propFullName) {
630	if (!isNode(props[propName])) {
631	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
632	}
633	return null;
634	}
635	return createChainableTypeChecker(validate);
636	}
637
638	function invalidValidatorError(componentName, location, propFullName, key, type) {
639	return new PropTypeError(
640	(componentName \|\| 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +
641	'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'
642	);
643	}
644
645	function createShapeTypeChecker(shapeTypes) {
646	function validate(props, propName, componentName, location, propFullName) {
647	var propValue = props[propName];
648	var propType = getPropType(propValue);
649	if (propType !== 'object') {
650	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
651	}
652	for (var key in shapeTypes) {
653	var checker = shapeTypes[key];
654	if (typeof checker !== 'function') {
655	return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
656	}
657	var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
658	if (error) {
659	return error;
660	}
661	}
662	return null;
663	}
664	return createChainableTypeChecker(validate);
665	}
666
667	function createStrictShapeTypeChecker(shapeTypes) {
668	function validate(props, propName, componentName, location, propFullName) {
669	var propValue = props[propName];
670	var propType = getPropType(propValue);
671	if (propType !== 'object') {
672	return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
673	}
674	// We need to check all keys in case some are required but missing from props.
675	var allKeys = assign({}, props[propName], shapeTypes);
676	for (var key in allKeys) {
677	var checker = shapeTypes[key];
678	if (has(shapeTypes, key) && typeof checker !== 'function') {
679	return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
680	}
681	if (!checker) {
682	return new PropTypeError(
683	'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
684	'\nBad object: ' + JSON.stringify(props[propName], null, ' ') +
685	'\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')
686	);
687	}
688	var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
689	if (error) {
690	return error;
691	}
692	}
693	return null;
694	}
695
696	return createChainableTypeChecker(validate);
697	}
698
699	function isNode(propValue) {
700	switch (typeof propValue) {
701	case 'number':
702	case 'string':
703	case 'undefined':
704	return true;
705	case 'boolean':
706	return !propValue;
707	case 'object':
708	if (Array.isArray(propValue)) {
709	return propValue.every(isNode);
710	}
711	if (propValue === null \|\| isValidElement(propValue)) {
712	return true;
713	}
714
715	var iteratorFn = getIteratorFn(propValue);
716	if (iteratorFn) {
717	var iterator = iteratorFn.call(propValue);
718	var step;
719	if (iteratorFn !== propValue.entries) {
720	while (!(step = iterator.next()).done) {
721	if (!isNode(step.value)) {
722	return false;
723	}
724	}
725	} else {
726	// Iterator will provide entry [k,v] tuples rather than values.
727	while (!(step = iterator.next()).done) {
728	var entry = step.value;
729	if (entry) {
730	if (!isNode(entry[1])) {
731	return false;
732	}
733	}
734	}
735	}
736	} else {
737	return false;
738	}
739
740	return true;
741	default:
742	return false;
743	}
744	}
745
746	function isSymbol(propType, propValue) {
747	// Native Symbol.
748	if (propType === 'symbol') {
749	return true;
750	}
751
752	// falsy value can't be a Symbol
753	if (!propValue) {
754	return false;
755	}
756
757	// 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
758	if (propValue['@@toStringTag'] === 'Symbol') {
759	return true;
760	}
761
762	// Fallback for non-spec compliant Symbols which are polyfilled.
763	if (typeof Symbol === 'function' && propValue instanceof Symbol) {
764	return true;
765	}
766
767	return false;
768	}
769
770	// Equivalent of `typeof` but with special handling for array and regexp.
771	function getPropType(propValue) {
772	var propType = typeof propValue;
773	if (Array.isArray(propValue)) {
774	return 'array';
775	}
776	if (propValue instanceof RegExp) {
777	// Old webkits (at least until Android 4.0) return 'function' rather than
778	// 'object' for typeof a RegExp. We'll normalize this here so that /bla/
779	// passes PropTypes.object.
780	return 'object';
781	}
782	if (isSymbol(propType, propValue)) {
783	return 'symbol';
784	}
785	return propType;
786	}
787
788	// This handles more types than `getPropType`. Only used for error messages.
789	// See `createPrimitiveTypeChecker`.
790	function getPreciseType(propValue) {
791	if (typeof propValue === 'undefined' \|\| propValue === null) {
792	return '' + propValue;
793	}
794	var propType = getPropType(propValue);
795	if (propType === 'object') {
796	if (propValue instanceof Date) {
797	return 'date';
798	} else if (propValue instanceof RegExp) {
799	return 'regexp';
800	}
801	}
802	return propType;
803	}
804
805	// Returns a string that is postfixed to a warning about an invalid type.
806	// For example, "undefined" or "of type array"
807	function getPostfixForTypeWarning(value) {
808	var type = getPreciseType(value);
809	switch (type) {
810	case 'array':
811	case 'object':
812	return 'an ' + type;
813	case 'boolean':
814	case 'date':
815	case 'regexp':
816	return 'a ' + type;
817	default:
818	return type;
819	}
820	}
821
822	// Returns class name of the object, if any.
823	function getClassName(propValue) {
824	if (!propValue.constructor \|\| !propValue.constructor.name) {
825	return ANONYMOUS;
826	}
827	return propValue.constructor.name;
828	}
829
830	ReactPropTypes.checkPropTypes = checkPropTypes;
831	ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
832	ReactPropTypes.PropTypes = ReactPropTypes;
833
834	return ReactPropTypes;
835	};
836
837
838	/***/ }),
839
840	/***/ "../node_modules/prop-types/index.js":
841	/!*****************************************!\
842	!* ../node_modules/prop-types/index.js *!
843	\*******************************************/
844	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
845
846	/**
847	* Copyright (c) 2013-present, Facebook, Inc.
848	*
849	* This source code is licensed under the MIT license found in the
850	* LICENSE file in the root directory of this source tree.
851	*/
852
853	if (true) {
854	var ReactIs = __webpack_require__(/! react-is / "../node_modules/prop-types/node_modules/react-is/index.js");
855
856	// By explicitly using `prop-types` you are opting into new development behavior.
857	// http://fb.me/prop-types-in-prod
858	var throwOnDirectAccess = true;
859	module.exports = __webpack_require__(/! ./factoryWithTypeCheckers / "../node_modules/prop-types/factoryWithTypeCheckers.js")(ReactIs.isElement, throwOnDirectAccess);
860	} else {}
861
862
863	/***/ }),
864
865	/***/ "../node_modules/prop-types/lib/ReactPropTypesSecret.js":
866	/!************************************************************!\
867	!* ../node_modules/prop-types/lib/ReactPropTypesSecret.js *!
868	\**************************************************************/
869	/***/ ((module) => {
870
871	"use strict";
872	/**
873	* Copyright (c) 2013-present, Facebook, Inc.
874	*
875	* This source code is licensed under the MIT license found in the
876	* LICENSE file in the root directory of this source tree.
877	*/
878
879
880
881	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
882
883	module.exports = ReactPropTypesSecret;
884
885
886	/***/ }),
887
888	/***/ "../node_modules/prop-types/lib/has.js":
889	/!*******************************************!\
890	!* ../node_modules/prop-types/lib/has.js *!
891	\*********************************************/
892	/***/ ((module) => {
893
894	module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
895
896
897	/***/ }),
898
899	/***/ "../node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js":
900	/!**********************************************************************************!\
901	!* ../node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js *!
902	\************************************************************************************/
903	/***/ ((__unused_webpack_module, exports) => {
904
905	"use strict";
906	/** @license React v16.13.1
907	* react-is.development.js
908	*
909	* Copyright (c) Facebook, Inc. and its affiliates.
910	*
911	* This source code is licensed under the MIT license found in the
912	* LICENSE file in the root directory of this source tree.
913	*/
914
915
916
917
918
919	if (true) {
920	(function() {
921	'use strict';
922
923	// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
924	// nor polyfill, then a plain number is used for performance.
925	var hasSymbol = typeof Symbol === 'function' && Symbol.for;
926	var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
927	var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
928	var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
929	var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
930	var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
931	var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
932	var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
933	// (unstable) APIs that have been removed. Can we remove the symbols?
934
935	var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
936	var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
937	var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
938	var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
939	var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
940	var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
941	var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
942	var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
943	var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
944	var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
945	var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
946
947	function isValidElementType(type) {
948	return typeof type === 'string' \|\| typeof type === 'function' \|\| // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
949	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);
950	}
951
952	function typeOf(object) {
953	if (typeof object === 'object' && object !== null) {
954	var $$typeof = object.$$typeof;
955
956	switch ($$typeof) {
957	case REACT_ELEMENT_TYPE:
958	var type = object.type;
959
960	switch (type) {
961	case REACT_ASYNC_MODE_TYPE:
962	case REACT_CONCURRENT_MODE_TYPE:
963	case REACT_FRAGMENT_TYPE:
964	case REACT_PROFILER_TYPE:
965	case REACT_STRICT_MODE_TYPE:
966	case REACT_SUSPENSE_TYPE:
967	return type;
968
969	default:
970	var $$typeofType = type && type.$$typeof;
971
972	switch ($$typeofType) {
973	case REACT_CONTEXT_TYPE:
974	case REACT_FORWARD_REF_TYPE:
975	case REACT_LAZY_TYPE:
976	case REACT_MEMO_TYPE:
977	case REACT_PROVIDER_TYPE:
978	return $$typeofType;
979
980	default:
981	return $$typeof;
982	}
983
984	}
985
986	case REACT_PORTAL_TYPE:
987	return $$typeof;
988	}
989	}
990
991	return undefined;
992	} // AsyncMode is deprecated along with isAsyncMode
993
994	var AsyncMode = REACT_ASYNC_MODE_TYPE;
995	var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
996	var ContextConsumer = REACT_CONTEXT_TYPE;
997	var ContextProvider = REACT_PROVIDER_TYPE;
998	var Element = REACT_ELEMENT_TYPE;
999	var ForwardRef = REACT_FORWARD_REF_TYPE;
1000	var Fragment = REACT_FRAGMENT_TYPE;
1001	var Lazy = REACT_LAZY_TYPE;
1002	var Memo = REACT_MEMO_TYPE;
1003	var Portal = REACT_PORTAL_TYPE;
1004	var Profiler = REACT_PROFILER_TYPE;
1005	var StrictMode = REACT_STRICT_MODE_TYPE;
1006	var Suspense = REACT_SUSPENSE_TYPE;
1007	var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
1008
1009	function isAsyncMode(object) {
1010	{
1011	if (!hasWarnedAboutDeprecatedIsAsyncMode) {
1012	hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
1013
1014	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.');
1015	}
1016	}
1017
1018	return isConcurrentMode(object) \|\| typeOf(object) === REACT_ASYNC_MODE_TYPE;
1019	}
1020	function isConcurrentMode(object) {
1021	return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
1022	}
1023	function isContextConsumer(object) {
1024	return typeOf(object) === REACT_CONTEXT_TYPE;
1025	}
1026	function isContextProvider(object) {
1027	return typeOf(object) === REACT_PROVIDER_TYPE;
1028	}
1029	function isElement(object) {
1030	return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
1031	}
1032	function isForwardRef(object) {
1033	return typeOf(object) === REACT_FORWARD_REF_TYPE;
1034	}
1035	function isFragment(object) {
1036	return typeOf(object) === REACT_FRAGMENT_TYPE;
1037	}
1038	function isLazy(object) {
1039	return typeOf(object) === REACT_LAZY_TYPE;
1040	}
1041	function isMemo(object) {
1042	return typeOf(object) === REACT_MEMO_TYPE;
1043	}
1044	function isPortal(object) {
1045	return typeOf(object) === REACT_PORTAL_TYPE;
1046	}
1047	function isProfiler(object) {
1048	return typeOf(object) === REACT_PROFILER_TYPE;
1049	}
1050	function isStrictMode(object) {
1051	return typeOf(object) === REACT_STRICT_MODE_TYPE;
1052	}
1053	function isSuspense(object) {
1054	return typeOf(object) === REACT_SUSPENSE_TYPE;
1055	}
1056
1057	exports.AsyncMode = AsyncMode;
1058	exports.ConcurrentMode = ConcurrentMode;
1059	exports.ContextConsumer = ContextConsumer;
1060	exports.ContextProvider = ContextProvider;
1061	exports.Element = Element;
1062	exports.ForwardRef = ForwardRef;
1063	exports.Fragment = Fragment;
1064	exports.Lazy = Lazy;
1065	exports.Memo = Memo;
1066	exports.Portal = Portal;
1067	exports.Profiler = Profiler;
1068	exports.StrictMode = StrictMode;
1069	exports.Suspense = Suspense;
1070	exports.isAsyncMode = isAsyncMode;
1071	exports.isConcurrentMode = isConcurrentMode;
1072	exports.isContextConsumer = isContextConsumer;
1073	exports.isContextProvider = isContextProvider;
1074	exports.isElement = isElement;
1075	exports.isForwardRef = isForwardRef;
1076	exports.isFragment = isFragment;
1077	exports.isLazy = isLazy;
1078	exports.isMemo = isMemo;
1079	exports.isPortal = isPortal;
1080	exports.isProfiler = isProfiler;
1081	exports.isStrictMode = isStrictMode;
1082	exports.isSuspense = isSuspense;
1083	exports.isValidElementType = isValidElementType;
1084	exports.typeOf = typeOf;
1085	})();
1086	}
1087
1088
1089	/***/ }),
1090
1091	/***/ "../node_modules/prop-types/node_modules/react-is/index.js":
1092	/!***************************************************************!\
1093	!* ../node_modules/prop-types/node_modules/react-is/index.js *!
1094	\*****************************************************************/
1095	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1096
1097	"use strict";
1098
1099
1100	if (false) {} else {
1101	module.exports = __webpack_require__(/! ./cjs/react-is.development.js / "../node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js");
1102	}
1103
1104
1105	/***/ }),
1106
1107	/***/ "../node_modules/@babel/runtime/helpers/arrayLikeToArray.js":
1108	/!****************************************************************!\
1109	!* ../node_modules/@babel/runtime/helpers/arrayLikeToArray.js *!
1110	\******************************************************************/
1111	/***/ ((module) => {
1112
1113	function _arrayLikeToArray(r, a) {
1114	(null == a \|\| a > r.length) && (a = r.length);
1115	for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
1116	return n;
1117	}
1118	module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
1119
1120	/***/ }),
1121
1122	/***/ "../node_modules/@babel/runtime/helpers/arrayWithHoles.js":
1123	/!**************************************************************!\
1124	!* ../node_modules/@babel/runtime/helpers/arrayWithHoles.js *!
1125	\****************************************************************/
1126	/***/ ((module) => {
1127
1128	function _arrayWithHoles(r) {
1129	if (Array.isArray(r)) return r;
1130	}
1131	module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
1132
1133	/***/ }),
1134
1135	/***/ "../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js":
1136	/!********************************************************************!\
1137	!* ../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js *!
1138	\**********************************************************************/
1139	/***/ ((module) => {
1140
1141	function _iterableToArrayLimit(r, l) {
1142	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] \|\| r["@@iterator"];
1143	if (null != t) {
1144	var e,
1145	n,
1146	i,
1147	u,
1148	a = [],
1149	f = !0,
1150	o = !1;
1151	try {
1152	if (i = (t = t.call(r)).next, 0 === l) {
1153	if (Object(t) !== t) return;
1154	f = !1;
1155	} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
1156	} catch (r) {
1157	o = !0, n = r;
1158	} finally {
1159	try {
1160	if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
1161	} finally {
1162	if (o) throw n;
1163	}
1164	}
1165	return a;
1166	}
1167	}
1168	module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
1169
1170	/***/ }),
1171
1172	/***/ "../node_modules/@babel/runtime/helpers/nonIterableRest.js":
1173	/!***************************************************************!\
1174	!* ../node_modules/@babel/runtime/helpers/nonIterableRest.js *!
1175	\*****************************************************************/
1176	/***/ ((module) => {
1177
1178	function _nonIterableRest() {
1179	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
1180	}
1181	module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
1182
1183	/***/ }),
1184
1185	/***/ "../node_modules/@babel/runtime/helpers/slicedToArray.js":
1186	/!*************************************************************!\
1187	!* ../node_modules/@babel/runtime/helpers/slicedToArray.js *!
1188	\***************************************************************/
1189	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1190
1191	var arrayWithHoles = __webpack_require__(/! ./arrayWithHoles.js / "../node_modules/@babel/runtime/helpers/arrayWithHoles.js");
1192	var iterableToArrayLimit = __webpack_require__(/! ./iterableToArrayLimit.js / "../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js");
1193	var unsupportedIterableToArray = __webpack_require__(/! ./unsupportedIterableToArray.js / "../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js");
1194	var nonIterableRest = __webpack_require__(/! ./nonIterableRest.js / "../node_modules/@babel/runtime/helpers/nonIterableRest.js");
1195	function _slicedToArray(r, e) {
1196	return arrayWithHoles(r) \|\| iterableToArrayLimit(r, e) \|\| unsupportedIterableToArray(r, e) \|\| nonIterableRest();
1197	}
1198	module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
1199
1200	/***/ }),
1201
1202	/***/ "../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js":
1203	/!**************************************************************************!\
1204	!* ../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js *!
1205	\****************************************************************************/
1206	/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1207
1208	var arrayLikeToArray = __webpack_require__(/! ./arrayLikeToArray.js / "../node_modules/@babel/runtime/helpers/arrayLikeToArray.js");
1209	function _unsupportedIterableToArray(r, a) {
1210	if (r) {
1211	if ("string" == typeof r) return arrayLikeToArray(r, a);
1212	var t = {}.toString.call(r).slice(8, -1);
1213	return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t \|\| "Set" === t ? Array.from(r) : "Arguments" === t \|\| /^(?:Ui\|I)nt(?:8\|16\|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;
1214	}
1215	}
1216	module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
1217
1218	/***/ })
1219
1220	}]);
1221	//# sourceMappingURL=056b8f3bbbcabf026cd1.bundle.js.map