source: imaps-frontend/node_modules/.vite/deps/react_jsx-dev-runtime.js@ d565449

main
Last change on this file since d565449 was d565449, checked in by stefan toskovski <stefantoska84@…>, 4 weeks ago

Update repo after prototype presentation
  • Property mode set to 100644
File size: 36.1 KB
RevLine 
[d565449]1import {
2 require_react
3} from "./chunk-QJTFJ6OV.js";
4import {
5 __commonJS
6} from "./chunk-V4OQ3NZ2.js";
7
8// node_modules/react/cjs/react-jsx-dev-runtime.development.js
9var require_react_jsx_dev_runtime_development = __commonJS({
10 "node_modules/react/cjs/react-jsx-dev-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 var jsxDEV$1 = jsxWithValidation;
882 exports.Fragment = REACT_FRAGMENT_TYPE;
883 exports.jsxDEV = jsxDEV$1;
884 })();
885 }
886 }
887});
888
889// node_modules/react/jsx-dev-runtime.js
890var require_jsx_dev_runtime = __commonJS({
891 "node_modules/react/jsx-dev-runtime.js"(exports, module) {
892 if (false) {
893 module.exports = null;
894 } else {
895 module.exports = require_react_jsx_dev_runtime_development();
896 }
897 }
898});
899export default require_jsx_dev_runtime();
900/*! Bundled license information:
901
902react/cjs/react-jsx-dev-runtime.development.js:
903 (**
904 * @license React
905 * react-jsx-dev-runtime.development.js
906 *
907 * Copyright (c) Facebook, Inc. and its affiliates.
908 *
909 * This source code is licensed under the MIT license found in the
910 * LICENSE file in the root directory of this source tree.
911 *)
912*/
913//# sourceMappingURL=react_jsx-dev-runtime.js.map
Note: See TracBrowser for help on using the repository browser.