https://learning-platform-v2.netlify.app/build/_shared/chunk-BNRLY3XL.js

31, temp), temp);
32  };
33})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
34

35// node_modules/object-assign/index.js
36var require_object_assign = __commonJS({
37  "node_modules/object-assign/index.js"(exports, module) {
38    "use strict";
39    init_react();
40    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
41    var hasOwnProperty = Object.prototype.hasOwnProperty;
42    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
43    function toObject(val) {
44      if (val === null || val === void 0) {
45        throw new TypeError("Object.assign cannot be called with null or undefined");
46      }
47      return Object(val);
48    }
49    function shouldUseNative() {
50      try {
51        if (!Object.assign) {
52          return false;
53        }
54        var test1 = new String("abc");
55        test1[5] = "de";
56        if (Object.getOwnPropertyNames(test1)[0] === "5") {
57          return false;
58        }
59        var test2 = {};
60        for (var i = 0; i < 10; i++) {
61          test2["_" + String.fromCharCode(i)] = i;
62        }
63        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
64          return test2[n];
65        });
66        if (order2.join("") !== "0123456789") {
67          return false;
68        }
69        var test3 = {};
70        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
71          test3[letter] = letter;
72        });
73        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
74          return false;
75        }
76        return true;
77      } catch (err) {
78        return false;
79      }
80    }
81    module.exports = shouldUseNative() ? Object.assign : function(target, source) {
82      var from;
83      var to = toObject(target);
84      var symbols;
85      for (var s = 1; s < arguments.length; s++) {
86        from = Object(arguments[s]);
87        for (var key in from) {
88          if (hasOwnProperty.call(from, key)) {
89            to[key] = from[key];
90          }
91        }
92        if (getOwnPropertySymbols) {
93          symbols = getOwnPropertySymbols(from);
94          for (var i = 0; i < symbols.length; i++) {
95            if (propIsEnumerable.call(from, symbols[i])) {
96              to[symbols[i]] = from[symbols[i]];
97            }
98          }
99        }
100      }
101      return to;
102    };
103  }
104});
105

106// node_modules/react/cjs/react.development.js
107var require_react_development = __commonJS({
108  "node_modules/react/cjs/react.development.js"(exports) {
109    "use strict";
110    init_react();
111    if (true) {
112      (function() {
113        "use strict";
114        var _assign = require_object_assign();
115        var ReactVersion = "17.0.2";
116        var REACT_ELEMENT_TYPE = 60103;
117        var REACT_PORTAL_TYPE = 60106;
118        exports.Fragment = 60107;
119        exports.StrictMode = 60108;
120        exports.Profiler = 60114;
121        var REACT_PROVIDER_TYPE = 60109;
122        var REACT_CONTEXT_TYPE = 60110;
123        var REACT_FORWARD_REF_TYPE = 60112;
124        exports.Suspense = 60113;
125        var REACT_SUSPENSE_LIST_TYPE = 60120;
126        var REACT_MEMO_TYPE = 60115;
127        var REACT_LAZY_TYPE = 60116;
128        var REACT_BLOCK_TYPE = 60121;
129        var REACT_SERVER_BLOCK_TYPE = 60122;
130        var REACT_FUNDAMENTAL_TYPE = 60117;
131        var REACT_SCOPE_TYPE = 60119;
132        var REACT_OPAQUE_ID_TYPE = 60128;
133        var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
134        var REACT_OFFSCREEN_TYPE = 60130;
135        var REACT_LEGACY_HIDDEN_TYPE = 60131;
136        if (typeof Symbol === "function" && Symbol.for) {
137          var symbolFor = Symbol.for;
138          REACT_ELEMENT_TYPE = symbolFor("react.element");
139          REACT_PORTAL_TYPE = symbolFor("react.portal");
140          exports.Fragment = symbolFor("react.fragment");
141          exports.StrictMode = symbolFor("react.strict_mode");
142          exports.Profiler = symbolFor("react.profiler");
143          REACT_PROVIDER_TYPE = symbolFor("react.provider");
144          REACT_CONTEXT_TYPE = symbolFor("react.context");
145          REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
146          exports.Suspense = symbolFor("react.suspense");
147          REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
148          REACT_MEMO_TYPE = symbolFor("react.memo");
149          REACT_LAZY_TYPE = symbolFor("react.lazy");
150          REACT_BLOCK_TYPE = symbolFor("react.block");
151          REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
152          REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
153          REACT_SCOPE_TYPE = symbolFor("react.scope");
154          REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id");
155          REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
156          REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
157          REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
158        }
159        var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
160        var FAUX_ITERATOR_SYMBOL = "@@iterator";
161        function getIteratorFn(maybeIterable) {
162          if (maybeIterable === null || typeof maybeIterable !== "object") {
163            return null;
164          }
165          var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
166          if (typeof maybeIterator === "function") {
167            return maybeIterator;
168          }
169          return null;
170        }
171        var ReactCurrentDispatcher = {
172          current: null
173        };
174        var ReactCurrentBatchConfig = {
175          transition: 0
176        };
177        var ReactCurrentOwner = {
178          current: null
179        };
180        var ReactDebugCurrentFrame = {};
181        var currentExtraStackFrame = null;
182        function setExtraStackFrame(stack) {
183          {
184            currentExtraStackFrame = stack;
185          }
186        }
187        {
188          ReactDebugCurrentFrame.setExtraStackFrame = function(stack) {
189            {
190              currentExtraStackFrame = stack;
191            }
192          };
193          ReactDebugCurrentFrame.getCurrentStack = null;
194          ReactDebugCurrentFrame.getStackAddendum = function() {
195            var stack = "";
196            if (currentExtraStackFrame) {
197              stack += currentExtraStackFrame;
198            }
199            var impl = ReactDebugCurrentFrame.getCurrentStack;
200            if (impl) {
201              stack += impl() || "";
202            }
203            return stack;
204          };
205        }
206        var IsSomeRendererActing = {
207          current: false
208        };
209        var ReactSharedInternals = {
210          ReactCurrentDispatcher,
211          ReactCurrentBatchConfig,
212          ReactCurrentOwner,
213          IsSomeRendererActing,
214          assign: _assign
215        };
216        {
217          ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
218        }
219        function warn(format) {
220          {
221            for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
222              args[_key - 1] = arguments[_key];
223            }
224            printWarning("warn", format, args);
225          }
226        }
227        function error(format) {
228          {
229            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
230              args[_key2 - 1] = arguments[_key2];
231            }
232            printWarning("error", format, args);
233          }
234        }
235        function printWarning(level, format, args) {
236          {
237            var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
238            var stack = ReactDebugCurrentFrame2.getStackAddendum();
239            if (stack !== "") {
240              format += "%s";
241              args = args.concat([stack]);
242            }
243            var argsWithFormat = args.map(function(item) {
244              return "" + item;
245            });
246            argsWithFormat.unshift("Warning: " + format);
247            Function.prototype.apply.call(console[level], console, argsWithFormat);
248          }
249        }
250        var didWarnStateUpdateForUnmountedComponent = {};
251        function warnNoop(publicInstance, callerName) {
252          {
253            var _constructor = publicInstance.constructor;
254            var componentName = _constructor && (_constructor.displayName || _constructor.name) || "ReactClass";
255            var warningKey = componentName + "." + callerName;
256            if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
257              return;
258            }
259            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);
260            didWarnStateUpdateForUnmountedComponent[warningKey] = true;
261          }
262        }
263        var ReactNoopUpdateQueue = {
264          isMounted: function(publicInstance) {
265            return false;
266          },
267          enqueueForceUpdate: function(publicInstance, callback, callerName) {
268            warnNoop(publicInstance, "forceUpdate");
269          },
270          enqueueReplaceState: function(publicInstance, completeState, callback, callerName) {
271            warnNoop(publicInstance, "replaceState");
272          },
273          enqueueSetState: function(publicInstance, partialState, callback, callerName) {
274            warnNoop(publicInstance, "setState");
275          }
276        };
277        var emptyObject = {};
278        {
279          Object.freeze(emptyObject);
280        }
281        function Component(props, context, updater) {
282          this.props = props;
283          this.context = context;
284          this.refs = emptyObject;
285          this.updater = updater || ReactNoopUpdateQueue;
286        }
287        Component.prototype.isReactComponent = {};
288        Component.prototype.setState = function(partialState, callback) {
289          if (!(typeof partialState === "object" || typeof partialState === "function" || partialState == null)) {
290            {
291              throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
292            }
293          }
294          this.updater.enqueueSetState(this, partialState, callback, "setState");
295        };
296        Component.prototype.forceUpdate = function(callback) {
297          this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
298        };
299        {
300          var deprecatedAPIs = {
301            isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
302            replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
303          };
304          var defineDeprecationWarning = function(methodName, info) {
305            Object.defineProperty(Component.prototype, methodName, {
306              get: function() {
307                warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
308                return void 0;
309              }
310            });
311          };
312          for (var fnName in deprecatedAPIs) {
313            if (deprecatedAPIs.hasOwnProperty(fnName)) {
314              defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
315            }
316          }
317        }
318        function ComponentDummy() {
319        }
320        ComponentDummy.prototype = Component.prototype;
321        function PureComponent(props, context, updater) {
322          this.props = props;
323          this.context = context;
324          this.refs = emptyObject;
325          this.updater = updater || ReactNoopUpdateQueue;
326        }
327        var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
328        pureComponentPrototype.constructor = PureComponent;
329        _assign(pureComponentPrototype, Component.prototype);
330        pureComponentPrototype.isPureReactComponent = true;
331        function createRef() {
332          var refObject = {
333            current: null
334          };
335          {
336            Object.seal(refObject);
337          }
338          return refObject;
339        }
340        function getWrappedName(outerType, innerType, wrapperName) {
341          var functionName = innerType.displayName || innerType.name || "";
342          return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
343        }
344        function getContextName(type) {
345          return type.displayName || "Context";
346        }
347        function getComponentName(type) {
348          if (type == null) {
349            return null;
350          }
351          {
352            if (typeof type.tag === "number") {
353              error("Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue.");
354            }
355          }
356          if (typeof type === "function") {
357            return type.displayName || type.name || null;
358          }
359          if (typeof type === "string") {
360            return type;
361          }
362          switch (type) {
363            case exports.Fragment:
364              return "Fragment";
365            case REACT_PORTAL_TYPE:
366              return "Portal";
367            case exports.Profiler:
368              return "Profiler";
369            case exports.StrictMode:
370              return "StrictMode";
371            case exports.Suspense:
372              return "Suspense";
373            case REACT_SUSPENSE_LIST_TYPE:
374              return "SuspenseList";
375          }
376          if (typeof type === "object") {
377            switch (type.$$typeof) {
378              case REACT_CONTEXT_TYPE:
379                var context = type;
380                return getContextName(context) + ".Consumer";
381              case REACT_PROVIDER_TYPE:
382                var provider = type;
383                return getContextName(provider._context) + ".Provider";
384              case REACT_FORWARD_REF_TYPE:
385                return getWrappedName(type, type.render, "ForwardRef");
386              case REACT_MEMO_TYPE:
387                return getComponentName(type.type);
388              case REACT_BLOCK_TYPE:
389                return getComponentName(type._render);
390              case REACT_LAZY_TYPE: {
391                var lazyComponent = type;
392                var payload = lazyComponent._payload;
393                var init = lazyComponent._init;
394                try {
395                  return getComponentName(init(payload));
396                } catch (x) {
397                  return null;
398                }
399              }
400            }
401          }
402          return null;
403        }
404        var hasOwnProperty = Object.prototype.hasOwnProperty;
405        var RESERVED_PROPS = {
406          key: true,
407          ref: true,
408          __self: true,
409          __source: true
410        };
411        var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;
412        {
413          didWarnAboutStringRefs = {};
414        }
415        function hasValidRef(config) {
416          {
417            if (hasOwnProperty.call(config, "ref")) {
418              var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
419              if (getter && getter.isReactWarning) {
420                return false;
421              }
422            }
423          }
424          return config.ref !== void 0;
425        }
426        function hasValidKey(config) {
427          {
428            if (hasOwnProperty.call(config, "key")) {
429              var getter = Object.getOwnPropertyDescriptor(config, "key").get;
430              if (getter && getter.isReactWarning) {
431                return false;
432              }
433            }
434          }
435          return config.key !== void 0;
436        }
437        function defineKeyPropWarningGetter(props, displayName) {
438          var warnAboutAccessingKey = function() {
439            {
440              if (!specialPropKeyWarningShown) {
441                specialPropKeyWarningShown = true;
442                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);
443              }
444            }
445          };
446          warnAboutAccessingKey.isReactWarning = true;
447          Object.defineProperty(props, "key", {
448            get: warnAboutAccessingKey,
449            configurable: true
450          });
451        }
452        function defineRefPropWarningGetter(props, displayName) {
453          var warnAboutAccessingRef = function() {
454            {
455              if (!specialPropRefWarningShown) {
456                specialPropRefWarningShown = true;
457                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);
458              }
459            }
460          };
461          warnAboutAccessingRef.isReactWarning = true;
462          Object.defineProperty(props, "ref", {
463            get: warnAboutAccessingRef,
464            configurable: true
465          });
466        }
467        function warnIfStringRefCannotBeAutoConverted(config) {
468          {
469            if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
470              var componentName = getComponentName(ReactCurrentOwner.current.type);
471              if (!didWarnAboutStringRefs[componentName]) {
472                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);
473                didWarnAboutStringRefs[componentName] = true;
474              }
475            }
476          }
477        }
478        var ReactElement = function(type, key, ref, self, source, owner, props) {
479          var element = {
480            $$typeof: REACT_ELEMENT_TYPE,
481            type,
482            key,
483            ref,
484            props,
485            _owner: owner
486          };
487          {
488            element._store = {};
489            Object.defineProperty(element._store, "validated", {
490              configurable: false,
491              enumerable: false,
492              writable: true,
493              value: false
494            });
495            Object.defineProperty(element, "_self", {
496              configurable: false,
497              enumerable: false,
498              writable: false,
499              value: self
500            });
501            Object.defineProperty(element, "_source", {
502              configurable: false,
503              enumerable: false,
504              writable: false,
505              value: source
506            });
507            if (Object.freeze) {
508              Object.freeze(element.props);
509              Object.freeze(element);
510            }
511          }
512          return element;
513        };
514        function createElement(type, config, children) {
515          var propName;
516          var props = {};
517          var key = null;
518          var ref = null;
519          var self = null;
520          var source = null;
521          if (config != null) {
522            if (hasValidRef(config)) {
523              ref = config.ref;
524              {
525                warnIfStringRefCannotBeAutoConverted(config);
526              }
527            }
528            if (hasValidKey(config)) {
529              key = "" + config.key;
530            }
531            self = config.__self === void 0 ? null : config.__self;
532            source = config.__source === void 0 ? null : config.__source;
533            for (propName in config) {
534              if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
535                props[propName] = config[propName];
536              }
537            }
538          }
539          var childrenLength = arguments.length - 2;
540          if (childrenLength === 1) {
541            props.children = children;
542          } else if (childrenLength > 1) {
543            var childArray = Array(childrenLength);
544            for (var i = 0; i < childrenLength; i++) {
545              childArray[i] = arguments[i + 2];
546            }
547            {
548              if (Object.freeze) {
549                Object.freeze(childArray);
550              }
551            }
552            props.children = childArray;
553          }
554          if (type && type.defaultProps) {
555            var defaultProps = type.defaultProps;
556            for (propName in defaultProps) {
557              if (props[propName] === void 0) {
558                props[propName] = defaultProps[propName];
559              }
560            }
561          }
562          {
563            if (key || ref) {
564              var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
565              if (key) {
566                defineKeyPropWarningGetter(props, displayName);
567              }
568              if (ref) {
569                defineRefPropWarningGetter(props, displayName);
570              }
571            }
572          }
573          return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
574        }
575        function cloneAndReplaceKey(oldElement, newKey) {
576          var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
577          return newElement;
578        }
579        function cloneElement(element, config, children) {
580          if (!!(element === null || element === void 0)) {
581            {
582              throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
583            }
584          }
585          var propName;
586          var props = _assign({}, element.props);
587          var key = element.key;
588          var ref = element.ref;
589          var self = element._self;
590          var source = element._source;
591          var owner = element._owner;
592          if (config != null) {
593            if (hasValidRef(config)) {
594              ref = config.ref;
595              owner = ReactCurrentOwner.current;
596            }
597            if (hasValidKey(config)) {
598              key = "" + config.key;
599            }
600            var defaultProps;
601            if (element.type && element.type.defaultProps) {
602              defaultProps = element.type.defaultProps;
603            }
604            for (propName in config) {
605              if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
606                if (config[propName] === void 0 && defaultProps !== void 0) {
607                  props[propName] = defaultProps[propName];
608                } else {
609                  props[propName] = config[propName];
610                }
611              }
612            }
613          }
614          var childrenLength = arguments.length - 2;
615          if (childrenLength === 1) {
616            props.children = children;
617          } else if (childrenLength > 1) {
618            var childArray = Array(childrenLength);
619            for (var i = 0; i < childrenLength; i++) {
620              childArray[i] = arguments[i + 2];
621            }
622            props.children = childArray;
623          }
624          return ReactElement(element.type, key, ref, self, source, owner, props);
625        }
626        function isValidElement(object) {
627          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
628        }
629        var SEPARATOR = ".";
630        var SUBSEPARATOR = ":";
631        function escape(key) {
632          var escapeRegex = /[=:]/g;
633          var escaperLookup = {
634            "=": "=0",
635            ":": "=2"
636          };
637          var escapedString = key.replace(escapeRegex, function(match) {
638            return escaperLookup[match];
639          });
640          return "$" + escapedString;
641        }
642        var didWarnAboutMaps = false;
643        var userProvidedKeyEscapeRegex = /\/+/g;
644        function escapeUserProvidedKey(text) {
645          return text.replace(userProvidedKeyEscapeRegex, "$&/");
646        }
647        function getElementKey(element, index) {
648          if (typeof element === "object" && element !== null && element.key != null) {
649            return escape("" + element.key);
650          }
651          return index.toString(36);
652        }
653        function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
654          var type = typeof children;
655          if (type === "undefined" || type === "boolean") {
656            children = null;
657          }
658          var invokeCallback = false;
659          if (children === null) {
660            invokeCallback = true;
661          } else {
662            switch (type) {
663              case "string":
664              case "number":
665                invokeCallback = true;
666                break;
667              case "object":
668                switch (children.$$typeof) {
669                  case REACT_ELEMENT_TYPE:
670                  case REACT_PORTAL_TYPE:
671                    invokeCallback = true;
672                }
673            }
674          }
675          if (invokeCallback) {
676            var _child = children;
677            var mappedChild = callback(_child);
678            var childKey = nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
679            if (Array.isArray(mappedChild)) {
680              var escapedChildKey = "";
681              if (childKey != null) {
682                escapedChildKey = escapeUserProvidedKey(childKey) + "/";
683              }
684              mapIntoArray(mappedChild, array, escapedChildKey, "", function(c) {
685                return c;
686              });
687            } else if (mappedChild != null) {
688              if (isValidElement(mappedChild)) {
689                mappedChild = cloneAndReplaceKey(mappedChild, escapedPrefix + (mappedChild.key && (!_child || _child.key !== mappedChild.key) ? escapeUserProvidedKey("" + mappedChild.key) + "/" : "") + childKey);
690              }
691              array.push(mappedChild);
692            }
693            return 1;
694          }
695          var child;
696          var nextName;
697          var subtreeCount = 0;
698          var nextNamePrefix = nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR;
699          if (Array.isArray(children)) {
700            for (var i = 0; i < children.length; i++) {
701              child = children[i];
702              nextName = nextNamePrefix + getElementKey(child, i);
703              subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
704            }
705          } else {
706            var iteratorFn = getIteratorFn(children);
707            if (typeof iteratorFn === "function") {
708              var iterableChildren = children;
709              {
710                if (iteratorFn === iterableChildren.entries) {
711                  if (!didWarnAboutMaps) {
712                    warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead.");
713                  }
714                  didWarnAboutMaps = true;
715                }
716              }
717              var iterator = iteratorFn.call(iterableChildren);
718              var step;
719              var ii = 0;
720              while (!(step = iterator.next()).done) {
721                child = step.value;
722                nextName = nextNamePrefix + getElementKey(child, ii++);
723                subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
724              }
725            } else if (type === "object") {
726              var childrenString = "" + children;
727              {
728                {
729                  throw 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.");
730                }
731              }
732            }
733          }
734          return subtreeCount;
735        }
736        function mapChildren(children, func, context) {
737          if (children == null) {
738            return children;
739          }
740          var result = [];
741          var count = 0;
742          mapIntoArray(children, result, "", "", function(child) {
743            return func.call(context, child, count++);
744          });
745          return result;
746        }
747        function countChildren(children) {
748          var n = 0;
749          mapChildren(children, function() {
750            n++;
751          });
752          return n;
753        }
754        function forEachChildren(children, forEachFunc, forEachContext) {
755          mapChildren(children, function() {
756            forEachFunc.apply(this, arguments);
757          }, forEachContext);
758        }
759        function toArray(children) {
760          return mapChildren(children, function(child) {
761            return child;
762          }) || [];
763        }
764        function onlyChild(children) {
765          if (!isValidElement(children)) {
766            {
767              throw Error("React.Children.only expected to receive a single React element child.");
768            }
769          }
770          return children;
771        }
772        function createContext(defaultValue, calculateChangedBits) {
773          if (calculateChangedBits === void 0) {
774            calculateChangedBits = null;
775          } else {
776            {
777              if (calculateChangedBits !== null && typeof calculateChangedBits !== "function") {
778                error("createContext: Expected the optional second argument to be a function. Instead received: %s", calculateChangedBits);
779              }
780            }
781          }
782          var context = {
783            $$typeof: REACT_CONTEXT_TYPE,
784            _calculateChangedBits: calculateChangedBits,
785            _currentValue: defaultValue,
786            _currentValue2: defaultValue,
787            _threadCount: 0,
788            Provider: null,
789            Consumer: null
790          };
791          context.Provider = {
792            $$typeof: REACT_PROVIDER_TYPE,
793            _context: context
794          };
795          var hasWarnedAboutUsingNestedContextConsumers = false;
796          var hasWarnedAboutUsingConsumerProvider = false;
797          var hasWarnedAboutDisplayNameOnConsumer = false;
798          {
799            var Consumer = {
800              $$typeof: REACT_CONTEXT_TYPE,
801              _context: context,
802              _calculateChangedBits: context._calculateChangedBits
803            };
804            Object.defineProperties(Consumer, {
805              Provider: {
806                get: function() {
807                  if (!hasWarnedAboutUsingConsumerProvider) {
808                    hasWarnedAboutUsingConsumerProvider = true;
809                    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?");
810                  }
811                  return context.Provider;
812                },
813                set: function(_Provider) {
814                  context.Provider = _Provider;
815                }
816              },
817              _currentValue: {
818                get: function() {
819                  return context._currentValue;
820                },
821                set: function(_currentValue) {
822                  context._currentValue = _currentValue;
823                }
824              },
825              _currentValue2: {
826                get: function() {
827                  return context._currentValue2;
828                },
829                set: function(_currentValue2) {
830                  context._currentValue2 = _currentValue2;
831                }
832              },
833              _threadCount: {
834                get: function() {
835                  return context._threadCount;
836                },
837                set: function(_threadCount) {
838                  context._threadCount = _threadCount;
839                }
840              },
841              Consumer: {
842                get: function() {
843                  if (!hasWarnedAboutUsingNestedContextConsumers) {
844                    hasWarnedAboutUsingNestedContextConsumers = true;
845                    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?");
846                  }
847                  return context.Consumer;
848                }
849              },
850              displayName: {
851                get: function() {
852                  return context.displayName;
853                },
854                set: function(displayName) {
855                  if (!hasWarnedAboutDisplayNameOnConsumer) {
856                    warn("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", displayName);
857                    hasWarnedAboutDisplayNameOnConsumer = true;
858                  }
859                }
860              }
861            });
862            context.Consumer = Consumer;
863          }
864          {
865            context._currentRenderer = null;
866            context._currentRenderer2 = null;
867          }
868          return context;
869        }
870        var Uninitialized = -1;
871        var Pending = 0;
872        var Resolved = 1;
873        var Rejected = 2;
874        function lazyInitializer(payload) {
875          if (payload._status === Uninitialized) {
876            var ctor = payload._result;
877            var thenable = ctor();
878            var pending = payload;
879            pending._status = Pending;
880            pending._result = thenable;
881            thenable.then(function(moduleObject) {
882              if (payload._status === Pending) {
883                var defaultExport = moduleObject.default;
884                {
885                  if (defaultExport === void 0) {
886                    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);
887                  }
888                }
889                var resolved = payload;
890                resolved._status = Resolved;
891                resolved._result = defaultExport;
892              }
893            }, function(error2) {
894              if (payload._status === Pending) {
895                var rejected = payload;
896                rejected._status = Rejected;
897                rejected._result = error2;
898              }
899            });
900          }
901          if (payload._status === Resolved) {
902            return payload._result;
903          } else {
904            throw payload._result;
905          }
906        }
907        function lazy(ctor) {
908          var payload = {
909            _status: -1,
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.displayName == null) {
983                  render.displayName = name;
984                }
985              }
986            });
987          }
988          return elementType;
989        }
990        var enableScopeAPI = false;
991        function isValidElementType(type) {
992          if (typeof type === "string" || typeof type === "function") {
993            return true;
994          }
995          if (type === exports.Fragment || type === exports.Profiler || type === REACT_DEBUG_TRACING_MODE_TYPE || type === exports.StrictMode || type === exports.Suspense || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI) {
996            return true;
997          }
998          if (typeof type === "object" && type !== null) {
999            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 || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
1000              return true;
1001            }
1002          }
1003          return false;
1004        }
1005        function memo(type, compare) {
1006          {
1007            if (!isValidElementType(type)) {
1008              error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
1009            }
1010          }
1011          var elementType = {
1012            $$typeof: REACT_MEMO_TYPE,
1013            type,
1014            compare: compare === void 0 ? null : compare
1015          };
1016          {
1017            var ownName;
1018            Object.defineProperty(elementType, "displayName", {
1019              enumerable: false,
1020              configurable: true,
1021              get: function() {
1022                return ownName;
1023              },
1024              set: function(name) {
1025                ownName = name;
1026                if (type.displayName == null) {
1027                  type.displayName = name;
1028                }
1029              }
1030            });
1031          }
1032          return elementType;
1033        }
1034        function resolveDispatcher() {
1035          var dispatcher = ReactCurrentDispatcher.current;
1036          if (!(dispatcher !== null)) {
1037            {
1038              throw 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.");
1039            }
1040          }
1041          return dispatcher;
1042        }
1043        function useContext(Context, unstable_observedBits) {
1044          var dispatcher = resolveDispatcher();
1045          {
1046            if (unstable_observedBits !== void 0) {
1047              error("useContext() second argument is reserved for future use in React. Passing it is not supported. You passed: %s.%s", unstable_observedBits, typeof unstable_observedBits === "number" && Array.isArray(arguments[2]) ? "\n\nDid you call array.map(useContext)? Calling Hooks inside a loop is not supported. Learn more at https://reactjs.org/link/rules-of-hooks" : "");
1048            }
1049            if (Context._context !== void 0) {
1050              var realContext = Context._context;
1051              if (realContext.Consumer === Context) {
1052                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?");
1053              } else if (realContext.Provider === Context) {
1054                error("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?");
1055              }
1056            }
1057          }
1058          return dispatcher.useContext(Context, unstable_observedBits);
1059        }
1060        function useState(initialState) {
1061          var dispatcher = resolveDispatcher();
1062          return dispatcher.useState(initialState);
1063        }
1064        function useReducer(reducer, initialArg, init) {
1065          var dispatcher = resolveDispatcher();
1066          return dispatcher.useReducer(reducer, initialArg, init);
1067        }
1068        function useRef(initialValue) {
1069          var dispatcher = resolveDispatcher();
1070          return dispatcher.useRef(initialValue);
1071        }
1072        function useEffect(create, deps) {
1073          var dispatcher = resolveDispatcher();
1074          return dispatcher.useEffect(create, deps);
1075        }
1076        function useLayoutEffect(create, deps) {
1077          var dispatcher = resolveDispatcher();
1078          return dispatcher.useLayoutEffect(create, deps);
1079        }
1080        function useCallback(callback, deps) {
1081          var dispatcher = resolveDispatcher();
1082          return dispatcher.useCallback(callback, deps);
1083        }
1084        function useMemo(create, deps) {
1085          var dispatcher = resolveDispatcher();
1086          return dispatcher.useMemo(create, deps);
1087        }
1088        function useImperativeHandle(ref, create, deps) {
1089          var dispatcher = resolveDispatcher();
1090          return dispatcher.useImperativeHandle(ref, create, deps);
1091        }
1092        function useDebugValue(value, formatterFn) {
1093          {
1094            var dispatcher = resolveDispatcher();
1095            return dispatcher.useDebugValue(value, formatterFn);
1096          }
1097        }
1098        var disabledDepth = 0;
1099        var prevLog;
1100        var prevInfo;
1101        var prevWarn;
1102        var prevError;
1103        var prevGroup;
1104        var prevGroupCollapsed;
1105        var prevGroupEnd;
1106        function disabledLog() {
1107        }
1108        disabledLog.__reactDisabledLog = true;
1109        function disableLogs() {
1110          {
1111            if (disabledDepth === 0) {
1112              prevLog = console.log;
1113              prevInfo = console.info;
1114              prevWarn = console.warn;
1115              prevError = console.error;
1116              prevGroup = console.group;
1117              prevGroupCollapsed = console.groupCollapsed;
1118              prevGroupEnd = console.groupEnd;
1119              var props = {
1120                configurable: true,
1121                enumerable: true,
1122                value: disabledLog,
1123                writable: true
1124              };
1125              Object.defineProperties(console, {
1126                info: props,
1127                log: props,
1128                warn: props,
1129                error: props,
1130                group: props,
1131                groupCollapsed: props,
1132                groupEnd: props
1133              });
1134            }
1135            disabledDepth++;
1136          }
1137        }
1138        function reenableLogs() {
1139          {
1140            disabledDepth--;
1141            if (disabledDepth === 0) {
1142              var props = {
1143                configurable: true,
1144                enumerable: true,
1145                writable: true
1146              };
1147              Object.defineProperties(console, {
1148                log: _assign({}, props, {
1149                  value: prevLog
1150                }),
1151                info: _assign({}, props, {
1152                  value: prevInfo
1153                }),
1154                warn: _assign({}, props, {
1155                  value: prevWarn
1156                }),
1157                error: _assign({}, props, {
1158                  value: prevError
1159                }),
1160                group: _assign({}, props, {
1161                  value: prevGroup
1162                }),
1163                groupCollapsed: _assign({}, props, {
1164                  value: prevGroupCollapsed
1165                }),
1166                groupEnd: _assign({}, props, {
1167                  value: prevGroupEnd
1168                })
1169              });
1170            }
1171            if (disabledDepth < 0) {
1172              error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
1173            }
1174          }
1175        }
1176        var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
1177        var prefix;
1178        function describeBuiltInComponentFrame(name, source, ownerFn) {
1179          {
1180            if (prefix === void 0) {
1181              try {
1182                throw Error();
1183              } catch (x) {
1184                var match = x.stack.trim().match(/\n( *(at )?)/);
1185                prefix = match && match[1] || "";
1186              }
1187            }
1188            return "\n" + prefix + name;
1189          }
1190        }
1191        var reentry = false;
1192        var componentFrameCache;
1193        {
1194          var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
1195          componentFrameCache = new PossiblyWeakMap();
1196        }
1197        function describeNativeComponentFrame(fn, construct) {
1198          if (!fn || reentry) {
1199            return "";
1200          }
1201          {
1202            var frame = componentFrameCache.get(fn);
1203            if (frame !== void 0) {
1204              return frame;
1205            }
1206          }
1207          var control;
1208          reentry = true;
1209          var previousPrepareStackTrace = Error.prepareStackTrace;
1210          Error.prepareStackTrace = void 0;
1211          var previousDispatcher;
1212          {
1213            previousDispatcher = ReactCurrentDispatcher$1.current;
1214            ReactCurrentDispatcher$1.current = null;
1215            disableLogs();
1216          }
1217          try {
1218            if (construct) {
1219              var Fake = function() {
1220                throw Error();
1221              };
1222              Object.defineProperty(Fake.prototype, "props", {
1223                set: function() {
1224                  throw Error();
1225                }
1226              });
1227              if (typeof Reflect === "object" && Reflect.construct) {
1228                try {
1229                  Reflect.construct(Fake, []);
1230                } catch (x) {
1231                  control = x;
1232                }
1233                Reflect.construct(fn, [], Fake);
1234              } else {
1235                try {
1236                  Fake.call();
1237                } catch (x) {
1238                  control = x;
1239                }
1240                fn.call(Fake.prototype);
1241              }
1242            } else {
1243              try {
1244                throw Error();
1245              } catch (x) {
1246                control = x;
1247              }
1248              fn();
1249            }
1250          } catch (sample) {
1251            if (sample && control && typeof sample.stack === "string") {
1252              var sampleLines = sample.stack.split("\n");
1253              var controlLines = control.stack.split("\n");
1254              var s = sampleLines.length - 1;
1255              var c = controlLines.length - 1;
1256              while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
1257                c--;
1258              }
1259              for (; s >= 1 && c >= 0; s--, c--) {
1260                if (sampleLines[s] !== controlLines[c]) {
1261                  if (s !== 1 || c !== 1) {
1262                    do {
1263                      s--;
1264                      c--;
1265                      if (c < 0 || sampleLines[s] !== controlLines[c]) {
1266                        var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
1267                        {
1268                          if (typeof fn === "function") {
1269                            componentFrameCache.set(fn, _frame);
1270                          }
1271                        }
1272                        return _frame;
1273                      }
1274                    } while (s >= 1 && c >= 0);
1275                  }
1276                  break;
1277                }
1278              }
1279            }
1280          } finally {
1281            reentry = false;
1282            {
1283              ReactCurrentDispatcher$1.current = previousDispatcher;
1284              reenableLogs();
1285            }
1286            Error.prepareStackTrace = previousPrepareStackTrace;
1287          }
1288          var name = fn ? fn.displayName || fn.name : "";
1289          var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
1290          {
1291            if (typeof fn === "function") {
1292              componentFrameCache.set(fn, syntheticFrame);
1293            }
1294          }
1295          return syntheticFrame;
1296        }
1297        function describeFunctionComponentFrame(fn, source, ownerFn) {
1298          {
1299            return describeNativeComponentFrame(fn, false);
1300          }
1301        }
1302        function shouldConstruct(Component2) {
1303          var prototype = Component2.prototype;
1304          return !!(prototype && prototype.isReactComponent);
1305        }
1306        function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
1307          if (type == null) {
1308            return "";
1309          }
1310          if (typeof type === "function") {
1311            {
1312              return describeNativeComponentFrame(type, shouldConstruct(type));
1313            }
1314          }
1315          if (typeof type === "string") {
1316            return describeBuiltInComponentFrame(type);
1317          }
1318          switch (type) {
1319            case exports.Suspense:
1320              return describeBuiltInComponentFrame("Suspense");
1321            case REACT_SUSPENSE_LIST_TYPE:
1322              return describeBuiltInComponentFrame("SuspenseList");
1323          }
1324          if (typeof type === "object") {
1325            switch (type.$$typeof) {
1326              case REACT_FORWARD_REF_TYPE:
1327                return describeFunctionComponentFrame(type.render);
1328              case REACT_MEMO_TYPE:
1329                return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
1330              case REACT_BLOCK_TYPE:
1331                return describeFunctionComponentFrame(type._render);
1332              case REACT_LAZY_TYPE: {
1333                var lazyComponent = type;
1334                var payload = lazyComponent._payload;
1335                var init = lazyComponent._init;
1336                try {
1337                  return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
1338                } catch (x) {
1339                }
1340              }
1341            }
1342          }
1343          return "";
1344        }
1345        var loggedTypeFailures = {};
1346        var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
1347        function setCurrentlyValidatingElement(element) {
1348          {
1349            if (element) {
1350              var owner = element._owner;
1351              var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
1352              ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
1353            } else {
1354              ReactDebugCurrentFrame$1.setExtraStackFrame(null);
1355            }
1356          }
1357        }
1358        function checkPropTypes(typeSpecs, values, location, componentName, element) {
1359          {
1360            var has = Function.call.bind(Object.prototype.hasOwnProperty);
1361            for (var typeSpecName in typeSpecs) {
1362              if (has(typeSpecs, typeSpecName)) {
1363                var error$1 = void 0;
1364                try {
1365                  if (typeof typeSpecs[typeSpecName] !== "function") {
1366                    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`.");
1367                    err.name = "Invariant Violation";
1368                    throw err;
1369                  }
1370                  error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
1371                } catch (ex) {
1372                  error$1 = ex;
1373                }
1374                if (error$1 && !(error$1 instanceof Error)) {
1375                  setCurrentlyValidatingElement(element);
1376                  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);
1377                  setCurrentlyValidatingElement(null);
1378                }
1379                if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
1380                  loggedTypeFailures[error$1.message] = true;
1381                  setCurrentlyValidatingElement(element);
1382                  error("Failed %s type: %s", location, error$1.message);
1383                  setCurrentlyValidatingElement(null);
1384                }
1385              }
1386            }
1387          }
1388        }
1389        function setCurrentlyValidatingElement$1(element) {
1390          {
1391            if (element) {
1392              var owner = element._owner;
1393              var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
1394              setExtraStackFrame(stack);
1395            } else {
1396              setExtraStackFrame(null);
1397            }
1398          }
1399        }
1400        var propTypesMisspellWarningShown;
1401        {
1402          propTypesMisspellWarningShown = false;
1403        }
1404        function getDeclarationErrorAddendum() {
1405          if (ReactCurrentOwner.current) {
1406            var name = getComponentName(ReactCurrentOwner.current.type);
1407            if (name) {
1408              return "\n\nCheck the render method of `" + name + "`.";
1409            }
1410          }
1411          return "";
1412        }
1413        function getSourceInfoErrorAddendum(source) {
1414          if (source !== void 0) {
1415            var fileName = source.fileName.replace(/^.*[\\\/]/, "");
1416            var lineNumber = source.lineNumber;
1417            return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
1418          }
1419          return "";
1420        }
1421        function getSourceInfoErrorAddendumForProps(elementProps) {
1422          if (elementProps !== null && elementProps !== void 0) {
1423            return getSourceInfoErrorAddendum(elementProps.__source);
1424          }
1425          return "";
1426        }
1427        var ownerHasKeyUseWarning = {};
1428        function getCurrentComponentErrorInfo(parentType) {
1429          var info = getDeclarationErrorAddendum();
1430          if (!info) {
1431            var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
1432            if (parentName) {
1433              info = "\n\nCheck the top-level render call using <" + parentName + ">.";
1434            }
1435          }
1436          return info;
1437        }
1438        function validateExplicitKey(element, parentType) {
1439          if (!element._store || element._store.validated || element.key != null) {
1440            return;
1441          }
1442          element._store.validated = true;
1443          var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
1444          if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
1445            return;
1446          }
1447          ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
1448          var childOwner = "";
1449          if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
1450            childOwner = " It was passed a child from " + getComponentName(element._owner.type) + ".";
1451          }
1452          {
1453            setCurrentlyValidatingElement$1(element);
1454            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);
1455            setCurrentlyValidatingElement$1(null);
1456          }
1457        }
1458        function validateChildKeys(node, parentType) {
1459          if (typeof node !== "object") {
1460            return;
1461          }
1462          if (Array.isArray(node)) {
1463            for (var i = 0; i < node.length; i++) {
1464              var child = node[i];
1465              if (isValidElement(child)) {
1466                validateExplicitKey(child, parentType);
1467              }
1468            }
1469          } else if (isValidElement(node)) {
1470            if (node._store) {
1471              node._store.validated = true;
1472            }
1473          } else if (node) {
1474            var iteratorFn = getIteratorFn(node);
1475            if (typeof iteratorFn === "function") {
1476              if (iteratorFn !== node.entries) {
1477                var iterator = iteratorFn.call(node);
1478                var step;
1479                while (!(step = iterator.next()).done) {
1480                  if (isValidElement(step.value)) {
1481                    validateExplicitKey(step.value, parentType);
1482                  }
1483                }
1484              }
1485            }
1486          }
1487        }
1488        function validatePropTypes(element) {
1489          {
1490            var type = element.type;
1491            if (type === null || type === void 0 || typeof type === "string") {
1492              return;
1493            }
1494            var propTypes;
1495            if (typeof type === "function") {
1496              propTypes = type.propTypes;
1497            } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) {
1498              propTypes = type.propTypes;
1499            } else {
1500              return;
1501            }
1502            if (propTypes) {
1503              var name = getComponentName(type);
1504              checkPropTypes(propTypes, element.props, "prop", name, element);
1505            } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
1506              propTypesMisspellWarningShown = true;
1507              var _name = getComponentName(type);
1508              error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
1509            }
1510            if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
1511              error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
1512            }
1513          }
1514        }
1515        function validateFragmentProps(fragment) {
1516          {
1517            var keys = Object.keys(fragment.props);
1518            for (var i = 0; i < keys.length; i++) {
1519              var key = keys[i];
1520              if (key !== "children" && key !== "key") {
1521                setCurrentlyValidatingElement$1(fragment);
1522                error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
1523                setCurrentlyValidatingElement$1(null);
1524                break;
1525              }
1526            }
1527            if (fragment.ref !== null) {
1528              setCurrentlyValidatingElement$1(fragment);
1529              error("Invalid attribute `ref` supplied to `React.Fragment`.");
1530              setCurrentlyValidatingElement$1(null);
1531            }
1532          }
1533        }
1534        function createElementWithValidation(type, props, children) {
1535          var validType = isValidElementType(type);
1536          if (!validType) {
1537            var info = "";
1538            if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
1539              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.";
1540            }
1541            var sourceInfo = getSourceInfoErrorAddendumForProps(props);
1542            if (sourceInfo) {
1543              info += sourceInfo;
1544            } else {
1545              info += getDeclarationErrorAddendum();
1546            }
1547            var typeString;
1548            if (type === null) {
1549              typeString = "null";
1550            } else if (Array.isArray(type)) {
1551              typeString = "array";
1552            } else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
1553              typeString = "<" + (getComponentName(type.type) || "Unknown") + " />";
1554              info = " Did you accidentally export a JSX literal instead of a component?";
1555            } else {
1556              typeString = typeof type;
1557            }
1558            {
1559              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);
1560            }
1561          }
1562          var element = createElement.apply(this, arguments);
1563          if (element == null) {
1564            return element;
1565          }
1566          if (validType) {
1567            for (var i = 2; i < arguments.length; i++) {
1568              validateChildKeys(arguments[i], type);
1569            }
1570          }
1571          if (type === exports.Fragment) {
1572            validateFragmentProps(element);
1573          } else {
1574            validatePropTypes(element);
1575          }
1576          return element;
1577        }
1578        var didWarnAboutDeprecatedCreateFactory = false;
1579        function createFactoryWithValidation(type) {
1580          var validatedFactory = createElementWithValidation.bind(null, type);
1581          validatedFactory.type = type;
1582          {
1583            if (!didWarnAboutDeprecatedCreateFactory) {
1584              didWarnAboutDeprecatedCreateFactory = true;
1585              warn("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.");
1586            }
1587            Object.defineProperty(validatedFactory, "type", {
1588              enumerable: false,
1589              get: function() {
1590                warn("Factory.type is deprecated. Access the class directly before passing it to createFactory.");
1591                Object.defineProperty(this, "type", {
1592                  value: type
1593                });
1594                return type;
1595              }
1596            });
1597          }
1598          return validatedFactory;
1599        }
1600        function cloneElementWithValidation(element, props, children) {
1601          var newElement = cloneElement.apply(this, arguments);
1602          for (var i = 2; i < arguments.length; i++) {
1603            validateChildKeys(arguments[i], newElement.type);
1604          }
1605          validatePropTypes(newElement);
1606          return newElement;
1607        }
1608        {
1609          try {
1610            var frozenObject = Object.freeze({});
1611            /* @__PURE__ */ new Map([[frozenObject, null]]);
1612            /* @__PURE__ */ new Set([frozenObject]);
1613          } catch (e) {
1614          }
1615        }
1616        var createElement$1 = createElementWithValidation;
1617        var cloneElement$1 = cloneElementWithValidation;
1618        var createFactory = createFactoryWithValidation;
1619        var Children = {
1620          map: mapChildren,
1621          forEach: forEachChildren,
1622          count: countChildren,
1623          toArray,
1624          only: onlyChild
1625        };
1626        exports.Children = Children;
1627        exports.Component = Component;
1628        exports.PureComponent = PureComponent;
1629        exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
1630        exports.cloneElement = cloneElement$1;
1631        exports.createContext = createContext;
1632        exports.createElement = createElement$1;
1633        exports.createFactory = createFactory;
1634        exports.createRef = createRef;
1635        exports.forwardRef = forwardRef;
1636        exports.isValidElement = isValidElement;
1637        exports.lazy = lazy;
1638        exports.memo = memo;
1639        exports.useCallback = useCallback;
1640        exports.useContext = useContext;
1641        exports.useDebugValue = useDebugValue;
1642        exports.useEffect = useEffect;
1643        exports.useImperativeHandle = useImperativeHandle;
1644        exports.useLayoutEffect = useLayoutEffect;
1645        exports.useMemo = useMemo;
1646        exports.useReducer = useReducer;
1647        exports.useRef = useRef;
1648        exports.useState = useState;
1649        exports.version = ReactVersion;
1650      })();
1651    }
1652  }
1653});
1654

1655// node_modules/react/index.js
1656var require_react = __commonJS({
1657  "node_modules/react/index.js"(exports, module) {
1658    "use strict";
1659    init_react();
1660    if (false) {
1661      module.exports = null;
1662    } else {
1663      module.exports = require_react_development();
1664    }
1665  }
1666});
1667

1668// node_modules/@remix-run/dev/dist/compiler/shims/react.ts
1669var React;
1670var init_react = __esm({
1671  "node_modules/@remix-run/dev/dist/compiler/shims/react.ts"() {
1672    React = __toESM(require_react());
1673  }
1674});
1675
1676export {
1677  __esm,
1678  __commonJS,
1679  __export,
1680  __toESM,
1681  __toCommonJS,
1682  require_object_assign,
1683  require_react,
1684  React,
1685  init_react
1686};
1687/*
1688object-assign
1689(c) Sindre Sorhus
1690@license MIT
1691*/
1692/** @license React v17.0.2
1693 * react.development.js
1694 *
1695 * Copyright (c) Facebook, Inc. and its affiliates.
1696 *
1697 * This source code is licensed under the MIT license found in the
1698 * LICENSE file in the root directory of this source tree.
1699 */
1700//# sourceMappingURL=/build/_shared/chunk-BNRLY3XL.js.map