https://attorneyfunnels.com/wp-content/plugins/legal-pages/build/public.bundle.js?ver=1791324851

1/******/ (() => { // webpackBootstrap
2/******/ 	"use strict";
3/******/ 	var __webpack_modules__ = ({
4
5/***/ "./node_modules/react/cjs/react-jsx-runtime.development.js"
6/*!*****************************************************************!*\
7  !*** ./node_modules/react/cjs/react-jsx-runtime.development.js ***!
8  \*****************************************************************/
9(__unused_webpack_module, exports, __webpack_require__) {
10
11/**
12 * @license React
13 * react-jsx-runtime.development.js
14 *
15 * Copyright (c) Meta Platforms, Inc. and affiliates.
16 *
17 * This source code is licensed under the MIT license found in the
18 * LICENSE file in the root directory of this source tree.
19 */
20
21
22 true &&
23  (function () {
24    function getComponentNameFromType(type) {
25      if (null == type) return null;
26      if ("function" === typeof type)
27        return type.$$typeof === REACT_CLIENT_REFERENCE
28          ? null
29          : type.displayName || type.name || null;
30      if ("string" === typeof type) return type;
31      switch (type) {
32        case REACT_FRAGMENT_TYPE:
33          return "Fragment";
34        case REACT_PROFILER_TYPE:
35          return "Profiler";
36        case REACT_STRICT_MODE_TYPE:
37          return "StrictMode";
38        case REACT_SUSPENSE_TYPE:
39          return "Suspense";
40        case REACT_SUSPENSE_LIST_TYPE:
41          return "SuspenseList";
42        case REACT_ACTIVITY_TYPE:
43          return "Activity";
44        case REACT_VIEW_TRANSITION_TYPE:
45          return "ViewTransition";
46      }
47      if ("object" === typeof type)
48        switch (
49          ("number" === typeof type.tag &&
50            console.error(
51              "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
52            ),
53          type.$$typeof)
54        ) {
55          case REACT_PORTAL_TYPE:
56            return "Portal";
57          case REACT_CONTEXT_TYPE:
58            return type.displayName || "Context";
59          case REACT_CONSUMER_TYPE:
60            return (type._context.displayName || "Context") + ".Consumer";
61          case REACT_FORWARD_REF_TYPE:
62            var innerType = type.render;
63            type = type.displayName;
64            type ||
65              ((type = innerType.displayName || innerType.name || ""),
66              (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
67            return type;
68          case REACT_MEMO_TYPE:
69            return (
70              (innerType = type.displayName || null),
71              null !== innerType
72                ? innerType
73                : getComponentNameFromType(type.type) || "Memo"
74            );
75          case REACT_LAZY_TYPE:
76            innerType = type._payload;
77            type = type._init;
78            try {
79              return getComponentNameFromType(type(innerType));
80            } catch (x) {}
81        }
82      return null;
83    }
84    function testStringCoercion(value) {
85      return "" + value;
86    }
87    function checkKeyStringCoercion(value) {
88      try {
89        testStringCoercion(value);
90        var JSCompiler_inline_result = !1;
91      } catch (e) {
92        JSCompiler_inline_result = !0;
93      }
94      if (JSCompiler_inline_result) {
95        JSCompiler_inline_result = console;
96        var JSCompiler_temp_const = JSCompiler_inline_result.error;
97        var JSCompiler_inline_result$jscomp$0 =
98          ("function" === typeof Symbol &&
99            Symbol.toStringTag &&
100            value[Symbol.toStringTag]) ||
101          value.constructor.name ||
102          "Object";
103        JSCompiler_temp_const.call(
104          JSCompiler_inline_result,
105          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
106          JSCompiler_inline_result$jscomp$0
107        );
108        return testStringCoercion(value);
109      }
110    }
111    function getTaskName(type) {
112      if (type === REACT_FRAGMENT_TYPE) return "<>";
113      if (
114        "object" === typeof type &&
115        null !== type &&
116        type.$$typeof === REACT_LAZY_TYPE
117      )
118        return "<...>";
119      try {
120        var name = getComponentNameFromType(type);
121        return name ? "<" + name + ">" : "<...>";
122      } catch (x) {
123        return "<...>";
124      }
125    }
126    function getOwner() {
127      var dispatcher = ReactSharedInternals.A;
128      return null === dispatcher ? null : dispatcher.getOwner();
129    }
130    function UnknownOwner() {
131      return Error("react-stack-top-frame");
132    }
133    function hasValidKey(config) {
134      if (hasOwnProperty.call(config, "key")) {
135        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
136        if (getter && getter.isReactWarning) return !1;
137      }
138      return void 0 !== config.key;
139    }
140    function defineKeyPropWarningGetter(props, displayName) {
141      function warnAboutAccessingKey() {
142        specialPropKeyWarningShown ||
143          ((specialPropKeyWarningShown = !0),
144          console.error(
145            "%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://react.dev/link/special-props)",
146            displayName
147          ));
148      }
149      warnAboutAccessingKey.isReactWarning = !0;
150      Object.defineProperty(props, "key", {
151        get: warnAboutAccessingKey,
152        configurable: !0
153      });
154    }
155    function elementRefGetterWithDeprecationWarning() {
156      var componentName = getComponentNameFromType(this.type);
157      didWarnAboutElementRef[componentName] ||
158        ((didWarnAboutElementRef[componentName] = !0),
159        console.error(
160          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
161        ));
162      componentName = this.props.ref;
163      return void 0 !== componentName ? componentName : null;
164    }
165    function ReactElement(type, key, props, owner, debugStack, debugTask) {
166      var refProp = props.ref;
167      type = {
168        $$typeof: REACT_ELEMENT_TYPE,
169        type: type,
170        key: key,
171        props: props,
172        _owner: owner
173      };
174      null !== (void 0 !== refProp ? refProp : null)
175        ? Object.defineProperty(type, "ref", {
176            enumerable: !1,
177            get: elementRefGetterWithDeprecationWarning
178          })
179        : Object.defineProperty(type, "ref", { enumerable: !1, value: null });
180      type._store = {};
181      Object.defineProperty(type._store, "validated", {
182        configurable: !1,
183        enumerable: !1,
184        writable: !0,
185        value: 0
186      });
187      Object.defineProperty(type, "_debugInfo", {
188        configurable: !1,
189        enumerable: !1,
190        writable: !0,
191        value: null
192      });
193      Object.defineProperty(type, "_debugStack", {
194        configurable: !1,
195        enumerable: !1,
196        writable: !0,
197        value: debugStack
198      });
199      Object.defineProperty(type, "_debugTask", {
200        configurable: !1,
201        enumerable: !1,
202        writable: !0,
203        value: debugTask
204      });
205      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
206      return type;
207    }
208    function jsxDEVImpl(
209      type,
210      config,
211      maybeKey,
212      isStaticChildren,
213      debugStack,
214      debugTask
215    ) {
216      var children = config.children;
217      if (void 0 !== children)
218        if (isStaticChildren)
219          if (isArrayImpl(children)) {
220            for (
221              isStaticChildren = 0;
222              isStaticChildren < children.length;
223              isStaticChildren++
224            )
225              validateChildKeys(children[isStaticChildren]);

402            "%s(...) is deprecated in plain JavaScript React classes. %s",
403            info[0],
404            info[1]
405          );
406        }
407      });
408    }
409    function getIteratorFn(maybeIterable) {
410      if (null === maybeIterable || "object" !== typeof maybeIterable)
411        return null;
412      maybeIterable =
413        (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
414        maybeIterable["@@iterator"];
415      return "function" === typeof maybeIterable ? maybeIterable : null;
416    }
417    function warnNoop(publicInstance, callerName) {
418      publicInstance =
419        ((publicInstance = publicInstance.constructor) &&
420          (publicInstance.displayName || publicInstance.name)) ||
421        "ReactClass";
422      var warningKey = publicInstance + "." + callerName;
423      didWarnStateUpdateForUnmountedComponent[warningKey] ||
424        (console.error(
425          "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.",
426          callerName,
427          publicInstance
428        ),
429        (didWarnStateUpdateForUnmountedComponent[warningKey] = !0));
430    }
431    function Component(props, context, updater) {
432      this.props = props;
433      this.context = context;
434      this.refs = emptyObject;
435      this.updater = updater || ReactNoopUpdateQueue;
436    }
437    function ComponentDummy() {}
438    function PureComponent(props, context, updater) {
439      this.props = props;
440      this.context = context;
441      this.refs = emptyObject;
442      this.updater = updater || ReactNoopUpdateQueue;
443    }
444    function noop() {}
445    function testStringCoercion(value) {
446      return "" + value;
447    }
448    function checkKeyStringCoercion(value) {
449      try {
450        testStringCoercion(value);
451        var JSCompiler_inline_result = !1;
452      } catch (e) {
453        JSCompiler_inline_result = !0;
454      }
455      if (JSCompiler_inline_result) {
456        JSCompiler_inline_result = console;
457        var JSCompiler_temp_const = JSCompiler_inline_result.error;
458        var JSCompiler_inline_result$jscomp$0 =
459          ("function" === typeof Symbol &&
460            Symbol.toStringTag &&
461            value[Symbol.toStringTag]) ||
462          value.constructor.name ||
463          "Object";
464        JSCompiler_temp_const.call(
465          JSCompiler_inline_result,
466          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
467          JSCompiler_inline_result$jscomp$0
468        );
469        return testStringCoercion(value);
470      }
471    }
472    function getComponentNameFromType(type) {
473      if (null == type) return null;
474      if ("function" === typeof type)
475        return type.$$typeof === REACT_CLIENT_REFERENCE
476          ? null
477          : type.displayName || type.name || null;
478      if ("string" === typeof type) return type;
479      switch (type) {
480        case REACT_FRAGMENT_TYPE:
481          return "Fragment";
482        case REACT_PROFILER_TYPE:
483          return "Profiler";
484        case REACT_STRICT_MODE_TYPE:
485          return "StrictMode";
486        case REACT_SUSPENSE_TYPE:
487          return "Suspense";
488        case REACT_SUSPENSE_LIST_TYPE:
489          return "SuspenseList";
490        case REACT_ACTIVITY_TYPE:
491          return "Activity";
492        case REACT_VIEW_TRANSITION_TYPE:
493          return "ViewTransition";
494      }
495      if ("object" === typeof type)
496        switch (
497          ("number" === typeof type.tag &&
498            console.error(
499              "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
500            ),
501          type.$$typeof)
502        ) {
503          case REACT_PORTAL_TYPE:
504            return "Portal";
505          case REACT_CONTEXT_TYPE:
506            return type.displayName || "Context";
507          case REACT_CONSUMER_TYPE:
508            return (type._context.displayName || "Context") + ".Consumer";
509          case REACT_FORWARD_REF_TYPE:
510            var innerType = type.render;
511            type = type.displayName;
512            type ||
513              ((type = innerType.displayName || innerType.name || ""),
514              (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
515            return type;
516          case REACT_MEMO_TYPE:
517            return (
518              (innerType = type.displayName || null),
519              null !== innerType
520                ? innerType
521                : getComponentNameFromType(type.type) || "Memo"
522            );
523          case REACT_LAZY_TYPE:
524            innerType = type._payload;
525            type = type._init;
526            try {
527              return getComponentNameFromType(type(innerType));
528            } catch (x) {}
529        }
530      return null;
531    }
532    function getTaskName(type) {
533      if (type === REACT_FRAGMENT_TYPE) return "<>";
534      if (
535        "object" === typeof type &&
536        null !== type &&
537        type.$$typeof === REACT_LAZY_TYPE
538      )
539        return "<...>";
540      try {
541        var name = getComponentNameFromType(type);
542        return name ? "<" + name + ">" : "<...>";
543      } catch (x) {
544        return "<...>";
545      }
546    }
547    function getOwner() {
548      var dispatcher = ReactSharedInternals.A;
549      return null === dispatcher ? null : dispatcher.getOwner();
550    }
551    function UnknownOwner() {
552      return Error("react-stack-top-frame");
553    }
554    function hasValidKey(config) {
555      if (hasOwnProperty.call(config, "key")) {
556        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
557        if (getter && getter.isReactWarning) return !1;
558      }
559      return void 0 !== config.key;
560    }
561    function defineKeyPropWarningGetter(props, displayName) {
562      function warnAboutAccessingKey() {
563        specialPropKeyWarningShown ||
564          ((specialPropKeyWarningShown = !0),
565          console.error(
566            "%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://react.dev/link/special-props)",
567            displayName
568          ));
569      }
570      warnAboutAccessingKey.isReactWarning = !0;
571      Object.defineProperty(props, "key", {
572        get: warnAboutAccessingKey,
573        configurable: !0
574      });
575    }
576    function elementRefGetterWithDeprecationWarning() {
577      var componentName = getComponentNameFromType(this.type);
578      didWarnAboutElementRef[componentName] ||
579        ((didWarnAboutElementRef[componentName] = !0),
580        console.error(
581          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
582        ));
583      componentName = this.props.ref;
584      return void 0 !== componentName ? componentName : null;
585    }
586    function ReactElement(type, key, props, owner, debugStack, debugTask) {
587      var refProp = props.ref;
588      type = {
589        $$typeof: REACT_ELEMENT_TYPE,
590        type: type,
591        key: key,
592        props: props,
593        _owner: owner
594      };
595      null !== (void 0 !== refProp ? refProp : null)
596        ? Object.defineProperty(type, "ref", {
597            enumerable: !1,
598            get: elementRefGetterWithDeprecationWarning
599          })
600        : Object.defineProperty(type, "ref", { enumerable: !1, value: null });
601      type._store = {};
602      Object.defineProperty(type._store, "validated", {
603        configurable: !1,
604        enumerable: !1,
605        writable: !0,
606        value: 0
607      });
608      Object.defineProperty(type, "_debugInfo", {
609        configurable: !1,
610        enumerable: !1,
611        writable: !0,
612        value: null
613      });
614      Object.defineProperty(type, "_debugStack", {
615        configurable: !1,
616        enumerable: !1,
617        writable: !0,
618        value: debugStack
619      });
620      Object.defineProperty(type, "_debugTask", {
621        configurable: !1,
622        enumerable: !1,
623        writable: !0,
624        value: debugTask
625      });
626      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
627      return type;
628    }
629    function cloneAndReplaceKey(oldElement, newKey) {
630      newKey = ReactElement(
631        oldElement.type,
632        newKey,
633        oldElement.props,
634        oldElement._owner,
635        oldElement._debugStack,
636        oldElement._debugTask
637      );
638      oldElement._store &&
639        (newKey._store.validated = oldElement._store.validated);
640      return newKey;
641    }
642    function validateChildKeys(node) {
643      isValidElement(node)
644        ? node._store && (node._store.validated = 1)
645        : "object" === typeof node &&
646          null !== node &&
647          node.$$typeof === REACT_LAZY_TYPE &&
648          ("fulfilled" === node._payload.status
649            ? isValidElement(node._payload.value) &&
650              node._payload.value._store &&
651              (node._payload.value._store.validated = 1)
652            : node._store && (node._store.validated = 1));
653    }
654    function isValidElement(object) {
655      return (
656        "object" === typeof object &&
657        null !== object &&
658        object.$$typeof === REACT_ELEMENT_TYPE
659      );
660    }
661    function escape(key) {
662      var escaperLookup = { "=": "=0", ":": "=2" };
663      return (
664        "$" +
665        key.replace(/[=:]/g, function (match) {
666          return escaperLookup[match];
667        })
668      );
669    }
670    function getElementKey(element, index) {
671      return "object" === typeof element &&
672        null !== element &&
673        null != element.key
674        ? (checkKeyStringCoercion(element.key), escape("" + element.key))
675        : index.toString(36);
676    }
677    function resolveThenable(thenable) {
678      switch (thenable.status) {
679        case "fulfilled":
680          return thenable.value;
681        case "rejected":
682          throw thenable.reason;
683        default:
684          switch (
685            ("string" === typeof thenable.status
686              ? thenable.then(noop, noop)
687              : ((thenable.status = "pending"),
688                thenable.then(
689                  function (fulfilledValue) {
690                    "pending" === thenable.status &&
691                      ((thenable.status = "fulfilled"),
692                      (thenable.value = fulfilledValue));
693                  },
694                  function (error) {
695                    "pending" === thenable.status &&
696                      ((thenable.status = "rejected"),

697                      (thenable.reason = error));
698                  }
699                )),
700            thenable.status)
701          ) {
702            case "fulfilled":
703              return thenable.value;
704            case "rejected":
705              throw thenable.reason;
706          }
707      }
708      throw thenable;
709    }
710    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
711      var type = typeof children;
712      if ("undefined" === type || "boolean" === type) children = null;
713      var invokeCallback = !1;
714      if (null === children) invokeCallback = !0;
715      else
716        switch (type) {
717          case "bigint":
718          case "string":
719          case "number":
720            invokeCallback = !0;
721            break;
722          case "object":
723            switch (children.$$typeof) {
724              case REACT_ELEMENT_TYPE:
725              case REACT_PORTAL_TYPE:
726                invokeCallback = !0;
727                break;
728              case REACT_LAZY_TYPE:
729                return (
730                  (invokeCallback = children._init),
731                  mapIntoArray(
732                    invokeCallback(children._payload),
733                    array,
734                    escapedPrefix,
735                    nameSoFar,
736                    callback
737                  )
738                );
739            }
740        }
741      if (invokeCallback) {
742        invokeCallback = children;
743        callback = callback(invokeCallback);
744        var childKey =
745          "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
746        isArrayImpl(callback)
747          ? ((escapedPrefix = ""),
748            null != childKey &&
749              (escapedPrefix =
750                childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"),
751            mapIntoArray(callback, array, escapedPrefix, "", function (c) {
752              return c;
753            }))
754          : null != callback &&
755            (isValidElement(callback) &&
756              (null != callback.key &&
757                ((invokeCallback && invokeCallback.key === callback.key) ||
758                  checkKeyStringCoercion(callback.key)),
759              (escapedPrefix = cloneAndReplaceKey(
760                callback,
761                escapedPrefix +
762                  (null == callback.key ||
763                  (invokeCallback && invokeCallback.key === callback.key)
764                    ? ""
765                    : ("" + callback.key).replace(
766                        userProvidedKeyEscapeRegex,
767                        "$&/"
768                      ) + "/") +
769                  childKey
770              )),
771              "" !== nameSoFar &&
772                null != invokeCallback &&
773                isValidElement(invokeCallback) &&
774                null == invokeCallback.key &&
775                invokeCallback._store &&
776                !invokeCallback._store.validated &&
777                (escapedPrefix._store.validated = 2),
778              (callback = escapedPrefix)),
779            array.push(callback));
780        return 1;
781      }
782      invokeCallback = 0;
783      childKey = "" === nameSoFar ? "." : nameSoFar + ":";
784      if (isArrayImpl(children))
785        for (var i = 0; i < children.length; i++)
786          (nameSoFar = children[i]),
787            (type = childKey + getElementKey(nameSoFar, i)),
788            (invokeCallback += mapIntoArray(
789              nameSoFar,
790              array,
791              escapedPrefix,
792              type,
793              callback
794            ));
795      else if (((i = getIteratorFn(children)), "function" === typeof i))
796        for (
797          i === children.entries &&
798            (didWarnAboutMaps ||
799              console.warn(
800                "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
801              ),
802            (didWarnAboutMaps = !0)),
803            children = i.call(children),
804            i = 0;
805          !(nameSoFar = children.next()).done;
806
807        )
808          (nameSoFar = nameSoFar.value),
809            (type = childKey + getElementKey(nameSoFar, i++)),
810            (invokeCallback += mapIntoArray(
811              nameSoFar,
812              array,
813              escapedPrefix,
814              type,
815              callback
816            ));
817      else if ("object" === type) {
818        if ("function" === typeof children.then)
819          return mapIntoArray(
820            resolveThenable(children),
821            array,
822            escapedPrefix,
823            nameSoFar,
824            callback
825          );
826        array = String(children);
827        throw Error(
828          "Objects are not valid as a React child (found: " +
829            ("[object Object]" === array
830              ? "object with keys {" + Object.keys(children).join(", ") + "}"
831              : array) +
832            "). If you meant to render a collection of children, use an array instead."
833        );
834      }
835      return invokeCallback;
836    }
837    function mapChildren(children, func, context) {
838      if (null == children) return children;
839      var result = [],
840        count = 0;
841      mapIntoArray(children, result, "", "", function (child) {
842        return func.call(context, child, count++);
843      });
844      return result;
845    }
846    function lazyInitializer(payload) {
847      if (-1 === payload._status) {
848        var resolveDebugValue = null,
849          rejectDebugValue = null,
850          ioInfo = payload._ioInfo;
851        null != ioInfo &&
852          ((ioInfo.start = ioInfo.end = performance.now()),
853          (ioInfo.value = new Promise(function (resolve, reject) {
854            resolveDebugValue = resolve;
855            rejectDebugValue = reject;
856          })));
857        ioInfo = payload._result;
858        var thenable = ioInfo();
859        thenable.then(
860          function (moduleObject) {
861            if (0 === payload._status || -1 === payload._status) {
862              payload._status = 1;
863              payload._result = moduleObject;
864              var _ioInfo = payload._ioInfo;
865              if (null != _ioInfo) {
866                _ioInfo.end = performance.now();
867                var debugValue =
868                  null == moduleObject ? void 0 : moduleObject.default;
869                resolveDebugValue(debugValue);
870                _ioInfo.value.status = "fulfilled";
871                _ioInfo.value.value = debugValue;
872              }
873              void 0 === thenable.status &&
874                ((thenable.status = "fulfilled"),
875                (thenable.value = moduleObject));
876            }
877          },
878          function (error) {
879            if (0 === payload._status || -1 === payload._status) {
880              payload._status = 2;
881              payload._result = error;
882              var _ioInfo2 = payload._ioInfo;
883              null != _ioInfo2 &&
884                ((_ioInfo2.end = performance.now()),
885                _ioInfo2.value.then(noop, noop),
886                rejectDebugValue(error),
887                (_ioInfo2.value.status = "rejected"),

888                (_ioInfo2.value.reason = error));
889              void 0 === thenable.status &&
890                ((thenable.status = "rejected"), (thenable.reason = error));
891            }
892          }
893        );
894        ioInfo = payload._ioInfo;
895        if (null != ioInfo) {
896          var displayName = thenable.displayName;
897          "string" === typeof displayName && (ioInfo.name = displayName);
898        }
899        -1 === payload._status &&
900          ((payload._status = 0), (payload._result = thenable));
901      }
902      if (1 === payload._status)
903        return (
904          (ioInfo = payload._result),
905          void 0 === ioInfo &&
906            console.error(
907              "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?",
908              ioInfo
909            ),
910          "default" in ioInfo ||
911            console.error(
912              "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))",
913              ioInfo
914            ),
915          ioInfo.default
916        );
917      throw payload._result;
918    }
919    function resolveDispatcher() {
920      var dispatcher = ReactSharedInternals.H;
921      null === dispatcher &&
922        console.error(
923          "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://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
924        );
925      return dispatcher;
926    }
927    function releaseAsyncTransition() {
928      ReactSharedInternals.asyncTransitions--;
929    }
930    function startTransition(scope) {
931      var prevTransition = ReactSharedInternals.T,
932        currentTransition = {};
933      currentTransition.types =
934        null !== prevTransition ? prevTransition.types : null;
935      currentTransition._updatedFibers = new Set();
936      ReactSharedInternals.T = currentTransition;

937      try {
938        var returnValue = scope(),
939          onStartTransitionFinish = ReactSharedInternals.S;
940        null !== onStartTransitionFinish &&
941          onStartTransitionFinish(currentTransition, returnValue);
942        "object" === typeof returnValue &&
943          null !== returnValue &&
944          "function" === typeof returnValue.then &&
945          (ReactSharedInternals.asyncTransitions++,
946          returnValue.then(releaseAsyncTransition, releaseAsyncTransition),
947          returnValue.then(noop, reportGlobalError));
948      } catch (error) {
949        reportGlobalError(error);
950      } finally {
951        null === prevTransition &&
952          currentTransition._updatedFibers &&
953          ((scope = currentTransition._updatedFibers.size),
954          currentTransition._updatedFibers.clear(),
955          10 < scope &&
956            console.warn(
957              "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."
958            )),
959          null !== prevTransition &&
960            null !== currentTransition.types &&
961            (null !== prevTransition.types &&
962              prevTransition.types !== currentTransition.types &&
963              console.error(
964                "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
965              ),
966            (prevTransition.types = currentTransition.types)),
967          (ReactSharedInternals.T = prevTransition);
968      }
969    }
970    function addTransitionType(type) {
971      var transition = ReactSharedInternals.T;
972      if (null !== transition) {
973        var transitionTypes = transition.types;
974        null === transitionTypes
975          ? (transition.types = [type])
976          : -1 === transitionTypes.indexOf(type) && transitionTypes.push(type);
977      } else
978        0 === ReactSharedInternals.asyncTransitions &&
979          console.error(
980            "addTransitionType can only be called inside a `startTransition()` callback. It must be associated with a specific Transition."
981          ),
982          startTransition(addTransitionType.bind(null, type));
983    }
984    function enqueueTask(task) {
985      if (null === enqueueTaskImpl)
986        try {
987          var requireString = ("require" + Math.random()).slice(0, 7);
988          enqueueTaskImpl = (module && module[requireString]).call(
989            module,
990            "timers"
991          ).setImmediate;
992        } catch (_err) {
993          enqueueTaskImpl = function (callback) {
994            !1 === didWarnAboutMessageChannel &&
995              ((didWarnAboutMessageChannel = !0),
996              "undefined" === typeof MessageChannel &&
997                console.error(
998                  "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."
999                ));
1000            var channel = new MessageChannel();
1001            channel.port1.onmessage = callback;
1002            channel.port2.postMessage(void 0);
1003          };
1004        }
1005      return enqueueTaskImpl(task);
1006    }
1007    function aggregateErrors(errors) {
1008      return 1 < errors.length && "function" === typeof AggregateError
1009        ? new AggregateError(errors)
1010        : errors[0];
1011    }
1012    function popActScope(prevActQueue, prevActScopeDepth) {
1013      prevActScopeDepth !== actScopeDepth - 1 &&
1014        console.error(
1015          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
1016        );
1017      actScopeDepth = prevActScopeDepth;
1018    }
1019    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
1020      var queue = ReactSharedInternals.actQueue;
1021      if (null !== queue)
1022        if (0 !== queue.length)
1023          try {
1024            flushActQueue(queue);
1025            enqueueTask(function () {
1026              return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
1027            });
1028            return;
1029          } catch (error) {
1030            ReactSharedInternals.thrownErrors.push(error);
1031          }
1032        else ReactSharedInternals.actQueue = null;
1033      0 < ReactSharedInternals.thrownErrors.length
1034        ? ((queue = aggregateErrors(ReactSharedInternals.thrownErrors)),
1035          (ReactSharedInternals.thrownErrors.length = 0),
1036          reject(queue))
1037        : resolve(returnValue);
1038    }
1039    function flushActQueue(queue) {
1040      if (!isFlushing) {
1041        isFlushing = !0;
1042        var i = 0;
1043        try {
1044          for (; i < queue.length; i++) {
1045            var callback = queue[i];
1046            do {
1047              ReactSharedInternals.didUsePromise = !1;
1048              var continuation = callback(!1);
1049              if (null !== continuation) {
1050                if (ReactSharedInternals.didUsePromise) {
1051                  queue[i] = callback;
1052                  queue.splice(0, i);
1053                  return;
1054                }
1055                callback = continuation;
1056              } else break;
1057            } while (1);
1058          }
1059          queue.length = 0;
1060        } catch (error) {
1061          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
1062        } finally {
1063          isFlushing = !1;
1064        }
1065      }
1066    }
1067    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
1068      "function" ===
1069        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
1070      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
1071    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
1072      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
1073      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
1074      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
1075      REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
1076      REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
1077      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
1078      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
1079      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
1080      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
1081      REACT_MEMO_TYPE = Symbol.for("react.memo"),
1082      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
1083      REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
1084      REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"),
1085      MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
1086      didWarnStateUpdateForUnmountedComponent = {},
1087      ReactNoopUpdateQueue = {
1088        isMounted: function () {
1089          return !1;
1090        },
1091        enqueueForceUpdate: function (publicInstance) {
1092          warnNoop(publicInstance, "forceUpdate");
1093        },
1094        enqueueReplaceState: function (publicInstance) {
1095          warnNoop(publicInstance, "replaceState");
1096        },
1097        enqueueSetState: function (publicInstance) {
1098          warnNoop(publicInstance, "setState");
1099        }
1100      },
1101      assign = Object.assign,
1102      emptyObject = {};

1103    Object.freeze(emptyObject);
1104    Component.prototype.isReactComponent = {};
1105    Component.prototype.setState = function (partialState, callback) {
1106      if (
1107        "object" !== typeof partialState &&
1108        "function" !== typeof partialState &&
1109        null != partialState
1110      )
1111        throw Error(
1112          "takes an object of state variables to update or a function which returns an object of state variables."
1113        );
1114      this.updater.enqueueSetState(this, partialState, callback, "setState");
1115    };
1116    Component.prototype.forceUpdate = function (callback) {
1117      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
1118    };
1119    var deprecatedAPIs = {
1120      isMounted: [
1121        "isMounted",
1122        "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
1123      ],
1124      replaceState: [
1125        "replaceState",
1126        "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
1127      ]
1128    };
1129    for (fnName in deprecatedAPIs)
1130      deprecatedAPIs.hasOwnProperty(fnName) &&
1131        defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
1132    ComponentDummy.prototype = Component.prototype;
1133    deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
1134    deprecatedAPIs.constructor = PureComponent;
1135    assign(deprecatedAPIs, Component.prototype);
1136    deprecatedAPIs.isPureReactComponent = !0;
1137    var isArrayImpl = Array.isArray,
1138      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
1139      ReactSharedInternals = {
1140        H: null,
1141        A: null,
1142        T: null,
1143        S: null,
1144        actQueue: null,
1145        asyncTransitions: 0,
1146        isBatchingLegacy: !1,
1147        didScheduleLegacyUpdate: !1,
1148        didUsePromise: !1,
1149        thrownErrors: [],
1150        getCurrentStack: null,
1151        recentlyCreatedOwnerStacks: 0
1152      },
1153      hasOwnProperty = Object.prototype.hasOwnProperty,
1154      createTask = console.createTask
1155        ? console.createTask
1156        : function () {
1157            return null;
1158          };
1159    deprecatedAPIs = {
1160      react_stack_bottom_frame: function (callStackForError) {
1161        return callStackForError();
1162      }
1163    };
1164    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
1165    var didWarnAboutElementRef = {};
1166    var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(
1167      deprecatedAPIs,
1168      UnknownOwner
1169    )();
1170    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
1171    var didWarnAboutMaps = !1,
1172      userProvidedKeyEscapeRegex = /\/+/g,
1173      reportGlobalError =
1174        "function" === typeof reportError
1175          ? reportError
1176          : function (error) {
1177              if (
1178                "object" === typeof window &&
1179                "function" === typeof window.ErrorEvent
1180              ) {
1181                var event = new window.ErrorEvent("error", {
1182                  bubbles: !0,
1183                  cancelable: !0,
1184                  message:
1185                    "object" === typeof error &&
1186                    null !== error &&
1187                    "string" === typeof error.message
1188                      ? String(error.message)
1189                      : String(error),
1190                  error: error
1191                });
1192                if (!window.dispatchEvent(event)) return;
1193              } else if (
1194                "object" === typeof process &&
1195                "function" === typeof process.emit
1196              ) {
1197                process.emit("uncaughtException", error);
1198                return;
1199              }
1200              console.error(error);
1201            },
1202      didWarnAboutMessageChannel = !1,
1203      enqueueTaskImpl = null,
1204      actScopeDepth = 0,
1205      didWarnNoAwaitAct = !1,
1206      isFlushing = !1,
1207      queueSeveralMicrotasks =
1208        "function" === typeof queueMicrotask
1209          ? function (callback) {
1210              queueMicrotask(function () {
1211                return queueMicrotask(callback);
1212              });
1213            }
1214          : enqueueTask;
1215    deprecatedAPIs = Object.freeze({
1216      __proto__: null,
1217      c: function (size) {
1218        return resolveDispatcher().useMemoCache(size);
1219      }
1220    });
1221    var fnName = {
1222      map: mapChildren,

1223      forEach: function (children, forEachFunc, forEachContext) {
1224        mapChildren(
1225          children,
1226          function () {
1227            forEachFunc.apply(this, arguments);
1228          },
1229          forEachContext
1230        );
1231      },
1232      count: function (children) {
1233        var n = 0;
1234        mapChildren(children, function () {
1235          n++;
1236        });
1237        return n;
1238      },
1239      toArray: function (children) {
1240        return (
1241          mapChildren(children, function (child) {
1242            return child;
1243          }) || []
1244        );
1245      },
1246      only: function (children) {
1247        if (!isValidElement(children))
1248          throw Error(
1249            "React.Children.only expected to receive a single React element child."
1250          );
1251        return children;
1252      }
1253    };
1254    exports.Activity = REACT_ACTIVITY_TYPE;
1255    exports.Children = fnName;
1256    exports.Component = Component;
1257    exports.Fragment = REACT_FRAGMENT_TYPE;
1258    exports.Profiler = REACT_PROFILER_TYPE;
1259    exports.PureComponent = PureComponent;
1260    exports.StrictMode = REACT_STRICT_MODE_TYPE;
1261    exports.Suspense = REACT_SUSPENSE_TYPE;
1262    exports.ViewTransition = REACT_VIEW_TRANSITION_TYPE;
1263    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
1264      ReactSharedInternals;
1265    exports.__COMPILER_RUNTIME = deprecatedAPIs;
1266    exports.act = function (callback) {
1267      var prevActQueue = ReactSharedInternals.actQueue,
1268        prevActScopeDepth = actScopeDepth;
1269      actScopeDepth++;
1270      var queue = (ReactSharedInternals.actQueue =
1271          null !== prevActQueue ? prevActQueue : []),
1272        didAwaitActCall = !1;
1273      try {
1274        var result = callback();
1275      } catch (error) {
1276        ReactSharedInternals.thrownErrors.push(error);
1277      }
1278      if (0 < ReactSharedInternals.thrownErrors.length)
1279        throw (
1280          (popActScope(prevActQueue, prevActScopeDepth),
1281          (callback = aggregateErrors(ReactSharedInternals.thrownErrors)),
1282          (ReactSharedInternals.thrownErrors.length = 0),
1283          callback)
1284        );
1285      if (
1286        null !== result &&
1287        "object" === typeof result &&
1288        "function" === typeof result.then
1289      ) {
1290        var thenable = result;
1291        queueSeveralMicrotasks(function () {
1292          didAwaitActCall ||
1293            didWarnNoAwaitAct ||
1294            ((didWarnNoAwaitAct = !0),
1295            console.error(
1296              "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 () => ...);"
1297            ));
1298        });
1299        return {
1300          then: function (resolve, reject) {
1301            didAwaitActCall = !0;
1302            thenable.then(
1303              function (returnValue) {
1304                popActScope(prevActQueue, prevActScopeDepth);
1305                if (0 === prevActScopeDepth) {
1306                  try {
1307                    flushActQueue(queue),
1308                      enqueueTask(function () {
1309                        return recursivelyFlushAsyncActWork(
1310                          returnValue,
1311                          resolve,
1312                          reject
1313                        );
1314                      });
1315                  } catch (error$0) {
1316                    ReactSharedInternals.thrownErrors.push(error$0);
1317                  }
1318                  if (0 < ReactSharedInternals.thrownErrors.length) {
1319                    var _thrownError = aggregateErrors(
1320                      ReactSharedInternals.thrownErrors
1321                    );
1322                    ReactSharedInternals.thrownErrors.length = 0;
1323                    reject(_thrownError);
1324                  }
1325                } else resolve(returnValue);
1326              },
1327              function (error) {
1328                popActScope(prevActQueue, prevActScopeDepth);
1329                0 < ReactSharedInternals.thrownErrors.length
1330                  ? ((error = aggregateErrors(
1331                      ReactSharedInternals.thrownErrors
1332                    )),
1333                    (ReactSharedInternals.thrownErrors.length = 0),
1334                    reject(error))
1335                  : reject(error);
1336              }
1337            );
1338          }
1339        };
1340      }
1341      var returnValue$jscomp$0 = result;
1342      popActScope(prevActQueue, prevActScopeDepth);
1343      0 === prevActScopeDepth &&
1344        (flushActQueue(queue),
1345        0 !== queue.length &&
1346          queueSeveralMicrotasks(function () {
1347            didAwaitActCall ||
1348              didWarnNoAwaitAct ||
1349              ((didWarnNoAwaitAct = !0),
1350              console.error(
1351                "A component suspended inside an `act` scope, but the `act` c

1351all was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
1352              ));
1353          }),
1354        (ReactSharedInternals.actQueue = null));
1355      if (0 < ReactSharedInternals.thrownErrors.length)
1356        throw (
1357          ((callback = aggregateErrors(ReactSharedInternals.thrownErrors)),
1358          (ReactSharedInternals.thrownErrors.length = 0),
1359          callback)
1360        );
1361      return {
1362        then: function (resolve, reject) {
1363          didAwaitActCall = !0;
1364          0 === prevActScopeDepth
1365            ? ((ReactSharedInternals.actQueue = queue),
1366              enqueueTask(function () {
1367                return recursivelyFlushAsyncActWork(
1368                  returnValue$jscomp$0,
1369                  resolve,
1370                  reject
1371                );
1372              }))
1373            : resolve(returnValue$jscomp$0);
1374        }
1375      };
1376    };
1377    exports.addTransitionType = addTransitionType;
1378    exports.cache = function (fn) {
1379      return function () {
1380        return fn.apply(null, arguments);
1381      };
1382    };
1383    exports.cacheSignal = function () {
1384      return null;
1385    };
1386    exports.captureOwnerStack = function () {
1387      var getCurrentStack = ReactSharedInternals.getCurrentStack;
1388      return null === getCurrentStack ? null : getCurrentStack();
1389    };
1390    exports.cloneElement = function (element, config, children) {
1391      if (null === element || void 0 === element)
1392        throw Error(
1393          "The argument must be a React element, but you passed " +
1394            element +
1395            "."
1396        );
1397      var props = assign({}, element.props),
1398        key = element.key,
1399        owner = element._owner;
1400      if (null != config) {
1401        var JSCompiler_inline_result;
1402        a: {
1403          if (
1404            hasOwnProperty.call(config, "ref") &&
1405            (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
1406              config,
1407              "ref"
1408            ).get) &&
1409            JSCompiler_inline_result.isReactWarning
1410          ) {
1411            JSCompiler_inline_result = !1;
1412            break a;
1413          }
1414          JSCompiler_inline_result = void 0 !== config.ref;
1415        }
1416        JSCompiler_inline_result && (owner = getOwner());
1417        hasValidKey(config) &&
1418          (checkKeyStringCoercion(config.key), (key = "" + config.key));
1419        for (propName in config)
1420          !hasOwnProperty.call(config, propName) ||
1421            "key" === propName ||
1422            "__self" === propName ||
1423            "__source" === propName ||
1424            ("ref" === propName && void 0 === config.ref) ||
1425            (props[propName] = config[propName]);
1426      }
1427      var propName = arguments.length - 2;
1428      if (1 === propName) props.children = children;
1429      else if (1 < propName) {
1430        JSCompiler_inline_result = Array(propName);
1431        for (var i = 0; i < propName; i++)
1432          JSCompiler_inline_result[i] = arguments[i + 2];
1433        props.children = JSCompiler_inline_result;
1434      }
1435      props = ReactElement(
1436        element.type,
1437        key,
1438        props,
1439        owner,
1440        element._debugStack,
1441        element._debugTask
1442      );
1443      for (key = 2; key < arguments.length; key++)
1444        validateChildKeys(arguments[key]);
1445      return props;
1446    };
1447    exports.createContext = function (defaultValue) {
1448      defaultValue = {
1449        $$typeof: REACT_CONTEXT_TYPE,
1450        _currentValue: defaultValue,
1451        _currentValue2: defaultValue,
1452        _threadCount: 0,
1453        Provider: null,
1454        Consumer: null
1455      };
1456      defaultValue.Provider = defaultValue;
1457      defaultValue.Consumer = {
1458        $$typeof: REACT_CONSUMER_TYPE,
1459        _context: defaultValue
1460      };
1461      defaultValue._currentRenderer = null;
1462      defaultValue._currentRenderer2 = null;
1463      return defaultValue;
1464    };
1465    exports.createElement = function (type, config, children) {
1466      for (var i = 2; i < arguments.length; i++)
1467        validateChildKeys(arguments[i]);
1468      var propName;
1469      i = {};
1470      var key = null;
1471      if (null != config)
1472        for (propName in (didWarnAboutOldJSXRuntime ||
1473          !("__self" in config) ||
1474          "key" in config ||
1475          ((didWarnAboutOldJSXRuntime = !0),
1476          console.warn(
1477            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
1478          )),
1479        hasValidKey(config) &&
1480          (checkKeyStringCoercion(config.key), (key = "" + config.key)),
1481        config))
1482          hasOwnProperty.call(config, propName) &&
1483            "key" !== propName &&
1484            "__self" !== propName &&
1485            "__source" !== propName &&
1486            (i[propName] = config[propName]);
1487      var childrenLength = arguments.length - 2;
1488      if (1 === childrenLength) i.children = children;
1489      else if (1 < childrenLength) {
1490        for (
1491          var childArray = Array(childrenLength), _i = 0;
1492          _i < childrenLength;
1493          _i++
1494        )
1495          childArray[_i] = arguments[_i + 2];
1496        Object.freeze && Object.freeze(childArray);
1497        i.children = childArray;
1498      }
1499      if (type && type.defaultProps)
1500        for (propName in ((childrenLength = type.defaultProps), childrenLength))
1501          void 0 === i[propName] && (i[propName] = childrenLength[propName]);
1502      key &&
1503        defineKeyPropWarningGetter(
1504          i,
1505          "function" === typeof type
1506            ? type.displayName || type.name || "Unknown"
1507            : type
1508        );
1509      (propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++)
1510        ? ((childArray = Error.stackTraceLimit),
1511          (Error.stackTraceLimit = 10),
1512          (childrenLength = Error("react-stack-top-frame")),
1513          (Error.stackTraceLimit = childArray))
1514        : (childrenLength = unknownOwnerDebugStack);
1515      return ReactElement(
1516        type,
1517        key,
1518        i,
1519        getOwner(),
1520        childrenLength,
1521        propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
1522      );
1523    };
1524    exports.createRef = function () {
1525      var refObject = { current: null };
1526      Object.seal(refObject);
1527      return refObject;
1528    };
1529    exports.forwardRef = function (render) {
1530      null != render && render.$$typeof === REACT_MEMO_TYPE
1531        ? console.error(
1532            "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
1533          )
1534        : "function" !== typeof render
1535          ? console.error(
1536              "forwardRef requires a render function but was given %s.",
1537              null === render ? "null" : typeof render
1538            )
1539          : 0 !== render.length &&
1540            2 !== render.length &&
1541            console.error(
1542              "forwardRef render functions accept exactly two parameters: props and ref. %s",
1543              1 === render.length
1544                ? "Did you forget to use the ref parameter?"
1545                : "Any additional parameter will be undefined."
1546            );
1547      null != render &&
1548        null != render.defaultProps &&
1549        console.error(
1550          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
1551        );
1552      var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render: render },
1553        ownName;
1554      Object.defineProperty(elementType, "displayName", {
1555        enumerable: !1,
1556        configurable: !0,
1557        get: function () {
1558          return ownName;
1559        },
1560        set: function (name) {
1561          ownName = name;
1562          render.name ||
1563            render.displayName ||
1564            (Object.defineProperty(render, "name", { value: name }),
1565            (render.displayName = name));
1566        }
1567      });
1568      return elementType;
1569    };
1570    exports.isValidElement = isValidElement;
1571    exports.lazy = function (ctor) {
1572      ctor = { _status: -1, _result: ctor };
1573      var lazyType = {
1574          $$typeof: REACT_LAZY_TYPE,
1575          _payload: ctor,
1576          _init: lazyInitializer
1577        },
1578        ioInfo = {
1579          name: "lazy",
1580          start: -1,
1581          end: -1,
1582          value: null,
1583          owner: null,
1584          debugStack: Error("react-stack-top-frame"),
1585          debugTask: console.createTask ? console.createTask("lazy()") : null
1586        };
1587      ctor._ioInfo = ioInfo;
1588      lazyType._debugInfo = [{ awaited: ioInfo }];
1589      return lazyType;
1590    };
1591    exports.memo = function (type, compare) {
1592      null == type &&
1593        console.error(
1594          "memo: The first argument must be a component. Instead received: %s",
1595          null === type ? "null" : typeof type
1596        );
1597      compare = {
1598        $$typeof: REACT_MEMO_TYPE,
1599        type: type,
1600        compare: void 0 === compare ? null : compare
1601      };
1602      var ownName;
1603      Object.defineProperty(compare, "displayName", {
1604        enumerable: !1,
1605        configurable: !0,
1606        get: function () {
1607          return ownName;
1608        },
1609        set: function (name) {
1610          ownName = name;
1611          type.name ||
1612            type.displayName ||