https://pi-challenge.replit.app/@fs/home/runner/workspace/node_modules/.vite/deps/chunk-3TFVT2CW.js?v=267253d4

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-3TFVT2CW.js.map