https://iqprompt.ai/node_modules/.vite/deps/chunk-FHHGISJF.js?v=06a3ba8c

8// node_modules/react/cjs/react-jsx-runtime.development.js
9var require_react_jsx_runtime_development = __commonJS({
10  "node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
11    "use strict";
12    if (true) {
13      (function() {
14        "use strict";
15        var React = require_react();
16        var REACT_ELEMENT_TYPE = Symbol.for("react.element");
17        var REACT_PORTAL_TYPE = Symbol.for("react.portal");
18        var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
19        var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
20        var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
21        var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
22        var REACT_CONTEXT_TYPE = Symbol.for("react.context");
23        var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
24        var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
25        var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
26        var REACT_MEMO_TYPE = Symbol.for("react.memo");
27        var REACT_LAZY_TYPE = Symbol.for("react.lazy");
28        var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
29        var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
30        var FAUX_ITERATOR_SYMBOL = "@@iterator";
31        function getIteratorFn(maybeIterable) {
32          if (maybeIterable === null || typeof maybeIterable !== "object") {
33            return null;
34          }
35          var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
36          if (typeof maybeIterator === "function") {
37            return maybeIterator;
38          }
39          return null;
40        }
41        var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
42        function error(format) {
43          {
44            {
45              for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
46                args[_key2 - 1] = arguments[_key2];
47              }
48              printWarning("error", format, args);
49            }
50          }
51        }
52        function printWarning(level, format, args) {
53          {
54            var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
55            var stack = ReactDebugCurrentFrame2.getStackAddendum();
56            if (stack !== "") {
57              format += "%s";
58              args = args.concat([stack]);
59            }
60            var argsWithFormat = args.map(function(item) {
61              return String(item);
62            });
63            argsWithFormat.unshift("Warning: " + format);
64            Function.prototype.apply.call(console[level], console, argsWithFormat);
65          }
66        }
67        var enableScopeAPI = false;
68        var enableCacheElement = false;
69        var enableTransitionTracing = false;
70        var enableLegacyHidden = false;
71        var enableDebugTracing = false;
72        var REACT_MODULE_REFERENCE;
73        {
74          REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
75        }
76        function isValidElementType(type) {
77          if (typeof type === "string" || typeof type === "function") {
78            return true;
79          }
80          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) {
81            return true;
82          }
83          if (typeof type === "object" && type !== null) {
84            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 || // This needs to include all possible module reference object
85            // types supported by any Flight configuration anywhere since
86            // we don't know which Flight build this will end up being used
87            // with.
88            type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
89              return true;
90            }
91          }
92          return false;
93        }
94        function getWrappedName(outerType, innerType, wrapperName) {
95          var displayName = outerType.displayName;
96          if (displayName) {
97            return displayName;
98          }
99          var functionName = innerType.displayName || innerType.name || "";
100          return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
101        }
102        function getContextName(type) {
103          return type.displayName || "Context";
104        }
105        function getComponentNameFromType(type) {
106          if (type == null) {
107            return null;
108          }
109          {
110            if (typeof type.tag === "number") {
111              error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
112            }
113          }
114          if (typeof type === "function") {
115            return type.displayName || type.name || null;
116          }
117          if (typeof type === "string") {
118            return type;
119          }
120          switch (type) {
121            case REACT_FRAGMENT_TYPE:
122              return "Fragment";
123            case REACT_PORTAL_TYPE:
124              return "Portal";
125            case REACT_PROFILER_TYPE:
126              return "Profiler";
127            case REACT_STRICT_MODE_TYPE:
128              return "StrictMode";
129            case REACT_SUSPENSE_TYPE:
130              return "Suspense";
131            case REACT_SUSPENSE_LIST_TYPE:
132              return "SuspenseList";
133          }
134          if (typeof type === "object") {
135            switch (type.$$typeof) {
136              case REACT_CONTEXT_TYPE:
137                var context = type;
138                return getContextName(context) + ".Consumer";
139              case REACT_PROVIDER_TYPE:
140                var provider = type;
141                return getContextName(provider._context) + ".Provider";
142              case REACT_FORWARD_REF_TYPE:
143                return getWrappedName(type, type.render, "ForwardRef");
144              case REACT_MEMO_TYPE:
145                var outerName = type.displayName || null;
146                if (outerName !== null) {
147                  return outerName;
148                }
149                return getComponentNameFromType(type.type) || "Memo";
150              case REACT_LAZY_TYPE: {
151                var lazyComponent = type;
152                var payload = lazyComponent._payload;
153                var init = lazyComponent._init;
154                try {
155                  return getComponentNameFromType(init(payload));
156                } catch (x) {
157                  return null;
158                }
159              }
160            }
161          }
162          return null;
163        }
164        var assign = Object.assign;
165        var disabledDepth = 0;
166        var prevLog;
167        var prevInfo;
168        var prevWarn;
169        var prevError;
170        var prevGroup;
171        var prevGroupCollapsed;
172        var prevGroupEnd;
173        function disabledLog() {
174        }
175        disabledLog.__reactDisabledLog = true;
176        function disableLogs() {
177          {
178            if (disabledDepth === 0) {
179              prevLog = console.log;
180              prevInfo = console.info;
181              prevWarn = console.warn;
182              prevError = console.error;
183              prevGroup = console.group;
184              prevGroupCollapsed = console.groupCollapsed;
185              prevGroupEnd = console.groupEnd;
186              var props = {
187                configurable: true,
188                enumerable: true,
189                value: disabledLog,
190                writable: true
191              };
192              Object.defineProperties(console, {
193                info: props,
194                log: props,
195                warn: props,
196                error: props,
197                group: props,
198                groupCollapsed: props,
199                groupEnd: props
200              });
201            }
202            disabledDepth++;
203          }
204        }
205        function reenableLogs() {
206          {
207            disabledDepth--;
208            if (disabledDepth === 0) {
209              var props = {
210                configurable: true,
211                enumerable: true,
212                writable: true
213              };
214              Object.defineProperties(console, {
215                log: assign({}, props, {
216                  value: prevLog
217                }),
218                info: assign({}, props, {
219                  value: prevInfo
220                }),
221                warn: assign({}, props, {
222                  value: prevWarn
223                }),
224                error: assign({}, props, {
225                  value: prevError
226                }),
227                group: assign({}, props, {
228                  value: prevGroup
229                }),
230                groupCollapsed: assign({}, props, {
231                  value: prevGroupCollapsed
232                }),
233                groupEnd: assign({}, props, {
234                  value: prevGroupEnd
235                })
236              });
237            }
238            if (disabledDepth < 0) {
239              error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
240            }
241          }
242        }
243        var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
244        var prefix;
245        function describeBuiltInComponentFrame(name, source, ownerFn) {
246          {
247            if (prefix === void 0) {
248              try {
249                throw Error();
250              } catch (x) {
251                var match = x.stack.trim().match(/\n( *(at )?)/);
252                prefix = match && match[1] || "";
253              }
254            }
255            return "\n" + prefix + name;
256          }
257        }
258        var reentry = false;
259        var componentFrameCache;
260        {
261          var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
262          componentFrameCache = new PossiblyWeakMap();
263        }
264        function describeNativeComponentFrame(fn, construct) {
265          if (!fn || reentry) {
266            return "";
267          }
268          {
269            var frame = componentFrameCache.get(fn);
270            if (frame !== void 0) {
271              return frame;
272            }
273          }
274          var control;
275          reentry = true;
276          var previousPrepareStackTrace = Error.prepareStackTrace;
277          Error.prepareStackTrace = void 0;
278          var previousDispatcher;
279          {
280            previousDispatcher = ReactCurrentDispatcher.current;
281            ReactCurrentDispatcher.current = null;
282            disableLogs();
283          }
284          try {
285            if (construct) {
286              var Fake = function() {
287                throw Error();
288              };
289              Object.defineProperty(Fake.prototype, "props", {
290                set: function() {
291                  throw Error();
292                }
293              });
294              if (typeof Reflect === "object" && Reflect.construct) {
295                try {
296                  Reflect.construct(Fake, []);
297                } catch (x) {
298                  control = x;
299                }
300                Reflect.construct(fn, [], Fake);
301              } else {
302                try {
303                  Fake.call();
304                } catch (x) {
305                  control = x;
306                }
307                fn.call(Fake.prototype);
308              }
309            } else {
310              try {
311                throw Error();
312              } catch (x) {
313                control = x;
314              }
315              fn();
316            }
317          } catch (sample) {
318            if (sample && control && typeof sample.stack === "string") {
319              var sampleLines = sample.stack.split("\n");
320              var controlLines = control.stack.split("\n");
321              var s = sampleLines.length - 1;
322              var c = controlLines.length - 1;
323              while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
324                c--;
325              }
326              for (; s >= 1 && c >= 0; s--, c--) {
327                if (sampleLines[s] !== controlLines[c]) {
328                  if (s !== 1 || c !== 1) {
329                    do {
330                      s--;
331                      c--;
332                      if (c < 0 || sampleLines[s] !== controlLines[c]) {
333                        var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
334                        if (fn.displayName && _frame.includes("<anonymous>")) {
335                          _frame = _frame.replace("<anonymous>", fn.displayName);
336                        }
337                        {
338                          if (typeof fn === "function") {
339                            componentFrameCache.set(fn, _frame);
340                          }
341                        }
342                        return _frame;
343                      }
344                    } while (s >= 1 && c >= 0);
345                  }
346                  break;
347                }
348              }
349            }
350          } finally {
351            reentry = false;
352            {
353              ReactCurrentDispatcher.current = previousDispatcher;
354              reenableLogs();
355            }
356            Error.prepareStackTrace = previousPrepareStackTrace;
357          }
358          var name = fn ? fn.displayName || fn.name : "";
359          var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
360          {
361            if (typeof fn === "function") {
362              componentFrameCache.set(fn, syntheticFrame);
363            }
364          }
365          return syntheticFrame;
366        }
367        function describeFunctionComponentFrame(fn, source, ownerFn) {
368          {
369            return describeNativeComponentFrame(fn, false);
370          }
371        }
372        function shouldConstruct(Component) {
373          var prototype = Component.prototype;
374          return !!(prototype && prototype.isReactComponent);
375        }
376        function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
377          if (type == null) {
378            return "";
379          }
380          if (typeof type === "function") {
381            {
382              return describeNativeComponentFrame(type, shouldConstruct(type));
383            }
384          }
385          if (typeof type === "string") {
386            return describeBuiltInComponentFrame(type);
387          }
388          switch (type) {
389            case REACT_SUSPENSE_TYPE:
390              return describeBuiltInComponentFrame("Suspense");
391            case REACT_SUSPENSE_LIST_TYPE:
392              return describeBuiltInComponentFrame("SuspenseList");
393          }
394          if (typeof type === "object") {
395            switch (type.$$typeof) {
396              case REACT_FORWARD_REF_TYPE:
397                return describeFunctionComponentFrame(type.render);
398              case REACT_MEMO_TYPE:
399                return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
400              case REACT_LAZY_TYPE: {
401                var lazyComponent = type;
402                var payload = lazyComponent._payload;
403                var init = lazyComponent._init;
404                try {
405                  return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
406                } catch (x) {
407                }
408              }
409            }
410          }
411          return "";
412        }
413        var hasOwnProperty = Object.prototype.hasOwnProperty;
414        var loggedTypeFailures = {};
415        var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
416        function setCurrentlyValidatingElement(element) {
417          {
418            if (element) {
419              var owner = element._owner;
420              var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
421              ReactDebugCurrentFrame.setExtraStackFrame(stack);
422            } else {
423              ReactDebugCurrentFrame.setExtraStackFrame(null);
424            }
425          }
426        }
427        function checkPropTypes(typeSpecs, values, location, componentName, element) {
428          {
429            var has = Function.call.bind(hasOwnProperty);
430            for (var typeSpecName in typeSpecs) {
431              if (has(typeSpecs, typeSpecName)) {
432                var error$1 = void 0;
433                try {
434                  if (typeof typeSpecs[typeSpecName] !== "function") {
435                    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`.");
436                    err.name = "Invariant Violation";
437                    throw err;
438                  }
439                  error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
440                } catch (ex) {
441                  error$1 = ex;
442                }
443                if (error$1 && !(error$1 instanceof Error)) {
444                  setCurrentlyValidatingElement(element);
445                  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);
446                  setCurrentlyValidatingElement(null);
447                }
448                if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
449                  loggedTypeFailures[error$1.message] = true;
450                  setCurrentlyValidatingElement(element);
451                  error("Failed %s type: %s", location, error$1.message);
452                  setCurrentlyValidatingElement(null);
453                }
454              }
455            }
456          }
457        }
458        var isArrayImpl = Array.isArray;
459        function isArray(a) {
460          return isArrayImpl(a);
461        }
462        function typeName(value) {
463          {
464            var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
465            var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
466            return type;
467          }
468        }
469        function willCoercionThrow(value) {
470          {
471            try {
472              testStringCoercion(value);
473              return false;
474            } catch (e) {
475              return true;
476            }
477          }
478        }
479        function testStringCoercion(value) {
480          return "" + value;
481        }
482        function checkKeyStringCoercion(value) {
483          {
484            if (willCoercionThrow(value)) {
485              error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
486              return testStringCoercion(value);
487            }
488          }
489        }
490        var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
491        var RESERVED_PROPS = {
492          key: true,
493          ref: true,
494          __self: true,
495          __source: true
496        };
497        var specialPropKeyWarningShown;
498        var specialPropRefWarningShown;
499        var didWarnAboutStringRefs;
500        {
501          didWarnAboutStringRefs = {};
502        }
503        function hasValidRef(config) {
504          {
505            if (hasOwnProperty.call(config, "ref")) {
506              var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
507              if (getter && getter.isReactWarning) {
508                return false;
509              }
510            }
511          }
512          return config.ref !== void 0;
513        }
514        function hasValidKey(config) {
515          {
516            if (hasOwnProperty.call(config, "key")) {
517              var getter = Object.getOwnPropertyDescriptor(config, "key").get;
518              if (getter && getter.isReactWarning) {
519                return false;
520              }
521            }
522          }
523          return config.key !== void 0;
524        }
525        function warnIfStringRefCannotBeAutoConverted(config, self) {
526          {
527            if (typeof config.ref === "string" && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
528              var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
529              if (!didWarnAboutStringRefs[componentName]) {
530                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);
531                didWarnAboutStringRefs[componentName] = true;
532              }
533            }
534          }
535        }
536        function defineKeyPropWarningGetter(props, displayName) {
537          {
538            var warnAboutAccessingKey = function() {
539              if (!specialPropKeyWarningShown) {
540                specialPropKeyWarningShown = true;
541                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);
542              }
543            };
544            warnAboutAccessingKey.isReactWarning = true;
545            Object.defineProperty(props, "key", {
546              get: warnAboutAccessingKey,
547              configurable: true
548            });
549          }
550        }
551        function defineRefPropWarningGetter(props, displayName) {
552          {
553            var warnAboutAccessingRef = function() {
554              if (!specialPropRefWarningShown) {
555                specialPropRefWarningShown = true;
556                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);
557              }
558            };
559            warnAboutAccessingRef.isReactWarning = true;
560            Object.defineProperty(props, "ref", {
561              get: warnAboutAccessingRef,
562              configurable: true
563            });
564          }
565        }
566        var ReactElement = function(type, key, ref, self, source, owner, props) {
567          var element = {
568            // This tag allows us to uniquely identify this as a React Element
569            $$typeof: REACT_ELEMENT_TYPE,
570            // Built-in properties that belong on the element
571            type,
572            key,
573            ref,
574            props,
575            // Record the component responsible for creating this element.
576            _owner: owner
577          };
578          {
579            element._store = {};
580            Object.defineProperty(element._store, "validated", {
581              configurable: false,
582              enumerable: false,
583              writable: true,
584              value: false
585            });
586            Object.defineProperty(element, "_self", {
587              configurable: false,
588              enumerable: false,
589              writable: false,
590              value: self
591            });
592            Object.defineProperty(element, "_source", {
593              configurable: false,
594              enumerable: false,
595              writable: false,
596              value: source
597            });
598            if (Object.freeze) {
599              Object.freeze(element.props);
600              Object.freeze(element);
601            }
602          }
603          return element;
604        };
605        function jsxDEV(type, config, maybeKey, source, self) {
606          {
607            var propName;
608            var props = {};
609            var key = null;
610            var ref = null;
611            if (maybeKey !== void 0) {
612              {
613                checkKeyStringCoercion(maybeKey);
614              }
615              key = "" + maybeKey;
616            }
617            if (hasValidKey(config)) {
618              {
619                checkKeyStringCoercion(config.key);
620              }
621              key = "" + config.key;
622            }
623            if (hasValidRef(config)) {
624              ref = config.ref;
625              warnIfStringRefCannotBeAutoConverted(config, self);
626            }
627            for (propName in config) {
628              if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
629                props[propName] = config[propName];
630              }
631            }
632            if (type && type.defaultProps) {
633              var defaultProps = type.defaultProps;
634              for (propName in defaultProps) {
635                if (props[propName] === void 0) {
636                  props[propName] = defaultProps[propName];
637                }
638              }
639            }
640            if (key || ref) {
641              var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
642              if (key) {
643                defineKeyPropWarningGetter(props, displayName);
644              }
645              if (ref) {
646                defineRefPropWarningGetter(props, displayName);
647              }
648            }
649            return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
650          }
651        }
652        var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
653        var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
654        function setCurrentlyValidatingElement$1(element) {
655          {
656            if (element) {
657              var owner = element._owner;
658              var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
659              ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
660            } else {
661              ReactDebugCurrentFrame$1.setExtraStackFrame(null);
662            }
663          }
664        }
665        var propTypesMisspellWarningShown;
666        {
667          propTypesMisspellWarningShown = false;
668        }
669        function isValidElement(object) {
670          {
671            return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
672          }
673        }
674        function getDeclarationErrorAddendum() {
675          {
676            if (ReactCurrentOwner$1.current) {
677              var name = getComponentNameFromType(ReactCurrentOwner$1.current.type);
678              if (name) {
679                return "\n\nCheck the render method of `" + name + "`.";
680              }
681            }
682            return "";
683          }
684        }
685        function getSourceInfoErrorAddendum(source) {
686          {
687            if (source !== void 0) {
688              var fileName = source.fileName.replace(/^.*[\\\/]/, "");
689              var lineNumber = source.lineNumber;
690              return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
691            }
692            return "";
693          }
694        }
695        var ownerHasKeyUseWarning = {};
696        function getCurrentComponentErrorInfo(parentType) {
697          {
698            var info = getDeclarationErrorAddendum();
699            if (!info) {
700              var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
701              if (parentName) {
702                info = "\n\nCheck the top-level render call using <" + parentName + ">.";
703              }
704            }
705            return info;
706          }
707        }
708        function validateExplicitKey(element, parentType) {
709          {
710            if (!element._store || element._store.validated || element.key != null) {
711              return;
712            }
713            element._store.validated = true;
714            var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
715            if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
716              return;
717            }
718            ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
719            var childOwner = "";
720            if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
721              childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
722            }
723            setCurrentlyValidatingElement$1(element);
724            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);
725            setCurrentlyValidatingElement$1(null);
726          }
727        }
728        function validateChildKeys(node, parentType) {
729          {
730            if (typeof node !== "object") {
731              return;
732            }
733            if (isArray(node)) {
734              for (var i = 0; i < node.length; i++) {
735                var child = node[i];
736                if (isValidElement(child)) {
737                  validateExplicitKey(child, parentType);
738                }
739              }
740            } else if (isValidElement(node)) {
741              if (node._store) {
742                node._store.validated = true;
743              }
744            } else if (node) {
745              var iteratorFn = getIteratorFn(node);
746              if (typeof iteratorFn === "function") {
747                if (iteratorFn !== node.entries) {
748                  var iterator = iteratorFn.call(node);
749                  var step;
750                  while (!(step = iterator.next()).done) {
751                    if (isValidElement(step.value)) {
752                      validateExplicitKey(step.value, parentType);
753                    }
754                  }
755                }
756              }
757            }
758          }
759        }
760        function validatePropTypes(element) {
761          {
762            var type = element.type;
763            if (type === null || type === void 0 || typeof type === "string") {
764              return;
765            }
766            var propTypes;
767            if (typeof type === "function") {
768              propTypes = type.propTypes;
769            } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
770            // Inner props are checked in the reconciler.
771            type.$$typeof === REACT_MEMO_TYPE)) {
772              propTypes = type.propTypes;
773            } else {
774              return;
775            }
776            if (propTypes) {
777              var name = getComponentNameFromType(type);
778              checkPropTypes(propTypes, element.props, "prop", name, element);
779            } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
780              propTypesMisspellWarningShown = true;
781              var _name = getComponentNameFromType(type);
782              error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
783            }
784            if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
785              error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
786            }
787          }
788        }
789        function validateFragmentProps(fragment) {
790          {
791            var keys = Object.keys(fragment.props);
792            for (var i = 0; i < keys.length; i++) {
793              var key = keys[i];
794              if (key !== "children" && key !== "key") {
795                setCurrentlyValidatingElement$1(fragment);
796                error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
797                setCurrentlyValidatingElement$1(null);
798                break;
799              }
800            }
801            if (fragment.ref !== null) {
802              setCurrentlyValidatingElement$1(fragment);
803              error("Invalid attribute `ref` supplied to `React.Fragment`.");
804              setCurrentlyValidatingElement$1(null);
805            }
806          }
807        }
808        var didWarnAboutKeySpread = {};
809        function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
810          {
811            var validType = isValidElementType(type);
812            if (!validType) {
813              var info = "";
814              if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
815                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.";
816              }
817              var sourceInfo = getSourceInfoErrorAddendum(source);
818              if (sourceInfo) {
819                info += sourceInfo;
820              } else {
821                info += getDeclarationErrorAddendum();
822              }
823              var typeString;
824              if (type === null) {
825                typeString = "null";
826              } else if (isArray(type)) {
827                typeString = "array";
828              } else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
829                typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />";
830                info = " Did you accidentally export a JSX literal instead of a component?";
831              } else {
832                typeString = typeof type;
833              }
834              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);
835            }
836            var element = jsxDEV(type, props, key, source, self);
837            if (element == null) {
838              return element;
839            }
840            if (validType) {
841              var children = props.children;
842              if (children !== void 0) {
843                if (isStaticChildren) {
844                  if (isArray(children)) {
845                    for (var i = 0; i < children.length; i++) {
846                      validateChildKeys(children[i], type);
847                    }
848                    if (Object.freeze) {
849                      Object.freeze(children);
850                    }
851                  } else {
852                    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.");
853                  }
854                } else {
855                  validateChildKeys(children, type);
856                }
857              }
858            }
859            {
860              if (hasOwnProperty.call(props, "key")) {
861                var componentName = getComponentNameFromType(type);
862                var keys = Object.keys(props).filter(function(k) {
863                  return k !== "key";
864                });
865                var beforeExample = keys.length > 0 ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
866                if (!didWarnAboutKeySpread[componentName + beforeExample]) {
867                  var afterExample = keys.length > 0 ? "{" + keys.join(": ..., ") + ": ...}" : "{}";
868                  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, afterExample, componentName);
869                  didWarnAboutKeySpread[componentName + beforeExample] = true;
870                }
871              }
872            }
873            if (type === REACT_FRAGMENT_TYPE) {
874              validateFragmentProps(element);
875            } else {
876              validatePropTypes(element);
877            }
878            return element;
879          }
880        }
881        function jsxWithValidationStatic(type, props, key) {
882          {
883            return jsxWithValidation(type, props, key, true);
884          }
885        }
886        function jsxWithValidationDynamic(type, props, key) {
887          {
888            return jsxWithValidation(type, props, key, false);
889          }
890        }
891        var jsx = jsxWithValidationDynamic;
892        var jsxs = jsxWithValidationStatic;
893        exports.Fragment = REACT_FRAGMENT_TYPE;
894        exports.jsx = jsx;
895        exports.jsxs = jsxs;
896      })();
897    }
898  }
899});
900

901// node_modules/react/jsx-runtime.js
902var require_jsx_runtime = __commonJS({
903  "node_modules/react/jsx-runtime.js"(exports, module) {
904    if (false) {
905      module.exports = null;
906    } else {
907      module.exports = require_react_jsx_runtime_development();
908    }
909  }
910});
911
912export {
913  require_jsx_runtime
914};
915/*! Bundled license information:
916
917react/cjs/react-jsx-runtime.development.js:
918  (**
919   * @license React
920   * react-jsx-runtime.development.js
921   *
922   * Copyright (c) Facebook, Inc. and its affiliates.
923   *
924   * This source code is licensed under the MIT license found in the
925   * LICENSE file in the root directory of this source tree.
926   *)
927*/
928//# sourceMappingURL=chunk-FHHGISJF.js.map