https://mariawolff.org/wp-includes/js/dist/vendor/react-jsx-runtime.js

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

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