source: imaps-frontend/node_modules/.vite/deps/chunk-QJTFJ6OV.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: 76.0 KB
Line 
1import {
2 __commonJS
3} from "./chunk-V4OQ3NZ2.js";
4
5// node_modules/react/cjs/react.development.js
6var require_react_development = __commonJS({
7 "node_modules/react/cjs/react.development.js"(exports, module) {
8 "use strict";
9 if (true) {
10 (function() {
11 "use strict";
12 if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
13 __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
14 }
15 var ReactVersion = "18.3.1";
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 ReactCurrentDispatcher = {
42 /**
43 * @internal
44 * @type {ReactComponent}
45 */
46 current: null
47 };
48 var ReactCurrentBatchConfig = {
49 transition: null
50 };
51 var ReactCurrentActQueue = {
52 current: null,
53 // Used to reproduce behavior of `batchedUpdates` in legacy mode.
54 isBatchingLegacy: false,
55 didScheduleLegacyUpdate: false
56 };
57 var ReactCurrentOwner = {
58 /**
59 * @internal
60 * @type {ReactComponent}
61 */
62 current: null
63 };
64 var ReactDebugCurrentFrame = {};
65 var currentExtraStackFrame = null;
66 function setExtraStackFrame(stack) {
67 {
68 currentExtraStackFrame = stack;
69 }
70 }
71 {
72 ReactDebugCurrentFrame.setExtraStackFrame = function(stack) {
73 {
74 currentExtraStackFrame = stack;
75 }
76 };
77 ReactDebugCurrentFrame.getCurrentStack = null;
78 ReactDebugCurrentFrame.getStackAddendum = function() {
79 var stack = "";
80 if (currentExtraStackFrame) {
81 stack += currentExtraStackFrame;
82 }
83 var impl = ReactDebugCurrentFrame.getCurrentStack;
84 if (impl) {
85 stack += impl() || "";
86 }
87 return stack;
88 };
89 }
90 var enableScopeAPI = false;
91 var enableCacheElement = false;
92 var enableTransitionTracing = false;
93 var enableLegacyHidden = false;
94 var enableDebugTracing = false;
95 var ReactSharedInternals = {
96 ReactCurrentDispatcher,
97 ReactCurrentBatchConfig,
98 ReactCurrentOwner
99 };
100 {
101 ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
102 ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
103 }
104 function warn(format) {
105 {
106 {
107 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
108 args[_key - 1] = arguments[_key];
109 }
110 printWarning("warn", format, args);
111 }
112 }
113 }
114 function error(format) {
115 {
116 {
117 for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
118 args[_key2 - 1] = arguments[_key2];
119 }
120 printWarning("error", format, args);
121 }
122 }
123 }
124 function printWarning(level, format, args) {
125 {
126 var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
127 var stack = ReactDebugCurrentFrame2.getStackAddendum();
128 if (stack !== "") {
129 format += "%s";
130 args = args.concat([stack]);
131 }
132 var argsWithFormat = args.map(function(item) {
133 return String(item);
134 });
135 argsWithFormat.unshift("Warning: " + format);
136 Function.prototype.apply.call(console[level], console, argsWithFormat);
137 }
138 }
139 var didWarnStateUpdateForUnmountedComponent = {};
140 function warnNoop(publicInstance, callerName) {
141 {
142 var _constructor = publicInstance.constructor;
143 var componentName = _constructor && (_constructor.displayName || _constructor.name) || "ReactClass";
144 var warningKey = componentName + "." + callerName;
145 if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
146 return;
147 }
148 error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, componentName);
149 didWarnStateUpdateForUnmountedComponent[warningKey] = true;
150 }
151 }
152 var ReactNoopUpdateQueue = {
153 /**
154 * Checks whether or not this composite component is mounted.
155 * @param {ReactClass} publicInstance The instance we want to test.
156 * @return {boolean} True if mounted, false otherwise.
157 * @protected
158 * @final
159 */
160 isMounted: function(publicInstance) {
161 return false;
162 },
163 /**
164 * Forces an update. This should only be invoked when it is known with
165 * certainty that we are **not** in a DOM transaction.
166 *
167 * You may want to call this when you know that some deeper aspect of the
168 * component's state has changed but `setState` was not called.
169 *
170 * This will not invoke `shouldComponentUpdate`, but it will invoke
171 * `componentWillUpdate` and `componentDidUpdate`.
172 *
173 * @param {ReactClass} publicInstance The instance that should rerender.
174 * @param {?function} callback Called after component is updated.
175 * @param {?string} callerName name of the calling function in the public API.
176 * @internal
177 */
178 enqueueForceUpdate: function(publicInstance, callback, callerName) {
179 warnNoop(publicInstance, "forceUpdate");
180 },
181 /**
182 * Replaces all of the state. Always use this or `setState` to mutate state.
183 * You should treat `this.state` as immutable.
184 *
185 * There is no guarantee that `this.state` will be immediately updated, so
186 * accessing `this.state` after calling this method may return the old value.
187 *
188 * @param {ReactClass} publicInstance The instance that should rerender.
189 * @param {object} completeState Next state.
190 * @param {?function} callback Called after component is updated.
191 * @param {?string} callerName name of the calling function in the public API.
192 * @internal
193 */
194 enqueueReplaceState: function(publicInstance, completeState, callback, callerName) {
195 warnNoop(publicInstance, "replaceState");
196 },
197 /**
198 * Sets a subset of the state. This only exists because _pendingState is
199 * internal. This provides a merging strategy that is not available to deep
200 * properties which is confusing. TODO: Expose pendingState or don't use it
201 * during the merge.
202 *
203 * @param {ReactClass} publicInstance The instance that should rerender.
204 * @param {object} partialState Next partial state to be merged with state.
205 * @param {?function} callback Called after component is updated.
206 * @param {?string} Name of the calling function in the public API.
207 * @internal
208 */
209 enqueueSetState: function(publicInstance, partialState, callback, callerName) {
210 warnNoop(publicInstance, "setState");
211 }
212 };
213 var assign = Object.assign;
214 var emptyObject = {};
215 {
216 Object.freeze(emptyObject);
217 }
218 function Component(props, context, updater) {
219 this.props = props;
220 this.context = context;
221 this.refs = emptyObject;
222 this.updater = updater || ReactNoopUpdateQueue;
223 }
224 Component.prototype.isReactComponent = {};
225 Component.prototype.setState = function(partialState, callback) {
226 if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null) {
227 throw new Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
228 }
229 this.updater.enqueueSetState(this, partialState, callback, "setState");
230 };
231 Component.prototype.forceUpdate = function(callback) {
232 this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
233 };
234 {
235 var deprecatedAPIs = {
236 isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
237 replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
238 };
239 var defineDeprecationWarning = function(methodName, info) {
240 Object.defineProperty(Component.prototype, methodName, {
241 get: function() {
242 warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
243 return void 0;
244 }
245 });
246 };
247 for (var fnName in deprecatedAPIs) {
248 if (deprecatedAPIs.hasOwnProperty(fnName)) {
249 defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
250 }
251 }
252 }
253 function ComponentDummy() {
254 }
255 ComponentDummy.prototype = Component.prototype;
256 function PureComponent(props, context, updater) {
257 this.props = props;
258 this.context = context;
259 this.refs = emptyObject;
260 this.updater = updater || ReactNoopUpdateQueue;
261 }
262 var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
263 pureComponentPrototype.constructor = PureComponent;
264 assign(pureComponentPrototype, Component.prototype);
265 pureComponentPrototype.isPureReactComponent = true;
266 function createRef() {
267 var refObject = {
268 current: null
269 };
270 {
271 Object.seal(refObject);
272 }
273 return refObject;
274 }
275 var isArrayImpl = Array.isArray;
276 function isArray(a) {
277 return isArrayImpl(a);
278 }
279 function typeName(value) {
280 {
281 var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
282 var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
283 return type;
284 }
285 }
286 function willCoercionThrow(value) {
287 {
288 try {
289 testStringCoercion(value);
290 return false;
291 } catch (e) {
292 return true;
293 }
294 }
295 }
296 function testStringCoercion(value) {
297 return "" + value;
298 }
299 function checkKeyStringCoercion(value) {
300 {
301 if (willCoercionThrow(value)) {
302 error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
303 return testStringCoercion(value);
304 }
305 }
306 }
307 function getWrappedName(outerType, innerType, wrapperName) {
308 var displayName = outerType.displayName;
309 if (displayName) {
310 return displayName;
311 }
312 var functionName = innerType.displayName || innerType.name || "";
313 return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
314 }
315 function getContextName(type) {
316 return type.displayName || "Context";
317 }
318 function getComponentNameFromType(type) {
319 if (type == null) {
320 return null;
321 }
322 {
323 if (typeof type.tag === "number") {
324 error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
325 }
326 }
327 if (typeof type === "function") {
328 return type.displayName || type.name || null;
329 }
330 if (typeof type === "string") {
331 return type;
332 }
333 switch (type) {
334 case REACT_FRAGMENT_TYPE:
335 return "Fragment";
336 case REACT_PORTAL_TYPE:
337 return "Portal";
338 case REACT_PROFILER_TYPE:
339 return "Profiler";
340 case REACT_STRICT_MODE_TYPE:
341 return "StrictMode";
342 case REACT_SUSPENSE_TYPE:
343 return "Suspense";
344 case REACT_SUSPENSE_LIST_TYPE:
345 return "SuspenseList";
346 }
347 if (typeof type === "object") {
348 switch (type.$$typeof) {
349 case REACT_CONTEXT_TYPE:
350 var context = type;
351 return getContextName(context) + ".Consumer";
352 case REACT_PROVIDER_TYPE:
353 var provider = type;
354 return getContextName(provider._context) + ".Provider";
355 case REACT_FORWARD_REF_TYPE:
356 return getWrappedName(type, type.render, "ForwardRef");
357 case REACT_MEMO_TYPE:
358 var outerName = type.displayName || null;
359 if (outerName !== null) {
360 return outerName;
361 }
362 return getComponentNameFromType(type.type) || "Memo";
363 case REACT_LAZY_TYPE: {
364 var lazyComponent = type;
365 var payload = lazyComponent._payload;
366 var init = lazyComponent._init;
367 try {
368 return getComponentNameFromType(init(payload));
369 } catch (x) {
370 return null;
371 }
372 }
373 }
374 }
375 return null;
376 }
377 var hasOwnProperty = Object.prototype.hasOwnProperty;
378 var RESERVED_PROPS = {
379 key: true,
380 ref: true,
381 __self: true,
382 __source: true
383 };
384 var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;
385 {
386 didWarnAboutStringRefs = {};
387 }
388 function hasValidRef(config) {
389 {
390 if (hasOwnProperty.call(config, "ref")) {
391 var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
392 if (getter && getter.isReactWarning) {
393 return false;
394 }
395 }
396 }
397 return config.ref !== void 0;
398 }
399 function hasValidKey(config) {
400 {
401 if (hasOwnProperty.call(config, "key")) {
402 var getter = Object.getOwnPropertyDescriptor(config, "key").get;
403 if (getter && getter.isReactWarning) {
404 return false;
405 }
406 }
407 }
408 return config.key !== void 0;
409 }
410 function defineKeyPropWarningGetter(props, displayName) {
411 var warnAboutAccessingKey = function() {
412 {
413 if (!specialPropKeyWarningShown) {
414 specialPropKeyWarningShown = true;
415 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);
416 }
417 }
418 };
419 warnAboutAccessingKey.isReactWarning = true;
420 Object.defineProperty(props, "key", {
421 get: warnAboutAccessingKey,
422 configurable: true
423 });
424 }
425 function defineRefPropWarningGetter(props, displayName) {
426 var warnAboutAccessingRef = function() {
427 {
428 if (!specialPropRefWarningShown) {
429 specialPropRefWarningShown = true;
430 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);
431 }
432 }
433 };
434 warnAboutAccessingRef.isReactWarning = true;
435 Object.defineProperty(props, "ref", {
436 get: warnAboutAccessingRef,
437 configurable: true
438 });
439 }
440 function warnIfStringRefCannotBeAutoConverted(config) {
441 {
442 if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
443 var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
444 if (!didWarnAboutStringRefs[componentName]) {
445 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', componentName, config.ref);
446 didWarnAboutStringRefs[componentName] = true;
447 }
448 }
449 }
450 }
451 var ReactElement = function(type, key, ref, self, source, owner, props) {
452 var element = {
453 // This tag allows us to uniquely identify this as a React Element
454 $$typeof: REACT_ELEMENT_TYPE,
455 // Built-in properties that belong on the element
456 type,
457 key,
458 ref,
459 props,
460 // Record the component responsible for creating this element.
461 _owner: owner
462 };
463 {
464 element._store = {};
465 Object.defineProperty(element._store, "validated", {
466 configurable: false,
467 enumerable: false,
468 writable: true,
469 value: false
470 });
471 Object.defineProperty(element, "_self", {
472 configurable: false,
473 enumerable: false,
474 writable: false,
475 value: self
476 });
477 Object.defineProperty(element, "_source", {
478 configurable: false,
479 enumerable: false,
480 writable: false,
481 value: source
482 });
483 if (Object.freeze) {
484 Object.freeze(element.props);
485 Object.freeze(element);
486 }
487 }
488 return element;
489 };
490 function createElement(type, config, children) {
491 var propName;
492 var props = {};
493 var key = null;
494 var ref = null;
495 var self = null;
496 var source = null;
497 if (config != null) {
498 if (hasValidRef(config)) {
499 ref = config.ref;
500 {
501 warnIfStringRefCannotBeAutoConverted(config);
502 }
503 }
504 if (hasValidKey(config)) {
505 {
506 checkKeyStringCoercion(config.key);
507 }
508 key = "" + config.key;
509 }
510 self = config.__self === void 0 ? null : config.__self;
511 source = config.__source === void 0 ? null : config.__source;
512 for (propName in config) {
513 if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
514 props[propName] = config[propName];
515 }
516 }
517 }
518 var childrenLength = arguments.length - 2;
519 if (childrenLength === 1) {
520 props.children = children;
521 } else if (childrenLength > 1) {
522 var childArray = Array(childrenLength);
523 for (var i = 0; i < childrenLength; i++) {
524 childArray[i] = arguments[i + 2];
525 }
526 {
527 if (Object.freeze) {
528 Object.freeze(childArray);
529 }
530 }
531 props.children = childArray;
532 }
533 if (type && type.defaultProps) {
534 var defaultProps = type.defaultProps;
535 for (propName in defaultProps) {
536 if (props[propName] === void 0) {
537 props[propName] = defaultProps[propName];
538 }
539 }
540 }
541 {
542 if (key || ref) {
543 var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
544 if (key) {
545 defineKeyPropWarningGetter(props, displayName);
546 }
547 if (ref) {
548 defineRefPropWarningGetter(props, displayName);
549 }
550 }
551 }
552 return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
553 }
554 function cloneAndReplaceKey(oldElement, newKey) {
555 var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
556 return newElement;
557 }
558 function cloneElement(element, config, children) {
559 if (element === null || element === void 0) {
560 throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
561 }
562 var propName;
563 var props = assign({}, element.props);
564 var key = element.key;
565 var ref = element.ref;
566 var self = element._self;
567 var source = element._source;
568 var owner = element._owner;
569 if (config != null) {
570 if (hasValidRef(config)) {
571 ref = config.ref;
572 owner = ReactCurrentOwner.current;
573 }
574 if (hasValidKey(config)) {
575 {
576 checkKeyStringCoercion(config.key);
577 }
578 key = "" + config.key;
579 }
580 var defaultProps;
581 if (element.type && element.type.defaultProps) {
582 defaultProps = element.type.defaultProps;
583 }
584 for (propName in config) {
585 if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
586 if (config[propName] === void 0 && defaultProps !== void 0) {
587 props[propName] = defaultProps[propName];
588 } else {
589 props[propName] = config[propName];
590 }
591 }
592 }
593 }
594 var childrenLength = arguments.length - 2;
595 if (childrenLength === 1) {
596 props.children = children;
597 } else if (childrenLength > 1) {
598 var childArray = Array(childrenLength);
599 for (var i = 0; i < childrenLength; i++) {
600 childArray[i] = arguments[i + 2];
601 }
602 props.children = childArray;
603 }
604 return ReactElement(element.type, key, ref, self, source, owner, props);
605 }
606 function isValidElement(object) {
607 return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
608 }
609 var SEPARATOR = ".";
610 var SUBSEPARATOR = ":";
611 function escape(key) {
612 var escapeRegex = /[=:]/g;
613 var escaperLookup = {
614 "=": "=0",
615 ":": "=2"
616 };
617 var escapedString = key.replace(escapeRegex, function(match) {
618 return escaperLookup[match];
619 });
620 return "$" + escapedString;
621 }
622 var didWarnAboutMaps = false;
623 var userProvidedKeyEscapeRegex = /\/+/g;
624 function escapeUserProvidedKey(text) {
625 return text.replace(userProvidedKeyEscapeRegex, "$&/");
626 }
627 function getElementKey(element, index) {
628 if (typeof element === "object" && element !== null && element.key != null) {
629 {
630 checkKeyStringCoercion(element.key);
631 }
632 return escape("" + element.key);
633 }
634 return index.toString(36);
635 }
636 function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
637 var type = typeof children;
638 if (type === "undefined" || type === "boolean") {
639 children = null;
640 }
641 var invokeCallback = false;
642 if (children === null) {
643 invokeCallback = true;
644 } else {
645 switch (type) {
646 case "string":
647 case "number":
648 invokeCallback = true;
649 break;
650 case "object":
651 switch (children.$$typeof) {
652 case REACT_ELEMENT_TYPE:
653 case REACT_PORTAL_TYPE:
654 invokeCallback = true;
655 }
656 }
657 }
658 if (invokeCallback) {
659 var _child = children;
660 var mappedChild = callback(_child);
661 var childKey = nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
662 if (isArray(mappedChild)) {
663 var escapedChildKey = "";
664 if (childKey != null) {
665 escapedChildKey = escapeUserProvidedKey(childKey) + "/";
666 }
667 mapIntoArray(mappedChild, array, escapedChildKey, "", function(c) {
668 return c;
669 });
670 } else if (mappedChild != null) {
671 if (isValidElement(mappedChild)) {
672 {
673 if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) {
674 checkKeyStringCoercion(mappedChild.key);
675 }
676 }
677 mappedChild = cloneAndReplaceKey(
678 mappedChild,
679 // Keep both the (mapped) and old keys if they differ, just as
680 // traverseAllChildren used to do for objects as children
681 escapedPrefix + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
682 (mappedChild.key && (!_child || _child.key !== mappedChild.key) ? (
683 // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
684 // eslint-disable-next-line react-internal/safe-string-coercion
685 escapeUserProvidedKey("" + mappedChild.key) + "/"
686 ) : "") + childKey
687 );
688 }
689 array.push(mappedChild);
690 }
691 return 1;
692 }
693 var child;
694 var nextName;
695 var subtreeCount = 0;
696 var nextNamePrefix = nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR;
697 if (isArray(children)) {
698 for (var i = 0; i < children.length; i++) {
699 child = children[i];
700 nextName = nextNamePrefix + getElementKey(child, i);
701 subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
702 }
703 } else {
704 var iteratorFn = getIteratorFn(children);
705 if (typeof iteratorFn === "function") {
706 var iterableChildren = children;
707 {
708 if (iteratorFn === iterableChildren.entries) {
709 if (!didWarnAboutMaps) {
710 warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead.");
711 }
712 didWarnAboutMaps = true;
713 }
714 }
715 var iterator = iteratorFn.call(iterableChildren);
716 var step;
717 var ii = 0;
718 while (!(step = iterator.next()).done) {
719 child = step.value;
720 nextName = nextNamePrefix + getElementKey(child, ii++);
721 subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
722 }
723 } else if (type === "object") {
724 var childrenString = String(children);
725 throw new Error("Objects are not valid as a React child (found: " + (childrenString === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString) + "). If you meant to render a collection of children, use an array instead.");
726 }
727 }
728 return subtreeCount;
729 }
730 function mapChildren(children, func, context) {
731 if (children == null) {
732 return children;
733 }
734 var result = [];
735 var count = 0;
736 mapIntoArray(children, result, "", "", function(child) {
737 return func.call(context, child, count++);
738 });
739 return result;
740 }
741 function countChildren(children) {
742 var n = 0;
743 mapChildren(children, function() {
744 n++;
745 });
746 return n;
747 }
748 function forEachChildren(children, forEachFunc, forEachContext) {
749 mapChildren(children, function() {
750 forEachFunc.apply(this, arguments);
751 }, forEachContext);
752 }
753 function toArray(children) {
754 return mapChildren(children, function(child) {
755 return child;
756 }) || [];
757 }
758 function onlyChild(children) {
759 if (!isValidElement(children)) {
760 throw new Error("React.Children.only expected to receive a single React element child.");
761 }
762 return children;
763 }
764 function createContext(defaultValue) {
765 var context = {
766 $$typeof: REACT_CONTEXT_TYPE,
767 // As a workaround to support multiple concurrent renderers, we categorize
768 // some renderers as primary and others as secondary. We only expect
769 // there to be two concurrent renderers at most: React Native (primary) and
770 // Fabric (secondary); React DOM (primary) and React ART (secondary).
771 // Secondary renderers store their context values on separate fields.
772 _currentValue: defaultValue,
773 _currentValue2: defaultValue,
774 // Used to track how many concurrent renderers this context currently
775 // supports within in a single renderer. Such as parallel server rendering.
776 _threadCount: 0,
777 // These are circular
778 Provider: null,
779 Consumer: null,
780 // Add these to use same hidden class in VM as ServerContext
781 _defaultValue: null,
782 _globalName: null
783 };
784 context.Provider = {
785 $$typeof: REACT_PROVIDER_TYPE,
786 _context: context
787 };
788 var hasWarnedAboutUsingNestedContextConsumers = false;
789 var hasWarnedAboutUsingConsumerProvider = false;
790 var hasWarnedAboutDisplayNameOnConsumer = false;
791 {
792 var Consumer = {
793 $$typeof: REACT_CONTEXT_TYPE,
794 _context: context
795 };
796 Object.defineProperties(Consumer, {
797 Provider: {
798 get: function() {
799 if (!hasWarnedAboutUsingConsumerProvider) {
800 hasWarnedAboutUsingConsumerProvider = true;
801 error("Rendering <Context.Consumer.Provider> is not supported and will be removed in a future major release. Did you mean to render <Context.Provider> instead?");
802 }
803 return context.Provider;
804 },
805 set: function(_Provider) {
806 context.Provider = _Provider;
807 }
808 },
809 _currentValue: {
810 get: function() {
811 return context._currentValue;
812 },
813 set: function(_currentValue) {
814 context._currentValue = _currentValue;
815 }
816 },
817 _currentValue2: {
818 get: function() {
819 return context._currentValue2;
820 },
821 set: function(_currentValue2) {
822 context._currentValue2 = _currentValue2;
823 }
824 },
825 _threadCount: {
826 get: function() {
827 return context._threadCount;
828 },
829 set: function(_threadCount) {
830 context._threadCount = _threadCount;
831 }
832 },
833 Consumer: {
834 get: function() {
835 if (!hasWarnedAboutUsingNestedContextConsumers) {
836 hasWarnedAboutUsingNestedContextConsumers = true;
837 error("Rendering <Context.Consumer.Consumer> is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?");
838 }
839 return context.Consumer;
840 }
841 },
842 displayName: {
843 get: function() {
844 return context.displayName;
845 },
846 set: function(displayName) {
847 if (!hasWarnedAboutDisplayNameOnConsumer) {
848 warn("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", displayName);
849 hasWarnedAboutDisplayNameOnConsumer = true;
850 }
851 }
852 }
853 });
854 context.Consumer = Consumer;
855 }
856 {
857 context._currentRenderer = null;
858 context._currentRenderer2 = null;
859 }
860 return context;
861 }
862 var Uninitialized = -1;
863 var Pending = 0;
864 var Resolved = 1;
865 var Rejected = 2;
866 function lazyInitializer(payload) {
867 if (payload._status === Uninitialized) {
868 var ctor = payload._result;
869 var thenable = ctor();
870 thenable.then(function(moduleObject2) {
871 if (payload._status === Pending || payload._status === Uninitialized) {
872 var resolved = payload;
873 resolved._status = Resolved;
874 resolved._result = moduleObject2;
875 }
876 }, function(error2) {
877 if (payload._status === Pending || payload._status === Uninitialized) {
878 var rejected = payload;
879 rejected._status = Rejected;
880 rejected._result = error2;
881 }
882 });
883 if (payload._status === Uninitialized) {
884 var pending = payload;
885 pending._status = Pending;
886 pending._result = thenable;
887 }
888 }
889 if (payload._status === Resolved) {
890 var moduleObject = payload._result;
891 {
892 if (moduleObject === void 0) {
893 error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?", moduleObject);
894 }
895 }
896 {
897 if (!("default" in moduleObject)) {
898 error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
899 }
900 }
901 return moduleObject.default;
902 } else {
903 throw payload._result;
904 }
905 }
906 function lazy(ctor) {
907 var payload = {
908 // We use these fields to store the result.
909 _status: Uninitialized,
910 _result: ctor
911 };
912 var lazyType = {
913 $$typeof: REACT_LAZY_TYPE,
914 _payload: payload,
915 _init: lazyInitializer
916 };
917 {
918 var defaultProps;
919 var propTypes;
920 Object.defineProperties(lazyType, {
921 defaultProps: {
922 configurable: true,
923 get: function() {
924 return defaultProps;
925 },
926 set: function(newDefaultProps) {
927 error("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it.");
928 defaultProps = newDefaultProps;
929 Object.defineProperty(lazyType, "defaultProps", {
930 enumerable: true
931 });
932 }
933 },
934 propTypes: {
935 configurable: true,
936 get: function() {
937 return propTypes;
938 },
939 set: function(newPropTypes) {
940 error("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it.");
941 propTypes = newPropTypes;
942 Object.defineProperty(lazyType, "propTypes", {
943 enumerable: true
944 });
945 }
946 }
947 });
948 }
949 return lazyType;
950 }
951 function forwardRef(render) {
952 {
953 if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
954 error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).");
955 } else if (typeof render !== "function") {
956 error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render);
957 } else {
958 if (render.length !== 0 && render.length !== 2) {
959 error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
960 }
961 }
962 if (render != null) {
963 if (render.defaultProps != null || render.propTypes != null) {
964 error("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?");
965 }
966 }
967 }
968 var elementType = {
969 $$typeof: REACT_FORWARD_REF_TYPE,
970 render
971 };
972 {
973 var ownName;
974 Object.defineProperty(elementType, "displayName", {
975 enumerable: false,
976 configurable: true,
977 get: function() {
978 return ownName;
979 },
980 set: function(name) {
981 ownName = name;
982 if (!render.name && !render.displayName) {
983 render.displayName = name;
984 }
985 }
986 });
987 }
988 return elementType;
989 }
990 var REACT_MODULE_REFERENCE;
991 {
992 REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
993 }
994 function isValidElementType(type) {
995 if (typeof type === "string" || typeof type === "function") {
996 return true;
997 }
998 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) {
999 return true;
1000 }
1001 if (typeof type === "object" && type !== null) {
1002 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
1003 // types supported by any Flight configuration anywhere since
1004 // we don't know which Flight build this will end up being used
1005 // with.
1006 type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
1007 return true;
1008 }
1009 }
1010 return false;
1011 }
1012 function memo(type, compare) {
1013 {
1014 if (!isValidElementType(type)) {
1015 error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
1016 }
1017 }
1018 var elementType = {
1019 $$typeof: REACT_MEMO_TYPE,
1020 type,
1021 compare: compare === void 0 ? null : compare
1022 };
1023 {
1024 var ownName;
1025 Object.defineProperty(elementType, "displayName", {
1026 enumerable: false,
1027 configurable: true,
1028 get: function() {
1029 return ownName;
1030 },
1031 set: function(name) {
1032 ownName = name;
1033 if (!type.name && !type.displayName) {
1034 type.displayName = name;
1035 }
1036 }
1037 });
1038 }
1039 return elementType;
1040 }
1041 function resolveDispatcher() {
1042 var dispatcher = ReactCurrentDispatcher.current;
1043 {
1044 if (dispatcher === null) {
1045 error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");
1046 }
1047 }
1048 return dispatcher;
1049 }
1050 function useContext(Context) {
1051 var dispatcher = resolveDispatcher();
1052 {
1053 if (Context._context !== void 0) {
1054 var realContext = Context._context;
1055 if (realContext.Consumer === Context) {
1056 error("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?");
1057 } else if (realContext.Provider === Context) {
1058 error("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?");
1059 }
1060 }
1061 }
1062 return dispatcher.useContext(Context);
1063 }
1064 function useState(initialState) {
1065 var dispatcher = resolveDispatcher();
1066 return dispatcher.useState(initialState);
1067 }
1068 function useReducer(reducer, initialArg, init) {
1069 var dispatcher = resolveDispatcher();
1070 return dispatcher.useReducer(reducer, initialArg, init);
1071 }
1072 function useRef(initialValue) {
1073 var dispatcher = resolveDispatcher();
1074 return dispatcher.useRef(initialValue);
1075 }
1076 function useEffect(create, deps) {
1077 var dispatcher = resolveDispatcher();
1078 return dispatcher.useEffect(create, deps);
1079 }
1080 function useInsertionEffect(create, deps) {
1081 var dispatcher = resolveDispatcher();
1082 return dispatcher.useInsertionEffect(create, deps);
1083 }
1084 function useLayoutEffect(create, deps) {
1085 var dispatcher = resolveDispatcher();
1086 return dispatcher.useLayoutEffect(create, deps);
1087 }
1088 function useCallback(callback, deps) {
1089 var dispatcher = resolveDispatcher();
1090 return dispatcher.useCallback(callback, deps);
1091 }
1092 function useMemo(create, deps) {
1093 var dispatcher = resolveDispatcher();
1094 return dispatcher.useMemo(create, deps);
1095 }
1096 function useImperativeHandle(ref, create, deps) {
1097 var dispatcher = resolveDispatcher();
1098 return dispatcher.useImperativeHandle(ref, create, deps);
1099 }
1100 function useDebugValue(value, formatterFn) {
1101 {
1102 var dispatcher = resolveDispatcher();
1103 return dispatcher.useDebugValue(value, formatterFn);
1104 }
1105 }
1106 function useTransition() {
1107 var dispatcher = resolveDispatcher();
1108 return dispatcher.useTransition();
1109 }
1110 function useDeferredValue(value) {
1111 var dispatcher = resolveDispatcher();
1112 return dispatcher.useDeferredValue(value);
1113 }
1114 function useId() {
1115 var dispatcher = resolveDispatcher();
1116 return dispatcher.useId();
1117 }
1118 function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
1119 var dispatcher = resolveDispatcher();
1120 return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
1121 }
1122 var disabledDepth = 0;
1123 var prevLog;
1124 var prevInfo;
1125 var prevWarn;
1126 var prevError;
1127 var prevGroup;
1128 var prevGroupCollapsed;
1129 var prevGroupEnd;
1130 function disabledLog() {
1131 }
1132 disabledLog.__reactDisabledLog = true;
1133 function disableLogs() {
1134 {
1135 if (disabledDepth === 0) {
1136 prevLog = console.log;
1137 prevInfo = console.info;
1138 prevWarn = console.warn;
1139 prevError = console.error;
1140 prevGroup = console.group;
1141 prevGroupCollapsed = console.groupCollapsed;
1142 prevGroupEnd = console.groupEnd;
1143 var props = {
1144 configurable: true,
1145 enumerable: true,
1146 value: disabledLog,
1147 writable: true
1148 };
1149 Object.defineProperties(console, {
1150 info: props,
1151 log: props,
1152 warn: props,
1153 error: props,
1154 group: props,
1155 groupCollapsed: props,
1156 groupEnd: props
1157 });
1158 }
1159 disabledDepth++;
1160 }
1161 }
1162 function reenableLogs() {
1163 {
1164 disabledDepth--;
1165 if (disabledDepth === 0) {
1166 var props = {
1167 configurable: true,
1168 enumerable: true,
1169 writable: true
1170 };
1171 Object.defineProperties(console, {
1172 log: assign({}, props, {
1173 value: prevLog
1174 }),
1175 info: assign({}, props, {
1176 value: prevInfo
1177 }),
1178 warn: assign({}, props, {
1179 value: prevWarn
1180 }),
1181 error: assign({}, props, {
1182 value: prevError
1183 }),
1184 group: assign({}, props, {
1185 value: prevGroup
1186 }),
1187 groupCollapsed: assign({}, props, {
1188 value: prevGroupCollapsed
1189 }),
1190 groupEnd: assign({}, props, {
1191 value: prevGroupEnd
1192 })
1193 });
1194 }
1195 if (disabledDepth < 0) {
1196 error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
1197 }
1198 }
1199 }
1200 var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
1201 var prefix;
1202 function describeBuiltInComponentFrame(name, source, ownerFn) {
1203 {
1204 if (prefix === void 0) {
1205 try {
1206 throw Error();
1207 } catch (x) {
1208 var match = x.stack.trim().match(/\n( *(at )?)/);
1209 prefix = match && match[1] || "";
1210 }
1211 }
1212 return "\n" + prefix + name;
1213 }
1214 }
1215 var reentry = false;
1216 var componentFrameCache;
1217 {
1218 var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
1219 componentFrameCache = new PossiblyWeakMap();
1220 }
1221 function describeNativeComponentFrame(fn, construct) {
1222 if (!fn || reentry) {
1223 return "";
1224 }
1225 {
1226 var frame = componentFrameCache.get(fn);
1227 if (frame !== void 0) {
1228 return frame;
1229 }
1230 }
1231 var control;
1232 reentry = true;
1233 var previousPrepareStackTrace = Error.prepareStackTrace;
1234 Error.prepareStackTrace = void 0;
1235 var previousDispatcher;
1236 {
1237 previousDispatcher = ReactCurrentDispatcher$1.current;
1238 ReactCurrentDispatcher$1.current = null;
1239 disableLogs();
1240 }
1241 try {
1242 if (construct) {
1243 var Fake = function() {
1244 throw Error();
1245 };
1246 Object.defineProperty(Fake.prototype, "props", {
1247 set: function() {
1248 throw Error();
1249 }
1250 });
1251 if (typeof Reflect === "object" && Reflect.construct) {
1252 try {
1253 Reflect.construct(Fake, []);
1254 } catch (x) {
1255 control = x;
1256 }
1257 Reflect.construct(fn, [], Fake);
1258 } else {
1259 try {
1260 Fake.call();
1261 } catch (x) {
1262 control = x;
1263 }
1264 fn.call(Fake.prototype);
1265 }
1266 } else {
1267 try {
1268 throw Error();
1269 } catch (x) {
1270 control = x;
1271 }
1272 fn();
1273 }
1274 } catch (sample) {
1275 if (sample && control && typeof sample.stack === "string") {
1276 var sampleLines = sample.stack.split("\n");
1277 var controlLines = control.stack.split("\n");
1278 var s = sampleLines.length - 1;
1279 var c = controlLines.length - 1;
1280 while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
1281 c--;
1282 }
1283 for (; s >= 1 && c >= 0; s--, c--) {
1284 if (sampleLines[s] !== controlLines[c]) {
1285 if (s !== 1 || c !== 1) {
1286 do {
1287 s--;
1288 c--;
1289 if (c < 0 || sampleLines[s] !== controlLines[c]) {
1290 var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
1291 if (fn.displayName && _frame.includes("<anonymous>")) {
1292 _frame = _frame.replace("<anonymous>", fn.displayName);
1293 }
1294 {
1295 if (typeof fn === "function") {
1296 componentFrameCache.set(fn, _frame);
1297 }
1298 }
1299 return _frame;
1300 }
1301 } while (s >= 1 && c >= 0);
1302 }
1303 break;
1304 }
1305 }
1306 }
1307 } finally {
1308 reentry = false;
1309 {
1310 ReactCurrentDispatcher$1.current = previousDispatcher;
1311 reenableLogs();
1312 }
1313 Error.prepareStackTrace = previousPrepareStackTrace;
1314 }
1315 var name = fn ? fn.displayName || fn.name : "";
1316 var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
1317 {
1318 if (typeof fn === "function") {
1319 componentFrameCache.set(fn, syntheticFrame);
1320 }
1321 }
1322 return syntheticFrame;
1323 }
1324 function describeFunctionComponentFrame(fn, source, ownerFn) {
1325 {
1326 return describeNativeComponentFrame(fn, false);
1327 }
1328 }
1329 function shouldConstruct(Component2) {
1330 var prototype = Component2.prototype;
1331 return !!(prototype && prototype.isReactComponent);
1332 }
1333 function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
1334 if (type == null) {
1335 return "";
1336 }
1337 if (typeof type === "function") {
1338 {
1339 return describeNativeComponentFrame(type, shouldConstruct(type));
1340 }
1341 }
1342 if (typeof type === "string") {
1343 return describeBuiltInComponentFrame(type);
1344 }
1345 switch (type) {
1346 case REACT_SUSPENSE_TYPE:
1347 return describeBuiltInComponentFrame("Suspense");
1348 case REACT_SUSPENSE_LIST_TYPE:
1349 return describeBuiltInComponentFrame("SuspenseList");
1350 }
1351 if (typeof type === "object") {
1352 switch (type.$$typeof) {
1353 case REACT_FORWARD_REF_TYPE:
1354 return describeFunctionComponentFrame(type.render);
1355 case REACT_MEMO_TYPE:
1356 return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
1357 case REACT_LAZY_TYPE: {
1358 var lazyComponent = type;
1359 var payload = lazyComponent._payload;
1360 var init = lazyComponent._init;
1361 try {
1362 return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
1363 } catch (x) {
1364 }
1365 }
1366 }
1367 }
1368 return "";
1369 }
1370 var loggedTypeFailures = {};
1371 var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
1372 function setCurrentlyValidatingElement(element) {
1373 {
1374 if (element) {
1375 var owner = element._owner;
1376 var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
1377 ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
1378 } else {
1379 ReactDebugCurrentFrame$1.setExtraStackFrame(null);
1380 }
1381 }
1382 }
1383 function checkPropTypes(typeSpecs, values, location, componentName, element) {
1384 {
1385 var has = Function.call.bind(hasOwnProperty);
1386 for (var typeSpecName in typeSpecs) {
1387 if (has(typeSpecs, typeSpecName)) {
1388 var error$1 = void 0;
1389 try {
1390 if (typeof typeSpecs[typeSpecName] !== "function") {
1391 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`.");
1392 err.name = "Invariant Violation";
1393 throw err;
1394 }
1395 error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
1396 } catch (ex) {
1397 error$1 = ex;
1398 }
1399 if (error$1 && !(error$1 instanceof Error)) {
1400 setCurrentlyValidatingElement(element);
1401 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);
1402 setCurrentlyValidatingElement(null);
1403 }
1404 if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
1405 loggedTypeFailures[error$1.message] = true;
1406 setCurrentlyValidatingElement(element);
1407 error("Failed %s type: %s", location, error$1.message);
1408 setCurrentlyValidatingElement(null);
1409 }
1410 }
1411 }
1412 }
1413 }
1414 function setCurrentlyValidatingElement$1(element) {
1415 {
1416 if (element) {
1417 var owner = element._owner;
1418 var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
1419 setExtraStackFrame(stack);
1420 } else {
1421 setExtraStackFrame(null);
1422 }
1423 }
1424 }
1425 var propTypesMisspellWarningShown;
1426 {
1427 propTypesMisspellWarningShown = false;
1428 }
1429 function getDeclarationErrorAddendum() {
1430 if (ReactCurrentOwner.current) {
1431 var name = getComponentNameFromType(ReactCurrentOwner.current.type);
1432 if (name) {
1433 return "\n\nCheck the render method of `" + name + "`.";
1434 }
1435 }
1436 return "";
1437 }
1438 function getSourceInfoErrorAddendum(source) {
1439 if (source !== void 0) {
1440 var fileName = source.fileName.replace(/^.*[\\\/]/, "");
1441 var lineNumber = source.lineNumber;
1442 return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
1443 }
1444 return "";
1445 }
1446 function getSourceInfoErrorAddendumForProps(elementProps) {
1447 if (elementProps !== null && elementProps !== void 0) {
1448 return getSourceInfoErrorAddendum(elementProps.__source);
1449 }
1450 return "";
1451 }
1452 var ownerHasKeyUseWarning = {};
1453 function getCurrentComponentErrorInfo(parentType) {
1454 var info = getDeclarationErrorAddendum();
1455 if (!info) {
1456 var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
1457 if (parentName) {
1458 info = "\n\nCheck the top-level render call using <" + parentName + ">.";
1459 }
1460 }
1461 return info;
1462 }
1463 function validateExplicitKey(element, parentType) {
1464 if (!element._store || element._store.validated || element.key != null) {
1465 return;
1466 }
1467 element._store.validated = true;
1468 var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
1469 if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
1470 return;
1471 }
1472 ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
1473 var childOwner = "";
1474 if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
1475 childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
1476 }
1477 {
1478 setCurrentlyValidatingElement$1(element);
1479 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);
1480 setCurrentlyValidatingElement$1(null);
1481 }
1482 }
1483 function validateChildKeys(node, parentType) {
1484 if (typeof node !== "object") {
1485 return;
1486 }
1487 if (isArray(node)) {
1488 for (var i = 0; i < node.length; i++) {
1489 var child = node[i];
1490 if (isValidElement(child)) {
1491 validateExplicitKey(child, parentType);
1492 }
1493 }
1494 } else if (isValidElement(node)) {
1495 if (node._store) {
1496 node._store.validated = true;
1497 }
1498 } else if (node) {
1499 var iteratorFn = getIteratorFn(node);
1500 if (typeof iteratorFn === "function") {
1501 if (iteratorFn !== node.entries) {
1502 var iterator = iteratorFn.call(node);
1503 var step;
1504 while (!(step = iterator.next()).done) {
1505 if (isValidElement(step.value)) {
1506 validateExplicitKey(step.value, parentType);
1507 }
1508 }
1509 }
1510 }
1511 }
1512 }
1513 function validatePropTypes(element) {
1514 {
1515 var type = element.type;
1516 if (type === null || type === void 0 || typeof type === "string") {
1517 return;
1518 }
1519 var propTypes;
1520 if (typeof type === "function") {
1521 propTypes = type.propTypes;
1522 } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
1523 // Inner props are checked in the reconciler.
1524 type.$$typeof === REACT_MEMO_TYPE)) {
1525 propTypes = type.propTypes;
1526 } else {
1527 return;
1528 }
1529 if (propTypes) {
1530 var name = getComponentNameFromType(type);
1531 checkPropTypes(propTypes, element.props, "prop", name, element);
1532 } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
1533 propTypesMisspellWarningShown = true;
1534 var _name = getComponentNameFromType(type);
1535 error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
1536 }
1537 if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
1538 error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
1539 }
1540 }
1541 }
1542 function validateFragmentProps(fragment) {
1543 {
1544 var keys = Object.keys(fragment.props);
1545 for (var i = 0; i < keys.length; i++) {
1546 var key = keys[i];
1547 if (key !== "children" && key !== "key") {
1548 setCurrentlyValidatingElement$1(fragment);
1549 error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
1550 setCurrentlyValidatingElement$1(null);
1551 break;
1552 }
1553 }
1554 if (fragment.ref !== null) {
1555 setCurrentlyValidatingElement$1(fragment);
1556 error("Invalid attribute `ref` supplied to `React.Fragment`.");
1557 setCurrentlyValidatingElement$1(null);
1558 }
1559 }
1560 }
1561 function createElementWithValidation(type, props, children) {
1562 var validType = isValidElementType(type);
1563 if (!validType) {
1564 var info = "";
1565 if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
1566 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.";
1567 }
1568 var sourceInfo = getSourceInfoErrorAddendumForProps(props);
1569 if (sourceInfo) {
1570 info += sourceInfo;
1571 } else {
1572 info += getDeclarationErrorAddendum();
1573 }
1574 var typeString;
1575 if (type === null) {
1576 typeString = "null";
1577 } else if (isArray(type)) {
1578 typeString = "array";
1579 } else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
1580 typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />";
1581 info = " Did you accidentally export a JSX literal instead of a component?";
1582 } else {
1583 typeString = typeof type;
1584 }
1585 {
1586 error("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
1587 }
1588 }
1589 var element = createElement.apply(this, arguments);
1590 if (element == null) {
1591 return element;
1592 }
1593 if (validType) {
1594 for (var i = 2; i < arguments.length; i++) {
1595 validateChildKeys(arguments[i], type);
1596 }
1597 }
1598 if (type === REACT_FRAGMENT_TYPE) {
1599 validateFragmentProps(element);
1600 } else {
1601 validatePropTypes(element);
1602 }
1603 return element;
1604 }
1605 var didWarnAboutDeprecatedCreateFactory = false;
1606 function createFactoryWithValidation(type) {
1607 var validatedFactory = createElementWithValidation.bind(null, type);
1608 validatedFactory.type = type;
1609 {
1610 if (!didWarnAboutDeprecatedCreateFactory) {
1611 didWarnAboutDeprecatedCreateFactory = true;
1612 warn("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.");
1613 }
1614 Object.defineProperty(validatedFactory, "type", {
1615 enumerable: false,
1616 get: function() {
1617 warn("Factory.type is deprecated. Access the class directly before passing it to createFactory.");
1618 Object.defineProperty(this, "type", {
1619 value: type
1620 });
1621 return type;
1622 }
1623 });
1624 }
1625 return validatedFactory;
1626 }
1627 function cloneElementWithValidation(element, props, children) {
1628 var newElement = cloneElement.apply(this, arguments);
1629 for (var i = 2; i < arguments.length; i++) {
1630 validateChildKeys(arguments[i], newElement.type);
1631 }
1632 validatePropTypes(newElement);
1633 return newElement;
1634 }
1635 function startTransition(scope, options) {
1636 var prevTransition = ReactCurrentBatchConfig.transition;
1637 ReactCurrentBatchConfig.transition = {};
1638 var currentTransition = ReactCurrentBatchConfig.transition;
1639 {
1640 ReactCurrentBatchConfig.transition._updatedFibers = /* @__PURE__ */ new Set();
1641 }
1642 try {
1643 scope();
1644 } finally {
1645 ReactCurrentBatchConfig.transition = prevTransition;
1646 {
1647 if (prevTransition === null && currentTransition._updatedFibers) {
1648 var updatedFibersCount = currentTransition._updatedFibers.size;
1649 if (updatedFibersCount > 10) {
1650 warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.");
1651 }
1652 currentTransition._updatedFibers.clear();
1653 }
1654 }
1655 }
1656 }
1657 var didWarnAboutMessageChannel = false;
1658 var enqueueTaskImpl = null;
1659 function enqueueTask(task) {
1660 if (enqueueTaskImpl === null) {
1661 try {
1662 var requireString = ("require" + Math.random()).slice(0, 7);
1663 var nodeRequire = module && module[requireString];
1664 enqueueTaskImpl = nodeRequire.call(module, "timers").setImmediate;
1665 } catch (_err) {
1666 enqueueTaskImpl = function(callback) {
1667 {
1668 if (didWarnAboutMessageChannel === false) {
1669 didWarnAboutMessageChannel = true;
1670 if (typeof MessageChannel === "undefined") {
1671 error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning.");
1672 }
1673 }
1674 }
1675 var channel = new MessageChannel();
1676 channel.port1.onmessage = callback;
1677 channel.port2.postMessage(void 0);
1678 };
1679 }
1680 }
1681 return enqueueTaskImpl(task);
1682 }
1683 var actScopeDepth = 0;
1684 var didWarnNoAwaitAct = false;
1685 function act(callback) {
1686 {
1687 var prevActScopeDepth = actScopeDepth;
1688 actScopeDepth++;
1689 if (ReactCurrentActQueue.current === null) {
1690 ReactCurrentActQueue.current = [];
1691 }
1692 var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
1693 var result;
1694 try {
1695 ReactCurrentActQueue.isBatchingLegacy = true;
1696 result = callback();
1697 if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
1698 var queue = ReactCurrentActQueue.current;
1699 if (queue !== null) {
1700 ReactCurrentActQueue.didScheduleLegacyUpdate = false;
1701 flushActQueue(queue);
1702 }
1703 }
1704 } catch (error2) {
1705 popActScope(prevActScopeDepth);
1706 throw error2;
1707 } finally {
1708 ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
1709 }
1710 if (result !== null && typeof result === "object" && typeof result.then === "function") {
1711 var thenableResult = result;
1712 var wasAwaited = false;
1713 var thenable = {
1714 then: function(resolve, reject) {
1715 wasAwaited = true;
1716 thenableResult.then(function(returnValue2) {
1717 popActScope(prevActScopeDepth);
1718 if (actScopeDepth === 0) {
1719 recursivelyFlushAsyncActWork(returnValue2, resolve, reject);
1720 } else {
1721 resolve(returnValue2);
1722 }
1723 }, function(error2) {
1724 popActScope(prevActScopeDepth);
1725 reject(error2);
1726 });
1727 }
1728 };
1729 {
1730 if (!didWarnNoAwaitAct && typeof Promise !== "undefined") {
1731 Promise.resolve().then(function() {
1732 }).then(function() {
1733 if (!wasAwaited) {
1734 didWarnNoAwaitAct = true;
1735 error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);");
1736 }
1737 });
1738 }
1739 }
1740 return thenable;
1741 } else {
1742 var returnValue = result;
1743 popActScope(prevActScopeDepth);
1744 if (actScopeDepth === 0) {
1745 var _queue = ReactCurrentActQueue.current;
1746 if (_queue !== null) {
1747 flushActQueue(_queue);
1748 ReactCurrentActQueue.current = null;
1749 }
1750 var _thenable = {
1751 then: function(resolve, reject) {
1752 if (ReactCurrentActQueue.current === null) {
1753 ReactCurrentActQueue.current = [];
1754 recursivelyFlushAsyncActWork(returnValue, resolve, reject);
1755 } else {
1756 resolve(returnValue);
1757 }
1758 }
1759 };
1760 return _thenable;
1761 } else {
1762 var _thenable2 = {
1763 then: function(resolve, reject) {
1764 resolve(returnValue);
1765 }
1766 };
1767 return _thenable2;
1768 }
1769 }
1770 }
1771 }
1772 function popActScope(prevActScopeDepth) {
1773 {
1774 if (prevActScopeDepth !== actScopeDepth - 1) {
1775 error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
1776 }
1777 actScopeDepth = prevActScopeDepth;
1778 }
1779 }
1780 function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
1781 {
1782 var queue = ReactCurrentActQueue.current;
1783 if (queue !== null) {
1784 try {
1785 flushActQueue(queue);
1786 enqueueTask(function() {
1787 if (queue.length === 0) {
1788 ReactCurrentActQueue.current = null;
1789 resolve(returnValue);
1790 } else {
1791 recursivelyFlushAsyncActWork(returnValue, resolve, reject);
1792 }
1793 });
1794 } catch (error2) {
1795 reject(error2);
1796 }
1797 } else {
1798 resolve(returnValue);
1799 }
1800 }
1801 }
1802 var isFlushing = false;
1803 function flushActQueue(queue) {
1804 {
1805 if (!isFlushing) {
1806 isFlushing = true;
1807 var i = 0;
1808 try {
1809 for (; i < queue.length; i++) {
1810 var callback = queue[i];
1811 do {
1812 callback = callback(true);
1813 } while (callback !== null);
1814 }
1815 queue.length = 0;
1816 } catch (error2) {
1817 queue = queue.slice(i + 1);
1818 throw error2;
1819 } finally {
1820 isFlushing = false;
1821 }
1822 }
1823 }
1824 }
1825 var createElement$1 = createElementWithValidation;
1826 var cloneElement$1 = cloneElementWithValidation;
1827 var createFactory = createFactoryWithValidation;
1828 var Children = {
1829 map: mapChildren,
1830 forEach: forEachChildren,
1831 count: countChildren,
1832 toArray,
1833 only: onlyChild
1834 };
1835 exports.Children = Children;
1836 exports.Component = Component;
1837 exports.Fragment = REACT_FRAGMENT_TYPE;
1838 exports.Profiler = REACT_PROFILER_TYPE;
1839 exports.PureComponent = PureComponent;
1840 exports.StrictMode = REACT_STRICT_MODE_TYPE;
1841 exports.Suspense = REACT_SUSPENSE_TYPE;
1842 exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
1843 exports.act = act;
1844 exports.cloneElement = cloneElement$1;
1845 exports.createContext = createContext;
1846 exports.createElement = createElement$1;
1847 exports.createFactory = createFactory;
1848 exports.createRef = createRef;
1849 exports.forwardRef = forwardRef;
1850 exports.isValidElement = isValidElement;
1851 exports.lazy = lazy;
1852 exports.memo = memo;
1853 exports.startTransition = startTransition;
1854 exports.unstable_act = act;
1855 exports.useCallback = useCallback;
1856 exports.useContext = useContext;
1857 exports.useDebugValue = useDebugValue;
1858 exports.useDeferredValue = useDeferredValue;
1859 exports.useEffect = useEffect;
1860 exports.useId = useId;
1861 exports.useImperativeHandle = useImperativeHandle;
1862 exports.useInsertionEffect = useInsertionEffect;
1863 exports.useLayoutEffect = useLayoutEffect;
1864 exports.useMemo = useMemo;
1865 exports.useReducer = useReducer;
1866 exports.useRef = useRef;
1867 exports.useState = useState;
1868 exports.useSyncExternalStore = useSyncExternalStore;
1869 exports.useTransition = useTransition;
1870 exports.version = ReactVersion;
1871 if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
1872 __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
1873 }
1874 })();
1875 }
1876 }
1877});
1878
1879// node_modules/react/index.js
1880var require_react = __commonJS({
1881 "node_modules/react/index.js"(exports, module) {
1882 if (false) {
1883 module.exports = null;
1884 } else {
1885 module.exports = require_react_development();
1886 }
1887 }
1888});
1889
1890export {
1891 require_react
1892};
1893/*! Bundled license information:
1894
1895react/cjs/react.development.js:
1896 (**
1897 * @license React
1898 * react.development.js
1899 *
1900 * Copyright (c) Facebook, Inc. and its affiliates.
1901 *
1902 * This source code is licensed under the MIT license found in the
1903 * LICENSE file in the root directory of this source tree.
1904 *)
1905*/
1906//# sourceMappingURL=chunk-QJTFJ6OV.js.map
Note: See TracBrowser for help on using the repository browser.