https://www.nic.sn/node_modules/.vite/deps/jsx-runtime-Dr3h7qjn.js?v=9133a454

1import { t as __commonJSMin } from "/node_modules/.vite/deps/chunk-olfrzTEO.js?v=9133a454";
2import { t as require_react } from "/node_modules/.vite/deps/react.js?v=9133a454";
3//#region node_modules/react/cjs/react-jsx-runtime.development.js
4/**
5* @license React
6* react-jsx-runtime.development.js
7*
8* Copyright (c) Facebook, Inc. and its affiliates.
9*
10* This source code is licensed under the MIT license found in the
11* LICENSE file in the root directory of this source tree.
12*/
13var require_react_jsx_runtime_development = /* @__PURE__ */ __commonJSMin(((exports) => {
14	(function() {
15		"use strict";
16		var React = require_react();
17		var REACT_ELEMENT_TYPE = Symbol.for("react.element");
18		var REACT_PORTAL_TYPE = Symbol.for("react.portal");
19		var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
20		var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
21		var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
22		var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
23		var REACT_CONTEXT_TYPE = Symbol.for("react.context");
24		var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
25		var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
26		var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
27		var REACT_MEMO_TYPE = Symbol.for("react.memo");
28		var REACT_LAZY_TYPE = Symbol.for("react.lazy");
29		var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
30		var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
31		var FAUX_ITERATOR_SYMBOL = "@@iterator";
32		function getIteratorFn(maybeIterable) {
33			if (maybeIterable === null || typeof maybeIterable !== "object") return null;
34			var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
35			if (typeof maybeIterator === "function") return maybeIterator;
36			return null;
37		}
38		var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
39		function error(format) {
40			for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) args[_key2 - 1] = arguments[_key2];
41			printWarning("error", format, args);
42		}
43		function printWarning(level, format, args) {
44			var stack = ReactSharedInternals.ReactDebugCurrentFrame.getStackAddendum();
45			if (stack !== "") {
46				format += "%s";
47				args = args.concat([stack]);
48			}
49			var argsWithFormat = args.map(function(item) {
50				return String(item);
51			});
52			argsWithFormat.unshift("Warning: " + format);
53			Function.prototype.apply.call(console[level], console, argsWithFormat);
54		}
55		var enableScopeAPI = false;
56		var enableCacheElement = false;
57		var enableTransitionTracing = false;
58		var enableLegacyHidden = false;
59		var enableDebugTracing = false;
60		var REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
61		function isValidElementType(type) {
62			if (typeof type === "string" || typeof type === "function") return true;
63			if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) return true;
64			if (typeof type === "object" && type !== null) {
65				if (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_MODULE_REFERENCE || type.getModuleId !== void 0) return true;
66			}
67			return false;
68		}
69		function getWrappedName(outerType, innerType, wrapperName) {
70			var displayName = outerType.displayName;
71			if (displayName) return displayName;
72			var functionName = innerType.displayName || innerType.name || "";
73			return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
74		}
75		function getContextName(type) {
76			return type.displayName || "Context";
77		}
78		function getComponentNameFromType(type) {
79			if (type == null) return null;
80			if (typeof type.tag === "number") error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
81			if (typeof type === "function") return type.displayName || type.name || null;
82			if (typeof type === "string") return type;
83			switch (type) {
84				case REACT_FRAGMENT_TYPE: return "Fragment";

85				case REACT_PORTAL_TYPE: return "Portal";
86				case REACT_PROFILER_TYPE: return "Profiler";
87				case REACT_STRICT_MODE_TYPE: return "StrictMode";
88				case REACT_SUSPENSE_TYPE: return "Suspense";
89				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
90			}
91			if (typeof type === "object") switch (type.$$typeof) {
92				case REACT_CONTEXT_TYPE: return getContextName(type) + ".Consumer";
93				case REACT_PROVIDER_TYPE: return getContextName(type._context) + ".Provider";
94				case REACT_FORWARD_REF_TYPE: return getWrappedName(type, type.render, "ForwardRef");
95				case REACT_MEMO_TYPE:
96					var outerName = type.displayName || null;
97					if (outerName !== null) return outerName;
98					return getComponentNameFromType(type.type) || "Memo";
99				case REACT_LAZY_TYPE:
100					var lazyComponent = type;
101					var payload = lazyComponent._payload;
102					var init = lazyComponent._init;
103					try {
104						return getComponentNameFromType(init(payload));
105					} catch (x) {
106						return null;
107					}
108			}
109			return null;
110		}
111		var assign = Object.assign;
112		var disabledDepth = 0;
113		var prevLog;
114		var prevInfo;
115		var prevWarn;
116		var prevError;
117		var prevGroup;
118		var prevGroupCollapsed;
119		var prevGroupEnd;
120		function disabledLog() {}
121		disabledLog.__reactDisabledLog = true;
122		function disableLogs() {
123			if (disabledDepth === 0) {
124				prevLog = console.log;
125				prevInfo = console.info;
126				prevWarn = console.warn;
127				prevError = console.error;
128				prevGroup = console.group;
129				prevGroupCollapsed = console.groupCollapsed;
130				prevGroupEnd = console.groupEnd;
131				var props = {
132					configurable: true,
133					enumerable: true,
134					value: disabledLog,
135					writable: true
136				};
137				Object.defineProperties(console, {
138					info: props,
139					log: props,
140					warn: props,
141					error: props,
142					group: props,
143					groupCollapsed: props,
144					groupEnd: props
145				});
146			}
147			disabledDepth++;
148		}
149		function reenableLogs() {
150			disabledDepth--;
151			if (disabledDepth === 0) {
152				var props = {
153					configurable: true,
154					enumerable: true,
155					writable: true
156				};
157				Object.defineProperties(console, {
158					log: assign({}, props, { value: prevLog }),
159					info: assign({}, props, { value: prevInfo }),
160					warn: assign({}, props, { value: prevWarn }),
161					error: assign({}, props, { value: prevError }),
162					group: assign({}, props, { value: prevGroup }),
163					groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
164					groupEnd: assign({}, props, { value: prevGroupEnd })
165				});
166			}
167			if (disabledDepth < 0) error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
168		}
169		var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
170		var prefix;
171		function describeBuiltInComponentFrame(name, source, ownerFn) {
172			if (prefix === void 0) try {
173				throw Error();
174			} catch (x) {
175				var match = x.stack.trim().match(/\n( *(at )?)/);
176				prefix = match && match[1] || "";
177			}
178			return "\n" + prefix + name;
179		}
180		var reentry = false;
181		var componentFrameCache = new (typeof WeakMap === "function" ? WeakMap : Map)();
182		function describeNativeComponentFrame(fn, construct) {
183			if (!fn || reentry) return "";
184			var frame = componentFrameCache.get(fn);
185			if (frame !== void 0) return frame;
186			var control;
187			reentry = true;
188			var previousPrepareStackTrace = Error.prepareStackTrace;
189			Error.prepareStackTrace = void 0;
190			var previousDispatcher = ReactCurrentDispatcher.current;
191			ReactCurrentDispatcher.current = null;
192			disableLogs();
193			try {
194				if (construct) {
195					var Fake = function() {
196						throw Error();
197					};
198					Object.defineProperty(Fake.prototype, "props", { set: function() {
199						throw Error();
200					} });
201					if (typeof Reflect === "object" && Reflect.construct) {
202						try {
203							Reflect.construct(Fake, []);
204						} catch (x) {
205							control = x;
206						}
207						Reflect.construct(fn, [], Fake);
208					} else {
209						try {
210							Fake.call();
211						} catch (x) {
212							control = x;
213						}
214						fn.call(Fake.prototype);
215					}
216				} else {
217					try {
218						throw Error();
219					} catch (x) {
220						control = x;
221					}
222					fn();
223				}
224			} catch (sample) {

225				if (sample && control && typeof sample.stack === "string") {
226					var sampleLines = sample.stack.split("\n");
227					var controlLines = control.stack.split("\n");
228					var s = sampleLines.length - 1;
229					var c = controlLines.length - 1;
230					while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) c--;
231					for (; s >= 1 && c >= 0; s--, c--) if (sampleLines[s] !== controlLines[c]) {
232						if (s !== 1 || c !== 1) do {
233							s--;
234							c--;
235							if (c < 0 || sampleLines[s] !== controlLines[c]) {
236								var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
237								if (fn.displayName && _frame.includes("<anonymous>")) _frame = _frame.replace("<anonymous>", fn.displayName);
238								if (typeof fn === "function") componentFrameCache.set(fn, _frame);
239								return _frame;
240							}
241						} while (s >= 1 && c >= 0);
242						break;
243					}
244				}
245			} finally {
246				reentry = false;
247				ReactCurrentDispatcher.current = previousDispatcher;
248				reenableLogs();
249				Error.prepareStackTrace = previousPrepareStackTrace;
250			}
251			var name = fn ? fn.displayName || fn.name : "";
252			var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
253			if (typeof fn === "function") componentFrameCache.set(fn, syntheticFrame);
254			return syntheticFrame;
255		}
256		function describeFunctionComponentFrame(fn, source, ownerFn) {
257			return describeNativeComponentFrame(fn, false);
258		}
259		function shouldConstruct(Component) {
260			var prototype = Component.prototype;
261			return !!(prototype && prototype.isReactComponent);
262		}
263		function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
264			if (type == null) return "";
265			if (typeof type === "function") return describeNativeComponentFrame(type, shouldConstruct(type));
266			if (typeof type === "string") return describeBuiltInComponentFrame(type);
267			switch (type) {
268				case REACT_SUSPENSE_TYPE: return describeBuiltInComponentFrame("Suspense");
269				case REACT_SUSPENSE_LIST_TYPE: return describeBuiltInComponentFrame("SuspenseList");
270			}
271			if (typeof type === "object") switch (type.$$typeof) {
272				case REACT_FORWARD_REF_TYPE: return describeFunctionComponentFrame(type.render);
273				case REACT_MEMO_TYPE: return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
274				case REACT_LAZY_TYPE:
275					var lazyComponent = type;
276					var payload = lazyComponent._payload;
277					var init = lazyComponent._init;
278					try {
279						return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
280					} catch (x) {}
281			}
282			return "";
283		}
284		var hasOwnProperty = Object.prototype.hasOwnProperty;
285		var loggedTypeFailures = {};
286		var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
287		function setCurrentlyValidatingElement(element) {
288			if (element) {
289				var owner = element._owner;
290				var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
291				ReactDebugCurrentFrame.setExtraStackFrame(stack);
292			} else ReactDebugCurrentFrame.setExtraStackFrame(null);
293		}
294		function checkPropTypes(typeSpecs, values, location, componentName, element) {
295			var has = Function.call.bind(hasOwnProperty);
296			for (var typeSpecName in typeSpecs) if (has(typeSpecs, typeSpecName)) {
297				var error$1 = void 0;
298				try {
299					if (typeof typeSpecs[typeSpecName] !== "function") {
300						var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
301						err.name = "Invariant Violation";
302						throw err;
303					}
304					error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
305				} catch (ex) {
306					error$1 = ex;
307				}
308				if (error$1 && !(error$1 instanceof Error)) {
309					setCurrentlyValidatingElement(element);
310					error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1);
311					setCurrentlyValidatingElement(null);
312				}
313				if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
314					loggedTypeFailures[error$1.message] = true;
315					setCurrentlyValidatingElement(element);
316					error("Failed %s type: %s", location, error$1.message);
317					setCurrentlyValidatingElement(null);
318				}
319			}
320		}
321		var isArrayImpl = Array.isArray;
322		function isArray(a) {
323			return isArrayImpl(a);
324		}
325		function typeName(value) {
326			return typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
327		}
328		function willCoercionThrow(value) {
329			try {
330				testStringCoercion(value);
331				return false;

332			} catch (e) {
333				return true;
334			}
335		}
336		function testStringCoercion(value) {
337			return "" + value;
338		}
339		function checkKeyStringCoercion(value) {
340			if (willCoercionThrow(value)) {
341				error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
342				return testStringCoercion(value);
343			}
344		}
345		var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
346		var RESERVED_PROPS = {
347			key: true,
348			ref: true,
349			__self: true,
350			__source: true
351		};
352		var specialPropKeyWarningShown;
353		var specialPropRefWarningShown;
354		var didWarnAboutStringRefs = {};
355		function hasValidRef(config) {
356			if (hasOwnProperty.call(config, "ref")) {
357				var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
358				if (getter && getter.isReactWarning) return false;
359			}
360			return config.ref !== void 0;
361		}
362		function hasValidKey(config) {
363			if (hasOwnProperty.call(config, "key")) {
364				var getter = Object.getOwnPropertyDescriptor(config, "key").get;
365				if (getter && getter.isReactWarning) return false;
366			}
367			return config.key !== void 0;
368		}
369		function warnIfStringRefCannotBeAutoConverted(config, self) {
370			if (typeof config.ref === "string" && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
371				var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
372				if (!didWarnAboutStringRefs[componentName]) {
373					error("Component \"%s\" contains the string ref \"%s\". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref", getComponentNameFromType(ReactCurrentOwner.current.type), config.ref);
374					didWarnAboutStringRefs[componentName] = true;
375				}
376			}
377		}
378		function defineKeyPropWarningGetter(props, displayName) {
379			var warnAboutAccessingKey = function() {
380				if (!specialPropKeyWarningShown) {
381					specialPropKeyWarningShown = true;
382					error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
383				}
384			};
385			warnAboutAccessingKey.isReactWarning = true;
386			Object.defineProperty(props, "key", {
387				get: warnAboutAccessingKey,
388				configurable: true
389			});
390		}
391		function defineRefPropWarningGetter(props, displayName) {
392			var warnAboutAccessingRef = function() {
393				if (!specialPropRefWarningShown) {
394					specialPropRefWarningShown = true;
395					error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
396				}
397			};
398			warnAboutAccessingRef.isReactWarning = true;
399			Object.defineProperty(props, "ref", {
400				get: warnAboutAccessingRef,
401				configurable: true
402			});
403		}
404		/**
405		* Factory method to create a new React element. This no longer adheres to
406		* the class pattern, so do not use new to call it. Also, instanceof check
407		* will not work. Instead test $$typeof field against Symbol.for('react.element') to check
408		* if something is a React Element.
409		*
410		* @param {*} type
411		* @param {*} props
412		* @param {*} key
413		* @param {string|object} ref
414		* @param {*} owner
415		* @param {*} self A *temporary* helper to detect places where `this` is
416		* different from the `owner` when React.createElement is called, so that we
417		* can warn. We want to get rid of owner and replace string `ref`s with arrow
418		* functions, and as long as `this` and owner are the same, there will be no
419		* change in behavior.
420		* @param {*} source An annotation object (added by a transpiler or otherwise)
421		* indicating filename, line number, and/or other information.
422		* @internal
423		*/
424		var ReactElement = function(type, key, ref, self, source, owner, props) {
425			var element = {
426				$$typeof: REACT_ELEMENT_TYPE,
427				type,
428				key,
429				ref,
430				props,
431				_owner: owner
432			};
433			element._store = {};
434			Object.defineProperty(element._store, "validated", {
435				configurable: false,
436				enumerable: false,
437				writable: true,
438				value: false
439			});
440			Object.defineProperty(element, "_self", {
441				configurable: false,
442				enumerable: false,
443				writable: false,
444				value: self
445			});
446			Object.defineProperty(element, "_source", {
447				configurable: false,
448				enumerable: false,
449				writable: false,
450				value: source
451			});
452			if (Object.freeze) {
453				Object.freeze(element.props);
454				Object.freeze(element);
455			}
456			return element;
457		};
458		/**
459		* https://github.com/reactjs/rfcs/pull/107
460		* @param {*} type
461		* @param {object} props
462		* @param {string} key
463		*/
464		function jsxDEV(type, config, maybeKey, source, self) {
465			var propName;
466			var props = {};
467			var key = null;
468			var ref = null;
469			if (maybeKey !== void 0) {
470				checkKeyStringCoercion(maybeKey);
471				key = "" + maybeKey;
472			}
473			if (hasValidKey(config)) {
474				checkKeyStringCoercion(config.key);
475				key = "" + config.key;
476			}
477			if (hasValidRef(config)) {
478				ref = config.ref;
479				warnIfStringRefCannotBeAutoConverted(config, self);
480			}
481			for (propName in config) if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) props[propName] = config[propName];
482			if (type && type.defaultProps) {
483				var defaultProps = type.defaultProps;
484				for (propName in defaultProps) if (props[propName] === void 0) props[propName] = defaultProps[propName];
485			}
486			if (key || ref) {
487				var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
488				if (key) defineKeyPropWarningGetter(props, displayName);
489				if (ref) defineRefPropWarningGetter(props, displayName);
490			}
491			return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
492		}
493		var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
494		var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
495		function setCurrentlyValidatingElement$1(element) {
496			if (element) {
497				var owner = element._owner;
498				var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
499				ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
500			} else ReactDebugCurrentFrame$1.setExtraStackFrame(null);
501		}
502		var propTypesMisspellWarningShown = false;

503		/**
504		* Verifies the object is a ReactElement.
505		* See https://reactjs.org/docs/react-api.html#isvalidelement
506		* @param {?object} object
507		* @return {boolean} True if `object` is a ReactElement.
508		* @final
509		*/
510		function isValidElement(object) {
511			return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
512		}
513		function getDeclarationErrorAddendum() {
514			if (ReactCurrentOwner$1.current) {
515				var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
516				if (name) return "\n\nCheck the render method of `" + name + "`.";
517			}
518			return "";
519		}
520		function getSourceInfoErrorAddendum(source) {
521			if (source !== void 0) {
522				var fileName = source.fileName.replace(/^.*[\\\/]/, "");
523				var lineNumber = source.lineNumber;
524				return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
525			}
526			return "";
527		}
528		/**
529		* Warn if there's no key explicitly set on dynamic arrays of children or
530		* object keys are not valid. This allows us to keep track of children between
531		* updates.
532		*/
533		var ownerHasKeyUseWarning = {};
534		function getCurrentComponentErrorInfo(parentType) {
535			var info = getDeclarationErrorAddendum();
536			if (!info) {
537				var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
538				if (parentName) info = "\n\nCheck the top-level render call using <" + parentName + ">.";
539			}
540			return info;
541		}
542		/**
543		* Warn if the element doesn't have an explicit key assigned to it.
544		* This element is in an array. The array could grow and shrink or be
545		* reordered. All children that haven't already been validated are required to
546		* have a "key" property assigned to it. Error statuses are cached so a warning
547		* will only be shown once.
548		*
549		* @internal
550		* @param {ReactElement} element Element that requires a key.
551		* @param {*} parentType element's parent's type.
552		*/
553		function validateExplicitKey(element, parentType) {
554			if (!element._store || element._store.validated || element.key != null) return;
555			element._store.validated = true;
556			var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
557			if (ownerHasKeyUseWarning[currentComponentErrorInfo]) return;
558			ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
559			var childOwner = "";
560			if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
561			setCurrentlyValidatingElement$1(element);
562			error("Each child in a list should have a unique \"key\" prop.%s%s See https://reactjs.org/link/warning-keys for more information.", currentComponentErrorInfo, childOwner);
563			setCurrentlyValidatingElement$1(null);
564		}
565		/**
566		* Ensure that every element either is passed in a static location, in an
567		* array with an explicit keys property defined, or in an object literal
568		* with valid key property.
569		*
570		* @internal
571		* @param {ReactNode} node Statically passed child of any type.
572		* @param {*} parentType node's parent's type.
573		*/
574		function validateChildKeys(node, parentType) {
575			if (typeof node !== "object") return;
576			if (isArray(node)) for (var i = 0; i < node.length; i++) {
577				var child = node[i];
578				if (isValidElement(child)) validateExplicitKey(child, parentType);
579			}
580			else if (isValidElement(node)) {
581				if (node._store) node._store.validated = true;
582			} else if (node) {
583				var iteratorFn = getIteratorFn(node);
584				if (typeof iteratorFn === "function") {
585					if (iteratorFn !== node.entries) {
586						var iterator = iteratorFn.call(node);
587						var step;
588						while (!(step = iterator.next()).done) if (isValidElement(step.value)) validateExplicitKey(step.value, parentType);
589					}
590				}
591			}
592		}
593		/**
594		* Given an element, validate that its props follow the propTypes definition,
595		* provided by the type.
596		*
597		* @param {ReactElement} element
598		*/
599		function validatePropTypes(element) {
600			var type = element.type;
601			if (type === null || type === void 0 || typeof type === "string") return;
602			var propTypes;

603			if (typeof type === "function") propTypes = type.propTypes;
604			else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) propTypes = type.propTypes;
605			else return;
606			if (propTypes) {
607				var name = getComponentNameFromType(type);
608				checkPropTypes(propTypes, element.props, "prop", name, element);
609			} else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
610				propTypesMisspellWarningShown = true;
611				error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", getComponentNameFromType(type) || "Unknown");
612			}
613			if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
614		}
615		/**
616		* Given a fragment, validate that it can only be provided with fragment props
617		* @param {ReactElement} fragment
618		*/
619		function validateFragmentProps(fragment) {
620			var keys = Object.keys(fragment.props);
621			for (var i = 0; i < keys.length; i++) {
622				var key = keys[i];
623				if (key !== "children" && key !== "key") {
624					setCurrentlyValidatingElement$1(fragment);
625					error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
626					setCurrentlyValidatingElement$1(null);
627					break;
628				}
629			}
630			if (fragment.ref !== null) {
631				setCurrentlyValidatingElement$1(fragment);
632				error("Invalid attribute `ref` supplied to `React.Fragment`.");
633				setCurrentlyValidatingElement$1(null);
634			}
635		}
636		var didWarnAboutKeySpread = {};
637		function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
638			var validType = isValidElementType(type);
639			if (!validType) {
640				var info = "";
641				if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
642				var sourceInfo = getSourceInfoErrorAddendum(source);
643				if (sourceInfo) info += sourceInfo;
644				else info += getDeclarationErrorAddendum();
645				var typeString;
646				if (type === null) typeString = "null";
647				else if (isArray(type)) typeString = "array";
648				else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
649					typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />";
650					info = " Did you accidentally export a JSX literal instead of a component?";
651				} else typeString = typeof type;
652				error("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
653			}
654			var element = jsxDEV(type, props, key, source, self);
655			if (element == null) return element;
656			if (validType) {
657				var children = props.children;
658				if (children !== void 0) if (isStaticChildren) if (isArray(children)) {
659					for (var i = 0; i < children.length; i++) validateChildKeys(children[i], type);
660					if (Object.freeze) Object.freeze(children);
661				} else error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
662				else validateChildKeys(children, type);
663			}
664			if (hasOwnProperty.call(props, "key")) {
665				var componentName = getComponentNameFromType(type);
666				var keys = Object.keys(props).filter(function(k) {
667					return k !== "key";
668				});
669				var beforeExample = keys.length > 0 ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
670				if (!didWarnAboutKeySpread[componentName + beforeExample]) {
671					error("A props object containing a \"key\" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />", beforeExample, componentName, keys.length > 0 ? "{" + keys.join(": ..., ") + ": ...}" : "{}", componentName);
672					didWarnAboutKeySpread[componentName + beforeExample] = true;
673				}
674			}
675			if (type === REACT_FRAGMENT_TYPE) validateFragmentProps(element);
676			else validatePropTypes(element);
677			return element;
678		}
679		function jsxWithValidationStatic(type, props, key) {
680			return jsxWithValidation(type, props, key, true);
681		}
682		function jsxWithValidationDynamic(type, props, key) {
683			return jsxWithValidation(type, props, key, false);
684		}
685		var jsx = jsxWithValidationDynamic;
686		var jsxs = jsxWithValidationStatic;
687		exports.Fragment = REACT_FRAGMENT_TYPE;
688		exports.jsx = jsx;
689		exports.jsxs = jsxs;
690	})();
691}));
692//#endregion
693//#region node_modules/react/jsx-runtime.js
694var require_jsx_runtime = /* @__PURE__ */ __commonJSMin(((exports, module) => {
695	module.exports = require_react_jsx_runtime_development();
696}));
697//#endregion
698export { require_jsx_runtime as t };
699
700//# sourceMappingURL=jsx-runtime-Dr3h7qjn.js.map