{"version":3,"names":["defaultSelectorFactory","useReduxContext","useDefaultReduxContext","useStore","useDefaultStore","useReduxContext","useDefaultReduxContext"],"sources":["../src/utils/react-is.ts","../src/utils/warning.ts","../src/connect/verifySubselectors.ts","../src/connect/selectorFactory.ts","../src/utils/bindActionCreators.ts","../src/utils/isPlainObject.ts","../src/utils/verifyPlainObject.ts","../src/connect/wrapMapToProps.ts","../src/connect/invalidArgFactory.ts","../src/connect/mapDispatchToProps.ts","../src/connect/mapStateToProps.ts","../src/connect/mergeProps.ts","../src/utils/batch.ts","../src/utils/Subscription.ts","../src/utils/useIsomorphicLayoutEffect.ts","../src/utils/shallowEqual.ts","../src/utils/hoistStatics.ts","../src/components/Context.ts","../src/components/connect.tsx","../src/components/Provider.tsx","../src/hooks/useReduxContext.ts","../src/hooks/useStore.ts","../src/hooks/useDispatch.ts","../src/hooks/useSelector.ts","../src/exports.ts"],"sourcesContent":["import type { ElementType, MemoExoticComponent, ReactElement } from 'react'\nimport { React } from './react'\n\n// Directly ported from:\n// https://unpkg.com/browse/react-is@19.0.0/cjs/react-is.production.js\n// It's very possible this could change in the future, but given that\n// we only use these in `connect`, this is a low priority.\n\nexport const IS_REACT_19 = /* @__PURE__ */ React.version.startsWith('19')\n\nconst REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for(\n  IS_REACT_19 ? 'react.transitional.element' : 'react.element',\n)\nconst REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for('react.portal')\nconst REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for('react.fragment')\nconst REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for('react.strict_mode')\nconst REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for('react.profiler')\nconst REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for('react.consumer')\nconst REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for('react.context')\nconst REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for('react.forward_ref')\nconst REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for('react.suspense')\nconst REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for(\n  'react.suspense_list',\n)\nconst REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for('react.memo')\nconst REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for('react.lazy')\nconst REACT_OFFSCREEN_TYPE = /* @__PURE__ */ Symbol.for('react.offscreen')\nconst REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for(\n  'react.client.reference',\n)\n\nexport const ForwardRef = REACT_FORWARD_REF_TYPE\nexport const Memo = REACT_MEMO_TYPE\n\nexport function isValidElementType(type: any): type is ElementType {\n  return typeof type === 'string' ||\n    typeof type === 'function' ||\n    type === REACT_FRAGMENT_TYPE ||\n    type === REACT_PROFILER_TYPE ||\n    type === REACT_STRICT_MODE_TYPE ||\n    type === REACT_SUSPENSE_TYPE ||\n    type === REACT_SUSPENSE_LIST_TYPE ||\n    type === REACT_OFFSCREEN_TYPE ||\n    (typeof type === 'object' &&\n      type !== null &&\n      (type.$$typeof === REACT_LAZY_TYPE ||\n        type.$$typeof === REACT_MEMO_TYPE ||\n        type.$$typeof === REACT_CONTEXT_TYPE ||\n        type.$$typeof === REACT_CONSUMER_TYPE ||\n        type.$$typeof === REACT_FORWARD_REF_TYPE ||\n        type.$$typeof === REACT_CLIENT_REFERENCE ||\n        type.getModuleId !== undefined))\n    ? !0\n    : !1\n}\n\nfunction typeOf(object: any): symbol | undefined {\n  if (typeof object === 'object' && object !== null) {\n    const { $$typeof } = object\n\n    switch ($$typeof) {\n      case REACT_ELEMENT_TYPE:\n        switch (((object = object.type), object)) {\n          case REACT_FRAGMENT_TYPE:\n          case REACT_PROFILER_TYPE:\n          case REACT_STRICT_MODE_TYPE:\n          case REACT_SUSPENSE_TYPE:\n          case REACT_SUSPENSE_LIST_TYPE:\n            return object\n          default:\n            switch (((object = object && object.$$typeof), object)) {\n              case REACT_CONTEXT_TYPE:\n              case REACT_FORWARD_REF_TYPE:\n              case REACT_LAZY_TYPE:\n              case REACT_MEMO_TYPE:\n                return object\n              case REACT_CONSUMER_TYPE:\n                return object\n              default:\n                return $$typeof\n            }\n        }\n      case REACT_PORTAL_TYPE:\n        return $$typeof\n    }\n  }\n\n  return undefined\n}\n\nexport function isContextConsumer(object: any): object is ReactElement {\n  return IS_REACT_19\n    ? typeOf(object) === REACT_CONSUMER_TYPE\n    : typeOf(object) === REACT_CONTEXT_TYPE\n}\n\nexport function isMemo(object: any): object is MemoExoticComponent<any> {\n  return typeOf(object) === REACT_MEMO_TYPE\n}\n","/**\n * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\nexport default function warning(message: string) {\n  /* eslint-disable no-console */\n  if (typeof console !== 'undefined' && typeof console.error === 'function') {\n    console.error(message)\n  }\n  /* eslint-enable no-console */\n  try {\n    // This error was thrown as a convenience so that if you enable\n    // \"break on all exceptions\" in your console,\n    // it would pause the execution at this line.\n    throw new Error(message)\n    /* eslint-disable no-empty */\n  } catch (e) {}\n  /* eslint-enable no-empty */\n}\n","import warning from '../utils/warning'\n\nfunction verify(selector: unknown, methodName: string): void {\n  if (!selector) {\n    throw new Error(`Unexpected value for ${methodName} in connect.`)\n  } else if (\n    methodName === 'mapStateToProps' ||\n    methodName === 'mapDispatchToProps'\n  ) {\n    if (!Object.prototype.hasOwnProperty.call(selector, 'dependsOnOwnProps')) {\n      warning(\n        `The selector for ${methodName} of connect did not specify a value for dependsOnOwnProps.`,\n      )\n    }\n  }\n}\n\nexport default function verifySubselectors(\n  mapStateToProps: unknown,\n  mapDispatchToProps: unknown,\n  mergeProps: unknown,\n): void {\n  verify(mapStateToProps, 'mapStateToProps')\n  verify(mapDispatchToProps, 'mapDispatchToProps')\n  verify(mergeProps, 'mergeProps')\n}\n","import type { Dispatch, Action } from 'redux'\nimport type { ComponentType } from 'react'\nimport verifySubselectors from './verifySubselectors'\nimport type { EqualityFn, ExtendedEqualityFn } from '../types'\n\nexport type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> = (\n  dispatch: Dispatch<Action<string>>,\n  factoryOptions: TFactoryOptions,\n) => Selector<S, TProps, TOwnProps>\n\nexport type Selector<S, TProps, TOwnProps = null> = TOwnProps extends\n  | null\n  | undefined\n  ? (state: S) => TProps\n  : (state: S, ownProps: TOwnProps) => TProps\n\nexport type MapStateToProps<TStateProps, TOwnProps, State> = (\n  state: State,\n  ownProps: TOwnProps,\n) => TStateProps\n\nexport type MapStateToPropsFactory<TStateProps, TOwnProps, State> = (\n  initialState: State,\n  ownProps: TOwnProps,\n) => MapStateToProps<TStateProps, TOwnProps, State>\n\nexport type MapStateToPropsParam<TStateProps, TOwnProps, State> =\n  | MapStateToPropsFactory<TStateProps, TOwnProps, State>\n  | MapStateToProps<TStateProps, TOwnProps, State>\n  | null\n  | undefined\n\nexport type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> = (\n  dispatch: Dispatch<Action<string>>,\n  ownProps: TOwnProps,\n) => TDispatchProps\n\nexport type MapDispatchToProps<TDispatchProps, TOwnProps> =\n  | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>\n  | TDispatchProps\n\nexport type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> = (\n  dispatch: Dispatch<Action<string>>,\n  ownProps: TOwnProps,\n) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>\n\nexport type MapDispatchToPropsParam<TDispatchProps, TOwnProps> =\n  | MapDispatchToPropsFactory<TDispatchProps, TOwnProps>\n  | MapDispatchToProps<TDispatchProps, TOwnProps>\n\nexport type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> =\n  | MapDispatchToPropsFactory<TDispatchProps, TOwnProps>\n  | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>\n\nexport type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> = (\n  stateProps: TStateProps,\n  dispatchProps: TDispatchProps,\n  ownProps: TOwnProps,\n) => TMergedProps\n\ninterface PureSelectorFactoryComparisonOptions<TStateProps, TOwnProps, State> {\n  readonly areStatesEqual: ExtendedEqualityFn<State, TOwnProps>\n  readonly areStatePropsEqual: EqualityFn<TStateProps>\n  readonly areOwnPropsEqual: EqualityFn<TOwnProps>\n}\n\nfunction pureFinalPropsSelectorFactory<\n  TStateProps,\n  TOwnProps,\n  TDispatchProps,\n  TMergedProps,\n  State,\n>(\n  mapStateToProps: WrappedMapStateToProps<TStateProps, TOwnProps, State>,\n  mapDispatchToProps: WrappedMapDispatchToProps<TDispatchProps, TOwnProps>,\n  mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,\n  dispatch: Dispatch<Action<string>>,\n  {\n    areStatesEqual,\n    areOwnPropsEqual,\n    areStatePropsEqual,\n  }: PureSelectorFactoryComparisonOptions<TStateProps, TOwnProps, State>,\n) {\n  let hasRunAtLeastOnce = false\n  let state: State\n  let ownProps: TOwnProps\n  let stateProps: TStateProps\n  let dispatchProps: TDispatchProps\n  let mergedProps: TMergedProps\n\n  function handleFirstCall(firstState: State, firstOwnProps: TOwnProps) {\n    state = firstState\n    ownProps = firstOwnProps\n    stateProps = mapStateToProps(state, ownProps)\n    dispatchProps = mapDispatchToProps(dispatch, ownProps)\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps)\n    hasRunAtLeastOnce = true\n    return mergedProps\n  }\n\n  function handleNewPropsAndNewState() {\n    stateProps = mapStateToProps(state, ownProps)\n\n    if (mapDispatchToProps.dependsOnOwnProps)\n      dispatchProps = mapDispatchToProps(dispatch, ownProps)\n\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps)\n    return mergedProps\n  }\n\n  function handleNewProps() {\n    if (mapStateToProps.dependsOnOwnProps)\n      stateProps = mapStateToProps(state, ownProps)\n\n    if (mapDispatchToProps.dependsOnOwnProps)\n      dispatchProps = mapDispatchToProps(dispatch, ownProps)\n\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps)\n    return mergedProps\n  }\n\n  function handleNewState() {\n    const nextStateProps = mapStateToProps(state, ownProps)\n    const statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps)\n    stateProps = nextStateProps\n\n    if (statePropsChanged)\n      mergedProps = mergeProps(stateProps, dispatchProps, ownProps)\n\n    return mergedProps\n  }\n\n  function handleSubsequentCalls(nextState: State, nextOwnProps: TOwnProps) {\n    const propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps)\n    const stateChanged = !areStatesEqual(\n      nextState,\n      state,\n      nextOwnProps,\n      ownProps,\n    )\n    state = nextState\n    ownProps = nextOwnProps\n\n    if (propsChanged && stateChanged) return handleNewPropsAndNewState()\n    if (propsChanged) return handleNewProps()\n    if (stateChanged) return handleNewState()\n    return mergedProps\n  }\n\n  return function pureFinalPropsSelector(\n    nextState: State,\n    nextOwnProps: TOwnProps,\n  ) {\n    return hasRunAtLeastOnce\n      ? handleSubsequentCalls(nextState, nextOwnProps)\n      : handleFirstCall(nextState, nextOwnProps)\n  }\n}\n\ninterface WrappedMapStateToProps<TStateProps, TOwnProps, State> {\n  (state: State, ownProps: TOwnProps): TStateProps\n  readonly dependsOnOwnProps: boolean\n}\n\ninterface WrappedMapDispatchToProps<TDispatchProps, TOwnProps> {\n  (dispatch: Dispatch<Action<string>>, ownProps: TOwnProps): TDispatchProps\n  readonly dependsOnOwnProps: boolean\n}\n\nexport interface InitOptions<\n  TStateProps,\n  TOwnProps,\n  TMergedProps,\n  State,\n> extends PureSelectorFactoryComparisonOptions<TStateProps, TOwnProps, State> {\n  readonly shouldHandleStateChanges: boolean\n  readonly displayName: string\n  readonly wrappedComponentName: string\n  readonly WrappedComponent: ComponentType<TOwnProps>\n  readonly areMergedPropsEqual: EqualityFn<TMergedProps>\n}\n\nexport interface SelectorFactoryOptions<\n  TStateProps,\n  TOwnProps,\n  TDispatchProps,\n  TMergedProps,\n  State,\n> extends InitOptions<TStateProps, TOwnProps, TMergedProps, State> {\n  readonly initMapStateToProps: (\n    dispatch: Dispatch<Action<string>>,\n    options: InitOptions<TStateProps, TOwnProps, TMergedProps, State>,\n  ) => WrappedMapStateToProps<TStateProps, TOwnProps, State>\n  readonly initMapDispatchToProps: (\n    dispatch: Dispatch<Action<string>>,\n    options: InitOptions<TStateProps, TOwnProps, TMergedProps, State>,\n  ) => WrappedMapDispatchToProps<TDispatchProps, TOwnProps>\n  readonly initMergeProps: (\n    dispatch: Dispatch<Action<string>>,\n    options: InitOptions<TStateProps, TOwnProps, TMergedProps, State>,\n  ) => MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>\n}\n\n// TODO: Add more comments\n\n// The selector returned by selectorFactory will memoize its results,\n// allowing connect's shouldComponentUpdate to return false if final\n// props have not changed.\n\nexport default function finalPropsSelectorFactory<\n  TStateProps,\n  TOwnProps,\n  TDispatchProps,\n  TMergedProps,\n  State,\n>(\n  dispatch: Dispatch<Action<string>>,\n  {\n    initMapStateToProps,\n    initMapDispatchToProps,\n    initMergeProps,\n    ...options\n  }: SelectorFactoryOptions<\n    TStateProps,\n    TOwnProps,\n    TDispatchProps,\n    TMergedProps,\n    State\n  >,\n) {\n  const mapStateToProps = initMapStateToProps(dispatch, options)\n  const mapDispatchToProps = initMapDispatchToProps(dispatch, options)\n  const mergeProps = initMergeProps(dispatch, options)\n\n  if (process.env.NODE_ENV !== 'production') {\n    verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps)\n  }\n\n  return pureFinalPropsSelectorFactory<\n    TStateProps,\n    TOwnProps,\n    TDispatchProps,\n    TMergedProps,\n    State\n  >(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options)\n}\n","import type { ActionCreatorsMapObject, Dispatch } from 'redux'\n\nexport default function bindActionCreators(\n  actionCreators: ActionCreatorsMapObject,\n  dispatch: Dispatch,\n): ActionCreatorsMapObject {\n  const boundActionCreators: ActionCreatorsMapObject = {}\n\n  for (const key in actionCreators) {\n    const actionCreator = actionCreators[key]\n    if (typeof actionCreator === 'function') {\n      boundActionCreators[key] = (...args) => dispatch(actionCreator(...args))\n    }\n  }\n  return boundActionCreators\n}\n","/**\n * @param {any} obj The object to inspect.\n * @returns {boolean} True if the argument appears to be a plain object.\n */\nexport default function isPlainObject(obj: unknown) {\n  if (typeof obj !== 'object' || obj === null) return false\n\n  const proto = Object.getPrototypeOf(obj)\n  if (proto === null) return true\n\n  let baseProto = proto\n  while (Object.getPrototypeOf(baseProto) !== null) {\n    baseProto = Object.getPrototypeOf(baseProto)\n  }\n\n  return proto === baseProto\n}\n","import isPlainObject from './isPlainObject'\nimport warning from './warning'\n\nexport default function verifyPlainObject(\n  value: unknown,\n  displayName: string,\n  methodName: string,\n) {\n  if (!isPlainObject(value)) {\n    warning(\n      `${methodName}() in ${displayName} must return a plain object. Instead received ${value}.`,\n    )\n  }\n}\n","import type { ActionCreatorsMapObject, Dispatch, ActionCreator } from 'redux'\n\nimport type { FixTypeLater } from '../types'\nimport verifyPlainObject from '../utils/verifyPlainObject'\n\ntype AnyState = { [key: string]: any }\ntype StateOrDispatch<S extends AnyState = AnyState> = S | Dispatch\n\ntype AnyProps = { [key: string]: any }\n\nexport type MapToProps<P extends AnyProps = AnyProps> = {\n  // eslint-disable-next-line no-unused-vars\n  (stateOrDispatch: StateOrDispatch, ownProps?: P): FixTypeLater\n  dependsOnOwnProps?: boolean\n}\n\nexport function wrapMapToPropsConstant(\n  // * Note:\n  //  It seems that the dispatch argument\n  //  could be a dispatch function in some cases (ex: whenMapDispatchToPropsIsMissing)\n  //  and a state object in some others (ex: whenMapStateToPropsIsMissing)\n  // eslint-disable-next-line no-unused-vars\n  getConstant: (dispatch: Dispatch) =>\n    | {\n        dispatch?: Dispatch\n        dependsOnOwnProps?: boolean\n      }\n    | ActionCreatorsMapObject\n    | ActionCreator<any>,\n) {\n  return function initConstantSelector(dispatch: Dispatch) {\n    const constant = getConstant(dispatch)\n\n    function constantSelector() {\n      return constant\n    }\n    constantSelector.dependsOnOwnProps = false\n    return constantSelector\n  }\n}\n\n// dependsOnOwnProps is used by createMapToPropsProxy to determine whether to pass props as args\n// to the mapToProps function being wrapped. It is also used by makePurePropsSelector to determine\n// whether mapToProps needs to be invoked when props have changed.\n//\n// A length of one signals that mapToProps does not depend on props from the parent component.\n// A length of zero is assumed to mean mapToProps is getting args via arguments or ...args and\n// therefore not reporting its length accurately..\n// TODO Can this get pulled out so that we can subscribe directly to the store if we don't need ownProps?\nfunction getDependsOnOwnProps(mapToProps: MapToProps) {\n  return mapToProps.dependsOnOwnProps != null\n    ? Boolean(mapToProps.dependsOnOwnProps)\n    : mapToProps.length !== 1\n}\n\n// Used by whenMapStateToPropsIsFunction and whenMapDispatchToPropsIsFunction,\n// this function wraps mapToProps in a proxy function which does several things:\n//\n//  * Detects whether the mapToProps function being called depends on props, which\n//    is used by selectorFactory to decide if it should reinvoke on props changes.\n//\n//  * On first call, handles mapToProps if returns another function, and treats that\n//    new function as the true mapToProps for subsequent calls.\n//\n//  * On first call, verifies the first result is a plain object, in order to warn\n//    the developer that their mapToProps function is not returning a valid result.\n//\nexport function wrapMapToPropsFunc<P extends AnyProps = AnyProps>(\n  mapToProps: MapToProps,\n  methodName: string,\n) {\n  return function initProxySelector(\n    dispatch: Dispatch,\n    { displayName }: { displayName: string },\n  ) {\n    const proxy = function mapToPropsProxy(\n      stateOrDispatch: StateOrDispatch,\n      ownProps?: P,\n    ): MapToProps {\n      return proxy.dependsOnOwnProps\n        ? proxy.mapToProps(stateOrDispatch, ownProps)\n        : proxy.mapToProps(stateOrDispatch, undefined)\n    }\n\n    // allow detectFactoryAndVerify to get ownProps\n    proxy.dependsOnOwnProps = true\n\n    proxy.mapToProps = function detectFactoryAndVerify(\n      stateOrDispatch: StateOrDispatch,\n      ownProps?: P,\n    ): MapToProps {\n      proxy.mapToProps = mapToProps\n      proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps)\n      let props = proxy(stateOrDispatch, ownProps)\n\n      if (typeof props === 'function') {\n        proxy.mapToProps = props\n        proxy.dependsOnOwnProps = getDependsOnOwnProps(props)\n        props = proxy(stateOrDispatch, ownProps)\n      }\n\n      if (process.env.NODE_ENV !== 'production')\n        verifyPlainObject(props, displayName, methodName)\n\n      return props\n    }\n\n    return proxy\n  }\n}\n","import type { Action, Dispatch } from 'redux'\n\nexport function createInvalidArgFactory(arg: unknown, name: string) {\n  return (\n    dispatch: Dispatch<Action<string>>,\n    options: { readonly wrappedComponentName: string },\n  ) => {\n    throw new Error(\n      `Invalid value of type ${typeof arg} for ${name} argument when connecting component ${\n        options.wrappedComponentName\n      }.`,\n    )\n  }\n}\n","import type { Action, Dispatch } from 'redux'\nimport bindActionCreators from '../utils/bindActionCreators'\nimport { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps'\nimport { createInvalidArgFactory } from './invalidArgFactory'\nimport type { MapDispatchToPropsParam } from './selectorFactory'\n\nexport function mapDispatchToPropsFactory<TDispatchProps, TOwnProps>(\n  mapDispatchToProps:\n    | MapDispatchToPropsParam<TDispatchProps, TOwnProps>\n    | undefined,\n) {\n  return mapDispatchToProps && typeof mapDispatchToProps === 'object'\n    ? wrapMapToPropsConstant((dispatch: Dispatch<Action<string>>) =>\n        // @ts-ignore\n        bindActionCreators(mapDispatchToProps, dispatch),\n      )\n    : !mapDispatchToProps\n      ? wrapMapToPropsConstant((dispatch: Dispatch<Action<string>>) => ({\n          dispatch,\n        }))\n      : typeof mapDispatchToProps === 'function'\n        ? // @ts-ignore\n          wrapMapToPropsFunc(mapDispatchToProps, 'mapDispatchToProps')\n        : createInvalidArgFactory(mapDispatchToProps, 'mapDispatchToProps')\n}\n","import { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps'\nimport { createInvalidArgFactory } from './invalidArgFactory'\nimport type { MapStateToPropsParam } from './selectorFactory'\n\nexport function mapStateToPropsFactory<TStateProps, TOwnProps, State>(\n  mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,\n) {\n  return !mapStateToProps\n    ? wrapMapToPropsConstant(() => ({}))\n    : typeof mapStateToProps === 'function'\n      ? // @ts-ignore\n        wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps')\n      : createInvalidArgFactory(mapStateToProps, 'mapStateToProps')\n}\n","import type { Action, Dispatch } from 'redux'\nimport verifyPlainObject from '../utils/verifyPlainObject'\nimport { createInvalidArgFactory } from './invalidArgFactory'\nimport type { MergeProps } from './selectorFactory'\nimport type { EqualityFn } from '../types'\n\nfunction defaultMergeProps<\n  TStateProps,\n  TDispatchProps,\n  TOwnProps,\n  TMergedProps,\n>(\n  stateProps: TStateProps,\n  dispatchProps: TDispatchProps,\n  ownProps: TOwnProps,\n): TMergedProps {\n  // @ts-ignore\n  return { ...ownProps, ...stateProps, ...dispatchProps }\n}\n\nfunction wrapMergePropsFunc<\n  TStateProps,\n  TDispatchProps,\n  TOwnProps,\n  TMergedProps,\n>(\n  mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,\n): (\n  dispatch: Dispatch<Action<string>>,\n  options: {\n    readonly displayName: string\n    readonly areMergedPropsEqual: EqualityFn<TMergedProps>\n  },\n) => MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> {\n  return function initMergePropsProxy(\n    dispatch,\n    { displayName, areMergedPropsEqual },\n  ) {\n    let hasRunOnce = false\n    let mergedProps: TMergedProps\n\n    return function mergePropsProxy(\n      stateProps: TStateProps,\n      dispatchProps: TDispatchProps,\n      ownProps: TOwnProps,\n    ) {\n      const nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps)\n\n      if (hasRunOnce) {\n        if (!areMergedPropsEqual(nextMergedProps, mergedProps))\n          mergedProps = nextMergedProps\n      } else {\n        hasRunOnce = true\n        mergedProps = nextMergedProps\n\n        if (process.env.NODE_ENV !== 'production')\n          verifyPlainObject(mergedProps, displayName, 'mergeProps')\n      }\n\n      return mergedProps\n    }\n  }\n}\n\nexport function mergePropsFactory<\n  TStateProps,\n  TDispatchProps,\n  TOwnProps,\n  TMergedProps,\n>(\n  mergeProps?: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,\n) {\n  return !mergeProps\n    ? () => defaultMergeProps\n    : typeof mergeProps === 'function'\n      ? wrapMergePropsFunc(mergeProps)\n      : createInvalidArgFactory(mergeProps, 'mergeProps')\n}\n","// Default to a dummy \"batch\" implementation that just runs the callback\nexport function defaultNoopBatch(callback: () => void) {\n  callback()\n}\n","import { defaultNoopBatch as batch } from './batch'\n\n// 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\ntype VoidFunc = () => void\n\ntype Listener = {\n  callback: VoidFunc\n  next: Listener | null\n  prev: Listener | null\n}\n\nfunction createListenerCollection() {\n  let first: Listener | null = null\n  let last: Listener | null = null\n\n  return {\n    clear() {\n      first = null\n      last = null\n    },\n\n    notify() {\n      batch(() => {\n        let listener = first\n        while (listener) {\n          listener.callback()\n          listener = listener.next\n        }\n      })\n    },\n\n    get() {\n      const listeners: Listener[] = []\n      let listener = first\n      while (listener) {\n        listeners.push(listener)\n        listener = listener.next\n      }\n      return listeners\n    },\n\n    subscribe(callback: () => void) {\n      let isSubscribed = true\n\n      const listener: 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        if (listener.prev) {\n          listener.prev.next = listener.next\n        } else {\n          first = listener.next\n        }\n      }\n    },\n  }\n}\n\ntype ListenerCollection = ReturnType<typeof createListenerCollection>\n\nexport interface Subscription {\n  addNestedSub: (listener: VoidFunc) => VoidFunc\n  notifyNestedSubs: VoidFunc\n  handleChangeWrapper: VoidFunc\n  isSubscribed: () => boolean\n  onStateChange?: VoidFunc | null\n  trySubscribe: VoidFunc\n  tryUnsubscribe: VoidFunc\n  getListeners: () => ListenerCollection\n}\n\nconst nullListeners = {\n  notify() {},\n  get: () => [],\n} as unknown as ListenerCollection\n\nexport function createSubscription(store: any, parentSub?: Subscription) {\n  let unsubscribe: VoidFunc | undefined\n  let listeners: ListenerCollection = nullListeners\n\n  // Reasons to keep the subscription active\n  let subscriptionsAmount = 0\n\n  // Is this specific subscription subscribed (or only nested ones?)\n  let selfSubscribed = false\n\n  function addNestedSub(listener: () => void) {\n    trySubscribe()\n\n    const cleanupListener = listeners.subscribe(listener)\n\n    // cleanup nested sub\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    if (!unsubscribe) {\n      unsubscribe = parentSub\n        ? parentSub.addNestedSub(handleChangeWrapper)\n        : store.subscribe(handleChangeWrapper)\n\n      listeners = createListenerCollection()\n    }\n  }\n\n  function tryUnsubscribe() {\n    subscriptionsAmount--\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: Subscription = {\n    addNestedSub,\n    notifyNestedSubs,\n    handleChangeWrapper,\n    isSubscribed,\n    trySubscribe: trySubscribeSelf,\n    tryUnsubscribe: tryUnsubscribeSelf,\n    getListeners: () => listeners,\n  }\n\n  return subscription\n}\n","import { React } from '../utils/react'\n\n// 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\n// Matches logic in React's `shared/ExecutionEnvironment` file\nconst canUseDOM = () =>\n  !!(\n    typeof window !== 'undefined' &&\n    typeof window.document !== 'undefined' &&\n    typeof window.document.createElement !== 'undefined'\n  )\n\nconst isDOM = /* @__PURE__ */ canUseDOM()\n\n// Under React Native, we know that we always want to use useLayoutEffect\n\n/**\n * Checks if the code is running in a React Native environment.\n *\n * @returns Whether the code is running in a React Native environment.\n *\n * @see {@link https://github.com/facebook/react-native/issues/1331 Reference}\n */\nconst isRunningInReactNative = () =>\n  typeof navigator !== 'undefined' && navigator.product === 'ReactNative'\n\nconst isReactNative = /* @__PURE__ */ isRunningInReactNative()\n\nconst getUseIsomorphicLayoutEffect = () =>\n  isDOM || isReactNative ? React.useLayoutEffect : React.useEffect\n\nexport const useIsomorphicLayoutEffect =\n  /* @__PURE__ */ getUseIsomorphicLayoutEffect()\n","function is(x: unknown, y: unknown) {\n  if (x === y) {\n    return x !== 0 || y !== 0 || 1 / x === 1 / y\n  } else {\n    return x !== x && y !== y\n  }\n}\n\nexport default function shallowEqual(objA: any, objB: any) {\n  if (is(objA, objB)) return true\n\n  if (\n    typeof objA !== 'object' ||\n    objA === null ||\n    typeof objB !== 'object' ||\n    objB === null\n  ) {\n    return false\n  }\n\n  const keysA = Object.keys(objA)\n  const keysB = Object.keys(objB)\n\n  if (keysA.length !== keysB.length) return false\n\n  for (let i = 0; i < keysA.length; i++) {\n    if (\n      !Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||\n      !is(objA[keysA[i]], objB[keysA[i]])\n    ) {\n      return false\n    }\n  }\n\n  return true\n}\n","// Copied directly from:\n// https://github.com/mridgway/hoist-non-react-statics/blob/main/src/index.js\n// https://unpkg.com/browse/@types/hoist-non-react-statics@3.3.6/index.d.ts\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nimport type { ForwardRefExoticComponent, MemoExoticComponent } from 'react'\nimport { ForwardRef, Memo, isMemo } from '../utils/react-is'\n\nconst 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} as const\n\nconst KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true,\n} as const\n\nconst FORWARD_REF_STATICS = {\n  $$typeof: true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n} as const\n\nconst MEMO_STATICS = {\n  $$typeof: true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true,\n} as const\n\nconst TYPE_STATICS = {\n  [ForwardRef]: FORWARD_REF_STATICS,\n  [Memo]: MEMO_STATICS,\n} as const\n\nfunction getStatics(component: any) {\n  // React v16.11 and below\n  if (isMemo(component)) {\n    return MEMO_STATICS\n  }\n\n  // React v16.12 and above\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS\n}\n\nexport type NonReactStatics<\n  Source,\n  C extends {\n    [key: string]: true\n  } = {},\n> = {\n  [\n    key in Exclude<\n      keyof Source,\n      Source extends MemoExoticComponent<any>\n        ? keyof typeof MEMO_STATICS | keyof C\n        : Source extends ForwardRefExoticComponent<any>\n          ? keyof typeof FORWARD_REF_STATICS | keyof C\n          : keyof typeof REACT_STATICS | keyof typeof KNOWN_STATICS | keyof C\n    >\n  ]: Source[key]\n}\n\nconst defineProperty = Object.defineProperty\nconst getOwnPropertyNames = Object.getOwnPropertyNames\nconst getOwnPropertySymbols = Object.getOwnPropertySymbols\nconst getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor\nconst getPrototypeOf = Object.getPrototypeOf\nconst objectPrototype = Object.prototype\n\nexport default function hoistNonReactStatics<\n  Target,\n  Source,\n  CustomStatic extends {\n    [key: string]: true\n  } = {},\n>(\n  targetComponent: Target,\n  sourceComponent: Source,\n): Target & NonReactStatics<Source, CustomStatic> {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n\n    if (objectPrototype) {\n      const inheritedComponent = getPrototypeOf(sourceComponent)\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent)\n      }\n    }\n\n    let keys: (string | symbol)[] = getOwnPropertyNames(sourceComponent)\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent))\n    }\n\n    const targetStatics = getStatics(targetComponent)\n    const sourceStatics = getStatics(sourceComponent)\n\n    for (let i = 0; i < keys.length; ++i) {\n      const key = keys[i]\n      if (\n        !KNOWN_STATICS[key as keyof typeof KNOWN_STATICS] &&\n        !(sourceStatics && sourceStatics[key as keyof typeof sourceStatics]) &&\n        !(targetStatics && targetStatics[key as keyof typeof targetStatics])\n      ) {\n        const descriptor = getOwnPropertyDescriptor(sourceComponent, key)\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor!)\n        } catch (e) {\n          // ignore\n        }\n      }\n    }\n  }\n\n  return targetComponent as any\n}\n","import type { Context } from 'react'\nimport { React } from '../utils/react'\nimport type { Action, Store, UnknownAction } from 'redux'\nimport type { Subscription } from '../utils/Subscription'\nimport type { ProviderProps } from './Provider'\n\nexport interface ReactReduxContextValue<\n  SS = any,\n  A extends Action<string> = UnknownAction,\n> extends Pick<ProviderProps, 'stabilityCheck' | 'identityFunctionCheck'> {\n  store: Store<SS, A>\n  subscription: Subscription\n  getServerState?: () => SS\n}\n\nconst ContextKey = /* @__PURE__ */ Symbol.for(`react-redux-context`)\nconst gT: {\n  [ContextKey]?: Map<\n    typeof React.createContext,\n    Context<ReactReduxContextValue | null>\n  >\n} = (\n  typeof globalThis !== 'undefined'\n    ? globalThis\n    : /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */ {}\n) as any\n\nfunction getContext(): Context<ReactReduxContextValue | null> {\n  if (!React.createContext) return {} as any\n\n  const contextMap = (gT[ContextKey] ??= new Map<\n    typeof React.createContext,\n    Context<ReactReduxContextValue | null>\n  >())\n  let realContext = contextMap.get(React.createContext)\n  if (!realContext) {\n    realContext = React.createContext<ReactReduxContextValue | null>(\n      null as any,\n    )\n    if (process.env.NODE_ENV !== 'production') {\n      realContext.displayName = 'ReactRedux'\n    }\n    contextMap.set(React.createContext, realContext)\n  }\n  return realContext\n}\n\nexport const ReactReduxContext = /*#__PURE__*/ getContext()\n\nexport type ReactReduxContextInstance = typeof ReactReduxContext\n","/* eslint-disable valid-jsdoc, @typescript-eslint/no-unused-vars */\nimport type { ComponentType } from 'react'\nimport { React } from '../utils/react'\nimport { isValidElementType, isContextConsumer } from '../utils/react-is'\n\nimport type { Store } from 'redux'\n\nimport type {\n  ConnectedComponent,\n  InferableComponentEnhancer,\n  InferableComponentEnhancerWithProps,\n  ResolveThunks,\n  DispatchProp,\n  ConnectPropsMaybeWithoutContext,\n} from '../types'\n\nimport type {\n  MapStateToProps,\n  MapStateToPropsFactory,\n  MapStateToPropsParam,\n  MapDispatchToProps,\n  MapDispatchToPropsFactory,\n  MapDispatchToPropsFunction,\n  MapDispatchToPropsParam,\n  MergeProps,\n  SelectorFactoryOptions,\n} from '../connect/selectorFactory'\nimport defaultSelectorFactory from '../connect/selectorFactory'\nimport { mapDispatchToPropsFactory } from '../connect/mapDispatchToProps'\nimport { mapStateToPropsFactory } from '../connect/mapStateToProps'\nimport { mergePropsFactory } from '../connect/mergeProps'\n\nimport type { Subscription } from '../utils/Subscription'\nimport { createSubscription } from '../utils/Subscription'\nimport { useIsomorphicLayoutEffect } from '../utils/useIsomorphicLayoutEffect'\nimport shallowEqual from '../utils/shallowEqual'\nimport hoistStatics from '../utils/hoistStatics'\nimport warning from '../utils/warning'\n\nimport type {\n  ReactReduxContextValue,\n  ReactReduxContextInstance,\n} from './Context'\nimport { ReactReduxContext } from './Context'\n\n// Accepts the same values as `MapStateToPropsParam`, but as a single function\n// type whose return is `TStateProps | MapStateToProps<...>`. Inference prefers\n// the non-naked `MapStateToProps` member, so a factory infers `TStateProps` from\n// its inner function on every compiler, independent of union member order.\ntype MapStateToPropsParamForMergeProps<TStateProps, TOwnProps, State> =\n  | ((\n      state: State,\n      ownProps: TOwnProps,\n    ) => TStateProps | MapStateToProps<TStateProps, TOwnProps, State>)\n  | null\n  | undefined\n\n// Define some constant arrays just to avoid re-creating these\nconst EMPTY_ARRAY: [unknown, number] = [null, 0]\nconst NO_SUBSCRIPTION_ARRAY = [null, null]\n\n// Attempts to stringify whatever not-really-a-component value we were given\n// for logging in an error message\nconst stringifyComponent = (Comp: unknown) => {\n  try {\n    return JSON.stringify(Comp)\n  } catch (err) {\n    return String(Comp)\n  }\n}\n\ntype EffectFunc = (...args: any[]) => void | ReturnType<React.EffectCallback>\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(\n  effectFunc: EffectFunc,\n  effectArgs: any[],\n  dependencies?: React.DependencyList,\n) {\n  useIsomorphicLayoutEffect(() => effectFunc(...effectArgs), dependencies)\n}\n\n// Effect callback, extracted: assign the latest props values to refs for later usage\nfunction captureWrapperProps(\n  lastWrapperProps: React.MutableRefObject<unknown>,\n  lastChildProps: React.MutableRefObject<unknown>,\n  renderIsScheduled: React.MutableRefObject<boolean>,\n  wrapperProps: unknown,\n  // actualChildProps: unknown,\n  childPropsFromStoreUpdate: React.MutableRefObject<unknown>,\n  notifyNestedSubs: () => void,\n) {\n  // We want to capture the wrapper props and child props we used for later comparisons\n  lastWrapperProps.current = wrapperProps\n  renderIsScheduled.current = false\n\n  // If the render was from a store update, clear out that reference and cascade the subscriber update\n  if (childPropsFromStoreUpdate.current) {\n    childPropsFromStoreUpdate.current = null\n    notifyNestedSubs()\n  }\n}\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.\nfunction subscribeUpdates(\n  shouldHandleStateChanges: boolean,\n  store: Store,\n  subscription: Subscription,\n  childPropsSelector: (state: unknown, props: unknown) => unknown,\n  lastWrapperProps: React.MutableRefObject<unknown>,\n  lastChildProps: React.MutableRefObject<unknown>,\n  renderIsScheduled: React.MutableRefObject<boolean>,\n  isMounted: React.MutableRefObject<boolean>,\n  childPropsFromStoreUpdate: React.MutableRefObject<unknown>,\n  notifyNestedSubs: () => void,\n  // forceComponentUpdateDispatch: React.Dispatch<any>,\n  additionalSubscribeListener: () => void,\n  displayName: string,\n) {\n  // If we're not subscribed to the store, nothing to do here\n  if (!shouldHandleStateChanges) return () => {}\n\n  // Capture values for checking if and when this component unmounts\n  let didUnsubscribe = false\n  let lastThrownError: Error | null = null\n\n  // We'll run this callback every time a store subscription update propagates to this component\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    }\n\n    // TODO We're currently calling getState ourselves here, rather than letting `uSES` do it\n    const latestStoreState = store.getState()\n\n    let newChildProps, error\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(\n        latestStoreState,\n        lastWrapperProps.current,\n      )\n    } catch (e) {\n      error = e\n      lastThrownError = e as Error | null\n      if (process.env.NODE_ENV !== 'production') {\n        console.error(\n          `An error occurred in \\`mapStateToProps\\` (or a selector) of the \\`connect()\\`-ed component \"${displayName}\". ` +\n            'See https://github.com/reduxjs/react-redux/issues/1942 for details.',\n          e,\n        )\n      }\n    }\n\n    if (!error) {\n      lastThrownError = null\n    }\n\n    // If the child props haven't changed, nothing to do here - cascade the subscription update\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\n\n      // TODO This is hacky and not how `uSES` is meant to be used\n      // Trigger the React `useSyncExternalStore` subscriber\n      additionalSubscribeListener()\n    }\n  }\n\n  // Actually subscribe to the nearest connected ancestor (or store)\n  subscription.onStateChange = checkForUpdates\n  subscription.trySubscribe()\n\n  // Pull data from the store after first render in case the store has\n  // changed since we began.\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}\n\n// Reducer initial state creation for our update reducer\nconst initStateUpdates = () => EMPTY_ARRAY\n\nexport interface ConnectProps {\n  /** A custom Context instance that the component can use to access the store from an alternate Provider using that same Context instance */\n  context?: ReactReduxContextInstance\n  /** A Redux store instance to be used for subscriptions instead of the store from a Provider */\n  store?: Store\n}\n\ninterface InternalConnectProps extends ConnectProps {\n  reactReduxForwardedRef?: React.ForwardedRef<unknown>\n}\n\nfunction strictEqual(a: unknown, b: unknown) {\n  return a === b\n}\n\n/**\n * Infers the type of props that a connector will inject into a component.\n */\nexport type ConnectedProps<TConnector> =\n  TConnector extends InferableComponentEnhancerWithProps<\n    infer TInjectedProps,\n    any\n  >\n    ? unknown extends TInjectedProps\n      ? TConnector extends InferableComponentEnhancer<infer TInjectedProps>\n        ? TInjectedProps\n        : never\n      : TInjectedProps\n    : never\n\nexport interface ConnectOptions<\n  State = unknown,\n  TStateProps = {},\n  TOwnProps = {},\n  TMergedProps = {},\n> {\n  forwardRef?: boolean\n  context?: typeof ReactReduxContext\n  areStatesEqual?: (\n    nextState: State,\n    prevState: State,\n    nextOwnProps: TOwnProps,\n    prevOwnProps: TOwnProps,\n  ) => boolean\n\n  areOwnPropsEqual?: (\n    nextOwnProps: TOwnProps,\n    prevOwnProps: TOwnProps,\n  ) => boolean\n\n  areStatePropsEqual?: (\n    nextStateProps: TStateProps,\n    prevStateProps: TStateProps,\n  ) => boolean\n  areMergedPropsEqual?: (\n    nextMergedProps: TMergedProps,\n    prevMergedProps: TMergedProps,\n  ) => boolean\n}\n\n/**\n\n *\n * Connects a React component to a Redux store.\n *\n * - Without arguments, just wraps the component, without changing the behavior / props\n *\n * - If 2 params are passed (3rd param, mergeProps, is skipped), default behavior\n * is to override ownProps (as stated in the docs), so what remains is everything that's\n * not a state or dispatch prop\n *\n * - When 3rd param is passed, we don't know if ownProps propagate and whether they\n * should be valid component props, because it depends on mergeProps implementation.\n * As such, it is the user's responsibility to extend ownProps interface from state or\n * dispatch props or both when applicable\n *\n * @param mapStateToProps\n * @param mapDispatchToProps\n * @param mergeProps\n * @param options\n */\nexport interface Connect<DefaultState = unknown> {\n  // tslint:disable:no-unnecessary-generics\n  //\n  // NOTE: the `mapStateToProps` and `mapDispatchToProps` parameters are\n  // intentionally split into separate \"factory\" and \"plain\" overloads instead of\n  // accepting the `MapStateToPropsParam` / `MapDispatchToProps{Param,NonObject}`\n  // unions directly. A factory (e.g. `() => (state) => props`) is structurally\n  // assignable to its plain counterpart, so when both forms live in a single\n  // union the compiler has to pick a \"first\" inference candidate - and the old\n  // and new (native, TS 7 / `tsgo`) compilers order union members differently,\n  // inferring `TStateProps` / `TDispatchProps` incorrectly on one of them.\n  // Listing the factory overload first makes the resolution order explicit and\n  // compiler-independent. The `mergeProps` overloads can't be split this way\n  // (see the note on those overloads below).\n  // See https://github.com/reduxjs/react-redux/issues/2244\n  (): InferableComponentEnhancer<DispatchProp>\n\n  /** mapState only (as a factory) */\n  <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n  ): InferableComponentEnhancerWithProps<TStateProps & DispatchProp, TOwnProps>\n\n  /** mapState only */\n  <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n  ): InferableComponentEnhancerWithProps<TStateProps & DispatchProp, TOwnProps>\n\n  /** mapDispatch only (as a factory) */\n  <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(\n    mapStateToProps: null | undefined,\n    mapDispatchToProps: MapDispatchToPropsFactory<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>\n\n  /** mapDispatch only (as a function) */\n  <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(\n    mapStateToProps: null | undefined,\n    mapDispatchToProps: MapDispatchToPropsFunction<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>\n\n  /** mapDispatch only (as an object) */\n  <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(\n    mapStateToProps: null | undefined,\n    mapDispatchToProps: MapDispatchToProps<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    ResolveThunks<TDispatchProps>,\n    TOwnProps\n  >\n\n  /** mapState (as a factory) and mapDispatch (as a factory) */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n    mapDispatchToProps: MapDispatchToPropsFactory<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & TDispatchProps,\n    TOwnProps\n  >\n\n  /** mapState (as a factory) and mapDispatch (as a function) */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n    mapDispatchToProps: MapDispatchToPropsFunction<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & TDispatchProps,\n    TOwnProps\n  >\n\n  /** mapState and mapDispatch (as a factory) */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n    mapDispatchToProps: MapDispatchToPropsFactory<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & TDispatchProps,\n    TOwnProps\n  >\n\n  /** mapState and mapDispatch (as a function)*/\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n    mapDispatchToProps: MapDispatchToPropsFunction<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & TDispatchProps,\n    TOwnProps\n  >\n\n  /** mapState (as a factory) and mapDispatch (nullish) */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n    mapDispatchToProps: null | undefined,\n  ): InferableComponentEnhancerWithProps<TStateProps, TOwnProps>\n\n  /** mapState and mapDispatch (nullish) */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n    mapDispatchToProps: null | undefined,\n  ): InferableComponentEnhancerWithProps<TStateProps, TOwnProps>\n\n  /** mapState (as a factory) and mapDispatch (as an object) */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n    mapDispatchToProps: MapDispatchToProps<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & ResolveThunks<TDispatchProps>,\n    TOwnProps\n  >\n\n  /** mapState and mapDispatch (as an object) */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n    mapDispatchToProps: MapDispatchToProps<TDispatchProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & ResolveThunks<TDispatchProps>,\n    TOwnProps\n  >\n\n  /** mergeProps only */\n  <no_state = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}>(\n    mapStateToProps: null | undefined,\n    mapDispatchToProps: null | undefined,\n    mergeProps: MergeProps<undefined, DispatchProp, TOwnProps, TMergedProps>,\n  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>\n\n  // `mergeProps` overloads don't split off a factory overload (see the note on\n  // the final `mergeProps` overload below) - doing so would collapse the\n  // inferred props to `{}`.\n\n  /** mapState and mergeProps */\n  <\n    TStateProps = {},\n    no_dispatch = {},\n    TOwnProps = {},\n    TMergedProps = {},\n    State = DefaultState,\n  >(\n    mapStateToProps: MapStateToPropsParamForMergeProps<\n      TStateProps,\n      TOwnProps,\n      State\n    >,\n    mapDispatchToProps: null | undefined,\n    mergeProps: MergeProps<TStateProps, DispatchProp, TOwnProps, TMergedProps>,\n  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>\n\n  /** mapDispatch (as a object) and mergeProps */\n  <no_state = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}>(\n    mapStateToProps: null | undefined,\n    mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,\n    mergeProps: MergeProps<undefined, TDispatchProps, TOwnProps, TMergedProps>,\n  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>\n\n  /** mapState (as a factory) and options */\n  <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n    mapDispatchToProps: null | undefined,\n    mergeProps: null | undefined,\n    options: ConnectOptions<State, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<DispatchProp & TStateProps, TOwnProps>\n\n  /** mapState and options */\n  <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n    mapDispatchToProps: null | undefined,\n    mergeProps: null | undefined,\n    options: ConnectOptions<State, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<DispatchProp & TStateProps, TOwnProps>\n\n  /** mapDispatch (as a factory) and options */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(\n    mapStateToProps: null | undefined,\n    mapDispatchToProps: MapDispatchToPropsFactory<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<{}, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>\n\n  /** mapDispatch (as a function) and options */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(\n    mapStateToProps: null | undefined,\n    mapDispatchToProps: MapDispatchToPropsFunction<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<{}, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>\n\n  /** mapDispatch (as an object) and options*/\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(\n    mapStateToProps: null | undefined,\n    mapDispatchToProps: MapDispatchToProps<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<{}, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    ResolveThunks<TDispatchProps>,\n    TOwnProps\n  >\n\n  /** mapState (as a factory), mapDispatch (as a factory), and options */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n    mapDispatchToProps: MapDispatchToPropsFactory<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<State, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & TDispatchProps,\n    TOwnProps\n  >\n\n  /** mapState (as a factory), mapDispatch (as a function), and options */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n    mapDispatchToProps: MapDispatchToPropsFunction<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<State, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & TDispatchProps,\n    TOwnProps\n  >\n\n  /** mapState, mapDispatch (as a factory), and options */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n    mapDispatchToProps: MapDispatchToPropsFactory<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<State, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & TDispatchProps,\n    TOwnProps\n  >\n\n  /** mapState,  mapDispatch (as a function), and options */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n    mapDispatchToProps: MapDispatchToPropsFunction<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<State, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & TDispatchProps,\n    TOwnProps\n  >\n\n  /** mapState (as a factory), mapDispatch (as an object), and options */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps: MapStateToPropsFactory<TStateProps, TOwnProps, State>,\n    mapDispatchToProps: MapDispatchToProps<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<State, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & ResolveThunks<TDispatchProps>,\n    TOwnProps\n  >\n\n  /** mapState,  mapDispatch (as an object), and options */\n  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(\n    mapStateToProps:\n      | MapStateToProps<TStateProps, TOwnProps, State>\n      | null\n      | undefined,\n    mapDispatchToProps: MapDispatchToProps<TDispatchProps, TOwnProps>,\n    mergeProps: null | undefined,\n    options: ConnectOptions<State, TStateProps, TOwnProps>,\n  ): InferableComponentEnhancerWithProps<\n    TStateProps & ResolveThunks<TDispatchProps>,\n    TOwnProps\n  >\n\n  // NOTE: the `mergeProps` overloads accept both map forms in one overload\n  // rather than the factory/plain split used above. `mergeProps` receives `stateProps` and\n  // `dispatchProps` as contextually-typed (non-inferring) parameters, so\n  // `TStateProps` / `TDispatchProps` can only be inferred from `mapStateToProps`\n  // / `mapDispatchToProps`. With a dedicated factory overload listed first a\n  // plain map function gets captured by it and the inferred props collapse to\n  // `{}`, because the contextually-typed `mergeProps` parameters keep the types\n  // from the failed overload attempt. `mapStateToProps` uses\n  // `MapStateToPropsParamForMergeProps` instead of the `MapStateToPropsParam`\n  // union so that a factory infers the same `TStateProps` on every compiler.\n\n  /** mapState, mapDispatch, mergeProps, and options */\n  <\n    TStateProps = {},\n    TDispatchProps = {},\n    TOwnProps = {},\n    TMergedProps = {},\n    State = DefaultState,\n  >(\n    mapStateToProps: MapStateToPropsParamForMergeProps<\n      TStateProps,\n      TOwnProps,\n      State\n    >,\n    mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,\n    mergeProps: MergeProps<\n      TStateProps,\n      TDispatchProps,\n      TOwnProps,\n      TMergedProps\n    >,\n    options?: ConnectOptions<State, TStateProps, TOwnProps, TMergedProps>,\n  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>\n  // tslint:enable:no-unnecessary-generics\n}\n\nlet hasWarnedAboutDeprecatedPureOption = false\n\n/**\n * @deprecated\n *\n * **We recommend using the `useSelector` and `useDispatch` hooks instead.**\n * See https://react-redux.js.org/api/hooks\n *\n * If you need to use `connect` without this visual deprecation warning,\n * import `legacy_connect` instead:\n *\n * `import { legacy_connect as connect } from 'react-redux'`\n *\n * Connects a React component to a Redux store.\n *\n * - Without arguments, just wraps the component, without changing the behavior / props\n *\n * - If 2 params are passed (3rd param, mergeProps, is skipped), default behavior\n * is to override ownProps (as stated in the docs), so what remains is everything that's\n * not a state or dispatch prop\n *\n * - When 3rd param is passed, we don't know if ownProps propagate and whether they\n * should be valid component props, because it depends on mergeProps implementation.\n * As such, it is the user's responsibility to extend ownProps interface from state or\n * dispatch props or both when applicable\n *\n * @param mapStateToProps A function that extracts values from state\n * @param mapDispatchToProps Setup for dispatching actions\n * @param mergeProps Optional callback to merge state and dispatch props together\n * @param options Options for configuring the connection\n *\n */\nfunction _connect<\n  TStateProps = {},\n  TDispatchProps = {},\n  TOwnProps = {},\n  TMergedProps = {},\n  State = unknown,\n>(\n  mapStateToProps?: MapStateToPropsParam<TStateProps, TOwnProps, State>,\n  mapDispatchToProps?: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,\n  mergeProps?: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,\n  {\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\n    // use React's forwardRef to expose a ref of the wrapped component\n    forwardRef = false,\n\n    // the context consumer to use\n    context = ReactReduxContext,\n  }: ConnectOptions<unknown, unknown, unknown, unknown> = {},\n): unknown {\n  if (process.env.NODE_ENV !== 'production') {\n    if (pure !== undefined && !hasWarnedAboutDeprecatedPureOption) {\n      hasWarnedAboutDeprecatedPureOption = true\n      warning(\n        'The `pure` option has been removed. `connect` is now always a \"pure/memoized\" component',\n      )\n    }\n  }\n\n  const Context = context\n\n  const initMapStateToProps = mapStateToPropsFactory(mapStateToProps)\n  const initMapDispatchToProps = mapDispatchToPropsFactory(mapDispatchToProps)\n  const initMergeProps = mergePropsFactory(mergeProps)\n\n  const shouldHandleStateChanges = Boolean(mapStateToProps)\n\n  const wrapWithConnect = <TProps,>(\n    WrappedComponent: ComponentType<TProps>,\n  ) => {\n    type WrappedComponentProps = TProps &\n      ConnectPropsMaybeWithoutContext<TProps>\n\n    if (process.env.NODE_ENV !== 'production') {\n      const isValid = /*#__PURE__*/ isValidElementType(WrappedComponent)\n      if (!isValid)\n        throw new Error(\n          `You must pass a component to the function returned by connect. Instead received ${stringifyComponent(\n            WrappedComponent,\n          )}`,\n        )\n    }\n\n    const wrappedComponentName =\n      WrappedComponent.displayName || WrappedComponent.name || 'Component'\n\n    const displayName = `Connect(${wrappedComponentName})`\n\n    const selectorFactoryOptions: SelectorFactoryOptions<\n      any,\n      any,\n      any,\n      any,\n      State\n    > = {\n      shouldHandleStateChanges,\n      displayName,\n      wrappedComponentName,\n      WrappedComponent,\n      // @ts-ignore\n      initMapStateToProps,\n      initMapDispatchToProps,\n      initMergeProps,\n      areStatesEqual,\n      areStatePropsEqual,\n      areOwnPropsEqual,\n      areMergedPropsEqual,\n    }\n\n    function ConnectFunction<TOwnProps>(\n      props: InternalConnectProps & TOwnProps,\n    ) {\n      const [propsContext, reactReduxForwardedRef, wrapperProps] =\n        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 { reactReduxForwardedRef, ...wrapperProps } = props\n          return [props.context, reactReduxForwardedRef, wrapperProps]\n        }, [props])\n\n      const ContextToUse: ReactReduxContextInstance = 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        let ResultContext = Context\n        if (propsContext?.Consumer) {\n          if (process.env.NODE_ENV !== 'production') {\n            const isValid = /*#__PURE__*/ isContextConsumer(\n              // @ts-ignore\n              <propsContext.Consumer />,\n            )\n            if (!isValid) {\n              throw new Error(\n                'You must pass a valid React context consumer as `props.context`',\n              )\n            }\n          }\n          ResultContext = propsContext\n        }\n        return ResultContext\n      }, [propsContext, Context])\n\n      // Retrieve the store and ancestor subscription via context, if available\n      const contextValue = React.useContext(ContextToUse)\n\n      // 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      const didStoreComeFromProps =\n        Boolean(props.store) &&\n        Boolean(props.store!.getState) &&\n        Boolean(props.store!.dispatch)\n      const didStoreComeFromContext =\n        Boolean(contextValue) && Boolean(contextValue!.store)\n\n      if (\n        process.env.NODE_ENV !== 'production' &&\n        !didStoreComeFromProps &&\n        !didStoreComeFromContext\n      ) {\n        throw new Error(\n          `Could not find \"store\" in the context of ` +\n            `\"${displayName}\". Either wrap the root component in a <Provider>, ` +\n            `or pass a custom React context provider to <Provider> and the corresponding ` +\n            `React context consumer to ${displayName} in connect options.`,\n        )\n      }\n\n      // Based on the previous check, one of these must be true\n      const store: Store = didStoreComeFromProps\n        ? props.store!\n        : contextValue!.store\n\n      const getServerState = didStoreComeFromContext\n        ? contextValue!.getServerState\n        : store.getState\n\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\n      const [subscription, notifyNestedSubs] = React.useMemo(() => {\n        if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY\n\n        // 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        const subscription = createSubscription(\n          store,\n          didStoreComeFromProps ? undefined : contextValue!.subscription,\n        )\n\n        // `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        const notifyNestedSubs =\n          subscription.notifyNestedSubs.bind(subscription)\n\n        return [subscription, notifyNestedSubs]\n      }, [store, didStoreComeFromProps, contextValue])\n\n      // Determine what {store, subscription} value should be put into nested context, if necessary,\n      // and memoize that value to avoid unnecessary context updates.\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        }\n\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        return {\n          ...contextValue,\n          subscription,\n        } as ReactReduxContextValue\n      }, [didStoreComeFromProps, contextValue, subscription])\n\n      // Set up refs to coordinate values between the subscription effect and the render logic\n      const lastChildProps = React.useRef<unknown>(undefined)\n      const lastWrapperProps = React.useRef(wrapperProps)\n      const childPropsFromStoreUpdate = React.useRef<unknown>(undefined)\n      const renderIsScheduled = React.useRef(false)\n      const isMounted = React.useRef(false)\n\n      // TODO: Change this to `React.useRef<Error>(undefined)` after upgrading to React 19.\n      /**\n       * @todo Change this to `React.useRef<Error>(undefined)` after upgrading to React 19.\n       */\n      const latestSubscriptionCallbackError = React.useRef<Error | undefined>(\n        undefined,\n      )\n\n      useIsomorphicLayoutEffect(() => {\n        isMounted.current = true\n        return () => {\n          isMounted.current = false\n        }\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 (\n            childPropsFromStoreUpdate.current &&\n            wrapperProps === lastWrapperProps.current\n          ) {\n            return childPropsFromStoreUpdate.current\n          }\n\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          return childPropsSelector(store.getState(), wrapperProps)\n        }\n        return selector\n      }, [store, wrapperProps])\n\n      // 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: () => void) => {\n          if (!subscription) {\n            return () => {}\n          }\n\n          return subscribeUpdates(\n            shouldHandleStateChanges,\n            store,\n            subscription,\n            // @ts-ignore\n            childPropsSelector,\n            lastWrapperProps,\n            lastChildProps,\n            renderIsScheduled,\n            isMounted,\n            childPropsFromStoreUpdate,\n            notifyNestedSubs,\n            reactListener,\n            displayName,\n          )\n        }\n\n        return subscribe\n      }, [subscription])\n\n      useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [\n        lastWrapperProps,\n        lastChildProps,\n        renderIsScheduled,\n        wrapperProps,\n        childPropsFromStoreUpdate,\n        notifyNestedSubs,\n      ])\n\n      let actualChildProps: Record<string, unknown>\n\n      try {\n        actualChildProps = React.useSyncExternalStore(\n          // TODO We're passing through a big wrapper that does a bunch of extra side effects besides subscribing\n          subscribeForReact,\n          // 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,\n          getServerState\n            ? () => childPropsSelector(getServerState(), wrapperProps)\n            : actualChildPropsSelector,\n        )\n      } catch (err) {\n        if (latestSubscriptionCallbackError.current) {\n          // eslint-disable-next-line no-extra-semi\n          ;(err as Error).message +=\n            `\\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      })\n\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      const renderedWrappedComponent = React.useMemo(() => {\n        const effectiveProps = { ...actualChildProps }\n        if (forwardRef) {\n          effectiveProps.ref = reactReduxForwardedRef\n        }\n        return (\n          // @ts-ignore\n          <WrappedComponent {...effectiveProps} />\n        )\n      }, [reactReduxForwardedRef, WrappedComponent, actualChildProps])\n\n      // 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      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 (\n            <ContextToUse.Provider value={overriddenContextValue}>\n              {renderedWrappedComponent}\n            </ContextToUse.Provider>\n          )\n        }\n\n        return renderedWrappedComponent\n      }, [ContextToUse, renderedWrappedComponent, overriddenContextValue])\n\n      return renderedChild\n    }\n\n    const _Connect = React.memo(ConnectFunction)\n\n    type ConnectedWrapperComponent = typeof _Connect & {\n      WrappedComponent: typeof WrappedComponent\n    }\n\n    // Add a hacky cast to get the right output type\n    const Connect = _Connect as unknown as ConnectedComponent<\n      typeof WrappedComponent,\n      WrappedComponentProps\n    >\n    Connect.WrappedComponent = WrappedComponent\n    Connect.displayName = ConnectFunction.displayName = displayName\n\n    if (forwardRef) {\n      const _forwarded = React.forwardRef(\n        function forwardConnectRef(props, ref) {\n          // @ts-ignore\n          return <Connect {...props} reactReduxForwardedRef={ref} />\n        },\n      )\n\n      const forwarded = _forwarded as ConnectedWrapperComponent\n      forwarded.displayName = displayName\n      forwarded.WrappedComponent = WrappedComponent\n      return /*#__PURE__*/ hoistStatics(forwarded, WrappedComponent)\n    }\n\n    return /*#__PURE__*/ hoistStatics(Connect, WrappedComponent)\n  }\n\n  return wrapWithConnect\n}\n\n/**\n *  * @deprecated\n *\n * **We recommend using the `useSelector` and `useDispatch` hooks instead.**\n * See https://react-redux.js.org/api/hooks\n *\n * If you need to use `connect` without this visual deprecation warning,\n * import `legacy_connect` instead:\n *\n * `import { legacy_connect as connect } from 'react-redux'`\n */\nexport const connect: Connect = _connect as Connect\n\n/**\n * Connects a React component to a Redux store. Same as `connect` but without\n * the deprecation warning.\n *\n * **We recommend using the `useSelector` and `useDispatch` hooks instead.**\n * See https://react-redux.js.org/api/hooks\n */\nexport const legacy_connect: Connect = _connect as Connect\n","import type { Context, ReactNode } from 'react'\nimport { React } from '../utils/react'\nimport type { Action, Store, UnknownAction } from 'redux'\nimport type { DevModeCheckFrequency } from '../hooks/useSelector'\nimport { createSubscription } from '../utils/Subscription'\nimport { useIsomorphicLayoutEffect } from '../utils/useIsomorphicLayoutEffect'\nimport type { ReactReduxContextValue } from './Context'\nimport { ReactReduxContext } from './Context'\n\nexport interface ProviderProps<\n  A extends Action<string> = UnknownAction,\n  S = unknown,\n> {\n  /**\n   * The single Redux store in your application.\n   */\n  store: Store<S, A>\n\n  /**\n   * An optional server state snapshot. Will be used during initial hydration render if available, to ensure that the UI output is consistent with the HTML generated on the server.\n   */\n  serverState?: S\n\n  /**\n   * Optional context to be used internally in react-redux. Use React.createContext() to create a context to be used.\n   * If this is used, you'll need to customize `connect` by supplying the same context provided to the Provider.\n   * Set the initial value to null, and the hooks will error\n   * if this is not overwritten by Provider.\n   */\n  context?: Context<ReactReduxContextValue<S, A> | null>\n\n  /**\n   * Determines the frequency of stability checks for all selectors.\n   * This setting overrides the global configuration for\n   * the `useSelector` stability check, allowing you to specify how often\n   * these checks should occur in development mode.\n   *\n   * @since 8.1.0\n   */\n  stabilityCheck?: DevModeCheckFrequency\n\n  /**\n   * Determines the frequency of identity function checks for all selectors.\n   * This setting overrides the global configuration for\n   * the `useSelector` identity function check, allowing you to specify how often\n   * these checks should occur in development mode.\n   *\n   * **Note**: Previously referred to as `noopCheck`.\n   *\n   * @since 9.0.0\n   */\n  identityFunctionCheck?: DevModeCheckFrequency\n\n  children: ReactNode\n}\n\nfunction Provider<A extends Action<string> = UnknownAction, S = unknown>(\n  providerProps: ProviderProps<A, S>,\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    // The React Server Components build of React has no effect hooks\n    if (typeof useIsomorphicLayoutEffect !== 'function') {\n      throw new Error(\n        'The React Redux `<Provider>` component requires React hooks that are ' +\n          'not available in a React Server Component. This usually means you are ' +\n          'rendering `<Provider>` in a Server Component. Add the `\"use client\"` ' +\n          'directive to the top of the file that renders `<Provider>` (or a ' +\n          'parent that ends up rendering it) so it is treated as a Client ' +\n          'Component. See https://react.dev/reference/rsc/use-client for more ' +\n          'information.',\n      )\n    }\n  }\n\n  const { children, context, serverState, store } = providerProps\n\n  const contextValue = React.useMemo(() => {\n    const subscription = createSubscription(store)\n\n    const baseContextValue = {\n      store,\n      subscription,\n      getServerState: serverState != null ? () => serverState : undefined,\n    }\n\n    if (process.env.NODE_ENV === 'production') {\n      return baseContextValue\n    } else {\n      const { identityFunctionCheck = 'once', stabilityCheck = 'once' } =\n        providerProps\n\n      return /* @__PURE__ */ Object.assign(baseContextValue, {\n        stabilityCheck,\n        identityFunctionCheck,\n      })\n    }\n  }, [store, serverState])\n\n  const previousState = React.useMemo(() => store.getState(), [store])\n\n  useIsomorphicLayoutEffect(() => {\n    const { subscription } = contextValue\n    subscription.onStateChange = subscription.notifyNestedSubs\n    subscription.trySubscribe()\n\n    if (previousState !== store.getState()) {\n      subscription.notifyNestedSubs()\n    }\n    return () => {\n      subscription.tryUnsubscribe()\n      subscription.onStateChange = undefined\n    }\n  }, [contextValue, previousState])\n\n  const Context = context || ReactReduxContext\n\n  return <Context.Provider value={contextValue}>{children}</Context.Provider>\n}\n\nexport default Provider\n","import { React } from '../utils/react'\nimport { ReactReduxContext } from '../components/Context'\nimport type { ReactReduxContextValue } from '../components/Context'\n\n/**\n * Hook factory, which creates a `useReduxContext` hook bound to a given context. This is a low-level\n * hook that you should usually not need to call directly.\n *\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\n * @returns {Function} A `useReduxContext` hook bound to the specified context.\n */\nexport function createReduxContextHook(context = ReactReduxContext) {\n  return function useReduxContext(): ReactReduxContextValue {\n    const contextValue = React.useContext(context)\n\n    if (process.env.NODE_ENV !== 'production' && !contextValue) {\n      throw new Error(\n        'could not find react-redux context value; please ensure the component is wrapped in a <Provider>',\n      )\n    }\n\n    return contextValue!\n  }\n}\n\n/**\n * A hook to access the value of the `ReactReduxContext`. This is a low-level\n * hook that you should usually not need to call directly.\n *\n * @returns {any} the value of the `ReactReduxContext`\n *\n * @example\n *\n * import React from 'react'\n * import { useReduxContext } from 'react-redux'\n *\n * export const CounterComponent = () => {\n *   const { store } = useReduxContext()\n *   return <div>{store.getState()}</div>\n * }\n */\nexport const useReduxContext = /*#__PURE__*/ createReduxContextHook()\n","import type { Context } from 'react'\nimport type { Action, Store } from 'redux'\nimport type { ReactReduxContextValue } from '../components/Context'\nimport { ReactReduxContext } from '../components/Context'\nimport {\n  createReduxContextHook,\n  useReduxContext as useDefaultReduxContext,\n} from './useReduxContext'\n\n/**\n * Represents a type that extracts the action type from a given Redux store.\n *\n * @template StoreType - The specific type of the Redux store.\n *\n * @since 9.1.0\n * @internal\n */\nexport type ExtractStoreActionType<StoreType extends Store> =\n  StoreType extends Store<any, infer ActionType> ? ActionType : never\n\n/**\n * Represents a custom hook that provides access to the Redux store.\n *\n * @template StoreType - The specific type of the Redux store that gets returned.\n *\n * @since 9.1.0\n * @public\n */\nexport interface UseStore<StoreType extends Store> {\n  /**\n   * Returns the Redux store instance.\n   *\n   * @returns The Redux store instance.\n   */\n  (): StoreType\n\n  /**\n   * Returns the Redux store instance with specific state and action types.\n   *\n   * @returns The Redux store with the specified state and action types.\n   *\n   * @template StateType - The specific type of the state used in the store.\n   * @template ActionType - The specific type of the actions used in the store.\n   */\n  <\n    StateType extends ReturnType<StoreType['getState']> = ReturnType<\n      StoreType['getState']\n    >,\n    ActionType extends Action = ExtractStoreActionType<Store>,\n  >(): Store<StateType, ActionType>\n\n  /**\n   * Creates a \"pre-typed\" version of {@linkcode useStore useStore}\n   * where the type of the Redux `store` is predefined.\n   *\n   * This allows you to set the `store` type once, eliminating the need to\n   * specify it with every {@linkcode useStore useStore} call.\n   *\n   * @returns A pre-typed `useStore` with the store type already defined.\n   *\n   * @example\n   * ```ts\n   * export const useAppStore = useStore.withTypes<AppStore>()\n   * ```\n   *\n   * @template OverrideStoreType - The specific type of the Redux store that gets returned.\n   *\n   * @since 9.1.0\n   */\n  withTypes: <\n    OverrideStoreType extends StoreType,\n  >() => UseStore<OverrideStoreType>\n}\n\n/**\n * Hook factory, which creates a `useStore` hook bound to a given context.\n *\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\n * @returns {Function} A `useStore` hook bound to the specified context.\n */\nexport function createStoreHook<\n  StateType = unknown,\n  ActionType extends Action = Action,\n>(\n  // @ts-ignore\n  context: Context<ReactReduxContextValue<\n    StateType,\n    ActionType\n  > | null> = ReactReduxContext,\n) {\n  const useReduxContext =\n    context === ReactReduxContext\n      ? useDefaultReduxContext\n      : // @ts-ignore\n        createReduxContextHook(context)\n  const useStore = () => {\n    const { store } = useReduxContext()\n    return store\n  }\n\n  Object.assign(useStore, {\n    withTypes: () => useStore,\n  })\n\n  return useStore as UseStore<Store<StateType, ActionType>>\n}\n\n/**\n * A hook to access the redux store.\n *\n * @returns {any} the redux store\n *\n * @example\n *\n * import React from 'react'\n * import { useStore } from 'react-redux'\n *\n * export const ExampleComponent = () => {\n *   const store = useStore()\n *   return <div>{store.getState()}</div>\n * }\n */\nexport const useStore = /*#__PURE__*/ createStoreHook()\n","import type { Context } from 'react'\nimport type { Action, Dispatch, UnknownAction } from 'redux'\nimport type { ReactReduxContextValue } from '../components/Context'\nimport { ReactReduxContext } from '../components/Context'\nimport { createStoreHook, useStore as useDefaultStore } from './useStore'\n\n/**\n * Represents a custom hook that provides a dispatch function\n * from the Redux store.\n *\n * @template DispatchType - The specific type of the dispatch function.\n *\n * @since 9.1.0\n * @public\n */\nexport interface UseDispatch<\n  DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,\n> {\n  /**\n   * Returns the dispatch function from the Redux store.\n   *\n   * @returns The dispatch function from the Redux store.\n   *\n   * @template AppDispatch - The specific type of the dispatch function.\n   */\n  <AppDispatch extends DispatchType = DispatchType>(): AppDispatch\n\n  /**\n   * Creates a \"pre-typed\" version of {@linkcode useDispatch useDispatch}\n   * where the type of the `dispatch` function is predefined.\n   *\n   * This allows you to set the `dispatch` type once, eliminating the need to\n   * specify it with every {@linkcode useDispatch useDispatch} call.\n   *\n   * @returns A pre-typed `useDispatch` with the dispatch type already defined.\n   *\n   * @example\n   * ```ts\n   * export const useAppDispatch = useDispatch.withTypes<AppDispatch>()\n   * ```\n   *\n   * @template OverrideDispatchType - The specific type of the dispatch function.\n   *\n   * @since 9.1.0\n   */\n  withTypes: <\n    OverrideDispatchType extends DispatchType,\n  >() => UseDispatch<OverrideDispatchType>\n}\n\n/**\n * Hook factory, which creates a `useDispatch` hook bound to a given context.\n *\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\n * @returns {Function} A `useDispatch` hook bound to the specified context.\n */\nexport function createDispatchHook<\n  StateType = unknown,\n  ActionType extends Action = UnknownAction,\n>(\n  // @ts-ignore\n  context: Context<ReactReduxContextValue<\n    StateType,\n    ActionType\n  > | null> = ReactReduxContext,\n) {\n  const useStore =\n    context === ReactReduxContext ? useDefaultStore : createStoreHook(context)\n\n  const useDispatch = () => {\n    const store = useStore()\n    return store.dispatch\n  }\n\n  Object.assign(useDispatch, {\n    withTypes: () => useDispatch,\n  })\n\n  return useDispatch as UseDispatch<Dispatch<ActionType>>\n}\n\n/**\n * A hook to access the redux `dispatch` function.\n *\n * @returns {any|function} redux store's `dispatch` function\n *\n * @example\n *\n * import React, { useCallback } from 'react'\n * import { useDispatch } from 'react-redux'\n *\n * export const CounterComponent = ({ value }) => {\n *   const dispatch = useDispatch()\n *   const increaseCounter = useCallback(() => dispatch({ type: 'increase-counter' }), [])\n *   return (\n *     <div>\n *       <span>{value}</span>\n *       <button onClick={increaseCounter}>Increase counter</button>\n *     </div>\n *   )\n * }\n */\nexport const useDispatch = /*#__PURE__*/ createDispatchHook()\n","//import * as React from 'react'\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector.js'\nimport type { ReactReduxContextValue } from '../components/Context'\nimport { ReactReduxContext } from '../components/Context'\nimport type { EqualityFn } from '../types'\nimport { React } from '../utils/react'\nimport {\n  createReduxContextHook,\n  useReduxContext as useDefaultReduxContext,\n} from './useReduxContext'\n\n/**\n * The frequency of development mode checks.\n *\n * @since 8.1.0\n * @internal\n */\nexport type DevModeCheckFrequency = 'never' | 'once' | 'always'\n\n/**\n * Represents the configuration for development mode checks.\n *\n * @since 9.0.0\n * @internal\n */\nexport interface DevModeChecks {\n  /**\n   * Overrides the global stability check for the selector.\n   * - `once` - Run only the first time the selector is called.\n   * - `always` - Run every time the selector is called.\n   * - `never` - Never run the stability check.\n   *\n   * @default 'once'\n   *\n   * @since 8.1.0\n   */\n  stabilityCheck: DevModeCheckFrequency\n\n  /**\n   * Overrides the global identity function check for the selector.\n   * - `once` - Run only the first time the selector is called.\n   * - `always` - Run every time the selector is called.\n   * - `never` - Never run the identity function check.\n   *\n   * **Note**: Previously referred to as `noopCheck`.\n   *\n   * @default 'once'\n   *\n   * @since 9.0.0\n   */\n  identityFunctionCheck: DevModeCheckFrequency\n}\n\nexport interface UseSelectorOptions<Selected = unknown> {\n  equalityFn?: EqualityFn<Selected>\n\n  /**\n   * `useSelector` performs additional checks in development mode to help\n   * identify and warn about potential issues in selector behavior. This\n   * option allows you to customize the behavior of these checks per selector.\n   *\n   * @since 9.0.0\n   */\n  devModeChecks?: Partial<DevModeChecks>\n}\n\n/**\n * Represents a custom hook that allows you to extract data from the\n * Redux store state, using a selector function. The selector function\n * takes the current state as an argument and returns a part of the state\n * or some derived data. The hook also supports an optional equality\n * function or options object to customize its behavior.\n *\n * @template StateType - The specific type of state this hook operates on.\n *\n * @public\n */\nexport interface UseSelector<StateType = unknown> {\n  /**\n   * A function that takes a selector function as its first argument.\n   * The selector function is responsible for selecting a part of\n   * the Redux store's state or computing derived data.\n   *\n   * @param selector - A function that receives the current state and returns a part of the state or some derived data.\n   * @param equalityFnOrOptions - An optional equality function or options object for customizing the behavior of the selector.\n   * @returns The selected part of the state or derived data.\n   *\n   * @template TState - The specific type of state this hook operates on.\n   * @template Selected - The type of the value that the selector function will return.\n   */\n  <TState extends StateType = StateType, Selected = unknown>(\n    selector: (state: TState) => Selected,\n    equalityFnOrOptions?: EqualityFn<Selected> | UseSelectorOptions<Selected>,\n  ): Selected\n\n  /**\n   * Creates a \"pre-typed\" version of {@linkcode useSelector useSelector}\n   * where the `state` type is predefined.\n   *\n   * This allows you to set the `state` type once, eliminating the need to\n   * specify it with every {@linkcode useSelector useSelector} call.\n   *\n   * @returns A pre-typed `useSelector` with the state type already defined.\n   *\n   * @example\n   * ```ts\n   * export const useAppSelector = useSelector.withTypes<RootState>()\n   * ```\n   *\n   * @template OverrideStateType - The specific type of state this hook operates on.\n   *\n   * @since 9.1.0\n   */\n  withTypes: <\n    OverrideStateType extends StateType,\n  >() => UseSelector<OverrideStateType>\n}\n\nconst refEquality: EqualityFn<any> = (a, b) => a === b\n\n/**\n * Hook factory, which creates a `useSelector` hook bound to a given context.\n *\n * @param {React.Context} [context=ReactReduxContext] Context passed to your `<Provider>`.\n * @returns {Function} A `useSelector` hook bound to the specified context.\n */\nexport function createSelectorHook(\n  context: React.Context<ReactReduxContextValue<\n    any,\n    any\n  > | null> = ReactReduxContext,\n): UseSelector {\n  const useReduxContext =\n    context === ReactReduxContext\n      ? useDefaultReduxContext\n      : createReduxContextHook(context)\n\n  const useSelector = <TState, Selected>(\n    selector: (state: TState) => Selected,\n    equalityFnOrOptions:\n      | EqualityFn<NoInfer<Selected>>\n      | UseSelectorOptions<NoInfer<Selected>> = {},\n  ): Selected => {\n    const { equalityFn = refEquality } =\n      typeof equalityFnOrOptions === 'function'\n        ? { equalityFn: equalityFnOrOptions }\n        : equalityFnOrOptions\n    if (process.env.NODE_ENV !== 'production') {\n      if (!selector) {\n        throw new Error(`You must pass a selector to useSelector`)\n      }\n      if (typeof selector !== 'function') {\n        throw new Error(`You must pass a function as a selector to useSelector`)\n      }\n      if (typeof equalityFn !== 'function') {\n        throw new Error(\n          `You must pass a function as an equality function to useSelector`,\n        )\n      }\n    }\n\n    const reduxContext = useReduxContext()\n\n    const { store, subscription, getServerState } = reduxContext\n\n    const firstRun = React.useRef(true)\n\n    const wrappedSelector = React.useCallback<typeof selector>(\n      {\n        [selector.name](state: TState) {\n          const selected = selector(state)\n          if (process.env.NODE_ENV !== 'production') {\n            const { devModeChecks = {} } =\n              typeof equalityFnOrOptions === 'function'\n                ? {}\n                : equalityFnOrOptions\n            const { identityFunctionCheck, stabilityCheck } = reduxContext\n            const {\n              identityFunctionCheck: finalIdentityFunctionCheck,\n              stabilityCheck: finalStabilityCheck,\n            } = {\n              stabilityCheck,\n              identityFunctionCheck,\n              ...devModeChecks,\n            }\n            if (\n              finalStabilityCheck === 'always' ||\n              (finalStabilityCheck === 'once' && firstRun.current)\n            ) {\n              const toCompare = selector(state)\n              if (!equalityFn(selected, toCompare)) {\n                let stack: string | undefined = undefined\n                try {\n                  throw new Error()\n                } catch (e) {\n                  // eslint-disable-next-line no-extra-semi\n                  ;({ stack } = e as Error)\n                }\n                console.warn(\n                  'Selector ' +\n                    (selector.name || 'unknown') +\n                    ' returned a different result when called with the same parameters. This can lead to unnecessary rerenders.' +\n                    '\\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                  {\n                    state,\n                    selected,\n                    selected2: toCompare,\n                    stack,\n                  },\n                )\n              }\n            }\n            if (\n              finalIdentityFunctionCheck === 'always' ||\n              (finalIdentityFunctionCheck === 'once' && firstRun.current)\n            ) {\n              // @ts-ignore\n              if (selected === state) {\n                let stack: string | undefined = undefined\n                try {\n                  throw new Error()\n                } catch (e) {\n                  // eslint-disable-next-line no-extra-semi\n                  ;({ stack } = e as Error)\n                }\n                console.warn(\n                  'Selector ' +\n                    (selector.name || 'unknown') +\n                    ' returned the root state when called. This can lead to unnecessary rerenders.' +\n                    '\\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            if (firstRun.current) firstRun.current = false\n          }\n          return selected\n        },\n      }[selector.name],\n      [selector],\n    )\n\n    const selectedState = useSyncExternalStoreWithSelector(\n      subscription.addNestedSub,\n      store.getState,\n      getServerState || store.getState,\n      wrappedSelector,\n      equalityFn,\n    )\n\n    React.useDebugValue(selectedState)\n\n    return selectedState\n  }\n\n  Object.assign(useSelector, {\n    withTypes: () => useSelector,\n  })\n\n  return useSelector as UseSelector\n}\n\n/**\n * A hook to access the redux store's state. This hook takes a selector function\n * as an argument. The selector is called with the store state.\n *\n * This hook takes an optional equality comparison function as the second parameter\n * that allows you to customize the way the selected state is compared to determine\n * whether the component needs to be re-rendered.\n *\n * @param {Function} selector the selector function\n * @param {Function=} equalityFn the function that will be used to determine equality\n *\n * @returns {any} the selected state\n *\n * @example\n *\n * import React from 'react'\n * import { useSelector } from 'react-redux'\n *\n * export const CounterComponent = () => {\n *   const counter = useSelector(state => state.counter)\n *   return <div>{counter}</div>\n * }\n */\nexport const useSelector = /*#__PURE__*/ createSelectorHook()\n","import { connect, legacy_connect } from './components/connect'\nexport type {\n  Connect,\n  ConnectProps,\n  ConnectedProps,\n} from './components/connect'\n\nimport shallowEqual from './utils/shallowEqual'\n\nimport Provider from './components/Provider'\nimport { defaultNoopBatch } from './utils/batch'\n\nexport { ReactReduxContext } from './components/Context'\nexport type { ReactReduxContextValue } from './components/Context'\n\nexport type { ProviderProps } from './components/Provider'\n\nexport type {\n  MapDispatchToProps,\n  MapDispatchToPropsFactory,\n  MapDispatchToPropsFunction,\n  MapDispatchToPropsNonObject,\n  MapDispatchToPropsParam,\n  MapStateToProps,\n  MapStateToPropsFactory,\n  MapStateToPropsParam,\n  MergeProps,\n  Selector,\n  SelectorFactory,\n} from './connect/selectorFactory'\n\nexport { createDispatchHook, useDispatch } from './hooks/useDispatch'\nexport type { UseDispatch } from './hooks/useDispatch'\n\nexport { createSelectorHook, useSelector } from './hooks/useSelector'\nexport type { UseSelector } from './hooks/useSelector'\n\nexport { createStoreHook, useStore } from './hooks/useStore'\nexport type { UseStore } from './hooks/useStore'\n\nexport type { Subscription } from './utils/Subscription'\n\nexport * from './types'\n\n/**\n * @deprecated As of React 18, batching is enabled by default for ReactDOM and React Native.\n * This is now a no-op that immediately runs the callback.\n */\nconst batch = defaultNoopBatch\n\nexport { Provider, batch, connect, legacy_connect, shallowEqual }\n"],"mappings":"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"}