{"version":3,"file":"static/chunks/7998-98be4342fe83942d.js","mappings":"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","sources":["webpack://_N_E/./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack://_N_E/./node_modules/next/dist/shared/lib/app-dynamic.js","webpack://_N_E/./node_modules/next/dist/shared/lib/lazy-dynamic/dynamic-no-ssr.js","webpack://_N_E/./node_modules/next/dist/shared/lib/lazy-dynamic/loadable.js","webpack://_N_E/./node_modules/react-is/cjs/react-is.production.min.js","webpack://_N_E/./node_modules/react-is/index.js","webpack://_N_E/./node_modules/react-redux/es/utils/reactBatchedUpdates.js","webpack://_N_E/./node_modules/react-redux/es/utils/batch.js","webpack://_N_E/./node_modules/react-redux/es/components/Context.js","webpack://_N_E/./node_modules/react-redux/es/hooks/useReduxContext.js","webpack://_N_E/./node_modules/react-redux/es/utils/useSyncExternalStore.js","webpack://_N_E/./node_modules/react-redux/es/hooks/useSelector.js","webpack://_N_E/./node_modules/react-redux/es/utils/Subscription.js","webpack://_N_E/./node_modules/react-redux/es/utils/useIsomorphicLayoutEffect.js","webpack://_N_E/./node_modules/react-redux/es/components/connect.js","webpack://_N_E/./node_modules/react-redux/es/components/Provider.js","webpack://_N_E/./node_modules/react-redux/es/hooks/useStore.js","webpack://_N_E/./node_modules/react-redux/es/hooks/useDispatch.js","webpack://_N_E/./node_modules/react-redux/es/exports.js","webpack://_N_E/./node_modules/react-redux/es/index.js","webpack://_N_E/./node_modules/react-redux/node_modules/react-is/cjs/react-is.production.min.js","webpack://_N_E/./node_modules/react-redux/node_modules/react-is/index.js","webpack://_N_E/./node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.min.js","webpack://_N_E/./node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.min.js","webpack://_N_E/./node_modules/use-sync-external-store/shim/index.js","webpack://_N_E/./node_modules/use-sync-external-store/shim/with-selector.js","webpack://_N_E/<anon>"],"sourcesContent":["'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nObject.defineProperty(exports, \"default\", {\n    enumerable: true,\n    get: function() {\n        return dynamic;\n    }\n});\nconst _interop_require_default = require(\"@swc/helpers/_/_interop_require_default\");\nconst _react = /*#__PURE__*/ _interop_require_default._(require(\"react\"));\nconst _loadable = /*#__PURE__*/ _interop_require_default._(require(\"./lazy-dynamic/loadable\"));\n// Normalize loader to return the module as form { default: Component } for `React.lazy`.\n// Also for backward compatible since next/dynamic allows to resolve a component directly with loader\n// Client component reference proxy need to be converted to a module.\nfunction convertModule(mod) {\n    return {\n        default: (mod == null ? void 0 : mod.default) || mod\n    };\n}\nfunction dynamic(dynamicOptions, options) {\n    const loadableFn = _loadable.default;\n    const loadableOptions = {\n        // A loading component is not required, so we default it\n        loading: (param)=>{\n            let { error, isLoading, pastDelay } = param;\n            if (!pastDelay) return null;\n            if (process.env.NODE_ENV !== \"production\") {\n                if (isLoading) {\n                    return null;\n                }\n                if (error) {\n                    return /*#__PURE__*/ _react.default.createElement(\"p\", null, error.message, /*#__PURE__*/ _react.default.createElement(\"br\", null), error.stack);\n                }\n            }\n            return null;\n        }\n    };\n    if (typeof dynamicOptions === \"function\") {\n        loadableOptions.loader = dynamicOptions;\n    }\n    Object.assign(loadableOptions, options);\n    const loaderFn = loadableOptions.loader;\n    const loader = ()=>loaderFn != null ? loaderFn().then(convertModule) : Promise.resolve(convertModule(()=>null));\n    return loadableFn({\n        ...loadableOptions,\n        loader: loader\n    });\n}\n\nif ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {\n  Object.defineProperty(exports.default, '__esModule', { value: true });\n  Object.assign(exports.default, exports);\n  module.exports = exports.default;\n}\n\n//# sourceMappingURL=app-dynamic.js.map","\"use client\";\n\n\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nObject.defineProperty(exports, \"NoSSR\", {\n    enumerable: true,\n    get: function() {\n        return NoSSR;\n    }\n});\nconst _nossrerror = require(\"./no-ssr-error\");\nfunction NoSSR(param) {\n    let { children } = param;\n    if (typeof window === \"undefined\") {\n        (0, _nossrerror.throwWithNoSSR)();\n    }\n    return children;\n}\n\n//# sourceMappingURL=dynamic-no-ssr.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nObject.defineProperty(exports, \"default\", {\n    enumerable: true,\n    get: function() {\n        return _default;\n    }\n});\nconst _interop_require_default = require(\"@swc/helpers/_/_interop_require_default\");\nconst _react = /*#__PURE__*/ _interop_require_default._(require(\"react\"));\nconst _dynamicnossr = require(\"./dynamic-no-ssr\");\nfunction Loadable(options) {\n    const opts = Object.assign({\n        loader: null,\n        loading: null,\n        ssr: true\n    }, options);\n    opts.lazy = /*#__PURE__*/ _react.default.lazy(opts.loader);\n    function LoadableComponent(props) {\n        const Loading = opts.loading;\n        const fallbackElement = /*#__PURE__*/ _react.default.createElement(Loading, {\n            isLoading: true,\n            pastDelay: true,\n            error: null\n        });\n        const Wrap = opts.ssr ? _react.default.Fragment : _dynamicnossr.NoSSR;\n        const Lazy = opts.lazy;\n        return /*#__PURE__*/ _react.default.createElement(_react.default.Suspense, {\n            fallback: fallbackElement\n        }, /*#__PURE__*/ _react.default.createElement(Wrap, null, /*#__PURE__*/ _react.default.createElement(Lazy, props)));\n    }\n    LoadableComponent.displayName = \"LoadableComponent\";\n    return LoadableComponent;\n}\nconst _default = Loadable;\n\n//# sourceMappingURL=loadable.js.map","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var b=\"function\"===typeof Symbol&&Symbol.for,c=b?Symbol.for(\"react.element\"):60103,d=b?Symbol.for(\"react.portal\"):60106,e=b?Symbol.for(\"react.fragment\"):60107,f=b?Symbol.for(\"react.strict_mode\"):60108,g=b?Symbol.for(\"react.profiler\"):60114,h=b?Symbol.for(\"react.provider\"):60109,k=b?Symbol.for(\"react.context\"):60110,l=b?Symbol.for(\"react.async_mode\"):60111,m=b?Symbol.for(\"react.concurrent_mode\"):60111,n=b?Symbol.for(\"react.forward_ref\"):60112,p=b?Symbol.for(\"react.suspense\"):60113,q=b?\nSymbol.for(\"react.suspense_list\"):60120,r=b?Symbol.for(\"react.memo\"):60115,t=b?Symbol.for(\"react.lazy\"):60116,v=b?Symbol.for(\"react.block\"):60121,w=b?Symbol.for(\"react.fundamental\"):60117,x=b?Symbol.for(\"react.responder\"):60118,y=b?Symbol.for(\"react.scope\"):60119;\nfunction z(a){if(\"object\"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;\nexports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};\nexports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||\"object\"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","export { unstable_batchedUpdates } from 'react-dom';","// Default to a dummy \"batch\" implementation that just runs the callback\nfunction defaultNoopBatch(callback) {\n  callback();\n}\n\nlet batch = defaultNoopBatch; // Allow injecting another batching function later\n\nexport const setBatch = newBatch => batch = newBatch; // Supply a getter just to skip dealing with ESM bindings\n\nexport const getBatch = () => batch;","import * as React from 'react';\nconst ContextKey = Symbol.for(`react-redux-context`);\nconst gT = typeof globalThis !== \"undefined\" ? globalThis :\n/* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */\n{};\n\nfunction getContext() {\n  var _gT$ContextKey;\n\n  if (!React.createContext) return {};\n  const contextMap = (_gT$ContextKey = gT[ContextKey]) != null ? _gT$ContextKey : gT[ContextKey] = new Map();\n  let realContext = contextMap.get(React.createContext);\n\n  if (!realContext) {\n    realContext = React.createContext(null);\n\n    if (process.env.NODE_ENV !== 'production') {\n      realContext.displayName = 'ReactRedux';\n    }\n\n    contextMap.set(React.createContext, realContext);\n  }\n\n  return realContext;\n}\n\nexport const ReactReduxContext = /*#__PURE__*/getContext();\nexport default ReactReduxContext;","import { useContext } from 'react';\nimport { ReactReduxContext } from '../components/Context';\n\n/**\r\n * Hook factory, which creates a `useReduxContext` hook bound to a given context. This is a low-level\r\n * hook that you should usually not need to call directly.\r\n *\r\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\r\n * @returns {Function} A `useReduxContext` hook bound to the specified context.\r\n */\nexport function createReduxContextHook(context = ReactReduxContext) {\n  return function useReduxContext() {\n    const contextValue = useContext(context);\n\n    if (process.env.NODE_ENV !== 'production' && !contextValue) {\n      throw new Error('could not find react-redux context value; please ensure the component is wrapped in a <Provider>');\n    }\n\n    return contextValue;\n  };\n}\n/**\r\n * A hook to access the value of the `ReactReduxContext`. This is a low-level\r\n * hook that you should usually not need to call directly.\r\n *\r\n * @returns {any} the value of the `ReactReduxContext`\r\n *\r\n * @example\r\n *\r\n * import React from 'react'\r\n * import { useReduxContext } from 'react-redux'\r\n *\r\n * export const CounterComponent = () => {\r\n *   const { store } = useReduxContext()\r\n *   return <div>{store.getState()}</div>\r\n * }\r\n */\n\nexport const useReduxContext = /*#__PURE__*/createReduxContextHook();","export const notInitialized = () => {\n  throw new Error('uSES not initialized!');\n};","import { useCallback, useDebugValue, useRef } from 'react';\nimport { createReduxContextHook, useReduxContext as useDefaultReduxContext } from './useReduxContext';\nimport { ReactReduxContext } from '../components/Context';\nimport { notInitialized } from '../utils/useSyncExternalStore';\nlet useSyncExternalStoreWithSelector = notInitialized;\nexport const initializeUseSelector = fn => {\n  useSyncExternalStoreWithSelector = fn;\n};\n\nconst refEquality = (a, b) => a === b;\n/**\r\n * Hook factory, which creates a `useSelector` hook bound to a given context.\r\n *\r\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\r\n * @returns {Function} A `useSelector` hook bound to the specified context.\r\n */\n\n\nexport function createSelectorHook(context = ReactReduxContext) {\n  const useReduxContext = context === ReactReduxContext ? useDefaultReduxContext : createReduxContextHook(context);\n  return function useSelector(selector, equalityFnOrOptions = {}) {\n    const {\n      equalityFn = refEquality,\n      stabilityCheck = undefined,\n      noopCheck = undefined\n    } = typeof equalityFnOrOptions === 'function' ? {\n      equalityFn: equalityFnOrOptions\n    } : equalityFnOrOptions;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (!selector) {\n        throw new Error(`You must pass a selector to useSelector`);\n      }\n\n      if (typeof selector !== 'function') {\n        throw new Error(`You must pass a function as a selector to useSelector`);\n      }\n\n      if (typeof equalityFn !== 'function') {\n        throw new Error(`You must pass a function as an equality function to useSelector`);\n      }\n    }\n\n    const {\n      store,\n      subscription,\n      getServerState,\n      stabilityCheck: globalStabilityCheck,\n      noopCheck: globalNoopCheck\n    } = useReduxContext();\n    const firstRun = useRef(true);\n    const wrappedSelector = useCallback({\n      [selector.name](state) {\n        const selected = selector(state);\n\n        if (process.env.NODE_ENV !== 'production') {\n          const finalStabilityCheck = typeof stabilityCheck === 'undefined' ? globalStabilityCheck : stabilityCheck;\n\n          if (finalStabilityCheck === 'always' || finalStabilityCheck === 'once' && firstRun.current) {\n            const toCompare = selector(state);\n\n            if (!equalityFn(selected, toCompare)) {\n              let stack = undefined;\n\n              try {\n                throw new Error();\n              } catch (e) {\n                ;\n                ({\n                  stack\n                } = e);\n              }\n\n              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', {\n                state,\n                selected,\n                selected2: toCompare,\n                stack\n              });\n            }\n          }\n\n          const finalNoopCheck = typeof noopCheck === 'undefined' ? globalNoopCheck : noopCheck;\n\n          if (finalNoopCheck === 'always' || finalNoopCheck === 'once' && firstRun.current) {\n            // @ts-ignore\n            if (selected === state) {\n              let stack = undefined;\n\n              try {\n                throw new Error();\n              } catch (e) {\n                ;\n                ({\n                  stack\n                } = e);\n              }\n\n              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.', {\n                stack\n              });\n            }\n          }\n\n          if (firstRun.current) firstRun.current = false;\n        }\n\n        return selected;\n      }\n\n    }[selector.name], [selector, globalStabilityCheck, stabilityCheck]);\n    const selectedState = useSyncExternalStoreWithSelector(subscription.addNestedSub, store.getState, getServerState || store.getState, wrappedSelector, equalityFn);\n    useDebugValue(selectedState);\n    return selectedState;\n  };\n}\n/**\r\n * A hook to access the redux store's state. This hook takes a selector function\r\n * as an argument. The selector is called with the store state.\r\n *\r\n * This hook takes an optional equality comparison function as the second parameter\r\n * that allows you to customize the way the selected state is compared to determine\r\n * whether the component needs to be re-rendered.\r\n *\r\n * @param {Function} selector the selector function\r\n * @param {Function=} equalityFn the function that will be used to determine equality\r\n *\r\n * @returns {any} the selected state\r\n *\r\n * @example\r\n *\r\n * import React from 'react'\r\n * import { useSelector } from 'react-redux'\r\n *\r\n * export const CounterComponent = () => {\r\n *   const counter = useSelector(state => state.counter)\r\n *   return <div>{counter}</div>\r\n * }\r\n */\n\nexport const useSelector = /*#__PURE__*/createSelectorHook();","import { getBatch } from './batch'; // encapsulates the subscription logic for connecting a component to the redux store, as\n// well as nesting subscriptions of descendant components, so that we can ensure the\n// ancestor components re-render before descendants\n\nfunction createListenerCollection() {\n  const batch = getBatch();\n  let first = null;\n  let last = null;\n  return {\n    clear() {\n      first = null;\n      last = null;\n    },\n\n    notify() {\n      batch(() => {\n        let listener = first;\n\n        while (listener) {\n          listener.callback();\n          listener = listener.next;\n        }\n      });\n    },\n\n    get() {\n      let listeners = [];\n      let listener = first;\n\n      while (listener) {\n        listeners.push(listener);\n        listener = listener.next;\n      }\n\n      return listeners;\n    },\n\n    subscribe(callback) {\n      let isSubscribed = true;\n      let listener = last = {\n        callback,\n        next: null,\n        prev: last\n      };\n\n      if (listener.prev) {\n        listener.prev.next = listener;\n      } else {\n        first = listener;\n      }\n\n      return function unsubscribe() {\n        if (!isSubscribed || first === null) return;\n        isSubscribed = false;\n\n        if (listener.next) {\n          listener.next.prev = listener.prev;\n        } else {\n          last = listener.prev;\n        }\n\n        if (listener.prev) {\n          listener.prev.next = listener.next;\n        } else {\n          first = listener.next;\n        }\n      };\n    }\n\n  };\n}\n\nconst nullListeners = {\n  notify() {},\n\n  get: () => []\n};\nexport function createSubscription(store, parentSub) {\n  let unsubscribe;\n  let listeners = nullListeners; // Reasons to keep the subscription active\n\n  let subscriptionsAmount = 0; // Is this specific subscription subscribed (or only nested ones?)\n\n  let selfSubscribed = false;\n\n  function addNestedSub(listener) {\n    trySubscribe();\n    const cleanupListener = listeners.subscribe(listener); // cleanup nested sub\n\n    let removed = false;\n    return () => {\n      if (!removed) {\n        removed = true;\n        cleanupListener();\n        tryUnsubscribe();\n      }\n    };\n  }\n\n  function notifyNestedSubs() {\n    listeners.notify();\n  }\n\n  function handleChangeWrapper() {\n    if (subscription.onStateChange) {\n      subscription.onStateChange();\n    }\n  }\n\n  function isSubscribed() {\n    return selfSubscribed;\n  }\n\n  function trySubscribe() {\n    subscriptionsAmount++;\n\n    if (!unsubscribe) {\n      unsubscribe = parentSub ? parentSub.addNestedSub(handleChangeWrapper) : store.subscribe(handleChangeWrapper);\n      listeners = createListenerCollection();\n    }\n  }\n\n  function tryUnsubscribe() {\n    subscriptionsAmount--;\n\n    if (unsubscribe && subscriptionsAmount === 0) {\n      unsubscribe();\n      unsubscribe = undefined;\n      listeners.clear();\n      listeners = nullListeners;\n    }\n  }\n\n  function trySubscribeSelf() {\n    if (!selfSubscribed) {\n      selfSubscribed = true;\n      trySubscribe();\n    }\n  }\n\n  function tryUnsubscribeSelf() {\n    if (selfSubscribed) {\n      selfSubscribed = false;\n      tryUnsubscribe();\n    }\n  }\n\n  const subscription = {\n    addNestedSub,\n    notifyNestedSubs,\n    handleChangeWrapper,\n    isSubscribed,\n    trySubscribe: trySubscribeSelf,\n    tryUnsubscribe: tryUnsubscribeSelf,\n    getListeners: () => listeners\n  };\n  return subscription;\n}","import * as React from 'react'; // React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser. We need useLayoutEffect to ensure the store\n// subscription callback always has the selector from the latest render commit\n// available, otherwise a store update may happen between render and the effect,\n// which may cause missed updates; we also must ensure the store subscription\n// is created synchronously, otherwise a store update may occur before the\n// subscription is created and an inconsistent state may be observed\n// Matches logic in React's `shared/ExecutionEnvironment` file\n\nexport const canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');\nexport const useIsomorphicLayoutEffect = canUseDOM ? React.useLayoutEffect : React.useEffect;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"reactReduxForwardedRef\"];\n\n/* eslint-disable valid-jsdoc, @typescript-eslint/no-unused-vars */\nimport hoistStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\nimport { isValidElementType, isContextConsumer } from 'react-is';\nimport defaultSelectorFactory from '../connect/selectorFactory';\nimport { mapDispatchToPropsFactory } from '../connect/mapDispatchToProps';\nimport { mapStateToPropsFactory } from '../connect/mapStateToProps';\nimport { mergePropsFactory } from '../connect/mergeProps';\nimport { createSubscription } from '../utils/Subscription';\nimport { useIsomorphicLayoutEffect } from '../utils/useIsomorphicLayoutEffect';\nimport shallowEqual from '../utils/shallowEqual';\nimport warning from '../utils/warning';\nimport { ReactReduxContext } from './Context';\nimport { notInitialized } from '../utils/useSyncExternalStore';\nlet useSyncExternalStore = notInitialized;\nexport const initializeConnect = fn => {\n  useSyncExternalStore = fn;\n}; // Define some constant arrays just to avoid re-creating these\n\nconst EMPTY_ARRAY = [null, 0];\nconst NO_SUBSCRIPTION_ARRAY = [null, null]; // Attempts to stringify whatever not-really-a-component value we were given\n// for logging in an error message\n\nconst stringifyComponent = Comp => {\n  try {\n    return JSON.stringify(Comp);\n  } catch (err) {\n    return String(Comp);\n  }\n};\n\n// This is \"just\" a `useLayoutEffect`, but with two modifications:\n// - we need to fall back to `useEffect` in SSR to avoid annoying warnings\n// - we extract this to a separate function to avoid closing over values\n//   and causing memory leaks\nfunction useIsomorphicLayoutEffectWithArgs(effectFunc, effectArgs, dependencies) {\n  useIsomorphicLayoutEffect(() => effectFunc(...effectArgs), dependencies);\n} // Effect callback, extracted: assign the latest props values to refs for later usage\n\n\nfunction captureWrapperProps(lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, // actualChildProps: unknown,\nchildPropsFromStoreUpdate, notifyNestedSubs) {\n  // We want to capture the wrapper props and child props we used for later comparisons\n  lastWrapperProps.current = wrapperProps;\n  renderIsScheduled.current = false; // If the render was from a store update, clear out that reference and cascade the subscriber update\n\n  if (childPropsFromStoreUpdate.current) {\n    childPropsFromStoreUpdate.current = null;\n    notifyNestedSubs();\n  }\n} // Effect callback, extracted: subscribe to the Redux store or nearest connected ancestor,\n// check for updates after dispatched actions, and trigger re-renders.\n\n\nfunction subscribeUpdates(shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted, childPropsFromStoreUpdate, notifyNestedSubs, // forceComponentUpdateDispatch: React.Dispatch<any>,\nadditionalSubscribeListener) {\n  // If we're not subscribed to the store, nothing to do here\n  if (!shouldHandleStateChanges) return () => {}; // Capture values for checking if and when this component unmounts\n\n  let didUnsubscribe = false;\n  let lastThrownError = null; // We'll run this callback every time a store subscription update propagates to this component\n\n  const checkForUpdates = () => {\n    if (didUnsubscribe || !isMounted.current) {\n      // Don't run stale listeners.\n      // Redux doesn't guarantee unsubscriptions happen until next dispatch.\n      return;\n    } // TODO We're currently calling getState ourselves here, rather than letting `uSES` do it\n\n\n    const latestStoreState = store.getState();\n    let newChildProps, error;\n\n    try {\n      // Actually run the selector with the most recent store state and wrapper props\n      // to determine what the child props should be\n      newChildProps = childPropsSelector(latestStoreState, lastWrapperProps.current);\n    } catch (e) {\n      error = e;\n      lastThrownError = e;\n    }\n\n    if (!error) {\n      lastThrownError = null;\n    } // If the child props haven't changed, nothing to do here - cascade the subscription update\n\n\n    if (newChildProps === lastChildProps.current) {\n      if (!renderIsScheduled.current) {\n        notifyNestedSubs();\n      }\n    } else {\n      // Save references to the new child props.  Note that we track the \"child props from store update\"\n      // as a ref instead of a useState/useReducer because we need a way to determine if that value has\n      // been processed.  If this went into useState/useReducer, we couldn't clear out the value without\n      // forcing another re-render, which we don't want.\n      lastChildProps.current = newChildProps;\n      childPropsFromStoreUpdate.current = newChildProps;\n      renderIsScheduled.current = true; // TODO This is hacky and not how `uSES` is meant to be used\n      // Trigger the React `useSyncExternalStore` subscriber\n\n      additionalSubscribeListener();\n    }\n  }; // Actually subscribe to the nearest connected ancestor (or store)\n\n\n  subscription.onStateChange = checkForUpdates;\n  subscription.trySubscribe(); // Pull data from the store after first render in case the store has\n  // changed since we began.\n\n  checkForUpdates();\n\n  const unsubscribeWrapper = () => {\n    didUnsubscribe = true;\n    subscription.tryUnsubscribe();\n    subscription.onStateChange = null;\n\n    if (lastThrownError) {\n      // It's possible that we caught an error due to a bad mapState function, but the\n      // parent re-rendered without this component and we're about to unmount.\n      // This shouldn't happen as long as we do top-down subscriptions correctly, but\n      // if we ever do those wrong, this throw will surface the error in our tests.\n      // In that case, throw the error from here so it doesn't get lost.\n      throw lastThrownError;\n    }\n  };\n\n  return unsubscribeWrapper;\n} // Reducer initial state creation for our update reducer\n\n\nconst initStateUpdates = () => EMPTY_ARRAY;\n\nfunction strictEqual(a, b) {\n  return a === b;\n}\n/**\r\n * Infers the type of props that a connector will inject into a component.\r\n */\n\n\nlet hasWarnedAboutDeprecatedPureOption = false;\n/**\r\n * Connects a React component to a Redux store.\r\n *\r\n * - Without arguments, just wraps the component, without changing the behavior / props\r\n *\r\n * - If 2 params are passed (3rd param, mergeProps, is skipped), default behavior\r\n * is to override ownProps (as stated in the docs), so what remains is everything that's\r\n * not a state or dispatch prop\r\n *\r\n * - When 3rd param is passed, we don't know if ownProps propagate and whether they\r\n * should be valid component props, because it depends on mergeProps implementation.\r\n * As such, it is the user's responsibility to extend ownProps interface from state or\r\n * dispatch props or both when applicable\r\n *\r\n * @param mapStateToProps A function that extracts values from state\r\n * @param mapDispatchToProps Setup for dispatching actions\r\n * @param mergeProps Optional callback to merge state and dispatch props together\r\n * @param options Options for configuring the connection\r\n *\r\n */\n\nfunction connect(mapStateToProps, mapDispatchToProps, mergeProps, {\n  // The `pure` option has been removed, so TS doesn't like us destructuring this to check its existence.\n  // @ts-ignore\n  pure,\n  areStatesEqual = strictEqual,\n  areOwnPropsEqual = shallowEqual,\n  areStatePropsEqual = shallowEqual,\n  areMergedPropsEqual = shallowEqual,\n  // use React's forwardRef to expose a ref of the wrapped component\n  forwardRef = false,\n  // the context consumer to use\n  context = ReactReduxContext\n} = {}) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (pure !== undefined && !hasWarnedAboutDeprecatedPureOption) {\n      hasWarnedAboutDeprecatedPureOption = true;\n      warning('The `pure` option has been removed. `connect` is now always a \"pure/memoized\" component');\n    }\n  }\n\n  const Context = context;\n  const initMapStateToProps = mapStateToPropsFactory(mapStateToProps);\n  const initMapDispatchToProps = mapDispatchToPropsFactory(mapDispatchToProps);\n  const initMergeProps = mergePropsFactory(mergeProps);\n  const shouldHandleStateChanges = Boolean(mapStateToProps);\n\n  const wrapWithConnect = WrappedComponent => {\n    if (process.env.NODE_ENV !== 'production' && !isValidElementType(WrappedComponent)) {\n      throw new Error(`You must pass a component to the function returned by connect. Instead received ${stringifyComponent(WrappedComponent)}`);\n    }\n\n    const wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component';\n    const displayName = `Connect(${wrappedComponentName})`;\n    const selectorFactoryOptions = {\n      shouldHandleStateChanges,\n      displayName,\n      wrappedComponentName,\n      WrappedComponent,\n      // @ts-ignore\n      initMapStateToProps,\n      // @ts-ignore\n      initMapDispatchToProps,\n      initMergeProps,\n      areStatesEqual,\n      areStatePropsEqual,\n      areOwnPropsEqual,\n      areMergedPropsEqual\n    };\n\n    function ConnectFunction(props) {\n      const [propsContext, reactReduxForwardedRef, wrapperProps] = React.useMemo(() => {\n        // Distinguish between actual \"data\" props that were passed to the wrapper component,\n        // and values needed to control behavior (forwarded refs, alternate context instances).\n        // To maintain the wrapperProps object reference, memoize this destructuring.\n        const {\n          reactReduxForwardedRef\n        } = props,\n              wrapperProps = _objectWithoutPropertiesLoose(props, _excluded);\n\n        return [props.context, reactReduxForwardedRef, wrapperProps];\n      }, [props]);\n      const ContextToUse = React.useMemo(() => {\n        // Users may optionally pass in a custom context instance to use instead of our ReactReduxContext.\n        // Memoize the check that determines which context instance we should use.\n        return propsContext && propsContext.Consumer && // @ts-ignore\n        isContextConsumer( /*#__PURE__*/React.createElement(propsContext.Consumer, null)) ? propsContext : Context;\n      }, [propsContext, Context]); // Retrieve the store and ancestor subscription via context, if available\n\n      const contextValue = React.useContext(ContextToUse); // The store _must_ exist as either a prop or in context.\n      // We'll check to see if it _looks_ like a Redux store first.\n      // This allows us to pass through a `store` prop that is just a plain value.\n\n      const didStoreComeFromProps = Boolean(props.store) && Boolean(props.store.getState) && Boolean(props.store.dispatch);\n      const didStoreComeFromContext = Boolean(contextValue) && Boolean(contextValue.store);\n\n      if (process.env.NODE_ENV !== 'production' && !didStoreComeFromProps && !didStoreComeFromContext) {\n        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.`);\n      } // Based on the previous check, one of these must be true\n\n\n      const store = didStoreComeFromProps ? props.store : contextValue.store;\n      const getServerState = didStoreComeFromContext ? contextValue.getServerState : store.getState;\n      const childPropsSelector = React.useMemo(() => {\n        // The child props selector needs the store reference as an input.\n        // Re-create this selector whenever the store changes.\n        return defaultSelectorFactory(store.dispatch, selectorFactoryOptions);\n      }, [store]);\n      const [subscription, notifyNestedSubs] = React.useMemo(() => {\n        if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY; // This Subscription's source should match where store came from: props vs. context. A component\n        // connected to the store via props shouldn't use subscription from context, or vice versa.\n\n        const subscription = createSubscription(store, didStoreComeFromProps ? undefined : contextValue.subscription); // `notifyNestedSubs` is duplicated to handle the case where the component is unmounted in\n        // the middle of the notification loop, where `subscription` will then be null. This can\n        // probably be avoided if Subscription's listeners logic is changed to not call listeners\n        // that have been unsubscribed in the  middle of the notification loop.\n\n        const notifyNestedSubs = subscription.notifyNestedSubs.bind(subscription);\n        return [subscription, notifyNestedSubs];\n      }, [store, didStoreComeFromProps, contextValue]); // Determine what {store, subscription} value should be put into nested context, if necessary,\n      // and memoize that value to avoid unnecessary context updates.\n\n      const overriddenContextValue = React.useMemo(() => {\n        if (didStoreComeFromProps) {\n          // This component is directly subscribed to a store from props.\n          // We don't want descendants reading from this store - pass down whatever\n          // the existing context value is from the nearest connected ancestor.\n          return contextValue;\n        } // Otherwise, put this component's subscription instance into context, so that\n        // connected descendants won't update until after this component is done\n\n\n        return _extends({}, contextValue, {\n          subscription\n        });\n      }, [didStoreComeFromProps, contextValue, subscription]); // Set up refs to coordinate values between the subscription effect and the render logic\n\n      const lastChildProps = React.useRef();\n      const lastWrapperProps = React.useRef(wrapperProps);\n      const childPropsFromStoreUpdate = React.useRef();\n      const renderIsScheduled = React.useRef(false);\n      const isProcessingDispatch = React.useRef(false);\n      const isMounted = React.useRef(false);\n      const latestSubscriptionCallbackError = React.useRef();\n      useIsomorphicLayoutEffect(() => {\n        isMounted.current = true;\n        return () => {\n          isMounted.current = false;\n        };\n      }, []);\n      const actualChildPropsSelector = React.useMemo(() => {\n        const selector = () => {\n          // Tricky logic here:\n          // - This render may have been triggered by a Redux store update that produced new child props\n          // - However, we may have gotten new wrapper props after that\n          // If we have new child props, and the same wrapper props, we know we should use the new child props as-is.\n          // But, if we have new wrapper props, those might change the child props, so we have to recalculate things.\n          // So, we'll use the child props from store update only if the wrapper props are the same as last time.\n          if (childPropsFromStoreUpdate.current && wrapperProps === lastWrapperProps.current) {\n            return childPropsFromStoreUpdate.current;\n          } // TODO We're reading the store directly in render() here. Bad idea?\n          // This will likely cause Bad Things (TM) to happen in Concurrent Mode.\n          // Note that we do this because on renders _not_ caused by store updates, we need the latest store state\n          // to determine what the child props should be.\n\n\n          return childPropsSelector(store.getState(), wrapperProps);\n        };\n\n        return selector;\n      }, [store, wrapperProps]); // We need this to execute synchronously every time we re-render. However, React warns\n      // about useLayoutEffect in SSR, so we try to detect environment and fall back to\n      // just useEffect instead to avoid the warning, since neither will run anyway.\n\n      const subscribeForReact = React.useMemo(() => {\n        const subscribe = reactListener => {\n          if (!subscription) {\n            return () => {};\n          }\n\n          return subscribeUpdates(shouldHandleStateChanges, store, subscription, // @ts-ignore\n          childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted, childPropsFromStoreUpdate, notifyNestedSubs, reactListener);\n        };\n\n        return subscribe;\n      }, [subscription]);\n      useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, childPropsFromStoreUpdate, notifyNestedSubs]);\n      let actualChildProps;\n\n      try {\n        actualChildProps = useSyncExternalStore( // TODO We're passing through a big wrapper that does a bunch of extra side effects besides subscribing\n        subscribeForReact, // TODO This is incredibly hacky. We've already processed the store update and calculated new child props,\n        // TODO and we're just passing that through so it triggers a re-render for us rather than relying on `uSES`.\n        actualChildPropsSelector, getServerState ? () => childPropsSelector(getServerState(), wrapperProps) : actualChildPropsSelector);\n      } catch (err) {\n        if (latestSubscriptionCallbackError.current) {\n          ;\n          err.message += `\\nThe error may be correlated with this previous error:\\n${latestSubscriptionCallbackError.current.stack}\\n\\n`;\n        }\n\n        throw err;\n      }\n\n      useIsomorphicLayoutEffect(() => {\n        latestSubscriptionCallbackError.current = undefined;\n        childPropsFromStoreUpdate.current = undefined;\n        lastChildProps.current = actualChildProps;\n      }); // Now that all that's done, we can finally try to actually render the child component.\n      // We memoize the elements for the rendered child component as an optimization.\n\n      const renderedWrappedComponent = React.useMemo(() => {\n        return (\n          /*#__PURE__*/\n          // @ts-ignore\n          React.createElement(WrappedComponent, _extends({}, actualChildProps, {\n            ref: reactReduxForwardedRef\n          }))\n        );\n      }, [reactReduxForwardedRef, WrappedComponent, actualChildProps]); // If React sees the exact same element reference as last time, it bails out of re-rendering\n      // that child, same as if it was wrapped in React.memo() or returned false from shouldComponentUpdate.\n\n      const renderedChild = React.useMemo(() => {\n        if (shouldHandleStateChanges) {\n          // If this component is subscribed to store updates, we need to pass its own\n          // subscription instance down to our descendants. That means rendering the same\n          // Context instance, and putting a different value into the context.\n          return /*#__PURE__*/React.createElement(ContextToUse.Provider, {\n            value: overriddenContextValue\n          }, renderedWrappedComponent);\n        }\n\n        return renderedWrappedComponent;\n      }, [ContextToUse, renderedWrappedComponent, overriddenContextValue]);\n      return renderedChild;\n    }\n\n    const _Connect = React.memo(ConnectFunction);\n\n    // Add a hacky cast to get the right output type\n    const Connect = _Connect;\n    Connect.WrappedComponent = WrappedComponent;\n    Connect.displayName = ConnectFunction.displayName = displayName;\n\n    if (forwardRef) {\n      const _forwarded = React.forwardRef(function forwardConnectRef(props, ref) {\n        // @ts-ignore\n        return /*#__PURE__*/React.createElement(Connect, _extends({}, props, {\n          reactReduxForwardedRef: ref\n        }));\n      });\n\n      const forwarded = _forwarded;\n      forwarded.displayName = displayName;\n      forwarded.WrappedComponent = WrappedComponent;\n      return hoistStatics(forwarded, WrappedComponent);\n    }\n\n    return hoistStatics(Connect, WrappedComponent);\n  };\n\n  return wrapWithConnect;\n}\n\nexport default connect;","import * as React from 'react';\nimport { ReactReduxContext } from './Context';\nimport { createSubscription } from '../utils/Subscription';\nimport { useIsomorphicLayoutEffect } from '../utils/useIsomorphicLayoutEffect';\n\nfunction Provider({\n  store,\n  context,\n  children,\n  serverState,\n  stabilityCheck = 'once',\n  noopCheck = 'once'\n}) {\n  const contextValue = React.useMemo(() => {\n    const subscription = createSubscription(store);\n    return {\n      store,\n      subscription,\n      getServerState: serverState ? () => serverState : undefined,\n      stabilityCheck,\n      noopCheck\n    };\n  }, [store, serverState, stabilityCheck, noopCheck]);\n  const previousState = React.useMemo(() => store.getState(), [store]);\n  useIsomorphicLayoutEffect(() => {\n    const {\n      subscription\n    } = contextValue;\n    subscription.onStateChange = subscription.notifyNestedSubs;\n    subscription.trySubscribe();\n\n    if (previousState !== store.getState()) {\n      subscription.notifyNestedSubs();\n    }\n\n    return () => {\n      subscription.tryUnsubscribe();\n      subscription.onStateChange = undefined;\n    };\n  }, [contextValue, previousState]);\n  const Context = context || ReactReduxContext; // @ts-ignore 'AnyAction' is assignable to the constraint of type 'A', but 'A' could be instantiated with a different subtype\n\n  return /*#__PURE__*/React.createElement(Context.Provider, {\n    value: contextValue\n  }, children);\n}\n\nexport default Provider;","import { ReactReduxContext } from '../components/Context';\nimport { useReduxContext as useDefaultReduxContext, createReduxContextHook } from './useReduxContext';\n/**\r\n * Hook factory, which creates a `useStore` hook bound to a given context.\r\n *\r\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\r\n * @returns {Function} A `useStore` hook bound to the specified context.\r\n */\n\nexport function createStoreHook(context = ReactReduxContext) {\n  const useReduxContext = // @ts-ignore\n  context === ReactReduxContext ? useDefaultReduxContext : // @ts-ignore\n  createReduxContextHook(context);\n  return function useStore() {\n    const {\n      store\n    } = useReduxContext(); // @ts-ignore\n\n    return store;\n  };\n}\n/**\r\n * A hook to access the redux store.\r\n *\r\n * @returns {any} the redux store\r\n *\r\n * @example\r\n *\r\n * import React from 'react'\r\n * import { useStore } from 'react-redux'\r\n *\r\n * export const ExampleComponent = () => {\r\n *   const store = useStore()\r\n *   return <div>{store.getState()}</div>\r\n * }\r\n */\n\nexport const useStore = /*#__PURE__*/createStoreHook();","import { ReactReduxContext } from '../components/Context';\nimport { useStore as useDefaultStore, createStoreHook } from './useStore';\n/**\r\n * Hook factory, which creates a `useDispatch` hook bound to a given context.\r\n *\r\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\r\n * @returns {Function} A `useDispatch` hook bound to the specified context.\r\n */\n\nexport function createDispatchHook(context = ReactReduxContext) {\n  const useStore = // @ts-ignore\n  context === ReactReduxContext ? useDefaultStore : createStoreHook(context);\n  return function useDispatch() {\n    const store = useStore(); // @ts-ignore\n\n    return store.dispatch;\n  };\n}\n/**\r\n * A hook to access the redux `dispatch` function.\r\n *\r\n * @returns {any|function} redux store's `dispatch` function\r\n *\r\n * @example\r\n *\r\n * import React, { useCallback } from 'react'\r\n * import { useDispatch } from 'react-redux'\r\n *\r\n * export const CounterComponent = ({ value }) => {\r\n *   const dispatch = useDispatch()\r\n *   const increaseCounter = useCallback(() => dispatch({ type: 'increase-counter' }), [])\r\n *   return (\r\n *     <div>\r\n *       <span>{value}</span>\r\n *       <button onClick={increaseCounter}>Increase counter</button>\r\n *     </div>\r\n *   )\r\n * }\r\n */\n\nexport const useDispatch = /*#__PURE__*/createDispatchHook();","import Provider from './components/Provider';\nimport connect from './components/connect';\nimport { ReactReduxContext } from './components/Context';\nimport { useDispatch, createDispatchHook } from './hooks/useDispatch';\nimport { useSelector, createSelectorHook } from './hooks/useSelector';\nimport { useStore, createStoreHook } from './hooks/useStore';\nimport shallowEqual from './utils/shallowEqual';\nexport * from './types';\nexport { Provider, ReactReduxContext, connect, useDispatch, createDispatchHook, useSelector, createSelectorHook, useStore, createStoreHook, shallowEqual };","// The primary entry point assumes we're working with standard ReactDOM/RN, but\n// older versions that do not include `useSyncExternalStore` (React 16.9 - 17.x).\n// Because of that, the useSyncExternalStore compat shim is needed.\nimport { useSyncExternalStore } from 'use-sync-external-store/shim';\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';\nimport { unstable_batchedUpdates as batch } from './utils/reactBatchedUpdates';\nimport { setBatch } from './utils/batch';\nimport { initializeUseSelector } from './hooks/useSelector';\nimport { initializeConnect } from './components/connect';\ninitializeUseSelector(useSyncExternalStoreWithSelector);\ninitializeConnect(useSyncExternalStore); // Enable batched updates in our subscriptions for use\n// with standard React renderers (ReactDOM, React Native)\n\nsetBatch(batch);\nexport { batch };\nexport * from './exports';","/**\n * @license React\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var b=Symbol.for(\"react.element\"),c=Symbol.for(\"react.portal\"),d=Symbol.for(\"react.fragment\"),e=Symbol.for(\"react.strict_mode\"),f=Symbol.for(\"react.profiler\"),g=Symbol.for(\"react.provider\"),h=Symbol.for(\"react.context\"),k=Symbol.for(\"react.server_context\"),l=Symbol.for(\"react.forward_ref\"),m=Symbol.for(\"react.suspense\"),n=Symbol.for(\"react.suspense_list\"),p=Symbol.for(\"react.memo\"),q=Symbol.for(\"react.lazy\"),t=Symbol.for(\"react.offscreen\"),u;u=Symbol.for(\"react.module.reference\");\nfunction v(a){if(\"object\"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}exports.ContextConsumer=h;exports.ContextProvider=g;exports.Element=b;exports.ForwardRef=l;exports.Fragment=d;exports.Lazy=q;exports.Memo=p;exports.Portal=c;exports.Profiler=f;exports.StrictMode=e;exports.Suspense=m;\nexports.SuspenseList=n;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return v(a)===h};exports.isContextProvider=function(a){return v(a)===g};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return v(a)===l};exports.isFragment=function(a){return v(a)===d};exports.isLazy=function(a){return v(a)===q};exports.isMemo=function(a){return v(a)===p};\nexports.isPortal=function(a){return v(a)===c};exports.isProfiler=function(a){return v(a)===f};exports.isStrictMode=function(a){return v(a)===e};exports.isSuspense=function(a){return v(a)===m};exports.isSuspenseList=function(a){return v(a)===n};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||\"object\"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};exports.typeOf=v;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","/**\n * @license React\n * use-sync-external-store-shim.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var e=require(\"react\");function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k=\"function\"===typeof Object.is?Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;function q(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r(c)&&g({inst:c})},[a,d,b]);m(function(){r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c})})},[a]);p(d);return d}\nfunction r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return!k(a,d)}catch(f){return!0}}function t(a,b){return b()}var u=\"undefined\"===typeof window||\"undefined\"===typeof window.document||\"undefined\"===typeof window.document.createElement?t:q;exports.useSyncExternalStore=void 0!==e.useSyncExternalStore?e.useSyncExternalStore:u;\n","/**\n * @license React\n * use-sync-external-store-shim/with-selector.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var h=require(\"react\"),n=require(\"use-sync-external-store/shim\");function p(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var q=\"function\"===typeof Object.is?Object.is:p,r=n.useSyncExternalStore,t=h.useRef,u=h.useEffect,v=h.useMemo,w=h.useDebugValue;\nexports.useSyncExternalStoreWithSelector=function(a,b,e,l,g){var c=t(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f}else f=c.current;c=v(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==g&&f.hasValue){var b=f.value;if(g(b,a))return k=b}return k=a}b=k;if(q(d,a))return b;var e=l(a);if(void 0!==g&&g(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return[function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,g]);var d=r(a,c[0],c[1]);\nu(function(){f.hasValue=!0;f.value=d},[d]);w(d);return d};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('../cjs/use-sync-external-store-shim.production.min.js');\n} else {\n  module.exports = require('../cjs/use-sync-external-store-shim.development.js');\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('../cjs/use-sync-external-store-shim/with-selector.production.min.js');\n} else {\n  module.exports = require('../cjs/use-sync-external-store-shim/with-selector.development.js');\n}\n"],"names":["reactIs","__webpack_require__","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","displayName","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","type","KNOWN_STATICS","name","length","prototype","caller","callee","arguments","arity","MEMO_STATICS","compare","TYPE_STATICS","getStatics","component","isMemo","ForwardRef","render","Memo","defineProperty","Object","getOwnPropertyNames","getOwnPropertySymbols","getOwnPropertyDescriptor","getPrototypeOf","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","keys","concat","targetStatics","sourceStatics","i","key","descriptor","e","module","exports","value","enumerable","get","dynamic","_interop_require_default","require","_loadable","_","convertModule","mod","default","dynamicOptions","options","loadableFn","loadableOptions","loading","error","isLoading","pastDelay","param","loader","assign","loaderFn","then","Promise","resolve","__esModule","NoSSR","children","_default","_react","_dynamicnossr","Loadable","opts","ssr","LoadableComponent","props","Loading","fallbackElement","createElement","Wrap","Fragment","Lazy","lazy","Suspense","fallback","b","Symbol","for","c","d","f","g","h","k","l","m","n","p","q","r","t","v","w","x","y","z","a","u","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","Portal","Profiler","StrictMode","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isPortal","isProfiler","isStrictMode","isSuspense","isValidElementType","typeOf","batch","callback","getBatch","ContextKey","gT","globalThis","getContext","_gT$ContextKey","react","createContext","contextMap","Map","realContext","set","Context_ReactReduxContext","createReduxContextHook","context","contextValue","useContext","useReduxContext_useReduxContext","useSyncExternalStoreWithSelector","refEquality","createSelectorHook","useReduxContext","selector","equalityFnOrOptions","equalityFn","stabilityCheck","noopCheck","store","subscription","getServerState","globalStabilityCheck","globalNoopCheck","useRef","wrappedSelector","useCallback","state","selected","selectedState","addNestedSub","getState","useDebugValue","useSelector","createListenerCollection","first","last","clear","notify","listener","next","listeners","push","subscribe","isSubscribed","prev","nullListeners","Subscription_createSubscription","parentSub","unsubscribe","subscriptionsAmount","selfSubscribed","trySubscribe","cleanupListener","removed","tryUnsubscribe","notifyNestedSubs","handleChangeWrapper","onStateChange","undefined","trySubscribeSelf","tryUnsubscribeSelf","getListeners","canUseDOM","window","document","useIsomorphicLayoutEffect_useIsomorphicLayoutEffect","useLayoutEffect","useEffect","components_Provider","serverState","useMemo","previousState","Context","Provider","createStoreHook","useStore_useStore","createDispatchHook","useStore","dispatch","useDispatch","with_selector","shim","useSyncExternalStore","react_dom","unstable_batchedUpdates","is","useState","inst","getSnapshot","current","hasValue"],"sourceRoot":""}