taro/dist/prebundle/vendors-node_modules_taro_weapp_prebundle_react-redux_js.js

"use strict";
(wx["webpackJsonp"] = wx["webpackJsonp"] || []).push([["vendors-node_modules_taro_weapp_prebundle_react-redux_js"],{

/***/ "./node_modules/.taro/weapp/prebundle/react-redux.js":
/*!***********************************************************!*\
  !*** ./node_modules/.taro/weapp/prebundle/react-redux.js ***!
  \***********************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Provider: function() { return /* binding */ Provider_default; },
/* harmony export */   ReactReduxContext: function() { return /* binding */ ReactReduxContext; },
/* harmony export */   batch: function() { return /* reexport safe */ _chunk_2Y2U3MWF_js__WEBPACK_IMPORTED_MODULE_0__.unstable_batchedUpdates; },
/* harmony export */   connect: function() { return /* binding */ connect_default; },
/* harmony export */   createDispatchHook: function() { return /* binding */ createDispatchHook; },
/* harmony export */   createSelectorHook: function() { return /* binding */ createSelectorHook; },
/* harmony export */   createStoreHook: function() { return /* binding */ createStoreHook; },
/* harmony export */   shallowEqual: function() { return /* binding */ shallowEqual; },
/* harmony export */   useDispatch: function() { return /* binding */ useDispatch; },
/* harmony export */   useSelector: function() { return /* binding */ useSelector; },
/* harmony export */   useStore: function() { return /* binding */ useStore; }
/* harmony export */ });
/* harmony import */ var _chunk_2Y2U3MWF_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./chunk-2Y2U3MWF.js */ "./node_modules/.taro/weapp/prebundle/chunk-2Y2U3MWF.js");
/* harmony import */ var _chunk_3EXGJ5BE_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./chunk-3EXGJ5BE.js */ "./node_modules/.taro/weapp/prebundle/chunk-3EXGJ5BE.js");
/* harmony import */ var _chunk_77KB62LY_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./chunk-77KB62LY.js */ "./node_modules/.taro/weapp/prebundle/chunk-77KB62LY.js");
/* harmony import */ var _chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./chunk-LNJCN3VW.js */ "./node_modules/.taro/weapp/prebundle/chunk-LNJCN3VW.js");
/* harmony import */ var _chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./chunk-P7VEE7PG.js */ "./node_modules/.taro/weapp/prebundle/chunk-P7VEE7PG.js");
/* provided dependency */ var window = __webpack_require__(/*! ./node_modules/.taro/weapp/prebundle/chunk-3EXGJ5BE.js */ "./node_modules/.taro/weapp/prebundle/chunk-3EXGJ5BE.js")["window$1"];





// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
var require_use_sync_external_store_shim_development = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js" (exports) {
        "use strict";
        if (true) {
            (function() {
                "use strict";
                if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
                    __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
                }
                var React5 = (0,_chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__.require_react_production_min)();
                var ReactSharedInternals = React5.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
                function error(format) {
                    {
                        {
                            for(var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++){
                                args[_key2 - 1] = arguments[_key2];
                            }
                            printWarning("error", format, args);
                        }
                    }
                }
                function printWarning(level, format, args) {
                    {
                        var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
                        var stack = ReactDebugCurrentFrame.getStackAddendum();
                        if (stack !== "") {
                            format += "%s";
                            args = args.concat([
                                stack
                            ]);
                        }
                        var argsWithFormat = args.map(function(item) {
                            return String(item);
                        });
                        argsWithFormat.unshift("Warning: " + format);
                        Function.prototype.apply.call(console[level], console, argsWithFormat);
                    }
                }
                function is2(x, y) {
                    return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
                }
                var objectIs = typeof Object.is === "function" ? Object.is : is2;
                var useState = React5.useState, useEffect2 = React5.useEffect, useLayoutEffect2 = React5.useLayoutEffect, useDebugValue2 = React5.useDebugValue;
                var didWarnOld18Alpha = false;
                var didWarnUncachedGetSnapshot = false;
                function useSyncExternalStore3(subscribe, getSnapshot, getServerSnapshot) {
                    {
                        if (!didWarnOld18Alpha) {
                            if (React5.startTransition !== void 0) {
                                didWarnOld18Alpha = true;
                                error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.");
                            }
                        }
                    }
                    var value = getSnapshot();
                    {
                        if (!didWarnUncachedGetSnapshot) {
                            var cachedValue = getSnapshot();
                            if (!objectIs(value, cachedValue)) {
                                error("The result of getSnapshot should be cached to avoid an infinite loop");
                                didWarnUncachedGetSnapshot = true;
                            }
                        }
                    }
                    var _useState = useState({
                        inst: {
                            value,
                            getSnapshot
                        }
                    }), inst = _useState[0].inst, forceUpdate = _useState[1];
                    useLayoutEffect2(function() {
                        inst.value = value;
                        inst.getSnapshot = getSnapshot;
                        if (checkIfSnapshotChanged(inst)) {
                            forceUpdate({
                                inst
                            });
                        }
                    }, [
                        subscribe,
                        value,
                        getSnapshot
                    ]);
                    useEffect2(function() {
                        if (checkIfSnapshotChanged(inst)) {
                            forceUpdate({
                                inst
                            });
                        }
                        var handleStoreChange = function() {
                            if (checkIfSnapshotChanged(inst)) {
                                forceUpdate({
                                    inst
                                });
                            }
                        };
                        return subscribe(handleStoreChange);
                    }, [
                        subscribe
                    ]);
                    useDebugValue2(value);
                    return value;
                }
                function checkIfSnapshotChanged(inst) {
                    var latestGetSnapshot = inst.getSnapshot;
                    var prevValue = inst.value;
                    try {
                        var nextValue = latestGetSnapshot();
                        return !objectIs(prevValue, nextValue);
                    } catch (error2) {
                        return true;
                    }
                }
                function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
                    return getSnapshot();
                }
                var canUseDOM2 = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
                var isServerEnvironment = !canUseDOM2;
                var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore3;
                var useSyncExternalStore$2 = React5.useSyncExternalStore !== void 0 ? React5.useSyncExternalStore : shim;
                exports.useSyncExternalStore = useSyncExternalStore$2;
                if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
                    __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
                }
            })();
        }
    }
});
// node_modules/use-sync-external-store/shim/index.js
var require_shim = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/use-sync-external-store/shim/index.js" (exports, module) {
        "use strict";
        if (false) {} else {
            module.exports = require_use_sync_external_store_shim_development();
        }
    }
});
// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
var require_with_selector_development = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js" (exports) {
        "use strict";
        if (true) {
            (function() {
                "use strict";
                if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
                    __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
                }
                var React5 = (0,_chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__.require_react_production_min)();
                var shim = require_shim();
                function is2(x, y) {
                    return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
                }
                var objectIs = typeof Object.is === "function" ? Object.is : is2;
                var useSyncExternalStore3 = shim.useSyncExternalStore;
                var useRef3 = React5.useRef, useEffect2 = React5.useEffect, useMemo3 = React5.useMemo, useDebugValue2 = React5.useDebugValue;
                function useSyncExternalStoreWithSelector3(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
                    var instRef = useRef3(null);
                    var inst;
                    if (instRef.current === null) {
                        inst = {
                            hasValue: false,
                            value: null
                        };
                        instRef.current = inst;
                    } else {
                        inst = instRef.current;
                    }
                    var _useMemo = useMemo3(function() {
                        var hasMemo = false;
                        var memoizedSnapshot;
                        var memoizedSelection;
                        var memoizedSelector = function(nextSnapshot) {
                            if (!hasMemo) {
                                hasMemo = true;
                                memoizedSnapshot = nextSnapshot;
                                var _nextSelection = selector(nextSnapshot);
                                if (isEqual !== void 0) {
                                    if (inst.hasValue) {
                                        var currentSelection = inst.value;
                                        if (isEqual(currentSelection, _nextSelection)) {
                                            memoizedSelection = currentSelection;
                                            return currentSelection;
                                        }
                                    }
                                }
                                memoizedSelection = _nextSelection;
                                return _nextSelection;
                            }
                            var prevSnapshot = memoizedSnapshot;
                            var prevSelection = memoizedSelection;
                            if (objectIs(prevSnapshot, nextSnapshot)) {
                                return prevSelection;
                            }
                            var nextSelection = selector(nextSnapshot);
                            if (isEqual !== void 0 && isEqual(prevSelection, nextSelection)) {
                                return prevSelection;
                            }
                            memoizedSnapshot = nextSnapshot;
                            memoizedSelection = nextSelection;
                            return nextSelection;
                        };
                        var maybeGetServerSnapshot = getServerSnapshot === void 0 ? null : getServerSnapshot;
                        var getSnapshotWithSelector = function() {
                            return memoizedSelector(getSnapshot());
                        };
                        var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? void 0 : function() {
                            return memoizedSelector(maybeGetServerSnapshot());
                        };
                        return [
                            getSnapshotWithSelector,
                            getServerSnapshotWithSelector
                        ];
                    }, [
                        getSnapshot,
                        getServerSnapshot,
                        selector,
                        isEqual
                    ]), getSelection = _useMemo[0], getServerSelection = _useMemo[1];
                    var value = useSyncExternalStore3(subscribe, getSelection, getServerSelection);
                    useEffect2(function() {
                        inst.hasValue = true;
                        inst.value = value;
                    }, [
                        value
                    ]);
                    useDebugValue2(value);
                    return value;
                }
                exports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector3;
                if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
                    __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
                }
            })();
        }
    }
});
// node_modules/use-sync-external-store/shim/with-selector.js
var require_with_selector = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/use-sync-external-store/shim/with-selector.js" (exports, module) {
        "use strict";
        if (false) {} else {
            module.exports = require_with_selector_development();
        }
    }
});
// node_modules/react-is/cjs/react-is.development.js
var require_react_is_development = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/react-is/cjs/react-is.development.js" (exports) {
        "use strict";
        if (true) {
            (function() {
                "use strict";
                var hasSymbol = typeof Symbol === "function" && Symbol.for;
                var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103;
                var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106;
                var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107;
                var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108;
                var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114;
                var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109;
                var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110;
                var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111;
                var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111;
                var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112;
                var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113;
                var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120;
                var REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115;
                var REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116;
                var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121;
                var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117;
                var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118;
                var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119;
                function isValidElementType2(type) {
                    return typeof type === "string" || typeof type === "function" || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
                }
                function typeOf(object) {
                    if (typeof object === "object" && object !== null) {
                        var $$typeof = object.$$typeof;
                        switch($$typeof){
                            case REACT_ELEMENT_TYPE:
                                var type = object.type;
                                switch(type){
                                    case REACT_ASYNC_MODE_TYPE:
                                    case REACT_CONCURRENT_MODE_TYPE:
                                    case REACT_FRAGMENT_TYPE:
                                    case REACT_PROFILER_TYPE:
                                    case REACT_STRICT_MODE_TYPE:
                                    case REACT_SUSPENSE_TYPE:
                                        return type;
                                    default:
                                        var $$typeofType = type && type.$$typeof;
                                        switch($$typeofType){
                                            case REACT_CONTEXT_TYPE:
                                            case REACT_FORWARD_REF_TYPE:
                                            case REACT_LAZY_TYPE:
                                            case REACT_MEMO_TYPE:
                                            case REACT_PROVIDER_TYPE:
                                                return $$typeofType;
                                            default:
                                                return $$typeof;
                                        }
                                }
                            case REACT_PORTAL_TYPE:
                                return $$typeof;
                        }
                    }
                    return void 0;
                }
                var AsyncMode = REACT_ASYNC_MODE_TYPE;
                var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
                var ContextConsumer = REACT_CONTEXT_TYPE;
                var ContextProvider = REACT_PROVIDER_TYPE;
                var Element = REACT_ELEMENT_TYPE;
                var ForwardRef = REACT_FORWARD_REF_TYPE;
                var Fragment = REACT_FRAGMENT_TYPE;
                var Lazy = REACT_LAZY_TYPE;
                var Memo = REACT_MEMO_TYPE;
                var Portal = REACT_PORTAL_TYPE;
                var Profiler = REACT_PROFILER_TYPE;
                var StrictMode = REACT_STRICT_MODE_TYPE;
                var Suspense = REACT_SUSPENSE_TYPE;
                var hasWarnedAboutDeprecatedIsAsyncMode = false;
                function isAsyncMode(object) {
                    {
                        if (!hasWarnedAboutDeprecatedIsAsyncMode) {
                            hasWarnedAboutDeprecatedIsAsyncMode = true;
                            console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
                        }
                    }
                    return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
                }
                function isConcurrentMode(object) {
                    return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
                }
                function isContextConsumer2(object) {
                    return typeOf(object) === REACT_CONTEXT_TYPE;
                }
                function isContextProvider(object) {
                    return typeOf(object) === REACT_PROVIDER_TYPE;
                }
                function isElement(object) {
                    return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
                }
                function isForwardRef(object) {
                    return typeOf(object) === REACT_FORWARD_REF_TYPE;
                }
                function isFragment(object) {
                    return typeOf(object) === REACT_FRAGMENT_TYPE;
                }
                function isLazy(object) {
                    return typeOf(object) === REACT_LAZY_TYPE;
                }
                function isMemo(object) {
                    return typeOf(object) === REACT_MEMO_TYPE;
                }
                function isPortal(object) {
                    return typeOf(object) === REACT_PORTAL_TYPE;
                }
                function isProfiler(object) {
                    return typeOf(object) === REACT_PROFILER_TYPE;
                }
                function isStrictMode(object) {
                    return typeOf(object) === REACT_STRICT_MODE_TYPE;
                }
                function isSuspense(object) {
                    return typeOf(object) === REACT_SUSPENSE_TYPE;
                }
                exports.AsyncMode = AsyncMode;
                exports.ConcurrentMode = ConcurrentMode;
                exports.ContextConsumer = ContextConsumer;
                exports.ContextProvider = ContextProvider;
                exports.Element = Element;
                exports.ForwardRef = ForwardRef;
                exports.Fragment = Fragment;
                exports.Lazy = Lazy;
                exports.Memo = Memo;
                exports.Portal = Portal;
                exports.Profiler = Profiler;
                exports.StrictMode = StrictMode;
                exports.Suspense = Suspense;
                exports.isAsyncMode = isAsyncMode;
                exports.isConcurrentMode = isConcurrentMode;
                exports.isContextConsumer = isContextConsumer2;
                exports.isContextProvider = isContextProvider;
                exports.isElement = isElement;
                exports.isForwardRef = isForwardRef;
                exports.isFragment = isFragment;
                exports.isLazy = isLazy;
                exports.isMemo = isMemo;
                exports.isPortal = isPortal;
                exports.isProfiler = isProfiler;
                exports.isStrictMode = isStrictMode;
                exports.isSuspense = isSuspense;
                exports.isValidElementType = isValidElementType2;
                exports.typeOf = typeOf;
            })();
        }
    }
});
// node_modules/react-is/index.js
var require_react_is = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/react-is/index.js" (exports, module) {
        "use strict";
        if (false) {} else {
            module.exports = require_react_is_development();
        }
    }
});
// node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js
var require_hoist_non_react_statics_cjs = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js" (exports, module) {
        "use strict";
        var reactIs = require_react_is();
        var REACT_STATICS = {
            childContextTypes: true,
            contextType: true,
            contextTypes: true,
            defaultProps: true,
            displayName: true,
            getDefaultProps: true,
            getDerivedStateFromError: true,
            getDerivedStateFromProps: true,
            mixins: true,
            propTypes: true,
            type: true
        };
        var KNOWN_STATICS = {
            name: true,
            length: true,
            prototype: true,
            caller: true,
            callee: true,
            arguments: true,
            arity: true
        };
        var FORWARD_REF_STATICS = {
            "$$typeof": true,
            render: true,
            defaultProps: true,
            displayName: true,
            propTypes: true
        };
        var MEMO_STATICS = {
            "$$typeof": true,
            compare: true,
            defaultProps: true,
            displayName: true,
            propTypes: true,
            type: true
        };
        var TYPE_STATICS = {};
        TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
        TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
        function getStatics(component) {
            if (reactIs.isMemo(component)) {
                return MEMO_STATICS;
            }
            return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
        }
        var defineProperty = Object.defineProperty;
        var getOwnPropertyNames = Object.getOwnPropertyNames;
        var getOwnPropertySymbols = Object.getOwnPropertySymbols;
        var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
        var getPrototypeOf = Object.getPrototypeOf;
        var objectPrototype = Object.prototype;
        function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
            if (typeof sourceComponent !== "string") {
                if (objectPrototype) {
                    var inheritedComponent = getPrototypeOf(sourceComponent);
                    if (inheritedComponent && inheritedComponent !== objectPrototype) {
                        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
                    }
                }
                var keys = getOwnPropertyNames(sourceComponent);
                if (getOwnPropertySymbols) {
                    keys = keys.concat(getOwnPropertySymbols(sourceComponent));
                }
                var targetStatics = getStatics(targetComponent);
                var sourceStatics = getStatics(sourceComponent);
                for(var i = 0; i < keys.length; ++i){
                    var key = keys[i];
                    if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
                        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
                        try {
                            defineProperty(targetComponent, key, descriptor);
                        } catch (e) {}
                    }
                }
            }
            return targetComponent;
        }
        module.exports = hoistNonReactStatics;
    }
});
// node_modules/react-redux/node_modules/react-is/cjs/react-is.development.js
var require_react_is_development2 = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/react-redux/node_modules/react-is/cjs/react-is.development.js" (exports) {
        "use strict";
        if (true) {
            (function() {
                "use strict";
                var REACT_ELEMENT_TYPE = Symbol.for("react.element");
                var REACT_PORTAL_TYPE = Symbol.for("react.portal");
                var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
                var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
                var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
                var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
                var REACT_CONTEXT_TYPE = Symbol.for("react.context");
                var REACT_SERVER_CONTEXT_TYPE = Symbol.for("react.server_context");
                var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
                var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
                var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
                var REACT_MEMO_TYPE = Symbol.for("react.memo");
                var REACT_LAZY_TYPE = Symbol.for("react.lazy");
                var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
                var enableScopeAPI = false;
                var enableCacheElement = false;
                var enableTransitionTracing = false;
                var enableLegacyHidden = false;
                var enableDebugTracing = false;
                var REACT_MODULE_REFERENCE;
                {
                    REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
                }
                function isValidElementType2(type) {
                    if (typeof type === "string" || typeof type === "function") {
                        return true;
                    }
                    if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
                        return true;
                    }
                    if (typeof type === "object" && type !== null) {
                        if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
                            return true;
                        }
                    }
                    return false;
                }
                function typeOf(object) {
                    if (typeof object === "object" && object !== null) {
                        var $$typeof = object.$$typeof;
                        switch($$typeof){
                            case REACT_ELEMENT_TYPE:
                                var type = object.type;
                                switch(type){
                                    case REACT_FRAGMENT_TYPE:
                                    case REACT_PROFILER_TYPE:
                                    case REACT_STRICT_MODE_TYPE:
                                    case REACT_SUSPENSE_TYPE:
                                    case REACT_SUSPENSE_LIST_TYPE:
                                        return type;
                                    default:
                                        var $$typeofType = type && type.$$typeof;
                                        switch($$typeofType){
                                            case REACT_SERVER_CONTEXT_TYPE:
                                            case REACT_CONTEXT_TYPE:
                                            case REACT_FORWARD_REF_TYPE:
                                            case REACT_LAZY_TYPE:
                                            case REACT_MEMO_TYPE:
                                            case REACT_PROVIDER_TYPE:
                                                return $$typeofType;
                                            default:
                                                return $$typeof;
                                        }
                                }
                            case REACT_PORTAL_TYPE:
                                return $$typeof;
                        }
                    }
                    return void 0;
                }
                var ContextConsumer = REACT_CONTEXT_TYPE;
                var ContextProvider = REACT_PROVIDER_TYPE;
                var Element = REACT_ELEMENT_TYPE;
                var ForwardRef = REACT_FORWARD_REF_TYPE;
                var Fragment = REACT_FRAGMENT_TYPE;
                var Lazy = REACT_LAZY_TYPE;
                var Memo = REACT_MEMO_TYPE;
                var Portal = REACT_PORTAL_TYPE;
                var Profiler = REACT_PROFILER_TYPE;
                var StrictMode = REACT_STRICT_MODE_TYPE;
                var Suspense = REACT_SUSPENSE_TYPE;
                var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
                var hasWarnedAboutDeprecatedIsAsyncMode = false;
                var hasWarnedAboutDeprecatedIsConcurrentMode = false;
                function isAsyncMode(object) {
                    {
                        if (!hasWarnedAboutDeprecatedIsAsyncMode) {
                            hasWarnedAboutDeprecatedIsAsyncMode = true;
                            console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.");
                        }
                    }
                    return false;
                }
                function isConcurrentMode(object) {
                    {
                        if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
                            hasWarnedAboutDeprecatedIsConcurrentMode = true;
                            console["warn"]("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.");
                        }
                    }
                    return false;
                }
                function isContextConsumer2(object) {
                    return typeOf(object) === REACT_CONTEXT_TYPE;
                }
                function isContextProvider(object) {
                    return typeOf(object) === REACT_PROVIDER_TYPE;
                }
                function isElement(object) {
                    return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
                }
                function isForwardRef(object) {
                    return typeOf(object) === REACT_FORWARD_REF_TYPE;
                }
                function isFragment(object) {
                    return typeOf(object) === REACT_FRAGMENT_TYPE;
                }
                function isLazy(object) {
                    return typeOf(object) === REACT_LAZY_TYPE;
                }
                function isMemo(object) {
                    return typeOf(object) === REACT_MEMO_TYPE;
                }
                function isPortal(object) {
                    return typeOf(object) === REACT_PORTAL_TYPE;
                }
                function isProfiler(object) {
                    return typeOf(object) === REACT_PROFILER_TYPE;
                }
                function isStrictMode(object) {
                    return typeOf(object) === REACT_STRICT_MODE_TYPE;
                }
                function isSuspense(object) {
                    return typeOf(object) === REACT_SUSPENSE_TYPE;
                }
                function isSuspenseList(object) {
                    return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
                }
                exports.ContextConsumer = ContextConsumer;
                exports.ContextProvider = ContextProvider;
                exports.Element = Element;
                exports.ForwardRef = ForwardRef;
                exports.Fragment = Fragment;
                exports.Lazy = Lazy;
                exports.Memo = Memo;
                exports.Portal = Portal;
                exports.Profiler = Profiler;
                exports.StrictMode = StrictMode;
                exports.Suspense = Suspense;
                exports.SuspenseList = SuspenseList;
                exports.isAsyncMode = isAsyncMode;
                exports.isConcurrentMode = isConcurrentMode;
                exports.isContextConsumer = isContextConsumer2;
                exports.isContextProvider = isContextProvider;
                exports.isElement = isElement;
                exports.isForwardRef = isForwardRef;
                exports.isFragment = isFragment;
                exports.isLazy = isLazy;
                exports.isMemo = isMemo;
                exports.isPortal = isPortal;
                exports.isProfiler = isProfiler;
                exports.isStrictMode = isStrictMode;
                exports.isSuspense = isSuspense;
                exports.isSuspenseList = isSuspenseList;
                exports.isValidElementType = isValidElementType2;
                exports.typeOf = typeOf;
            })();
        }
    }
});
// node_modules/react-redux/node_modules/react-is/index.js
var require_react_is2 = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__commonJS)({
    "node_modules/react-redux/node_modules/react-is/index.js" (exports, module) {
        "use strict";
        if (false) {} else {
            module.exports = require_react_is_development2();
        }
    }
});
// node_modules/react-redux/es/index.js
var import_shim = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)(require_shim());
var import_with_selector = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)(require_with_selector());
// node_modules/react-redux/es/utils/batch.js
function defaultNoopBatch(callback) {
    callback();
}
var batch = defaultNoopBatch;
var setBatch = (newBatch)=>batch = newBatch;
var getBatch = ()=>batch;
// node_modules/react-redux/es/hooks/useSelector.js
var import_react2 = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)((0,_chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__.require_react_production_min)());
// node_modules/react-redux/es/hooks/useReduxContext.js
var import_react = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)((0,_chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__.require_react_production_min)());
// node_modules/react-redux/es/components/Context.js
var React = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)((0,_chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__.require_react_production_min)());
var ContextKey = Symbol.for(`react-redux-context`);
var gT = typeof globalThis !== "undefined" ? globalThis : {};
function getContext() {
    var _gT$ContextKey;
    if (!React.createContext) return {};
    const contextMap = (_gT$ContextKey = gT[ContextKey]) != null ? _gT$ContextKey : gT[ContextKey] = /* @__PURE__ */ new Map();
    let realContext = contextMap.get(React.createContext);
    if (!realContext) {
        realContext = React.createContext(null);
        if (true) {
            realContext.displayName = "ReactRedux";
        }
        contextMap.set(React.createContext, realContext);
    }
    return realContext;
}
var ReactReduxContext = getContext();
// node_modules/react-redux/es/hooks/useReduxContext.js
function createReduxContextHook(context = ReactReduxContext) {
    return function useReduxContext2() {
        const contextValue = (0, import_react.useContext)(context);
        if (!contextValue) {
            throw new Error("could not find react-redux context value; please ensure the component is wrapped in a <Provider>");
        }
        return contextValue;
    };
}
var useReduxContext = createReduxContextHook();
// node_modules/react-redux/es/utils/useSyncExternalStore.js
var notInitialized = ()=>{
    throw new Error("uSES not initialized!");
};
// node_modules/react-redux/es/hooks/useSelector.js
var useSyncExternalStoreWithSelector = notInitialized;
var initializeUseSelector = (fn)=>{
    useSyncExternalStoreWithSelector = fn;
};
var refEquality = (a, b)=>a === b;
function createSelectorHook(context = ReactReduxContext) {
    const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
    return function useSelector2(selector, equalityFnOrOptions = {}) {
        const { equalityFn =refEquality , stabilityCheck =void 0 , noopCheck =void 0  } = typeof equalityFnOrOptions === "function" ? {
            equalityFn: equalityFnOrOptions
        } : equalityFnOrOptions;
        if (true) {
            if (!selector) {
                throw new Error(`You must pass a selector to useSelector`);
            }
            if (typeof selector !== "function") {
                throw new Error(`You must pass a function as a selector to useSelector`);
            }
            if (typeof equalityFn !== "function") {
                throw new Error(`You must pass a function as an equality function to useSelector`);
            }
        }
        const { store , subscription , getServerState , stabilityCheck: globalStabilityCheck , noopCheck: globalNoopCheck  } = useReduxContext2();
        const firstRun = (0, import_react2.useRef)(true);
        const wrappedSelector = (0, import_react2.useCallback)({
            [selector.name] (state) {
                const selected = selector(state);
                if (true) {
                    const finalStabilityCheck = typeof stabilityCheck === "undefined" ? globalStabilityCheck : stabilityCheck;
                    if (finalStabilityCheck === "always" || finalStabilityCheck === "once" && firstRun.current) {
                        const toCompare = selector(state);
                        if (!equalityFn(selected, toCompare)) {
                            let stack = void 0;
                            try {
                                throw new Error();
                            } catch (e) {
                                ;
                                ({ stack  } = e);
                            }
                            console.warn("Selector " + (selector.name || "unknown") + " returned a different result when called with the same parameters. This can lead to unnecessary rerenders.\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization", {
                                state,
                                selected,
                                selected2: toCompare,
                                stack
                            });
                        }
                    }
                    const finalNoopCheck = typeof noopCheck === "undefined" ? globalNoopCheck : noopCheck;
                    if (finalNoopCheck === "always" || finalNoopCheck === "once" && firstRun.current) {
                        if (selected === state) {
                            let stack1 = void 0;
                            try {
                                throw new Error();
                            } catch (e1) {
                                ;
                                ({ stack: stack1  } = e1);
                            }
                            console.warn("Selector " + (selector.name || "unknown") + " returned the root state when called. This can lead to unnecessary rerenders.\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.", {
                                stack: stack1
                            });
                        }
                    }
                    if (firstRun.current) firstRun.current = false;
                }
                return selected;
            }
        }[selector.name], [
            selector,
            globalStabilityCheck,
            stabilityCheck
        ]);
        const selectedState = useSyncExternalStoreWithSelector(subscription.addNestedSub, store.getState, getServerState || store.getState, wrappedSelector, equalityFn);
        (0, import_react2.useDebugValue)(selectedState);
        return selectedState;
    };
}
var useSelector = createSelectorHook();
// node_modules/react-redux/node_modules/@babel/runtime/helpers/esm/extends.js
function _extends() {
    _extends = Object.assign ? Object.assign.bind() : function(target) {
        for(var i = 1; i < arguments.length; i++){
            var source = arguments[i];
            for(var key in source){
                if (Object.prototype.hasOwnProperty.call(source, key)) {
                    target[key] = source[key];
                }
            }
        }
        return target;
    };
    return _extends.apply(this, arguments);
}
// node_modules/react-redux/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;
    for(i = 0; i < sourceKeys.length; i++){
        key = sourceKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        target[key] = source[key];
    }
    return target;
}
// node_modules/react-redux/es/components/connect.js
var import_hoist_non_react_statics = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)(require_hoist_non_react_statics_cjs());
var React3 = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)((0,_chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__.require_react_production_min)());
var import_react_is = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)(require_react_is2());
// node_modules/react-redux/es/utils/warning.js
function warning(message) {
    if (typeof console !== "undefined" && typeof console.error === "function") {
        console.error(message);
    }
    try {
        throw new Error(message);
    } catch (e) {}
}
// node_modules/react-redux/es/connect/verifySubselectors.js
function verify(selector, methodName) {
    if (!selector) {
        throw new Error(`Unexpected value for ${methodName} in connect.`);
    } else if (methodName === "mapStateToProps" || methodName === "mapDispatchToProps") {
        if (!Object.prototype.hasOwnProperty.call(selector, "dependsOnOwnProps")) {
            warning(`The selector for ${methodName} of connect did not specify a value for dependsOnOwnProps.`);
        }
    }
}
function verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps) {
    verify(mapStateToProps, "mapStateToProps");
    verify(mapDispatchToProps, "mapDispatchToProps");
    verify(mergeProps, "mergeProps");
}
// node_modules/react-redux/es/connect/selectorFactory.js
var _excluded = [
    "initMapStateToProps",
    "initMapDispatchToProps",
    "initMergeProps"
];
function pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, { areStatesEqual , areOwnPropsEqual , areStatePropsEqual  }) {
    let hasRunAtLeastOnce = false;
    let state;
    let ownProps;
    let stateProps;
    let dispatchProps;
    let mergedProps;
    function handleFirstCall(firstState, firstOwnProps) {
        state = firstState;
        ownProps = firstOwnProps;
        stateProps = mapStateToProps(state, ownProps);
        dispatchProps = mapDispatchToProps(dispatch, ownProps);
        mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
        hasRunAtLeastOnce = true;
        return mergedProps;
    }
    function handleNewPropsAndNewState() {
        stateProps = mapStateToProps(state, ownProps);
        if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps);
        mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
        return mergedProps;
    }
    function handleNewProps() {
        if (mapStateToProps.dependsOnOwnProps) stateProps = mapStateToProps(state, ownProps);
        if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps);
        mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
        return mergedProps;
    }
    function handleNewState() {
        const nextStateProps = mapStateToProps(state, ownProps);
        const statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps);
        stateProps = nextStateProps;
        if (statePropsChanged) mergedProps = mergeProps(stateProps, dispatchProps, ownProps);
        return mergedProps;
    }
    function handleSubsequentCalls(nextState, nextOwnProps) {
        const propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps);
        const stateChanged = !areStatesEqual(nextState, state, nextOwnProps, ownProps);
        state = nextState;
        ownProps = nextOwnProps;
        if (propsChanged && stateChanged) return handleNewPropsAndNewState();
        if (propsChanged) return handleNewProps();
        if (stateChanged) return handleNewState();
        return mergedProps;
    }
    return function pureFinalPropsSelector(nextState, nextOwnProps) {
        return hasRunAtLeastOnce ? handleSubsequentCalls(nextState, nextOwnProps) : handleFirstCall(nextState, nextOwnProps);
    };
}
function finalPropsSelectorFactory(dispatch, _ref) {
    let { initMapStateToProps , initMapDispatchToProps , initMergeProps  } = _ref, options = _objectWithoutPropertiesLoose(_ref, _excluded);
    const mapStateToProps = initMapStateToProps(dispatch, options);
    const mapDispatchToProps = initMapDispatchToProps(dispatch, options);
    const mergeProps = initMergeProps(dispatch, options);
    if (true) {
        verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps);
    }
    return pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options);
}
// node_modules/react-redux/es/utils/bindActionCreators.js
function bindActionCreators(actionCreators, dispatch) {
    const boundActionCreators = {};
    for(const key in actionCreators){
        const actionCreator = actionCreators[key];
        if (typeof actionCreator === "function") {
            boundActionCreators[key] = (...args)=>dispatch(actionCreator(...args));
        }
    }
    return boundActionCreators;
}
// node_modules/react-redux/es/utils/isPlainObject.js
function isPlainObject(obj) {
    if (typeof obj !== "object" || obj === null) return false;
    let proto = Object.getPrototypeOf(obj);
    if (proto === null) return true;
    let baseProto = proto;
    while(Object.getPrototypeOf(baseProto) !== null){
        baseProto = Object.getPrototypeOf(baseProto);
    }
    return proto === baseProto;
}
// node_modules/react-redux/es/utils/verifyPlainObject.js
function verifyPlainObject(value, displayName, methodName) {
    if (!isPlainObject(value)) {
        warning(`${methodName}() in ${displayName} must return a plain object. Instead received ${value}.`);
    }
}
// node_modules/react-redux/es/connect/wrapMapToProps.js
function wrapMapToPropsConstant(getConstant) {
    return function initConstantSelector(dispatch) {
        const constant = getConstant(dispatch);
        function constantSelector() {
            return constant;
        }
        constantSelector.dependsOnOwnProps = false;
        return constantSelector;
    };
}
function getDependsOnOwnProps(mapToProps) {
    return mapToProps.dependsOnOwnProps ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1;
}
function wrapMapToPropsFunc(mapToProps, methodName) {
    return function initProxySelector(dispatch, { displayName  }) {
        const proxy = function mapToPropsProxy(stateOrDispatch, ownProps) {
            return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch, void 0);
        };
        proxy.dependsOnOwnProps = true;
        proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) {
            proxy.mapToProps = mapToProps;
            proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps);
            let props = proxy(stateOrDispatch, ownProps);
            if (typeof props === "function") {
                proxy.mapToProps = props;
                proxy.dependsOnOwnProps = getDependsOnOwnProps(props);
                props = proxy(stateOrDispatch, ownProps);
            }
            if (true) verifyPlainObject(props, displayName, methodName);
            return props;
        };
        return proxy;
    };
}
// node_modules/react-redux/es/connect/invalidArgFactory.js
function createInvalidArgFactory(arg, name) {
    return (dispatch, options)=>{
        throw new Error(`Invalid value of type ${typeof arg} for ${name} argument when connecting component ${options.wrappedComponentName}.`);
    };
}
// node_modules/react-redux/es/connect/mapDispatchToProps.js
function mapDispatchToPropsFactory(mapDispatchToProps) {
    return mapDispatchToProps && typeof mapDispatchToProps === "object" ? wrapMapToPropsConstant((dispatch)=>bindActionCreators(mapDispatchToProps, dispatch)) : !mapDispatchToProps ? wrapMapToPropsConstant((dispatch)=>({
            dispatch
        })) : typeof mapDispatchToProps === "function" ? wrapMapToPropsFunc(mapDispatchToProps, "mapDispatchToProps") : createInvalidArgFactory(mapDispatchToProps, "mapDispatchToProps");
}
// node_modules/react-redux/es/connect/mapStateToProps.js
function mapStateToPropsFactory(mapStateToProps) {
    return !mapStateToProps ? wrapMapToPropsConstant(()=>({})) : typeof mapStateToProps === "function" ? wrapMapToPropsFunc(mapStateToProps, "mapStateToProps") : createInvalidArgFactory(mapStateToProps, "mapStateToProps");
}
// node_modules/react-redux/es/connect/mergeProps.js
function defaultMergeProps(stateProps, dispatchProps, ownProps) {
    return _extends({}, ownProps, stateProps, dispatchProps);
}
function wrapMergePropsFunc(mergeProps) {
    return function initMergePropsProxy(dispatch, { displayName , areMergedPropsEqual  }) {
        let hasRunOnce = false;
        let mergedProps;
        return function mergePropsProxy(stateProps, dispatchProps, ownProps) {
            const nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps);
            if (hasRunOnce) {
                if (!areMergedPropsEqual(nextMergedProps, mergedProps)) mergedProps = nextMergedProps;
            } else {
                hasRunOnce = true;
                mergedProps = nextMergedProps;
                if (true) verifyPlainObject(mergedProps, displayName, "mergeProps");
            }
            return mergedProps;
        };
    };
}
function mergePropsFactory(mergeProps) {
    return !mergeProps ? ()=>defaultMergeProps : typeof mergeProps === "function" ? wrapMergePropsFunc(mergeProps) : createInvalidArgFactory(mergeProps, "mergeProps");
}
// node_modules/react-redux/es/utils/Subscription.js
function createListenerCollection() {
    const batch2 = getBatch();
    let first = null;
    let last = null;
    return {
        clear () {
            first = null;
            last = null;
        },
        notify () {
            batch2(()=>{
                let listener = first;
                while(listener){
                    listener.callback();
                    listener = listener.next;
                }
            });
        },
        get () {
            let listeners = [];
            let listener = first;
            while(listener){
                listeners.push(listener);
                listener = listener.next;
            }
            return listeners;
        },
        subscribe (callback) {
            let isSubscribed = true;
            let listener = last = {
                callback,
                next: null,
                prev: last
            };
            if (listener.prev) {
                listener.prev.next = listener;
            } else {
                first = listener;
            }
            return function unsubscribe() {
                if (!isSubscribed || first === null) return;
                isSubscribed = false;
                if (listener.next) {
                    listener.next.prev = listener.prev;
                } else {
                    last = listener.prev;
                }
                if (listener.prev) {
                    listener.prev.next = listener.next;
                } else {
                    first = listener.next;
                }
            };
        }
    };
}
var nullListeners = {
    notify () {},
    get: ()=>[]
};
function createSubscription(store, parentSub) {
    let unsubscribe;
    let listeners = nullListeners;
    let subscriptionsAmount = 0;
    let selfSubscribed = false;
    function addNestedSub(listener) {
        trySubscribe();
        const cleanupListener = listeners.subscribe(listener);
        let removed = false;
        return ()=>{
            if (!removed) {
                removed = true;
                cleanupListener();
                tryUnsubscribe();
            }
        };
    }
    function notifyNestedSubs() {
        listeners.notify();
    }
    function handleChangeWrapper() {
        if (subscription.onStateChange) {
            subscription.onStateChange();
        }
    }
    function isSubscribed() {
        return selfSubscribed;
    }
    function trySubscribe() {
        subscriptionsAmount++;
        if (!unsubscribe) {
            unsubscribe = parentSub ? parentSub.addNestedSub(handleChangeWrapper) : store.subscribe(handleChangeWrapper);
            listeners = createListenerCollection();
        }
    }
    function tryUnsubscribe() {
        subscriptionsAmount--;
        if (unsubscribe && subscriptionsAmount === 0) {
            unsubscribe();
            unsubscribe = void 0;
            listeners.clear();
            listeners = nullListeners;
        }
    }
    function trySubscribeSelf() {
        if (!selfSubscribed) {
            selfSubscribed = true;
            trySubscribe();
        }
    }
    function tryUnsubscribeSelf() {
        if (selfSubscribed) {
            selfSubscribed = false;
            tryUnsubscribe();
        }
    }
    const subscription = {
        addNestedSub,
        notifyNestedSubs,
        handleChangeWrapper,
        isSubscribed,
        trySubscribe: trySubscribeSelf,
        tryUnsubscribe: tryUnsubscribeSelf,
        getListeners: ()=>listeners
    };
    return subscription;
}
// node_modules/react-redux/es/utils/useIsomorphicLayoutEffect.js
var React2 = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)((0,_chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__.require_react_production_min)());
var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
var useIsomorphicLayoutEffect = canUseDOM ? React2.useLayoutEffect : React2.useEffect;
// node_modules/react-redux/es/utils/shallowEqual.js
function is(x, y) {
    if (x === y) {
        return x !== 0 || y !== 0 || 1 / x === 1 / y;
    } else {
        return x !== x && y !== y;
    }
}
function shallowEqual(objA, objB) {
    if (is(objA, objB)) return true;
    if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
        return false;
    }
    const keysA = Object.keys(objA);
    const keysB = Object.keys(objB);
    if (keysA.length !== keysB.length) return false;
    for(let i = 0; i < keysA.length; i++){
        if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
            return false;
        }
    }
    return true;
}
// node_modules/react-redux/es/components/connect.js
var _excluded2 = [
    "reactReduxForwardedRef"
];
var useSyncExternalStore = notInitialized;
var initializeConnect = (fn)=>{
    useSyncExternalStore = fn;
};
var NO_SUBSCRIPTION_ARRAY = [
    null,
    null
];
var stringifyComponent = (Comp)=>{
    try {
        return JSON.stringify(Comp);
    } catch (err) {
        return String(Comp);
    }
};
function useIsomorphicLayoutEffectWithArgs(effectFunc, effectArgs, dependencies) {
    useIsomorphicLayoutEffect(()=>effectFunc(...effectArgs), dependencies);
}
function captureWrapperProps(lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, childPropsFromStoreUpdate, notifyNestedSubs) {
    lastWrapperProps.current = wrapperProps;
    renderIsScheduled.current = false;
    if (childPropsFromStoreUpdate.current) {
        childPropsFromStoreUpdate.current = null;
        notifyNestedSubs();
    }
}
function subscribeUpdates(shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted, childPropsFromStoreUpdate, notifyNestedSubs, additionalSubscribeListener) {
    if (!shouldHandleStateChanges) return ()=>{};
    let didUnsubscribe = false;
    let lastThrownError = null;
    const checkForUpdates = ()=>{
        if (didUnsubscribe || !isMounted.current) {
            return;
        }
        const latestStoreState = store.getState();
        let newChildProps, error;
        try {
            newChildProps = childPropsSelector(latestStoreState, lastWrapperProps.current);
        } catch (e) {
            error = e;
            lastThrownError = e;
        }
        if (!error) {
            lastThrownError = null;
        }
        if (newChildProps === lastChildProps.current) {
            if (!renderIsScheduled.current) {
                notifyNestedSubs();
            }
        } else {
            lastChildProps.current = newChildProps;
            childPropsFromStoreUpdate.current = newChildProps;
            renderIsScheduled.current = true;
            additionalSubscribeListener();
        }
    };
    subscription.onStateChange = checkForUpdates;
    subscription.trySubscribe();
    checkForUpdates();
    const unsubscribeWrapper = ()=>{
        didUnsubscribe = true;
        subscription.tryUnsubscribe();
        subscription.onStateChange = null;
        if (lastThrownError) {
            throw lastThrownError;
        }
    };
    return unsubscribeWrapper;
}
function strictEqual(a, b) {
    return a === b;
}
var hasWarnedAboutDeprecatedPureOption = false;
function connect(mapStateToProps, mapDispatchToProps, mergeProps, { pure , areStatesEqual =strictEqual , areOwnPropsEqual =shallowEqual , areStatePropsEqual =shallowEqual , areMergedPropsEqual =shallowEqual , forwardRef: forwardRef2 = false , context =ReactReduxContext  } = {}) {
    if (true) {
        if (pure !== void 0 && !hasWarnedAboutDeprecatedPureOption) {
            hasWarnedAboutDeprecatedPureOption = true;
            warning('The `pure` option has been removed. `connect` is now always a "pure/memoized" component');
        }
    }
    const Context = context;
    const initMapStateToProps = mapStateToPropsFactory(mapStateToProps);
    const initMapDispatchToProps = mapDispatchToPropsFactory(mapDispatchToProps);
    const initMergeProps = mergePropsFactory(mergeProps);
    const shouldHandleStateChanges = Boolean(mapStateToProps);
    const wrapWithConnect = (WrappedComponent)=>{
        if (!(0, import_react_is.isValidElementType)(WrappedComponent)) {
            throw new Error(`You must pass a component to the function returned by connect. Instead received ${stringifyComponent(WrappedComponent)}`);
        }
        const wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || "Component";
        const displayName = `Connect(${wrappedComponentName})`;
        const selectorFactoryOptions = {
            shouldHandleStateChanges,
            displayName,
            wrappedComponentName,
            WrappedComponent,
            initMapStateToProps,
            initMapDispatchToProps,
            initMergeProps,
            areStatesEqual,
            areStatePropsEqual,
            areOwnPropsEqual,
            areMergedPropsEqual
        };
        function ConnectFunction(props) {
            const [propsContext, reactReduxForwardedRef, wrapperProps] = React3.useMemo(()=>{
                const { reactReduxForwardedRef: reactReduxForwardedRef2  } = props, wrapperProps2 = _objectWithoutPropertiesLoose(props, _excluded2);
                return [
                    props.context,
                    reactReduxForwardedRef2,
                    wrapperProps2
                ];
            }, [
                props
            ]);
            const ContextToUse = React3.useMemo(()=>{
                return propsContext && propsContext.Consumer && (0, import_react_is.isContextConsumer)(React3.createElement(propsContext.Consumer, null)) ? propsContext : Context;
            }, [
                propsContext,
                Context
            ]);
            const contextValue = React3.useContext(ContextToUse);
            const didStoreComeFromProps = Boolean(props.store) && Boolean(props.store.getState) && Boolean(props.store.dispatch);
            const didStoreComeFromContext = Boolean(contextValue) && Boolean(contextValue.store);
            if (!didStoreComeFromProps && !didStoreComeFromContext) {
                throw new Error(`Could not find "store" in the context of "${displayName}". Either wrap the root component in a <Provider>, or pass a custom React context provider to <Provider> and the corresponding React context consumer to ${displayName} in connect options.`);
            }
            const store = didStoreComeFromProps ? props.store : contextValue.store;
            const getServerState = didStoreComeFromContext ? contextValue.getServerState : store.getState;
            const childPropsSelector = React3.useMemo(()=>{
                return finalPropsSelectorFactory(store.dispatch, selectorFactoryOptions);
            }, [
                store
            ]);
            const [subscription, notifyNestedSubs] = React3.useMemo(()=>{
                if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY;
                const subscription2 = createSubscription(store, didStoreComeFromProps ? void 0 : contextValue.subscription);
                const notifyNestedSubs2 = subscription2.notifyNestedSubs.bind(subscription2);
                return [
                    subscription2,
                    notifyNestedSubs2
                ];
            }, [
                store,
                didStoreComeFromProps,
                contextValue
            ]);
            const overriddenContextValue = React3.useMemo(()=>{
                if (didStoreComeFromProps) {
                    return contextValue;
                }
                return _extends({}, contextValue, {
                    subscription
                });
            }, [
                didStoreComeFromProps,
                contextValue,
                subscription
            ]);
            const lastChildProps = React3.useRef();
            const lastWrapperProps = React3.useRef(wrapperProps);
            const childPropsFromStoreUpdate = React3.useRef();
            const renderIsScheduled = React3.useRef(false);
            const isProcessingDispatch = React3.useRef(false);
            const isMounted = React3.useRef(false);
            const latestSubscriptionCallbackError = React3.useRef();
            useIsomorphicLayoutEffect(()=>{
                isMounted.current = true;
                return ()=>{
                    isMounted.current = false;
                };
            }, []);
            const actualChildPropsSelector = React3.useMemo(()=>{
                const selector = ()=>{
                    if (childPropsFromStoreUpdate.current && wrapperProps === lastWrapperProps.current) {
                        return childPropsFromStoreUpdate.current;
                    }
                    return childPropsSelector(store.getState(), wrapperProps);
                };
                return selector;
            }, [
                store,
                wrapperProps
            ]);
            const subscribeForReact = React3.useMemo(()=>{
                const subscribe = (reactListener)=>{
                    if (!subscription) {
                        return ()=>{};
                    }
                    return subscribeUpdates(shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted, childPropsFromStoreUpdate, notifyNestedSubs, reactListener);
                };
                return subscribe;
            }, [
                subscription
            ]);
            useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [
                lastWrapperProps,
                lastChildProps,
                renderIsScheduled,
                wrapperProps,
                childPropsFromStoreUpdate,
                notifyNestedSubs
            ]);
            let actualChildProps;
            try {
                actualChildProps = useSyncExternalStore(subscribeForReact, actualChildPropsSelector, getServerState ? ()=>childPropsSelector(getServerState(), wrapperProps) : actualChildPropsSelector);
            } catch (err) {
                if (latestSubscriptionCallbackError.current) {
                    ;
                    err.message += `
The error may be correlated with this previous error:
${latestSubscriptionCallbackError.current.stack}

`;
                }
                throw err;
            }
            useIsomorphicLayoutEffect(()=>{
                latestSubscriptionCallbackError.current = void 0;
                childPropsFromStoreUpdate.current = void 0;
                lastChildProps.current = actualChildProps;
            });
            const renderedWrappedComponent = React3.useMemo(()=>{
                return React3.createElement(WrappedComponent, _extends({}, actualChildProps, {
                    ref: reactReduxForwardedRef
                }));
            }, [
                reactReduxForwardedRef,
                WrappedComponent,
                actualChildProps
            ]);
            const renderedChild = React3.useMemo(()=>{
                if (shouldHandleStateChanges) {
                    return React3.createElement(ContextToUse.Provider, {
                        value: overriddenContextValue
                    }, renderedWrappedComponent);
                }
                return renderedWrappedComponent;
            }, [
                ContextToUse,
                renderedWrappedComponent,
                overriddenContextValue
            ]);
            return renderedChild;
        }
        const _Connect = React3.memo(ConnectFunction);
        const Connect = _Connect;
        Connect.WrappedComponent = WrappedComponent;
        Connect.displayName = ConnectFunction.displayName = displayName;
        if (forwardRef2) {
            const _forwarded = React3.forwardRef(function forwardConnectRef(props, ref) {
                return React3.createElement(Connect, _extends({}, props, {
                    reactReduxForwardedRef: ref
                }));
            });
            const forwarded = _forwarded;
            forwarded.displayName = displayName;
            forwarded.WrappedComponent = WrappedComponent;
            return (0, import_hoist_non_react_statics.default)(forwarded, WrappedComponent);
        }
        return (0, import_hoist_non_react_statics.default)(Connect, WrappedComponent);
    };
    return wrapWithConnect;
}
var connect_default = connect;
// node_modules/react-redux/es/components/Provider.js
var React4 = (0,_chunk_P7VEE7PG_js__WEBPACK_IMPORTED_MODULE_4__.__toESM)((0,_chunk_LNJCN3VW_js__WEBPACK_IMPORTED_MODULE_3__.require_react_production_min)());
function Provider({ store , context , children , serverState , stabilityCheck ="once" , noopCheck ="once"  }) {
    const contextValue = React4.useMemo(()=>{
        const subscription = createSubscription(store);
        return {
            store,
            subscription,
            getServerState: serverState ? ()=>serverState : void 0,
            stabilityCheck,
            noopCheck
        };
    }, [
        store,
        serverState,
        stabilityCheck,
        noopCheck
    ]);
    const previousState = React4.useMemo(()=>store.getState(), [
        store
    ]);
    useIsomorphicLayoutEffect(()=>{
        const { subscription  } = contextValue;
        subscription.onStateChange = subscription.notifyNestedSubs;
        subscription.trySubscribe();
        if (previousState !== store.getState()) {
            subscription.notifyNestedSubs();
        }
        return ()=>{
            subscription.tryUnsubscribe();
            subscription.onStateChange = void 0;
        };
    }, [
        contextValue,
        previousState
    ]);
    const Context = context || ReactReduxContext;
    return React4.createElement(Context.Provider, {
        value: contextValue
    }, children);
}
var Provider_default = Provider;
// node_modules/react-redux/es/hooks/useStore.js
function createStoreHook(context = ReactReduxContext) {
    const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
    return function useStore2() {
        const { store  } = useReduxContext2();
        return store;
    };
}
var useStore = createStoreHook();
// node_modules/react-redux/es/hooks/useDispatch.js
function createDispatchHook(context = ReactReduxContext) {
    const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);
    return function useDispatch2() {
        const store = useStore2();
        return store.dispatch;
    };
}
var useDispatch = createDispatchHook();
// node_modules/react-redux/es/index.js
initializeUseSelector(import_with_selector.useSyncExternalStoreWithSelector);
initializeConnect(import_shim.useSyncExternalStore);
setBatch(_chunk_2Y2U3MWF_js__WEBPACK_IMPORTED_MODULE_0__.unstable_batchedUpdates);
 /**
 * @license React
 * react-is.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */  /**
 * @license React
 * use-sync-external-store-shim.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */  /**
 * @license React
 * use-sync-external-store-shim/with-selector.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */  /** @license React v16.13.1
 * react-is.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */ 


/***/ })

}]);