https://www.blacksouthernbelle.com/wp-content/plugins/legal-pages/build/public.bundle.js?ver=1.6.2

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      }
45      if ("object" === typeof type)
46        switch (
47          ("number" === typeof type.tag &&
48            console.error(
49              "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
50            ),
51          type.$$typeof)
52        ) {
53          case REACT_PORTAL_TYPE:
54            return "Portal";
55          case REACT_CONTEXT_TYPE:
56            return type.displayName || "Context";
57          case REACT_CONSUMER_TYPE:
58            return (type._context.displayName || "Context") + ".Consumer";
59          case REACT_FORWARD_REF_TYPE:
60            var innerType = type.render;
61            type = type.displayName;
62            type ||
63              ((type = innerType.displayName || innerType.name || ""),
64              (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
65            return type;
66          case REACT_MEMO_TYPE:
67            return (
68              (innerType = type.displayName || null),
69              null !== innerType
70                ? innerType
71                : getComponentNameFromType(type.type) || "Memo"
72            );
73          case REACT_LAZY_TYPE:
74            innerType = type._payload;
75            type = type._init;
76            try {
77              return getComponentNameFromType(type(innerType));
78            } catch (x) {}
79        }
80      return null;
81    }
82    function testStringCoercion(value) {
83      return "" + value;
84    }
85    function checkKeyStringCoercion(value) {
86      try {
87        testStringCoercion(value);
88        var JSCompiler_inline_result = !1;
89      } catch (e) {
90        JSCompiler_inline_result = !0;
91      }
92      if (JSCompiler_inline_result) {
93        JSCompiler_inline_result = console;
94        var JSCompiler_temp_const = JSCompiler_inline_result.error;
95        var JSCompiler_inline_result$jscomp$0 =
96          ("function" === typeof Symbol &&
97            Symbol.toStringTag &&
98            value[Symbol.toStringTag]) ||
99          value.constructor.name ||
100          "Object";
101        JSCompiler_temp_const.call(
102          JSCompiler_inline_result,
103          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
104          JSCompiler_inline_result$jscomp$0
105        );
106        return testStringCoercion(value);
107      }
108    }
109    function getTaskName(type) {
110      if (type === REACT_FRAGMENT_TYPE) return "<>";
111      if (
112        "object" === typeof type &&
113        null !== type &&
114        type.$$typeof === REACT_LAZY_TYPE
115      )
116        return "<...>";
117      try {
118        var name = getComponentNameFromType(type);
119        return name ? "<" + name + ">" : "<...>";
120      } catch (x) {
121        return "<...>";
122      }
123    }
124    function getOwner() {
125      var dispatcher = ReactSharedInternals.A;
126      return null === dispatcher ? null : dispatcher.getOwner();
127    }
128    function UnknownOwner() {
129      return Error("react-stack-top-frame");
130    }
131    function hasValidKey(config) {
132      if (hasOwnProperty.call(config, "key")) {
133        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
134        if (getter && getter.isReactWarning) return !1;
135      }
136      return void 0 !== config.key;
137    }
138    function defineKeyPropWarningGetter(props, displayName) {
139      function warnAboutAccessingKey() {
140        specialPropKeyWarningShown ||
141          ((specialPropKeyWarningShown = !0),
142          console.error(
143            "%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)",
144            displayName
145          ));
146      }
147      warnAboutAccessingKey.isReactWarning = !0;
148      Object.defineProperty(props, "key", {
149        get: warnAboutAccessingKey,
150        configurable: !0
151      });
152    }
153    function elementRefGetterWithDeprecationWarning() {
154      var componentName = getComponentNameFromType(this.type);
155      didWarnAboutElementRef[componentName] ||
156        ((didWarnAboutElementRef[componentName] = !0),
157        console.error(
158          "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."
159        ));
160      componentName = this.props.ref;
161      return void 0 !== componentName ? componentName : null;
162    }
163    function ReactElement(type, key, props, owner, debugStack, debugTask) {
164      var refProp = props.ref;
165      type = {
166        $$typeof: REACT_ELEMENT_TYPE,
167        type: type,
168        key: key,
169        props: props,
170        _owner: owner
171      };
172      null !== (void 0 !== refProp ? refProp : null)
173        ? Object.defineProperty(type, "ref", {
174            enumerable: !1,
175            get: elementRefGetterWithDeprecationWarning
176          })
177        : Object.defineProperty(type, "ref", { enumerable: !1, value: null });
178      type._store = {};
179      Object.defineProperty(type._store, "validated", {
180        configurable: !1,
181        enumerable: !1,
182        writable: !0,
183        value: 0
184      });
185      Object.defineProperty(type, "_debugInfo", {
186        configurable: !1,
187        enumerable: !1,
188        writable: !0,
189        value: null
190      });
191      Object.defineProperty(type, "_debugStack", {
192        configurable: !1,
193        enumerable: !1,
194        writable: !0,
195        value: debugStack
196      });
197      Object.defineProperty(type, "_debugTask", {
198        configurable: !1,
199        enumerable: !1,
200        writable: !0,
201        value: debugTask
202      });
203      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
204      return type;
205    }
206    function jsxDEVImpl(
207      type,
208      config,
209      maybeKey,
210      isStaticChildren,
211      debugStack,
212      debugTask
213    ) {
214      var children = config.children;
215      if (void 0 !== children)
216        if (isStaticChildren)
217          if (isArrayImpl(children)) {
218            for (
219              isStaticChildren = 0;
220              isStaticChildren < children.length;
221              isStaticChildren++
222            )
223              validateChildKeys(children[isStaticChildren]);

391            "%s(...) is deprecated in plain JavaScript React classes. %s",
392            info[0],
393            info[1]
394          );
395        }
396      });
397    }
398    function getIteratorFn(maybeIterable) {
399      if (null === maybeIterable || "object" !== typeof maybeIterable)
400        return null;
401      maybeIterable =
402        (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
403        maybeIterable["@@iterator"];
404      return "function" === typeof maybeIterable ? maybeIterable : null;
405    }
406    function warnNoop(publicInstance, callerName) {
407      publicInstance =
408        ((publicInstance = publicInstance.constructor) &&
409          (publicInstance.displayName || publicInstance.name)) ||
410        "ReactClass";
411      var warningKey = publicInstance + "." + callerName;
412      didWarnStateUpdateForUnmountedComponent[warningKey] ||
413        (console.error(
414          "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.",
415          callerName,
416          publicInstance
417        ),
418        (didWarnStateUpdateForUnmountedComponent[warningKey] = !0));
419    }
420    function Component(props, context, updater) {
421      this.props = props;
422      this.context = context;
423      this.refs = emptyObject;
424      this.updater = updater || ReactNoopUpdateQueue;
425    }
426    function ComponentDummy() {}
427    function PureComponent(props, context, updater) {
428      this.props = props;
429      this.context = context;
430      this.refs = emptyObject;
431      this.updater = updater || ReactNoopUpdateQueue;
432    }
433    function noop() {}
434    function testStringCoercion(value) {
435      return "" + value;
436    }
437    function checkKeyStringCoercion(value) {
438      try {
439        testStringCoercion(value);
440        var JSCompiler_inline_result = !1;
441      } catch (e) {
442        JSCompiler_inline_result = !0;
443      }
444      if (JSCompiler_inline_result) {
445        JSCompiler_inline_result = console;
446        var JSCompiler_temp_const = JSCompiler_inline_result.error;
447        var JSCompiler_inline_result$jscomp$0 =
448          ("function" === typeof Symbol &&
449            Symbol.toStringTag &&
450            value[Symbol.toStringTag]) ||
451          value.constructor.name ||
452          "Object";
453        JSCompiler_temp_const.call(
454          JSCompiler_inline_result,
455          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
456          JSCompiler_inline_result$jscomp$0
457        );
458        return testStringCoercion(value);
459      }
460    }
461    function getComponentNameFromType(type) {
462      if (null == type) return null;
463      if ("function" === typeof type)
464        return type.$$typeof === REACT_CLIENT_REFERENCE
465          ? null
466          : type.displayName || type.name || null;
467      if ("string" === typeof type) return type;
468      switch (type) {
469        case REACT_FRAGMENT_TYPE:
470          return "Fragment";
471        case REACT_PROFILER_TYPE:
472          return "Profiler";
473        case REACT_STRICT_MODE_TYPE:
474          return "StrictMode";
475        case REACT_SUSPENSE_TYPE:
476          return "Suspense";
477        case REACT_SUSPENSE_LIST_TYPE:
478          return "SuspenseList";
479        case REACT_ACTIVITY_TYPE:
480          return "Activity";
481      }
482      if ("object" === typeof type)
483        switch (
484          ("number" === typeof type.tag &&
485            console.error(
486              "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
487            ),
488          type.$$typeof)
489        ) {
490          case REACT_PORTAL_TYPE:
491            return "Portal";
492          case REACT_CONTEXT_TYPE:
493            return type.displayName || "Context";
494          case REACT_CONSUMER_TYPE:
495            return (type._context.displayName || "Context") + ".Consumer";
496          case REACT_FORWARD_REF_TYPE:
497            var innerType = type.render;
498            type = type.displayName;
499            type ||
500              ((type = innerType.displayName || innerType.name || ""),
501              (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
502            return type;
503          case REACT_MEMO_TYPE:
504            return (
505              (innerType = type.displayName || null),
506              null !== innerType
507                ? innerType
508                : getComponentNameFromType(type.type) || "Memo"
509            );
510          case REACT_LAZY_TYPE:
511            innerType = type._payload;
512            type = type._init;
513            try {
514              return getComponentNameFromType(type(innerType));
515            } catch (x) {}
516        }
517      return null;
518    }
519    function getTaskName(type) {
520      if (type === REACT_FRAGMENT_TYPE) return "<>";
521      if (
522        "object" === typeof type &&
523        null !== type &&
524        type.$$typeof === REACT_LAZY_TYPE
525      )
526        return "<...>";
527      try {
528        var name = getComponentNameFromType(type);
529        return name ? "<" + name + ">" : "<...>";
530      } catch (x) {
531        return "<...>";
532      }
533    }
534    function getOwner() {
535      var dispatcher = ReactSharedInternals.A;
536      return null === dispatcher ? null : dispatcher.getOwner();
537    }
538    function UnknownOwner() {
539      return Error("react-stack-top-frame");
540    }
541    function hasValidKey(config) {
542      if (hasOwnProperty.call(config, "key")) {
543        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
544        if (getter && getter.isReactWarning) return !1;
545      }
546      return void 0 !== config.key;
547    }
548    function defineKeyPropWarningGetter(props, displayName) {
549      function warnAboutAccessingKey() {
550        specialPropKeyWarningShown ||
551          ((specialPropKeyWarningShown = !0),
552          console.error(
553            "%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)",
554            displayName
555          ));
556      }
557      warnAboutAccessingKey.isReactWarning = !0;
558      Object.defineProperty(props, "key", {
559        get: warnAboutAccessingKey,
560        configurable: !0
561      });
562    }
563    function elementRefGetterWithDeprecationWarning() {
564      var componentName = getComponentNameFromType(this.type);
565      didWarnAboutElementRef[componentName] ||
566        ((didWarnAboutElementRef[componentName] = !0),
567        console.error(
568          "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."
569        ));
570      componentName = this.props.ref;
571      return void 0 !== componentName ? componentName : null;
572    }
573    function ReactElement(type, key, props, owner, debugStack, debugTask) {
574      var refProp = props.ref;
575      type = {
576        $$typeof: REACT_ELEMENT_TYPE,
577        type: type,
578        key: key,
579        props: props,
580        _owner: owner
581      };
582      null !== (void 0 !== refProp ? refProp : null)
583        ? Object.defineProperty(type, "ref", {
584            enumerable: !1,
585            get: elementRefGetterWithDeprecationWarning
586          })
587        : Object.defineProperty(type, "ref", { enumerable: !1, value: null });
588      type._store = {};
589      Object.defineProperty(type._store, "validated", {
590        configurable: !1,
591        enumerable: !1,
592        writable: !0,
593        value: 0
594      });
595      Object.defineProperty(type, "_debugInfo", {
596        configurable: !1,
597        enumerable: !1,
598        writable: !0,
599        value: null
600      });
601      Object.defineProperty(type, "_debugStack", {
602        configurable: !1,
603        enumerable: !1,
604        writable: !0,
605        value: debugStack
606      });
607      Object.defineProperty(type, "_debugTask", {
608        configurable: !1,
609        enumerable: !1,
610        writable: !0,
611        value: debugTask
612      });
613      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
614      return type;
615    }
616    function cloneAndReplaceKey(oldElement, newKey) {
617      newKey = ReactElement(
618        oldElement.type,
619        newKey,
620        oldElement.props,
621        oldElement._owner,
622        oldElement._debugStack,
623        oldElement._debugTask
624      );
625      oldElement._store &&
626        (newKey._store.validated = oldElement._store.validated);
627      return newKey;
628    }
629    function validateChildKeys(node) {
630      isValidElement(node)
631        ? node._store && (node._store.validated = 1)
632        : "object" === typeof node &&
633          null !== node &&
634          node.$$typeof === REACT_LAZY_TYPE &&
635          ("fulfilled" === node._payload.status
636            ? isValidElement(node._payload.value) &&
637              node._payload.value._store &&
638              (node._payload.value._store.validated = 1)
639            : node._store && (node._store.validated = 1));
640    }
641    function isValidElement(object) {
642      return (
643        "object" === typeof object &&
644        null !== object &&
645        object.$$typeof === REACT_ELEMENT_TYPE
646      );
647    }
648    function escape(key) {
649      var escaperLookup = { "=": "=0", ":": "=2" };
650      return (
651        "$" +
652        key.replace(/[=:]/g, function (match) {
653          return escaperLookup[match];
654        })
655      );
656    }
657    function getElementKey(element, index) {
658      return "object" === typeof element &&
659        null !== element &&
660        null != element.key
661        ? (checkKeyStringCoercion(element.key), escape("" + element.key))
662        : index.toString(36);
663    }
664    function resolveThenable(thenable) {
665      switch (thenable.status) {
666        case "fulfilled":
667          return thenable.value;
668        case "rejected":
669          throw thenable.reason;
670        default:
671          switch (
672            ("string" === typeof thenable.status
673              ? thenable.then(noop, noop)
674              : ((thenable.status = "pending"),
675                thenable.then(
676                  function (fulfilledValue) {
677                    "pending" === thenable.status &&
678                      ((thenable.status = "fulfilled"),
679                      (thenable.value = fulfilledValue));
680                  },
681                  function (error) {
682                    "pending" === thenable.status &&
683                      ((thenable.status = "rejected"),
684                      (thenable.reason = error));
685                  }
686                )),
687            thenable.status)
688          ) {
689            case "fulfilled":
690              return thenable.value;
691            case "rejected":
692              throw thenable.reason;
693          }
694      }
695      throw thenable;
696    }
697    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
698      var type = typeof children;
699      if ("undefined" === type || "boolean" === type) children = null;
700      var invokeCallback = !1;
701      if (null === children) invokeCallback = !0;
702      else
703        switch (type) {
704          case "bigint":
705          case "string":
706          case "number":
707            invokeCallback = !0;
708            break;
709          case "object":
710            switch (children.$$typeof) {
711              case REACT_ELEMENT_TYPE:
712              case REACT_PORTAL_TYPE:
713                invokeCallback = !0;
714                break;
715              case REACT_LAZY_TYPE:
716                return (
717                  (invokeCallback = children._init),
718                  mapIntoArray(
719                    invokeCallback(children._payload),
720                    array,
721                    escapedPrefix,
722                    nameSoFar,
723                    callback
724                  )
725                );
726            }
727        }
728      if (invokeCallback) {
729        invokeCallback = children;
730        callback = callback(invokeCallback);
731        var childKey =
732          "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
733        isArrayImpl(callback)
734          ? ((escapedPrefix = ""),
735            null != childKey &&
736              (escapedPrefix =
737                childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"),
738            mapIntoArray(callback, array, escapedPrefix, "", function (c) {
739              return c;
740            }))
741          : null != callback &&
742            (isValidElement(callback) &&
743              (null != callback.key &&
744                ((invokeCallback && invokeCallback.key === callback.key) ||
745                  checkKeyStringCoercion(callback.key)),
746              (escapedPrefix = cloneAndReplaceKey(
747                callback,
748                escapedPrefix +
749                  (null == callback.key ||
750                  (invokeCallback && invokeCallback.key === callback.key)
751                    ? ""
752                    : ("" + callback.key).replace(
753                        userProvidedKeyEscapeRegex,
754                        "$&/"
755                      ) + "/") +
756                  childKey
757              )),
758              "" !== nameSoFar &&
759                null != invokeCallback &&
760                isValidElement(invokeCallback) &&
761                null == invokeCallback.key &&
762                invokeCallback._store &&
763                !invokeCallback._store.validated &&
764                (escapedPrefix._store.validated = 2),
765              (callback = escapedPrefix)),
766            array.push(callback));
767        return 1;
768      }
769      invokeCallback = 0;
770      childKey = "" === nameSoFar ? "." : nameSoFar + ":";
771      if (isArrayImpl(children))
772        for (var i = 0; i < children.length; i++)
773          (nameSoFar = children[i]),
774            (type = childKey + getElementKey(nameSoFar, i)),
775            (invokeCallback += mapIntoArray(
776              nameSoFar,
777              array,
778              escapedPrefix,
779              type,
780              callback
781            ));
782      else if (((i = getIteratorFn(children)), "function" === typeof i))
783        for (
784          i === children.entries &&
785            (didWarnAboutMaps ||
786              console.warn(
787                "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
788              ),
789            (didWarnAboutMaps = !0)),
790            children = i.call(children),
791            i = 0;
792          !(nameSoFar = children.next()).done;
793
794        )
795          (nameSoFar = nameSoFar.value),
796            (type = childKey + getElementKey(nameSoFar, i++)),
797            (invokeCallback += mapIntoArray(
798              nameSoFar,
799              array,
800              escapedPrefix,
801              type,
802              callback
803            ));
804      else if ("object" === type) {
805        if ("function" === typeof children.then)
806          return mapIntoArray(
807            resolveThenable(children),
808            array,
809            escapedPrefix,
810            nameSoFar,
811            callback
812          );
813        array = String(children);
814        throw Error(
815          "Objects are not valid as a React child (found: " +
816            ("[object Object]" === array
817              ? "object with keys {" + Object.keys(children).join(", ") + "}"
818              : array) +
819            "). If you meant to render a collection of children, use an array instead."
820        );
821      }
822      return invokeCallback;
823    }
824    function mapChildren(children, func, context) {
825      if (null == children) return children;
826      var result = [],
827        count = 0;
828      mapIntoArray(children, result, "", "", function (child) {
829        return func.call(context, child, count++);
830      });
831      return result;
832    }
833    function lazyInitializer(payload) {
834      if (-1 === payload._status) {
835        var ioInfo = payload._ioInfo;
836        null != ioInfo && (ioInfo.start = ioInfo.end = performance.now());
837        ioInfo = payload._result;
838        var thenable = ioInfo();
839        thenable.then(
840          function (moduleObject) {
841            if (0 === payload._status || -1 === payload._status) {
842              payload._status = 1;
843              payload._result = moduleObject;
844              var _ioInfo = payload._ioInfo;
845              null != _ioInfo && (_ioInfo.end = performance.now());
846              void 0 === thenable.status &&
847                ((thenable.status = "fulfilled"),
848                (thenable.value = moduleObject));
849            }
850          },
851          function (error) {
852            if (0 === payload._status || -1 === payload._status) {
853              payload._status = 2;
854              payload._result = error;
855              var _ioInfo2 = payload._ioInfo;
856              null != _ioInfo2 && (_ioInfo2.end = performance.now());
857              void 0 === thenable.status &&
858                ((thenable.status = "rejected"), (thenable.reason = error));
859            }
860          }
861        );
862        ioInfo = payload._ioInfo;
863        if (null != ioInfo) {
864          ioInfo.value = thenable;
865          var displayName = thenable.displayName;
866          "string" === typeof displayName && (ioInfo.name = displayName);
867        }
868        -1 === payload._status &&
869          ((payload._status = 0), (payload._result = thenable));
870      }
871      if (1 === payload._status)
872        return (
873          (ioInfo = payload._result),
874          void 0 === ioInfo &&
875            console.error(
876              "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?",
877              ioInfo
878            ),
879          "default" in ioInfo ||
880            console.error(
881              "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))",
882              ioInfo
883            ),
884          ioInfo.default
885        );
886      throw payload._result;
887    }
888    function resolveDispatcher() {
889      var dispatcher = ReactSharedInternals.H;
890      null === dispatcher &&
891        console.error(
892          "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."
893        );

894      return dispatcher;
895    }
896    function releaseAsyncTransition() {
897      ReactSharedInternals.asyncTransitions--;
898    }
899    function enqueueTask(task) {
900      if (null === enqueueTaskImpl)
901        try {
902          var requireString = ("require" + Math.random()).slice(0, 7);
903          enqueueTaskImpl = (module && module[requireString]).call(
904            module,
905            "timers"
906          ).setImmediate;
907        } catch (_err) {
908          enqueueTaskImpl = function (callback) {
909            !1 === didWarnAboutMessageChannel &&
910              ((didWarnAboutMessageChannel = !0),
911              "undefined" === typeof MessageChannel &&
912                console.error(
913                  "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."
914                ));
915            var channel = new MessageChannel();
916            channel.port1.onmessage = callback;
917            channel.port2.postMessage(void 0);
918          };
919        }
920      return enqueueTaskImpl(task);
921    }
922    function aggregateErrors(errors) {
923      return 1 < errors.length && "function" === typeof AggregateError
924        ? new AggregateError(errors)
925        : errors[0];
926    }
927    function popActScope(prevActQueue, prevActScopeDepth) {
928      prevActScopeDepth !== actScopeDepth - 1 &&
929        console.error(
930          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
931        );
932      actScopeDepth = prevActScopeDepth;
933    }
934    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
935      var queue = ReactSharedInternals.actQueue;
936      if (null !== queue)
937        if (0 !== queue.length)
938          try {
939            flushActQueue(queue);
940            enqueueTask(function () {
941              return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
942            });
943            return;
944          } catch (error) {
945            ReactSharedInternals.thrownErrors.push(error);
946          }
947        else ReactSharedInternals.actQueue = null;
948      0 < ReactSharedInternals.thrownErrors.length
949        ? ((queue = aggregateErrors(ReactSharedInternals.thrownErrors)),
950          (ReactSharedInternals.thrownErrors.length = 0),
951          reject(queue))
952        : resolve(returnValue);
953    }
954    function flushActQueue(queue) {
955      if (!isFlushing) {
956        isFlushing = !0;
957        var i = 0;
958        try {
959          for (; i < queue.length; i++) {
960            var callback = queue[i];
961            do {
962              ReactSharedInternals.didUsePromise = !1;
963              var continuation = callback(!1);
964              if (null !== continuation) {
965                if (ReactSharedInternals.didUsePromise) {
966                  queue[i] = callback;
967                  queue.splice(0, i);
968                  return;
969                }
970                callback = continuation;
971              } else break;
972            } while (1);
973          }
974          queue.length = 0;
975        } catch (error) {
976          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
977        } finally {
978          isFlushing = !1;
979        }
980      }
981    }
982    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
983      "function" ===
984        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
985      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
986    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
987      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
988      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
989      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
990      REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
991      REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
992      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
993      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
994      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
995      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
996      REACT_MEMO_TYPE = Symbol.for("react.memo"),
997      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
998      REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
999      MAYBE_ITERATOR_SYMBOL = Symbol.iterator,
1000      didWarnStateUpdateForUnmountedComponent = {},
1001      ReactNoopUpdateQueue = {
1002        isMounted: function () {
1003          return !1;
1004        },
1005        enqueueForceUpdate: function (publicInstance) {
1006          warnNoop(publicInstance, "forceUpdate");
1007        },
1008        enqueueReplaceState: function (publicInstance) {
1009          warnNoop(publicInstance, "replaceState");
1010        },
1011        enqueueSetState: function (publicInstance) {
1012          warnNoop(publicInstance, "setState");
1013        }
1014      },
1015      assign = Object.assign,
1016      emptyObject = {};

1017    Object.freeze(emptyObject);
1018    Component.prototype.isReactComponent = {};
1019    Component.prototype.setState = function (partialState, callback) {
1020      if (
1021        "object" !== typeof partialState &&
1022        "function" !== typeof partialState &&
1023        null != partialState
1024      )
1025        throw Error(
1026          "takes an object of state variables to update or a function which returns an object of state variables."
1027        );
1028      this.updater.enqueueSetState(this, partialState, callback, "setState");
1029    };
1030    Component.prototype.forceUpdate = function (callback) {
1031      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
1032    };
1033    var deprecatedAPIs = {
1034      isMounted: [
1035        "isMounted",
1036        "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
1037      ],
1038      replaceState: [
1039        "replaceState",
1040        "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
1041      ]
1042    };
1043    for (fnName in deprecatedAPIs)
1044      deprecatedAPIs.hasOwnProperty(fnName) &&
1045        defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
1046    ComponentDummy.prototype = Component.prototype;
1047    deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
1048    deprecatedAPIs.constructor = PureComponent;
1049    assign(deprecatedAPIs, Component.prototype);
1050    deprecatedAPIs.isPureReactComponent = !0;
1051    var isArrayImpl = Array.isArray,
1052      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
1053      ReactSharedInternals = {
1054        H: null,
1055        A: null,
1056        T: null,
1057        S: null,
1058        actQueue: null,
1059        asyncTransitions: 0,
1060        isBatchingLegacy: !1,
1061        didScheduleLegacyUpdate: !1,
1062        didUsePromise: !1,
1063        thrownErrors: [],
1064        getCurrentStack: null,
1065        recentlyCreatedOwnerStacks: 0
1066      },
1067      hasOwnProperty = Object.prototype.hasOwnProperty,
1068      createTask = console.createTask
1069        ? console.createTask
1070        : function () {
1071            return null;
1072          };
1073    deprecatedAPIs = {
1074      react_stack_bottom_frame: function (callStackForError) {
1075        return callStackForError();
1076      }
1077    };
1078    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
1079    var didWarnAboutElementRef = {};
1080    var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(
1081      deprecatedAPIs,
1082      UnknownOwner
1083    )();
1084    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
1085    var didWarnAboutMaps = !1,
1086      userProvidedKeyEscapeRegex = /\/+/g,
1087      reportGlobalError =
1088        "function" === typeof reportError
1089          ? reportError
1090          : function (error) {
1091              if (
1092                "object" === typeof window &&
1093                "function" === typeof window.ErrorEvent
1094              ) {
1095                var event = new window.ErrorEvent("error", {
1096                  bubbles: !0,
1097                  cancelable: !0,
1098                  message:
1099                    "object" === typeof error &&
1100                    null !== error &&
1101                    "string" === typeof error.message
1102                      ? String(error.message)
1103                      : String(error),
1104                  error: error
1105                });
1106                if (!window.dispatchEvent(event)) return;
1107              } else if (
1108                "object" === typeof process &&
1109                "function" === typeof process.emit
1110              ) {
1111                process.emit("uncaughtException", error);
1112                return;
1113              }
1114              console.error(error);
1115            },
1116      didWarnAboutMessageChannel = !1,
1117      enqueueTaskImpl = null,
1118      actScopeDepth = 0,
1119      didWarnNoAwaitAct = !1,
1120      isFlushing = !1,
1121      queueSeveralMicrotasks =
1122        "function" === typeof queueMicrotask
1123          ? function (callback) {
1124              queueMicrotask(function () {
1125                return queueMicrotask(callback);
1126              });
1127            }
1128          : enqueueTask;
1129    deprecatedAPIs = Object.freeze({
1130      __proto__: null,
1131      c: function (size) {
1132        return resolveDispatcher().useMemoCache(size);
1133      }
1134    });
1135    var fnName = {
1136      map: mapChildren,

1137      forEach: function (children, forEachFunc, forEachContext) {
1138        mapChildren(
1139          children,
1140          function () {
1141            forEachFunc.apply(this, arguments);
1142          },
1143          forEachContext
1144        );
1145      },
1146      count: function (children) {
1147        var n = 0;
1148        mapChildren(children, function () {
1149          n++;
1150        });
1151        return n;
1152      },
1153      toArray: function (children) {
1154        return (
1155          mapChildren(children, function (child) {
1156            return child;
1157          }) || []
1158        );
1159      },
1160      only: function (children) {
1161        if (!isValidElement(children))
1162          throw Error(
1163            "React.Children.only expected to receive a single React element child."
1164          );
1165        return children;
1166      }
1167    };
1168    exports.Activity = REACT_ACTIVITY_TYPE;
1169    exports.Children = fnName;
1170    exports.Component = Component;
1171    exports.Fragment = REACT_FRAGMENT_TYPE;
1172    exports.Profiler = REACT_PROFILER_TYPE;
1173    exports.PureComponent = PureComponent;
1174    exports.StrictMode = REACT_STRICT_MODE_TYPE;
1175    exports.Suspense = REACT_SUSPENSE_TYPE;
1176    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
1177      ReactSharedInternals;
1178    exports.__COMPILER_RUNTIME = deprecatedAPIs;
1179    exports.act = function (callback) {
1180      var prevActQueue = ReactSharedInternals.actQueue,
1181        prevActScopeDepth = actScopeDepth;
1182      actScopeDepth++;
1183      var queue = (ReactSharedInternals.actQueue =
1184          null !== prevActQueue ? prevActQueue : []),
1185        didAwaitActCall = !1;
1186      try {
1187        var result = callback();
1188      } catch (error) {
1189        ReactSharedInternals.thrownErrors.push(error);
1190      }
1191      if (0 < ReactSharedInternals.thrownErrors.length)
1192        throw (
1193          (popActScope(prevActQueue, prevActScopeDepth),
1194          (callback = aggregateErrors(ReactSharedInternals.thrownErrors)),
1195          (ReactSharedInternals.thrownErrors.length = 0),
1196          callback)
1197        );
1198      if (
1199        null !== result &&
1200        "object" === typeof result &&
1201        "function" === typeof result.then
1202      ) {
1203        var thenable = result;
1204        queueSeveralMicrotasks(function () {
1205          didAwaitActCall ||
1206            didWarnNoAwaitAct ||
1207            ((didWarnNoAwaitAct = !0),
1208            console.error(
1209              "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 () => ...);"
1210            ));
1211        });
1212        return {
1213          then: function (resolve, reject) {
1214            didAwaitActCall = !0;
1215            thenable.then(
1216              function (returnValue) {
1217                popActScope(prevActQueue, prevActScopeDepth);
1218                if (0 === prevActScopeDepth) {
1219                  try {
1220                    flushActQueue(queue),
1221                      enqueueTask(function () {
1222                        return recursivelyFlushAsyncActWork(
1223                          returnValue,
1224                          resolve,
1225                          reject
1226                        );
1227                      });
1228                  } catch (error$0) {
1229                    ReactSharedInternals.thrownErrors.push(error$0);
1230                  }
1231                  if (0 < ReactSharedInternals.thrownErrors.length) {
1232                    var _thrownError = aggregateErrors(
1233                      ReactSharedInternals.thrownErrors
1234                    );
1235                    ReactSharedInternals.thrownErrors.length = 0;
1236                    reject(_thrownError);
1237                  }
1238                } else resolve(returnValue);
1239              },
1240              function (error) {
1241                popActScope(prevActQueue, prevActScopeDepth);
1242                0 < ReactSharedInternals.thrownErrors.length
1243                  ? ((error = aggregateErrors(
1244                      ReactSharedInternals.thrownErrors
1245                    )),
1246                    (ReactSharedInternals.thrownErrors.length = 0),
1247                    reject(error))
1248                  : reject(error);
1249              }
1250            );
1251          }
1252        };
1253      }
1254      var returnValue$jscomp$0 = result;
1255      popActScope(prevActQueue, prevActScopeDepth);
1256      0 === prevActScopeDepth &&
1257        (flushActQueue(queue),
1258        0 !== queue.length &&
1259          queueSeveralMicrotasks(function () {
1260            didAwaitActCall ||
1261              didWarnNoAwaitAct ||
1262              ((didWarnNoAwaitAct = !0),
1263              console.error(
1264                "A component suspended inside an `act` scope, but the `act` c

1264all was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
1265              ));
1266          }),
1267        (ReactSharedInternals.actQueue = null));
1268      if (0 < ReactSharedInternals.thrownErrors.length)
1269        throw (
1270          ((callback = aggregateErrors(ReactSharedInternals.thrownErrors)),
1271          (ReactSharedInternals.thrownErrors.length = 0),
1272          callback)
1273        );
1274      return {
1275        then: function (resolve, reject) {
1276          didAwaitActCall = !0;
1277          0 === prevActScopeDepth
1278            ? ((ReactSharedInternals.actQueue = queue),
1279              enqueueTask(function () {
1280                return recursivelyFlushAsyncActWork(
1281                  returnValue$jscomp$0,
1282                  resolve,
1283                  reject
1284                );
1285              }))
1286            : resolve(returnValue$jscomp$0);
1287        }
1288      };
1289    };
1290    exports.cache = function (fn) {
1291      return function () {
1292        return fn.apply(null, arguments);
1293      };
1294    };
1295    exports.cacheSignal = function () {
1296      return null;
1297    };
1298    exports.captureOwnerStack = function () {
1299      var getCurrentStack = ReactSharedInternals.getCurrentStack;
1300      return null === getCurrentStack ? null : getCurrentStack();
1301    };
1302    exports.cloneElement = function (element, config, children) {
1303      if (null === element || void 0 === element)
1304        throw Error(
1305          "The argument must be a React element, but you passed " +
1306            element +
1307            "."
1308        );
1309      var props = assign({}, element.props),
1310        key = element.key,
1311        owner = element._owner;
1312      if (null != config) {
1313        var JSCompiler_inline_result;
1314        a: {
1315          if (
1316            hasOwnProperty.call(config, "ref") &&
1317            (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
1318              config,
1319              "ref"
1320            ).get) &&
1321            JSCompiler_inline_result.isReactWarning
1322          ) {
1323            JSCompiler_inline_result = !1;
1324            break a;
1325          }
1326          JSCompiler_inline_result = void 0 !== config.ref;
1327        }
1328        JSCompiler_inline_result && (owner = getOwner());
1329        hasValidKey(config) &&
1330          (checkKeyStringCoercion(config.key), (key = "" + config.key));
1331        for (propName in config)
1332          !hasOwnProperty.call(config, propName) ||
1333            "key" === propName ||
1334            "__self" === propName ||
1335            "__source" === propName ||
1336            ("ref" === propName && void 0 === config.ref) ||
1337            (props[propName] = config[propName]);
1338      }
1339      var propName = arguments.length - 2;
1340      if (1 === propName) props.children = children;
1341      else if (1 < propName) {
1342        JSCompiler_inline_result = Array(propName);
1343        for (var i = 0; i < propName; i++)
1344          JSCompiler_inline_result[i] = arguments[i + 2];
1345        props.children = JSCompiler_inline_result;
1346      }
1347      props = ReactElement(
1348        element.type,
1349        key,
1350        props,
1351        owner,
1352        element._debugStack,
1353        element._debugTask
1354      );
1355      for (key = 2; key < arguments.length; key++)
1356        validateChildKeys(arguments[key]);
1357      return props;
1358    };
1359    exports.createContext = function (defaultValue) {
1360      defaultValue = {
1361        $$typeof: REACT_CONTEXT_TYPE,
1362        _currentValue: defaultValue,
1363        _currentValue2: defaultValue,
1364        _threadCount: 0,
1365        Provider: null,
1366        Consumer: null
1367      };
1368      defaultValue.Provider = defaultValue;
1369      defaultValue.Consumer = {
1370        $$typeof: REACT_CONSUMER_TYPE,
1371        _context: defaultValue
1372      };
1373      defaultValue._currentRenderer = null;
1374      defaultValue._currentRenderer2 = null;
1375      return defaultValue;
1376    };
1377    exports.createElement = function (type, config, children) {
1378      for (var i = 2; i < arguments.length; i++)
1379        validateChildKeys(arguments[i]);
1380      i = {};
1381      var key = null;
1382      if (null != config)
1383        for (propName in (didWarnAboutOldJSXRuntime ||
1384          !("__self" in config) ||
1385          "key" in config ||
1386          ((didWarnAboutOldJSXRuntime = !0),
1387          console.warn(
1388            "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"
1389          )),
1390        hasValidKey(config) &&
1391          (checkKeyStringCoercion(config.key), (key = "" + config.key)),
1392        config))
1393          hasOwnProperty.call(config, propName) &&
1394            "key" !== propName &&
1395            "__self" !== propName &&
1396            "__source" !== propName &&
1397            (i[propName] = config[propName]);
1398      var childrenLength = arguments.length - 2;
1399      if (1 === childrenLength) i.children = children;
1400      else if (1 < childrenLength) {
1401        for (
1402          var childArray = Array(childrenLength), _i = 0;
1403          _i < childrenLength;
1404          _i++
1405        )
1406          childArray[_i] = arguments[_i + 2];
1407        Object.freeze && Object.freeze(childArray);
1408        i.children = childArray;
1409      }
1410      if (type && type.defaultProps)
1411        for (propName in ((childrenLength = type.defaultProps), childrenLength))
1412          void 0 === i[propName] && (i[propName] = childrenLength[propName]);
1413      key &&
1414        defineKeyPropWarningGetter(
1415          i,
1416          "function" === typeof type
1417            ? type.displayName || type.name || "Unknown"
1418            : type
1419        );
1420      var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
1421      return ReactElement(
1422        type,
1423        key,
1424        i,
1425        getOwner(),
1426        propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
1427        propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
1428      );
1429    };
1430    exports.createRef = function () {
1431      var refObject = { current: null };
1432      Object.seal(refObject);
1433      return refObject;
1434    };
1435    exports.forwardRef = function (render) {
1436      null != render && render.$$typeof === REACT_MEMO_TYPE
1437        ? console.error(
1438            "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
1439          )
1440        : "function" !== typeof render
1441          ? console.error(
1442              "forwardRef requires a render function but was given %s.",
1443              null === render ? "null" : typeof render
1444            )
1445          : 0 !== render.length &&
1446            2 !== render.length &&
1447            console.error(
1448              "forwardRef render functions accept exactly two parameters: props and ref. %s",
1449              1 === render.length
1450                ? "Did you forget to use the ref parameter?"
1451                : "Any additional parameter will be undefined."
1452            );
1453      null != render &&
1454        null != render.defaultProps &&
1455        console.error(
1456          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
1457        );
1458      var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render: render },
1459        ownName;
1460      Object.defineProperty(elementType, "displayName", {
1461        enumerable: !1,
1462        configurable: !0,
1463        get: function () {
1464          return ownName;
1465        },
1466        set: function (name) {
1467          ownName = name;
1468          render.name ||
1469            render.displayName ||
1470            (Object.defineProperty(render, "name", { value: name }),
1471            (render.displayName = name));
1472        }
1473      });
1474      return elementType;
1475    };
1476    exports.isValidElement = isValidElement;
1477    exports.lazy = function (ctor) {
1478      ctor = { _status: -1, _result: ctor };
1479      var lazyType = {
1480          $$typeof: REACT_LAZY_TYPE,
1481          _payload: ctor,
1482          _init: lazyInitializer
1483        },
1484        ioInfo = {
1485          name: "lazy",
1486          start: -1,
1487          end: -1,
1488          value: null,
1489          owner: null,
1490          debugStack: Error("react-stack-top-frame"),
1491          debugTask: console.createTask ? console.createTask("lazy()") : null
1492        };
1493      ctor._ioInfo = ioInfo;
1494      lazyType._debugInfo = [{ awaited: ioInfo }];
1495      return lazyType;
1496    };
1497    exports.memo = function (type, compare) {
1498      null == type &&
1499        console.error(
1500          "memo: The first argument must be a component. Instead received: %s",
1501          null === type ? "null" : typeof type
1502        );
1503      compare = {
1504        $$typeof: REACT_MEMO_TYPE,
1505        type: type,
1506        compare: void 0 === compare ? null : compare
1507      };
1508      var ownName;
1509      Object.defineProperty(compare, "displayName", {
1510        enumerable: !1,
1511        configurable: !0,
1512        get: function () {
1513          return ownName;
1514        },
1515        set: function (name) {
1516          ownName = name;
1517          type.name ||
1518            type.displayName ||
1519            (Object.defineProperty(type, "name", { value: name }),
1520            (type.displayName = name));
1521        }
1522      });
1523      return compare;
1524    };
1525    exports.startTransition = function (scope) {
1526      var prevTransition = ReactSharedInternals.T,
1527        currentTransition = {};
1528      currentTransition._updatedFibers = new Set();
1529      ReactSharedInternals.T = currentTransition;
1530      try {
1531        var returnValue = scope(),
1532          onStartTransitionFinish = ReactSharedInternals.S;
1533        null !== onStartTransitionFinish &&
1534          onStartTransitionFinish(currentTransition, returnValue);
1535        "object" === typeof returnValue &&
1536          null !== returnValue &&
1537          "function" === typeof returnValue.then &&
1538          (ReactSharedInternals.asyncTransitions++,
1539          returnValue.then(releaseAsyncTransition, releaseAsyncTransition),
1540          returnValue.then(noop, reportGlobalError));
1541      } catch (error) {
1542        reportGlobalError(error);
1543      } finally {
1544        null === prevTransition &&
1545          currentTransition._updatedFibers &&
1546          ((scope = currentTransition._updatedFibers.size),
1547          currentTransition._updatedFibers.clear(),
1548          10 < scope &&
1549            console.warn(
1550              "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."
1551            )),
1552          null !== prevTransition &&
1553            null !== currentTransition.types &&
1554            (null !== prevTransition.types &&
1555              prevTransition.types !== currentTransition.types &&
1556              console.error(
1557                "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."
1558              ),
1559            (prevTransition.types = currentTransition.types)),
1560          (ReactSharedInternals.T = prevTransition);
1561      }
1562    };
1563    exports.unstable_useCacheRefresh = function () {
1564      return resolveDispatcher().useCacheRefresh();
1565    };
1566    exports.use = function (usable) {
1567      return resolveDispatcher().use(usable);
1568    };
1569    exports.useActionState = function (action, initialState, permalink) {
1570      return resolveDispatcher().useActionState(
1571        action,
1572        initialState,
1573        permalink
1574      );
1575    };
1576    exports.useCallback = function (callback, deps) {
1577      return resolveDispatcher().useCallback(callback, deps);
1578    };
1579    exports.useContext = function (Context) {
1580      var dispatcher = resolveDispatcher();
1581      Context.$$typeof === REACT_CONSUMER_TYPE &&
1582        console.error(
1583          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
1584        );
1585      return dispatcher.useContext(Context);
1586    };
1587    exports.useDebugValue = function (value, formatterFn) {
1588      return resolveDispatcher().useDebugValue(value, formatterFn);
1589    };
1590    exports.useDeferredValue = function (value, initialValue) {
1591      return resolveDispatcher().useDeferredValue(value, initialValue);
1592    };
1593    exports.useEffect = function (create, deps) {
1594      null == create &&
1595        console.warn(
1596          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
1597        );
1598      return resolveDispatcher().useEffect(create, deps);
1599    };
1600    exports.useEffectEvent = function (callback) {
1601      return resolveDispatcher().useEffectEvent(callback);
1602    };
1603    exports.useId = function () {
1604      return resolveDispatcher().useId();
1605    };
1606    exports.useImperativeHandle = function (ref, create, deps) {
1607      return resolveDispatcher().useImperativeHandle(ref, create, deps);
1608    };
1609    exports.useInsertionEffect = function (create, deps) {
1610      null == create &&
1611        console.warn(
1612          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
1613        );
1614      return resolveDispatcher().useInsertionEffect(create, deps);
1615    };
1616    exports.useLayoutEffect = function (create, deps) {
1617      null == create &&
1618        console.warn(
1619          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
1620        );
1621      return resolveDispatcher().useLayoutEffect(create, deps);
1622    };
1623    exports.useMemo = function (create, deps) {
1624      return resolveDispatcher().useMemo(create, deps);
1625    };
1626    exports.useOptimistic = function (passthrough, reducer) {
1627      return resolveDispatcher().useOptimistic(passthrough, reducer);
1628    };
1629    exports.useReducer = function (reducer, initialArg, init) {
1630      return resolveDispatcher().useReducer(reducer, initialArg, init);
1631    };
1632    exports.useRef = function (initialValue) {
1633      return resolveDispatcher().useRef(initialValue);
1634    };
1635    exports.useState = function (initialState) {
1636      return resolveDispatcher().useState(initialState);
1637    };
1638    exports.useSyncExternalStore = function (
1639      subscribe,
1640      getSnapshot,
1641      getServerSnapshot
1642    ) {
1643      return resolveDispatcher().useSyncExternalStore(
1644        subscribe,
1645        getSnapshot,
1646        getServerSnapshot
1647      );
1648    };
1649    exports.useTransition = function () {
1650      return resolveDispatcher().useTransition();
1651    };
1652    exports.version = "19.2.5";
1653    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
1654      "function" ===
1655        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
1656      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
1657  })();
1658
1659
1660/***/ },
1661
1662/***/ "./node_modules/react/index.js"
1663/*!*************************************!*\
1664  !*** ./node_modules/react/index.js ***!
1665  \*************************************/
1666(module, __unused_webpack_exports, __webpack_require__) {
1667
1668
1669
1670if (false) // removed by dead control flow
1671{} else {
1672  module.exports = __webpack_require__(/*! ./cjs/react.development.js */ "./node_modules/react/cjs/react.development.js");
1673}
1674
1675
1676/***/ },
1677
1678/***/ "./node_modules/react/jsx-runtime.js"
1679/*!*******************************************!*\
1680  !*** ./node_modules/react/jsx-runtime.js ***!
1681  \*******************************************/
1682(module, __unused_webpack_exports, __webpack_require__) {
1683
1684
1685
1686if (false) // removed by dead control flow
1687{} else {
1688  module.exports = __webpack_require__(/*! ./cjs/react-jsx-runtime.development.js */ "./node_modules/react/cjs/react-jsx-runtime.development.js");
1689}
1690
1691
1692/***/ }
1693
1694/******/ 	});
1695/************************************************************************/
1696/******/ 	// The module cache
1697/******/ 	var __webpack_module_cache__ = {};
1698/******/ 	
1699/******/ 	// The require function
1700/******/ 	function __webpack_require__(moduleId) {
1701/******/ 		// Check if module is in cache
1702/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
1703/******/ 		if (cachedModule !== undefined) {
1704/******/ 			return cachedModule.exports;
1705/******/ 		}
1706/******/ 		// Create a new module (and put it into the cache)
1707/******/ 		var module = __webpack_module_cache__[moduleId] = {
1708/******/ 			id: moduleId,
1709/******/ 			loaded: false,
1710/******/ 			exports: {}
1711/******/ 		};
1712/******/ 	
1713/******/ 		// Execute the module function
1714/******/ 		if (!(moduleId in __webpack_modules__)) {
1715/******/ 			delete __webpack_module_cache__[moduleId];
1716/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
1717/******/ 			e.code = 'MODULE_NOT_FOUND';
1718/******/ 			throw e;
1719/******/ 		}
1720/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
1721/******/ 	
1722/******/ 		// Flag the module as loaded

1723/******/ 		module.loaded = true;
1724/******/ 	
1725/******/ 		// Return the exports of the module
1726/******/ 		return module.exports;
1727/******/ 	}
1728/******/ 	
1729/************************************************************************/
1730/******/ 	/* webpack/runtime/compat get default export */
1731/******/ 	(() => {
1732/******/ 		// getDefaultExport function for compatibility with non-harmony modules
1733/******/ 		__webpack_require__.n = (module) => {
1734/******/ 			var getter = module && module.__esModule ?
1735/******/ 				() => (module['default']) :
1736/******/ 				() => (module);
1737/******/ 			__webpack_require__.d(getter, { a: getter });
1738/******/ 			return getter;
1739/******/ 		};
1740/******/ 	})();
1741/******/ 	
1742/******/ 	/* webpack/runtime/define property getters */
1743/******/ 	(() => {
1744/******/ 		// define getter functions for harmony exports
1745/******/ 		__webpack_require__.d = (exports, definition) => {
1746/******/ 			for(var key in definition) {
1747/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
1748/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
1749/******/ 				}
1750/******/ 			}
1751/******/ 		};
1752/******/ 	})();
1753/******/ 	
1754/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
1755/******/ 	(() => {
1756/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
1757/******/ 	})();
1758/******/ 	
1759/******/ 	/* webpack/runtime/make namespace object */
1760/******/ 	(() => {
1761/******/ 		// define __esModule on exports
1762/******/ 		__webpack_require__.r = (exports) => {
1763/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
1764/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
1765/******/ 			}
1766/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
1767/******/ 		};
1768/******/ 	})();
1769/******/ 	
1770/******/ 	/* webpack/runtime/node module decorator */
1771/******/ 	(() => {
1772/******/ 		__webpack_require__.nmd = (module) => {
1773/******/ 			module.paths = [];
1774/******/ 			if (!module.children) module.children = [];
1775/******/ 			return module;
1776/******/ 		};
1777/******/ 	})();
1778/******/ 	
1779/************************************************************************/
1780var __webpack_exports__ = {};
1781// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
1782(() => {
1783/*!********************************!*\
1784  !*** ./spa/public/src/App.jsx ***!
1785  \********************************/
1786__webpack_require__.r(__webpack_exports__);
1787/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1788/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
1789/* harmony export */ });
1790/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "./node_modules/react/index.js");
1791/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
1792/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react/jsx-runtime */ "./node_modules/react/jsx-runtime.js");
1793
1794
1795var App = function App() {
1796  return /*#__PURE__*/(0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__.jsx)("div", {
1797    children: "Hello World"
1798  });
1799};
1800/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (App);
1801})();
1802
1803/******/ })()
1804;
1805//# sourceMappingURL=public.bundle.js.map