Index: node_modules/redux/src/createStore.ts
===================================================================
--- node_modules/redux/src/createStore.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/redux/src/createStore.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,490 @@
+import $$observable from './utils/symbol-observable'
+
+import {
+  Store,
+  StoreEnhancer,
+  Dispatch,
+  Observer,
+  ListenerCallback,
+  UnknownIfNonSpecific
+} from './types/store'
+import { Action } from './types/actions'
+import { Reducer } from './types/reducers'
+import ActionTypes from './utils/actionTypes'
+import isPlainObject from './utils/isPlainObject'
+import { kindOf } from './utils/kindOf'
+
+/**
+ * @deprecated
+ *
+ * **We recommend using the `configureStore` method
+ * of the `@reduxjs/toolkit` package**, which replaces `createStore`.
+ *
+ * Redux Toolkit is our recommended approach for writing Redux logic today,
+ * including store setup, reducers, data fetching, and more.
+ *
+ * **For more details, please read this Redux docs page:**
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * `configureStore` from Redux Toolkit is an improved version of `createStore` that
+ * simplifies setup and helps avoid common bugs.
+ *
+ * You should not be using the `redux` core package by itself today, except for learning purposes.
+ * The `createStore` method from the core `redux` package will not be removed, but we encourage
+ * all users to migrate to using Redux Toolkit for all Redux code.
+ *
+ * If you want to use `createStore` without this visual deprecation warning, use
+ * the `legacy_createStore` import instead:
+ *
+ * `import { legacy_createStore as createStore} from 'redux'`
+ *
+ */
+export function createStore<
+  S,
+  A extends Action,
+  Ext extends {} = {},
+  StateExt extends {} = {}
+>(
+  reducer: Reducer<S, A>,
+  enhancer?: StoreEnhancer<Ext, StateExt>
+): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext
+/**
+ * @deprecated
+ *
+ * **We recommend using the `configureStore` method
+ * of the `@reduxjs/toolkit` package**, which replaces `createStore`.
+ *
+ * Redux Toolkit is our recommended approach for writing Redux logic today,
+ * including store setup, reducers, data fetching, and more.
+ *
+ * **For more details, please read this Redux docs page:**
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * `configureStore` from Redux Toolkit is an improved version of `createStore` that
+ * simplifies setup and helps avoid common bugs.
+ *
+ * You should not be using the `redux` core package by itself today, except for learning purposes.
+ * The `createStore` method from the core `redux` package will not be removed, but we encourage
+ * all users to migrate to using Redux Toolkit for all Redux code.
+ *
+ * If you want to use `createStore` without this visual deprecation warning, use
+ * the `legacy_createStore` import instead:
+ *
+ * `import { legacy_createStore as createStore} from 'redux'`
+ *
+ */
+export function createStore<
+  S,
+  A extends Action,
+  Ext extends {} = {},
+  StateExt extends {} = {},
+  PreloadedState = S
+>(
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | undefined,
+  enhancer?: StoreEnhancer<Ext, StateExt>
+): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext
+export function createStore<
+  S,
+  A extends Action,
+  Ext extends {} = {},
+  StateExt extends {} = {},
+  PreloadedState = S
+>(
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | StoreEnhancer<Ext, StateExt> | undefined,
+  enhancer?: StoreEnhancer<Ext, StateExt>
+): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext {
+  if (typeof reducer !== 'function') {
+    throw new Error(
+      `Expected the root reducer to be a function. Instead, received: '${kindOf(
+        reducer
+      )}'`
+    )
+  }
+
+  if (
+    (typeof preloadedState === 'function' && typeof enhancer === 'function') ||
+    (typeof enhancer === 'function' && typeof arguments[3] === 'function')
+  ) {
+    throw new Error(
+      'It looks like you are passing several store enhancers to ' +
+        'createStore(). This is not supported. Instead, compose them ' +
+        'together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example.'
+    )
+  }
+
+  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
+    enhancer = preloadedState as StoreEnhancer<Ext, StateExt>
+    preloadedState = undefined
+  }
+
+  if (typeof enhancer !== 'undefined') {
+    if (typeof enhancer !== 'function') {
+      throw new Error(
+        `Expected the enhancer to be a function. Instead, received: '${kindOf(
+          enhancer
+        )}'`
+      )
+    }
+
+    return enhancer(createStore)(
+      reducer,
+      preloadedState as PreloadedState | undefined
+    )
+  }
+
+  let currentReducer = reducer
+  let currentState: S | PreloadedState | undefined = preloadedState as
+    | PreloadedState
+    | undefined
+  let currentListeners: Map<number, ListenerCallback> | null = new Map()
+  let nextListeners = currentListeners
+  let listenerIdCounter = 0
+  let isDispatching = false
+
+  /**
+   * This makes a shallow copy of currentListeners so we can use
+   * nextListeners as a temporary list while dispatching.
+   *
+   * This prevents any bugs around consumers calling
+   * subscribe/unsubscribe in the middle of a dispatch.
+   */
+  function ensureCanMutateNextListeners() {
+    if (nextListeners === currentListeners) {
+      nextListeners = new Map()
+      currentListeners.forEach((listener, key) => {
+        nextListeners.set(key, listener)
+      })
+    }
+  }
+
+  /**
+   * Reads the state tree managed by the store.
+   *
+   * @returns The current state tree of your application.
+   */
+  function getState(): S {
+    if (isDispatching) {
+      throw new Error(
+        'You may not call store.getState() while the reducer is executing. ' +
+          'The reducer has already received the state as an argument. ' +
+          'Pass it down from the top reducer instead of reading it from the store.'
+      )
+    }
+
+    return currentState as S
+  }
+
+  /**
+   * Adds a change listener. It will be called any time an action is dispatched,
+   * and some part of the state tree may potentially have changed. You may then
+   * call `getState()` to read the current state tree inside the callback.
+   *
+   * You may call `dispatch()` from a change listener, with the following
+   * caveats:
+   *
+   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
+   * If you subscribe or unsubscribe while the listeners are being invoked, this
+   * will not have any effect on the `dispatch()` that is currently in progress.
+   * However, the next `dispatch()` call, whether nested or not, will use a more
+   * recent snapshot of the subscription list.
+   *
+   * 2. The listener should not expect to see all state changes, as the state
+   * might have been updated multiple times during a nested `dispatch()` before
+   * the listener is called. It is, however, guaranteed that all subscribers
+   * registered before the `dispatch()` started will be called with the latest
+   * state by the time it exits.
+   *
+   * @param listener A callback to be invoked on every dispatch.
+   * @returns A function to remove this change listener.
+   */
+  function subscribe(listener: () => void) {
+    if (typeof listener !== 'function') {
+      throw new Error(
+        `Expected the listener to be a function. Instead, received: '${kindOf(
+          listener
+        )}'`
+      )
+    }
+
+    if (isDispatching) {
+      throw new Error(
+        'You may not call store.subscribe() while the reducer is executing. ' +
+          'If you would like to be notified after the store has been updated, subscribe from a ' +
+          'component and invoke store.getState() in the callback to access the latest state. ' +
+          'See https://redux.js.org/api/store#subscribelistener for more details.'
+      )
+    }
+
+    let isSubscribed = true
+
+    ensureCanMutateNextListeners()
+    const listenerId = listenerIdCounter++
+    nextListeners.set(listenerId, listener)
+
+    return function unsubscribe() {
+      if (!isSubscribed) {
+        return
+      }
+
+      if (isDispatching) {
+        throw new Error(
+          'You may not unsubscribe from a store listener while the reducer is executing. ' +
+            'See https://redux.js.org/api/store#subscribelistener for more details.'
+        )
+      }
+
+      isSubscribed = false
+
+      ensureCanMutateNextListeners()
+      nextListeners.delete(listenerId)
+      currentListeners = null
+    }
+  }
+
+  /**
+   * Dispatches an action. It is the only way to trigger a state change.
+   *
+   * The `reducer` function, used to create the store, will be called with the
+   * current state tree and the given `action`. Its return value will
+   * be considered the **next** state of the tree, and the change listeners
+   * will be notified.
+   *
+   * The base implementation only supports plain object actions. If you want to
+   * dispatch a Promise, an Observable, a thunk, or something else, you need to
+   * wrap your store creating function into the corresponding middleware. For
+   * example, see the documentation for the `redux-thunk` package. Even the
+   * middleware will eventually dispatch plain object actions using this method.
+   *
+   * @param action A plain object representing “what changed”. It is
+   * a good idea to keep actions serializable so you can record and replay user
+   * sessions, or use the time travelling `redux-devtools`. An action must have
+   * a `type` property which may not be `undefined`. It is a good idea to use
+   * string constants for action types.
+   *
+   * @returns For convenience, the same action object you dispatched.
+   *
+   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
+   * return something else (for example, a Promise you can await).
+   */
+  function dispatch(action: A) {
+    if (!isPlainObject(action)) {
+      throw new Error(
+        `Actions must be plain objects. Instead, the actual type was: '${kindOf(
+          action
+        )}'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples.`
+      )
+    }
+
+    if (typeof action.type === 'undefined') {
+      throw new Error(
+        'Actions may not have an undefined "type" property. You may have misspelled an action type string constant.'
+      )
+    }
+
+    if (typeof action.type !== 'string') {
+      throw new Error(
+        `Action "type" property must be a string. Instead, the actual type was: '${kindOf(
+          action.type
+        )}'. Value was: '${action.type}' (stringified)`
+      )
+    }
+
+    if (isDispatching) {
+      throw new Error('Reducers may not dispatch actions.')
+    }
+
+    try {
+      isDispatching = true
+      currentState = currentReducer(currentState, action)
+    } finally {
+      isDispatching = false
+    }
+
+    const listeners = (currentListeners = nextListeners)
+    listeners.forEach(listener => {
+      listener()
+    })
+    return action
+  }
+
+  /**
+   * Replaces the reducer currently used by the store to calculate the state.
+   *
+   * You might need this if your app implements code splitting and you want to
+   * load some of the reducers dynamically. You might also need this if you
+   * implement a hot reloading mechanism for Redux.
+   *
+   * @param nextReducer The reducer for the store to use instead.
+   */
+  function replaceReducer(nextReducer: Reducer<S, A>): void {
+    if (typeof nextReducer !== 'function') {
+      throw new Error(
+        `Expected the nextReducer to be a function. Instead, received: '${kindOf(
+          nextReducer
+        )}`
+      )
+    }
+
+    currentReducer = nextReducer as unknown as Reducer<S, A, PreloadedState>
+
+    // This action has a similar effect to ActionTypes.INIT.
+    // Any reducers that existed in both the new and old rootReducer
+    // will receive the previous state. This effectively populates
+    // the new state tree with any relevant data from the old one.
+    dispatch({ type: ActionTypes.REPLACE } as A)
+  }
+
+  /**
+   * Interoperability point for observable/reactive libraries.
+   * @returns A minimal observable of state changes.
+   * For more information, see the observable proposal:
+   * https://github.com/tc39/proposal-observable
+   */
+  function observable() {
+    const outerSubscribe = subscribe
+    return {
+      /**
+       * The minimal observable subscription method.
+       * @param observer Any object that can be used as an observer.
+       * The observer object should have a `next` method.
+       * @returns An object with an `unsubscribe` method that can
+       * be used to unsubscribe the observable from the store, and prevent further
+       * emission of values from the observable.
+       */
+      subscribe(observer: unknown) {
+        if (typeof observer !== 'object' || observer === null) {
+          throw new TypeError(
+            `Expected the observer to be an object. Instead, received: '${kindOf(
+              observer
+            )}'`
+          )
+        }
+
+        function observeState() {
+          const observerAsObserver = observer as Observer<S>
+          if (observerAsObserver.next) {
+            observerAsObserver.next(getState())
+          }
+        }
+
+        observeState()
+        const unsubscribe = outerSubscribe(observeState)
+        return { unsubscribe }
+      },
+
+      [$$observable]() {
+        return this
+      }
+    }
+  }
+
+  // When a store is created, an "INIT" action is dispatched so that every
+  // reducer returns their initial state. This effectively populates
+  // the initial state tree.
+  dispatch({ type: ActionTypes.INIT } as A)
+
+  const store = {
+    dispatch: dispatch as Dispatch<A>,
+    subscribe,
+    getState,
+    replaceReducer,
+    [$$observable]: observable
+  } as unknown as Store<S, A, StateExt> & Ext
+  return store
+}
+
+/**
+ * Creates a Redux store that holds the state tree.
+ *
+ * **We recommend using `configureStore` from the
+ * `@reduxjs/toolkit` package**, which replaces `createStore`:
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * The only way to change the data in the store is to call `dispatch()` on it.
+ *
+ * There should only be a single store in your app. To specify how different
+ * parts of the state tree respond to actions, you may combine several reducers
+ * into a single reducer function by using `combineReducers`.
+ *
+ * @param {Function} reducer A function that returns the next state tree, given
+ * the current state tree and the action to handle.
+ *
+ * @param {any} [preloadedState] The initial state. You may optionally specify it
+ * to hydrate the state from the server in universal apps, or to restore a
+ * previously serialized user session.
+ * If you use `combineReducers` to produce the root reducer function, this must be
+ * an object with the same shape as `combineReducers` keys.
+ *
+ * @param {Function} [enhancer] The store enhancer. You may optionally specify it
+ * to enhance the store with third-party capabilities such as middleware,
+ * time travel, persistence, etc. The only store enhancer that ships with Redux
+ * is `applyMiddleware()`.
+ *
+ * @returns {Store} A Redux store that lets you read the state, dispatch actions
+ * and subscribe to changes.
+ */
+export function legacy_createStore<
+  S,
+  A extends Action,
+  Ext extends {} = {},
+  StateExt extends {} = {}
+>(
+  reducer: Reducer<S, A>,
+  enhancer?: StoreEnhancer<Ext, StateExt>
+): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext
+/**
+ * Creates a Redux store that holds the state tree.
+ *
+ * **We recommend using `configureStore` from the
+ * `@reduxjs/toolkit` package**, which replaces `createStore`:
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * The only way to change the data in the store is to call `dispatch()` on it.
+ *
+ * There should only be a single store in your app. To specify how different
+ * parts of the state tree respond to actions, you may combine several reducers
+ * into a single reducer function by using `combineReducers`.
+ *
+ * @param {Function} reducer A function that returns the next state tree, given
+ * the current state tree and the action to handle.
+ *
+ * @param {any} [preloadedState] The initial state. You may optionally specify it
+ * to hydrate the state from the server in universal apps, or to restore a
+ * previously serialized user session.
+ * If you use `combineReducers` to produce the root reducer function, this must be
+ * an object with the same shape as `combineReducers` keys.
+ *
+ * @param {Function} [enhancer] The store enhancer. You may optionally specify it
+ * to enhance the store with third-party capabilities such as middleware,
+ * time travel, persistence, etc. The only store enhancer that ships with Redux
+ * is `applyMiddleware()`.
+ *
+ * @returns {Store} A Redux store that lets you read the state, dispatch actions
+ * and subscribe to changes.
+ */
+export function legacy_createStore<
+  S,
+  A extends Action,
+  Ext extends {} = {},
+  StateExt extends {} = {},
+  PreloadedState = S
+>(
+  reducer: Reducer<S, A, PreloadedState>,
+  preloadedState?: PreloadedState | undefined,
+  enhancer?: StoreEnhancer<Ext, StateExt>
+): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext
+export function legacy_createStore<
+  S,
+  A extends Action,
+  Ext extends {} = {},
+  StateExt extends {} = {},
+  PreloadedState = S
+>(
+  reducer: Reducer<S, A>,
+  preloadedState?: PreloadedState | StoreEnhancer<Ext, StateExt> | undefined,
+  enhancer?: StoreEnhancer<Ext, StateExt>
+): Store<S, A, UnknownIfNonSpecific<StateExt>> & Ext {
+  return createStore(reducer, preloadedState as any, enhancer)
+}