https://maisondelaphotographie.ma/wp-content/plugins/gutenberg/build/scripts/vendors/react.js?ver=18.3.1

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

1881// ../../node_modules/react/index.js
1882  var require_react = __commonJS({
1883    "../../node_modules/react/index.js"(exports, module) {
1884      "use strict";
1885      if (false) {
1886        module.exports = null;
1887      } else {
1888        module.exports = require_react_development();
1889      }
1890    }
1891  });
1892
1893