From ca4bfd32a9459b42508acdd336baf49d25e76926 Mon Sep 17 00:00:00 2001
From: Arya Emami <aryaemami59@yahoo.com>
Date: Thu, 21 Mar 2024 12:09:35 -0500
Subject: [PATCH] Run Prettier on all files

---
 .gitattributes                                |   1 +
 .github/ISSUE_TEMPLATE/bug_report.yml         |   4 +-
 .github/ISSUE_TEMPLATE/config.yml             |   6 +-
 .github/ISSUE_TEMPLATE/feature_request.yml    |   2 +-
 CODE_OF_CONDUCT.md                            |   1 -
 etc/react-redux.api.md                        | 700 +++++++++++++-----
 etc/react-redux.dt-types.api.md               | 643 ++++++++++------
 .../rr-rsc-context/app/page.module.css        |   4 +-
 src/types.ts                                  |  11 +-
 test/tsconfig.test.json                       |   2 +-
 test/typeTestHelpers.ts                       |  17 +-
 test/typetests/tsconfig.json                  |   3 +-
 tsup.config.ts                                |   2 +-
 vitest.setup.ts                               |   2 +-
 website/README.md                             |  15 +-
 website/src/pages/index.js                    |   2 +-
 website/src/theme/NotFound.js                 |  35 +-
 website/static/css/404.css                    |  50 +-
 website/static/css/codeblock.css              |   6 +-
 website/static/css/custom.css                 |   8 +-
 website/static/scripts/codeblock.js           |  48 +-
 website/static/scripts/monokaiTheme.js        |  42 +-
 website/static/scripts/sidebarScroll.js       |  17 +-
 website/versioned_docs/version-5.x/api.md     | 159 ++--
 .../version-5.x/api/Provider.md               |  93 ++-
 website/versioned_docs/version-5.x/api/api.md |  16 +-
 .../version-5.x/api/connect-advanced.md       |  27 +-
 .../versioned_docs/version-5.x/api/connect.md |  99 +--
 .../introduction/basic-tutorial.md            | 132 ++--
 .../version-5.x/introduction/quick-start.md   |  33 +-
 .../version-5.x/troubleshooting.md            |  16 +-
 ...atching-actions-with-mapDispatchToProps.md | 126 ++--
 ...ct-extracting-data-with-mapStateToProps.md | 112 ++-
 .../version-6.x/api/Provider.md               |   4 +-
 .../version-6.x/api/connect-advanced.md       |   2 +-
 .../versioned_docs/version-6.x/api/connect.md | 116 +--
 .../introduction/basic-tutorial.md            |  58 +-
 .../version-6.x/introduction/quick-start.md   |   2 +-
 .../version-6.x/troubleshooting.md            |  13 +-
 .../using-react-redux/accessing-store.md      |  18 +-
 ...atching-actions-with-mapDispatchToProps.md |  49 +-
 ...ct-extracting-data-with-mapStateToProps.md |   6 +-
 .../version-7.0/api/Provider.md               |   4 +-
 .../versioned_docs/version-7.0/api/batch.md   |  16 +-
 .../version-7.0/api/connect-advanced.md       |   2 +-
 .../versioned_docs/version-7.0/api/connect.md | 114 +--
 .../introduction/basic-tutorial.md            |  58 +-
 .../version-7.0/introduction/quick-start.md   |   2 +-
 .../version-7.0/troubleshooting.md            |  13 +-
 .../using-react-redux/accessing-store.md      |  14 +-
 ...atching-actions-with-mapDispatchToProps.md |  49 +-
 ...ct-extracting-data-with-mapStateToProps.md |   6 +-
 .../version-7.1/api/Provider.md               |   4 +-
 .../version-7.1/api/connect-advanced.md       |   2 +-
 .../versioned_docs/version-7.1/api/connect.md | 116 +--
 .../versioned_docs/version-7.1/api/hooks.md   |  33 +-
 .../introduction/basic-tutorial.md            |  58 +-
 .../version-7.1/introduction/quick-start.md   |   2 +-
 .../version-7.1/troubleshooting.md            |  13 +-
 .../using-react-redux/accessing-store.md      |  14 +-
 ...atching-actions-with-mapDispatchToProps.md |  49 +-
 ...ct-extracting-data-with-mapStateToProps.md |   6 +-
 .../using-react-redux/static-types.md         |  23 +-
 .../version-7.2/api/Provider.md               |   4 +-
 .../version-7.2/api/connect-advanced.md       |   2 +-
 .../versioned_docs/version-7.2/api/connect.md | 116 +--
 .../versioned_docs/version-7.2/api/hooks.md   |  33 +-
 .../introduction/basic-tutorial.md            |  58 +-
 .../version-7.2/introduction/quick-start.md   |   2 +-
 .../version-7.2/troubleshooting.md            |  13 +-
 ...atching-actions-with-mapDispatchToProps.md |  49 +-
 ...ct-extracting-data-with-mapStateToProps.md |   6 +-
 .../using-react-redux/static-types.md         |  23 +-
 .../version-5.x-sidebars.json                 |   4 +-
 .../version-6.x-sidebars.json                 |   4 +-
 75 files changed, 1877 insertions(+), 1737 deletions(-)
 create mode 100644 .gitattributes

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 000000000..6313b56c5
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+* text=auto eol=lf
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index ea03203a9..c815e043e 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -1,6 +1,6 @@
 name: 🐛 Bug Report
 description: Something isn't working correctly.
-body: 
+body:
   - type: markdown
     attributes:
       value: |
@@ -50,6 +50,6 @@ body:
     attributes:
       label: Did this work in previous versions of React Redux?
       options:
-      - label: "Yes"
+        - label: 'Yes'
     validations:
       required: false
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index 8cffa4e1c..28219ad1f 100644
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,5 +1,5 @@
 blank_issues_enabled: false
 contact_links:
-    - name: 🤔 Questions and Help
-      url: https://redux.js.org/introduction/getting-started#help-and-discussion
-      about: This is a bug tracker, not a support system. For usage questions, please use our support resources.
+  - name: 🤔 Questions and Help
+    url: https://redux.js.org/introduction/getting-started#help-and-discussion
+    about: This is a bug tracker, not a support system. For usage questions, please use our support resources.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
index f63190bb5..b90fe2d7f 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -1,6 +1,6 @@
 name: 👍 Feature Request
 description: I'd like React Redux to do something new.
-body: 
+body:
   - type: markdown
     attributes:
       value: |
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index a0fd0d6b5..4ead0e1da 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -11,4 +11,3 @@ Project maintainers have the right and responsibility to remove, edit, or reject
 Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
 
 This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)
-
diff --git a/etc/react-redux.api.md b/etc/react-redux.api.md
index 978c8fe91..341c55777 100644
--- a/etc/react-redux.api.md
+++ b/etc/react-redux.api.md
@@ -3,312 +3,624 @@
 > Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
 
 ```ts
-
 /// <reference types="react" />
 
-import { Action } from 'redux';
-import { AnyAction } from 'redux';
-import { unstable_batchedUpdates as batch } from 'react-dom';
-import { ClassAttributes } from 'react';
-import { ComponentClass } from 'react';
-import { ComponentType } from 'react';
-import { Context } from 'react';
-import { Dispatch } from 'redux';
-import type { NonReactStatics } from 'hoist-non-react-statics';
-import { default as React_2 } from 'react';
-import { ReactNode } from 'react';
-import { Store } from 'redux';
+import { Action } from 'redux'
+import { AnyAction } from 'redux'
+import { unstable_batchedUpdates as batch } from 'react-dom'
+import { ClassAttributes } from 'react'
+import { ComponentClass } from 'react'
+import { ComponentType } from 'react'
+import { Context } from 'react'
+import { Dispatch } from 'redux'
+import type { NonReactStatics } from 'hoist-non-react-statics'
+import { default as React_2 } from 'react'
+import { ReactNode } from 'react'
+import { Store } from 'redux'
 
 // @public (undocumented)
-export type AdvancedComponentDecorator<TProps, TOwnProps> = (component: ComponentType<TProps>) => ComponentType<TOwnProps>;
+export type AdvancedComponentDecorator<TProps, TOwnProps> = (
+  component: ComponentType<TProps>,
+) => ComponentType<TOwnProps>
 
 // @public (undocumented)
-export type AnyIfEmpty<T extends object> = keyof T extends never ? any : T;
+export type AnyIfEmpty<T extends object> = keyof T extends never ? any : T
 
 export { batch }
 
 // @public (undocumented)
 export const connect: {
-    (): InferableComponentEnhancer<DispatchProp>;
-    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultRootState>(mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>): InferableComponentEnhancerWithProps<TStateProps & DispatchProp<AnyAction>, TOwnProps>;
-    <no_state = {}, TDispatchProps = {}, TOwnProps_1 = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps_1>): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps_1>;
-    <no_state_1 = {}, TDispatchProps_1 = {}, TOwnProps_2 = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_1, TOwnProps_2>): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps_1>, TOwnProps_2>;
-    <TStateProps_1 = {}, TDispatchProps_2 = {}, TOwnProps_3 = {}, State_1 = DefaultRootState>(mapStateToProps: MapStateToPropsParam<TStateProps_1, TOwnProps_3, State_1>, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps_2, TOwnProps_3>): InferableComponentEnhancerWithProps<TStateProps_1 & TDispatchProps_2, TOwnProps_3>;
-    <TStateProps_2 = {}, TDispatchProps_3 = {}, TOwnProps_4 = {}, State_2 = DefaultRootState>(mapStateToProps: MapStateToPropsParam<TStateProps_2, TOwnProps_4, State_2>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_3, TOwnProps_4>): InferableComponentEnhancerWithProps<TStateProps_2 & ResolveThunks<TDispatchProps_3>, TOwnProps_4>;
-    <no_state_2 = {}, no_dispatch_1 = {}, TOwnProps_5 = {}, TMergedProps = {}>(mapStateToProps: null | undefined, mapDispatchToProps: null | undefined, mergeProps: MergeProps<undefined, undefined, TOwnProps_5, TMergedProps>): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps_5>;
-    <TStateProps_3 = {}, no_dispatch_2 = {}, TOwnProps_6 = {}, TMergedProps_1 = {}, State_3 = DefaultRootState>(mapStateToProps: MapStateToPropsParam<TStateProps_3, TOwnProps_6, State_3>, mapDispatchToProps: null | undefined, mergeProps: MergeProps<TStateProps_3, undefined, TOwnProps_6, TMergedProps_1>): InferableComponentEnhancerWithProps<TMergedProps_1, TOwnProps_6>;
-    <no_state_3 = {}, TDispatchProps_4 = {}, TOwnProps_7 = {}, TMergedProps_2 = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_4, TOwnProps_7>, mergeProps: MergeProps<undefined, TDispatchProps_4, TOwnProps_7, TMergedProps_2>): InferableComponentEnhancerWithProps<TMergedProps_2, TOwnProps_7>;
-    <TStateProps_4 = {}, no_dispatch_3 = {}, TOwnProps_8 = {}, State_4 = DefaultRootState>(mapStateToProps: MapStateToPropsParam<TStateProps_4, TOwnProps_8, State_4>, mapDispatchToProps: null | undefined, mergeProps: null | undefined, options: ConnectOptions<State_4, TStateProps_4, TOwnProps_8, {}>): InferableComponentEnhancerWithProps<DispatchProp<AnyAction> & TStateProps_4, TOwnProps_8>;
-    <TStateProps_5 = {}, TDispatchProps_5 = {}, TOwnProps_9 = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps_5, TOwnProps_9>, mergeProps: null | undefined, options: ConnectOptions<{}, TStateProps_5, TOwnProps_9, {}>): InferableComponentEnhancerWithProps<TDispatchProps_5, TOwnProps_9>;
-    <TStateProps_6 = {}, TDispatchProps_6 = {}, TOwnProps_10 = {}>(mapStateToProps: null | undefined, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_6, TOwnProps_10>, mergeProps: null | undefined, options: ConnectOptions<{}, TStateProps_6, TOwnProps_10, {}>): InferableComponentEnhancerWithProps<ResolveThunks<TDispatchProps_6>, TOwnProps_10>;
-    <TStateProps_7 = {}, TDispatchProps_7 = {}, TOwnProps_11 = {}, State_5 = DefaultRootState>(mapStateToProps: MapStateToPropsParam<TStateProps_7, TOwnProps_11, State_5>, mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps_7, TOwnProps_11>, mergeProps: null | undefined, options: ConnectOptions<State_5, TStateProps_7, TOwnProps_11, {}>): InferableComponentEnhancerWithProps<TStateProps_7 & TDispatchProps_7, TOwnProps_11>;
-    <TStateProps_8 = {}, TDispatchProps_8 = {}, TOwnProps_12 = {}, State_6 = DefaultRootState>(mapStateToProps: MapStateToPropsParam<TStateProps_8, TOwnProps_12, State_6>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_8, TOwnProps_12>, mergeProps: null | undefined, options: ConnectOptions<State_6, TStateProps_8, TOwnProps_12, {}>): InferableComponentEnhancerWithProps<TStateProps_8 & ResolveThunks<TDispatchProps_8>, TOwnProps_12>;
-    <TStateProps_9 = {}, TDispatchProps_9 = {}, TOwnProps_13 = {}, TMergedProps_3 = {}, State_7 = DefaultRootState>(mapStateToProps: MapStateToPropsParam<TStateProps_9, TOwnProps_13, State_7>, mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_9, TOwnProps_13>, mergeProps: MergeProps<TStateProps_9, TDispatchProps_9, TOwnProps_13, TMergedProps_3>, options?: ConnectOptions<State_7, TStateProps_9, TOwnProps_13, TMergedProps_3> | undefined): InferableComponentEnhancerWithProps<TMergedProps_3, TOwnProps_13>;
-};
-
-// @public (undocumented)
-export function connectAdvanced<S, TProps, TOwnProps, TFactoryOptions = {}>(selectorFactory: SelectorFactory<S, TProps, unknown, unknown>, { getDisplayName, methodName, shouldHandleStateChanges, forwardRef, context, ...connectOptions }?: ConnectAdvancedOptions & Partial<TFactoryOptions>): AdvancedComponentDecorator<TProps, TOwnProps & ConnectProps>;
+  (): InferableComponentEnhancer<DispatchProp>
+  <
+    TStateProps = {},
+    no_dispatch = {},
+    TOwnProps = {},
+    State = DefaultRootState,
+  >(
+    mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  ): InferableComponentEnhancerWithProps<
+    TStateProps & DispatchProp<AnyAction>,
+    TOwnProps
+  >
+  <no_state = {}, TDispatchProps = {}, TOwnProps_1 = {}>(
+    mapStateToProps: null | undefined,
+    mapDispatchToProps: MapDispatchToPropsNonObject<
+      TDispatchProps,
+      TOwnProps_1
+    >,
+  ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps_1>
+  <no_state_1 = {}, TDispatchProps_1 = {}, TOwnProps_2 = {}>(
+    mapStateToProps: null | undefined,
+    mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_1, TOwnProps_2>,
+  ): InferableComponentEnhancerWithProps<
+    ResolveThunks<TDispatchProps_1>,
+    TOwnProps_2
+  >
+  <
+    TStateProps_1 = {},
+    TDispatchProps_2 = {},
+    TOwnProps_3 = {},
+    State_1 = DefaultRootState,
+  >(
+    mapStateToProps: MapStateToPropsParam<TStateProps_1, TOwnProps_3, State_1>,
+    mapDispatchToProps: MapDispatchToPropsNonObject<
+      TDispatchProps_2,
+      TOwnProps_3
+    >,
+  ): InferableComponentEnhancerWithProps<
+    TStateProps_1 & TDispatchProps_2,
+    TOwnProps_3
+  >
+  <
+    TStateProps_2 = {},
+    TDispatchProps_3 = {},
+    TOwnProps_4 = {},
+    State_2 = DefaultRootState,
+  >(
+    mapStateToProps: MapStateToPropsParam<TStateProps_2, TOwnProps_4, State_2>,
+    mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_3, TOwnProps_4>,
+  ): InferableComponentEnhancerWithProps<
+    TStateProps_2 & ResolveThunks<TDispatchProps_3>,
+    TOwnProps_4
+  >
+  <no_state_2 = {}, no_dispatch_1 = {}, TOwnProps_5 = {}, TMergedProps = {}>(
+    mapStateToProps: null | undefined,
+    mapDispatchToProps: null | undefined,
+    mergeProps: MergeProps<undefined, undefined, TOwnProps_5, TMergedProps>,
+  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps_5>
+  <
+    TStateProps_3 = {},
+    no_dispatch_2 = {},
+    TOwnProps_6 = {},
+    TMergedProps_1 = {},
+    State_3 = DefaultRootState,
+  >(
+    mapStateToProps: MapStateToPropsParam<TStateProps_3, TOwnProps_6, State_3>,
+    mapDispatchToProps: null | undefined,
+    mergeProps: MergeProps<
+      TStateProps_3,
+      undefined,
+      TOwnProps_6,
+      TMergedProps_1
+    >,
+  ): InferableComponentEnhancerWithProps<TMergedProps_1, TOwnProps_6>
+  <
+    no_state_3 = {},
+    TDispatchProps_4 = {},
+    TOwnProps_7 = {},
+    TMergedProps_2 = {},
+  >(
+    mapStateToProps: null | undefined,
+    mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_4, TOwnProps_7>,
+    mergeProps: MergeProps<
+      undefined,
+      TDispatchProps_4,
+      TOwnProps_7,
+      TMergedProps_2
+    >,
+  ): InferableComponentEnhancerWithProps<TMergedProps_2, TOwnProps_7>
+  <
+    TStateProps_4 = {},
+    no_dispatch_3 = {},
+    TOwnProps_8 = {},
+    State_4 = DefaultRootState,
+  >(
+    mapStateToProps: MapStateToPropsParam<TStateProps_4, TOwnProps_8, State_4>,
+    mapDispatchToProps: null | undefined,
+    mergeProps: null | undefined,
+    options: ConnectOptions<State_4, TStateProps_4, TOwnProps_8, {}>,
+  ): InferableComponentEnhancerWithProps<
+    DispatchProp<AnyAction> & TStateProps_4,
+    TOwnProps_8
+  >
+  <TStateProps_5 = {}, TDispatchProps_5 = {}, TOwnProps_9 = {}>(
+    mapStateToProps: null | undefined,
+    mapDispatchToProps: MapDispatchToPropsNonObject<
+      TDispatchProps_5,
+      TOwnProps_9
+    >,
+    mergeProps: null | undefined,
+    options: ConnectOptions<{}, TStateProps_5, TOwnProps_9, {}>,
+  ): InferableComponentEnhancerWithProps<TDispatchProps_5, TOwnProps_9>
+  <TStateProps_6 = {}, TDispatchProps_6 = {}, TOwnProps_10 = {}>(
+    mapStateToProps: null | undefined,
+    mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_6, TOwnProps_10>,
+    mergeProps: null | undefined,
+    options: ConnectOptions<{}, TStateProps_6, TOwnProps_10, {}>,
+  ): InferableComponentEnhancerWithProps<
+    ResolveThunks<TDispatchProps_6>,
+    TOwnProps_10
+  >
+  <
+    TStateProps_7 = {},
+    TDispatchProps_7 = {},
+    TOwnProps_11 = {},
+    State_5 = DefaultRootState,
+  >(
+    mapStateToProps: MapStateToPropsParam<TStateProps_7, TOwnProps_11, State_5>,
+    mapDispatchToProps: MapDispatchToPropsNonObject<
+      TDispatchProps_7,
+      TOwnProps_11
+    >,
+    mergeProps: null | undefined,
+    options: ConnectOptions<State_5, TStateProps_7, TOwnProps_11, {}>,
+  ): InferableComponentEnhancerWithProps<
+    TStateProps_7 & TDispatchProps_7,
+    TOwnProps_11
+  >
+  <
+    TStateProps_8 = {},
+    TDispatchProps_8 = {},
+    TOwnProps_12 = {},
+    State_6 = DefaultRootState,
+  >(
+    mapStateToProps: MapStateToPropsParam<TStateProps_8, TOwnProps_12, State_6>,
+    mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_8, TOwnProps_12>,
+    mergeProps: null | undefined,
+    options: ConnectOptions<State_6, TStateProps_8, TOwnProps_12, {}>,
+  ): InferableComponentEnhancerWithProps<
+    TStateProps_8 & ResolveThunks<TDispatchProps_8>,
+    TOwnProps_12
+  >
+  <
+    TStateProps_9 = {},
+    TDispatchProps_9 = {},
+    TOwnProps_13 = {},
+    TMergedProps_3 = {},
+    State_7 = DefaultRootState,
+  >(
+    mapStateToProps: MapStateToPropsParam<TStateProps_9, TOwnProps_13, State_7>,
+    mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps_9, TOwnProps_13>,
+    mergeProps: MergeProps<
+      TStateProps_9,
+      TDispatchProps_9,
+      TOwnProps_13,
+      TMergedProps_3
+    >,
+    options?:
+      | ConnectOptions<State_7, TStateProps_9, TOwnProps_13, TMergedProps_3>
+      | undefined,
+  ): InferableComponentEnhancerWithProps<TMergedProps_3, TOwnProps_13>
+}
+
+// @public (undocumented)
+export function connectAdvanced<S, TProps, TOwnProps, TFactoryOptions = {}>(
+  selectorFactory: SelectorFactory<S, TProps, unknown, unknown>,
+  {
+    getDisplayName,
+    methodName,
+    shouldHandleStateChanges,
+    forwardRef,
+    context,
+    ...connectOptions
+  }?: ConnectAdvancedOptions & Partial<TFactoryOptions>,
+): AdvancedComponentDecorator<TProps, TOwnProps & ConnectProps>
 
 // @public (undocumented)
 export interface ConnectAdvancedOptions {
-    // (undocumented)
-    context?: typeof ReactReduxContext;
-    // (undocumented)
-    forwardRef?: boolean;
-    // (undocumented)
-    getDisplayName?: (name: string) => string;
-    // (undocumented)
-    methodName?: string;
-    // (undocumented)
-    pure?: boolean;
-    // (undocumented)
-    shouldHandleStateChanges?: boolean;
+  // (undocumented)
+  context?: typeof ReactReduxContext
+  // (undocumented)
+  forwardRef?: boolean
+  // (undocumented)
+  getDisplayName?: (name: string) => string
+  // (undocumented)
+  methodName?: string
+  // (undocumented)
+  pure?: boolean
+  // (undocumented)
+  shouldHandleStateChanges?: boolean
 }
 
 // @public (undocumented)
-export type ConnectedComponent<C extends ComponentType<any>, P> = ComponentType<P> & NonReactStatics<C> & {
-    WrappedComponent: C;
-};
+export type ConnectedComponent<
+  C extends ComponentType<any>,
+  P,
+> = ComponentType<P> &
+  NonReactStatics<C> & {
+    WrappedComponent: C
+  }
 
 // @public
-export type ConnectedProps<TConnector> = TConnector extends InferableComponentEnhancerWithProps<infer TInjectedProps, any> ? unknown extends TInjectedProps ? TConnector extends InferableComponentEnhancer<infer TInjectedProps> ? TInjectedProps : never : TInjectedProps : never;
+export type ConnectedProps<TConnector> =
+  TConnector extends InferableComponentEnhancerWithProps<
+    infer TInjectedProps,
+    any
+  >
+    ? unknown extends TInjectedProps
+      ? TConnector extends InferableComponentEnhancer<infer TInjectedProps>
+        ? TInjectedProps
+        : never
+      : TInjectedProps
+    : never
 
 // @public (undocumented)
 export interface ConnectProps {
-    // (undocumented)
-    context?: ReactReduxContextInstance;
-    // (undocumented)
-    reactReduxForwardedRef?: React_2.ForwardedRef<unknown>;
-    // (undocumented)
-    store?: Store;
+  // (undocumented)
+  context?: ReactReduxContextInstance
+  // (undocumented)
+  reactReduxForwardedRef?: React_2.ForwardedRef<unknown>
+  // (undocumented)
+  store?: Store
 }
 
 // @public
-export function createDispatchHook(context?: Context<ReactReduxContextValue<any, AnyAction> | null>): () => Dispatch<AnyAction>;
+export function createDispatchHook(
+  context?: Context<ReactReduxContextValue<any, AnyAction> | null>,
+): () => Dispatch<AnyAction>
 
 // @public
-export function createSelectorHook(context?: Context<ReactReduxContextValue<any, AnyAction> | null>): <TState = DefaultRootState, Selected = unknown>(selector: (state: TState) => Selected, equalityFn?: EqualityFn<Selected>) => Selected;
+export function createSelectorHook(
+  context?: Context<ReactReduxContextValue<any, AnyAction> | null>,
+): <TState = DefaultRootState, Selected = unknown>(
+  selector: (state: TState) => Selected,
+  equalityFn?: EqualityFn<Selected>,
+) => Selected
 
 // @public
-export function createStoreHook(context?: Context<ReactReduxContextValue<any, AnyAction> | null>): () => Store<any, AnyAction>;
+export function createStoreHook(
+  context?: Context<ReactReduxContextValue<any, AnyAction> | null>,
+): () => Store<any, AnyAction>
 
 // @public
-export interface DefaultRootState {
-}
+export interface DefaultRootState {}
 
 // @public (undocumented)
 export interface DispatchProp<A extends Action = AnyAction> {
-    // (undocumented)
-    dispatch: Dispatch<A>;
+  // (undocumented)
+  dispatch: Dispatch<A>
 }
 
 // @public (undocumented)
-export type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit_2<T, K> : never;
+export type DistributiveOmit<T, K extends keyof T> = T extends unknown
+  ? Omit_2<T, K>
+  : never
 
 // @public (undocumented)
-export type EqualityFn<T> = (a: T | undefined, b: T | undefined) => boolean;
+export type EqualityFn<T> = (a: T | undefined, b: T | undefined) => boolean
 
 // @public (undocumented)
-export type FixTypeLater = any;
+export type FixTypeLater = any
 
 // @public (undocumented)
-export type GetProps<C> = C extends ComponentType<infer P> ? C extends ComponentClass<P> ? ClassAttributes<InstanceType<C>> & P : P : never;
+export type GetProps<C> =
+  C extends ComponentType<infer P>
+    ? C extends ComponentClass<P>
+      ? ClassAttributes<InstanceType<C>> & P
+      : P
+    : never
 
 // @public (undocumented)
-export type HandleThunkActionCreator<TActionCreator> = TActionCreator extends (...args: any[]) => any ? InferThunkActionCreatorType<TActionCreator> : TActionCreator;
+export type HandleThunkActionCreator<TActionCreator> = TActionCreator extends (
+  ...args: any[]
+) => any
+  ? InferThunkActionCreatorType<TActionCreator>
+  : TActionCreator
 
 // @public (undocumented)
-export type InferableComponentEnhancer<TInjectedProps> = InferableComponentEnhancerWithProps<TInjectedProps, {}>;
+export type InferableComponentEnhancer<TInjectedProps> =
+  InferableComponentEnhancerWithProps<TInjectedProps, {}>
 
 // @public (undocumented)
-export type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> = <C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>>(component: C) => ConnectedComponent<C, DistributiveOmit<GetProps<C>, keyof Shared<TInjectedProps, GetProps<C>>> & TNeedsProps>;
+export type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> = <
+  C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>,
+>(
+  component: C,
+) => ConnectedComponent<
+  C,
+  DistributiveOmit<GetProps<C>, keyof Shared<TInjectedProps, GetProps<C>>> &
+    TNeedsProps
+>
 
 // @public (undocumented)
-export type InferThunkActionCreatorType<TActionCreator extends (...args: any[]) => any> = TActionCreator extends (...args: infer TParams) => (...args: any[]) => infer TReturn ? (...args: TParams) => TReturn : TActionCreator;
+export type InferThunkActionCreatorType<
+  TActionCreator extends (...args: any[]) => any,
+> = TActionCreator extends (
+  ...args: infer TParams
+) => (...args: any[]) => infer TReturn
+  ? (...args: TParams) => TReturn
+  : TActionCreator
 
 // @public (undocumented)
-export type MapDispatchToProps<TDispatchProps, TOwnProps> = MapDispatchToPropsFunction<TDispatchProps, TOwnProps> | TDispatchProps;
+export type MapDispatchToProps<TDispatchProps, TOwnProps> =
+  | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>
+  | TDispatchProps
 
 // @public (undocumented)
-export type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> = (dispatch: Dispatch<Action>, ownProps: TOwnProps) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
+export type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> = (
+  dispatch: Dispatch<Action>,
+  ownProps: TOwnProps,
+) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>
 
 // @public (undocumented)
-export type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> = (dispatch: Dispatch<Action>, ownProps: TOwnProps) => TDispatchProps;
+export type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> = (
+  dispatch: Dispatch<Action>,
+  ownProps: TOwnProps,
+) => TDispatchProps
 
 // @public (undocumented)
-export type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
+export type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> =
+  | MapDispatchToPropsFactory<TDispatchProps, TOwnProps>
+  | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>
 
 // @public (undocumented)
-export type MapDispatchToPropsParam<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToProps<TDispatchProps, TOwnProps>;
+export type MapDispatchToPropsParam<TDispatchProps, TOwnProps> =
+  | MapDispatchToPropsFactory<TDispatchProps, TOwnProps>
+  | MapDispatchToProps<TDispatchProps, TOwnProps>
 
 // @public (undocumented)
-export type MapStateToProps<TStateProps, TOwnProps, State = DefaultRootState> = (state: State, ownProps: TOwnProps) => TStateProps;
+export type MapStateToProps<
+  TStateProps,
+  TOwnProps,
+  State = DefaultRootState,
+> = (state: State, ownProps: TOwnProps) => TStateProps
 
 // @public (undocumented)
-export type MapStateToPropsFactory<TStateProps, TOwnProps, State = DefaultRootState> = (initialState: State, ownProps: TOwnProps) => MapStateToProps<TStateProps, TOwnProps, State>;
+export type MapStateToPropsFactory<
+  TStateProps,
+  TOwnProps,
+  State = DefaultRootState,
+> = (
+  initialState: State,
+  ownProps: TOwnProps,
+) => MapStateToProps<TStateProps, TOwnProps, State>
 
 // @public (undocumented)
-export type MapStateToPropsParam<TStateProps, TOwnProps, State = DefaultRootState> = MapStateToPropsFactory<TStateProps, TOwnProps, State> | MapStateToProps<TStateProps, TOwnProps, State> | null | undefined;
+export type MapStateToPropsParam<
+  TStateProps,
+  TOwnProps,
+  State = DefaultRootState,
+> =
+  | MapStateToPropsFactory<TStateProps, TOwnProps, State>
+  | MapStateToProps<TStateProps, TOwnProps, State>
+  | null
+  | undefined
 
 // @public
 export type Matching<InjectedProps, DecorationTargetProps> = {
-    [P in keyof DecorationTargetProps]: P extends keyof InjectedProps ? InjectedProps[P] extends DecorationTargetProps[P] ? DecorationTargetProps[P] : InjectedProps[P] : DecorationTargetProps[P];
-};
+  [P in keyof DecorationTargetProps]: P extends keyof InjectedProps
+    ? InjectedProps[P] extends DecorationTargetProps[P]
+      ? DecorationTargetProps[P]
+      : InjectedProps[P]
+    : DecorationTargetProps[P]
+}
 
 // @public (undocumented)
-export type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> = (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps) => TMergedProps;
+export type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> = (
+  stateProps: TStateProps,
+  dispatchProps: TDispatchProps,
+  ownProps: TOwnProps,
+) => TMergedProps
 
 // @public (undocumented)
-type Omit_2<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type Omit_2<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 export { Omit_2 as Omit }
 
 // @public (undocumented)
-export function Provider({ store, context, children }: ProviderProps): JSX.Element;
+export function Provider({
+  store,
+  context,
+  children,
+}: ProviderProps): JSX.Element
 
 // @public (undocumented)
 export interface ProviderProps<A extends Action = AnyAction> {
-    // (undocumented)
-    children: ReactNode;
-    context?: Context<ReactReduxContextValue>;
-    store: Store<FixTypeLater, A>;
+  // (undocumented)
+  children: ReactNode
+  context?: Context<ReactReduxContextValue>
+  store: Store<FixTypeLater, A>
 }
 
 // @public (undocumented)
-export const ReactReduxContext: React_2.Context<ReactReduxContextValue<any, AnyAction> | null>;
+export const ReactReduxContext: React_2.Context<ReactReduxContextValue<
+  any,
+  AnyAction
+> | null>
 
 // @public (undocumented)
-export interface ReactReduxContextValue<SS = FixTypeLater, A extends Action = AnyAction> {
-    // (undocumented)
-    store: Store<SS, A>;
-    // (undocumented)
-    subscription: Subscription;
+export interface ReactReduxContextValue<
+  SS = FixTypeLater,
+  A extends Action = AnyAction,
+> {
+  // (undocumented)
+  store: Store<SS, A>
+  // (undocumented)
+  subscription: Subscription
 }
 
 // @public (undocumented)
-export type ResolveArrayThunks<TDispatchProps extends ReadonlyArray<any>> = TDispatchProps extends [
-infer A1,
-infer A2,
-infer A3,
-infer A4,
-infer A5,
-infer A6,
-infer A7,
-infer A8,
-infer A9
-] ? [
-HandleThunkActionCreator<A1>,
-HandleThunkActionCreator<A2>,
-HandleThunkActionCreator<A3>,
-HandleThunkActionCreator<A4>,
-HandleThunkActionCreator<A5>,
-HandleThunkActionCreator<A6>,
-HandleThunkActionCreator<A7>,
-HandleThunkActionCreator<A8>,
-HandleThunkActionCreator<A9>
-] : TDispatchProps extends [
-infer A1,
-infer A2,
-infer A3,
-infer A4,
-infer A5,
-infer A6,
-infer A7,
-infer A8
-] ? [
-HandleThunkActionCreator<A1>,
-HandleThunkActionCreator<A2>,
-HandleThunkActionCreator<A3>,
-HandleThunkActionCreator<A4>,
-HandleThunkActionCreator<A5>,
-HandleThunkActionCreator<A6>,
-HandleThunkActionCreator<A7>,
-HandleThunkActionCreator<A8>
-] : TDispatchProps extends [
-infer A1,
-infer A2,
-infer A3,
-infer A4,
-infer A5,
-infer A6,
-infer A7
-] ? [
-HandleThunkActionCreator<A1>,
-HandleThunkActionCreator<A2>,
-HandleThunkActionCreator<A3>,
-HandleThunkActionCreator<A4>,
-HandleThunkActionCreator<A5>,
-HandleThunkActionCreator<A6>,
-HandleThunkActionCreator<A7>
-] : TDispatchProps extends [
-infer A1,
-infer A2,
-infer A3,
-infer A4,
-infer A5,
-infer A6
-] ? [
-HandleThunkActionCreator<A1>,
-HandleThunkActionCreator<A2>,
-HandleThunkActionCreator<A3>,
-HandleThunkActionCreator<A4>,
-HandleThunkActionCreator<A5>,
-HandleThunkActionCreator<A6>
-] : TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5] ? [
-HandleThunkActionCreator<A1>,
-HandleThunkActionCreator<A2>,
-HandleThunkActionCreator<A3>,
-HandleThunkActionCreator<A4>,
-HandleThunkActionCreator<A5>
-] : TDispatchProps extends [infer A1, infer A2, infer A3, infer A4] ? [
-HandleThunkActionCreator<A1>,
-HandleThunkActionCreator<A2>,
-HandleThunkActionCreator<A3>,
-HandleThunkActionCreator<A4>
-] : TDispatchProps extends [infer A1, infer A2, infer A3] ? [
-HandleThunkActionCreator<A1>,
-HandleThunkActionCreator<A2>,
-HandleThunkActionCreator<A3>
-] : TDispatchProps extends [infer A1, infer A2] ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>] : TDispatchProps extends [infer A1] ? [HandleThunkActionCreator<A1>] : TDispatchProps extends Array<infer A> ? Array<HandleThunkActionCreator<A>> : TDispatchProps extends ReadonlyArray<infer A> ? ReadonlyArray<HandleThunkActionCreator<A>> : never;
+export type ResolveArrayThunks<TDispatchProps extends ReadonlyArray<any>> =
+  TDispatchProps extends [
+    infer A1,
+    infer A2,
+    infer A3,
+    infer A4,
+    infer A5,
+    infer A6,
+    infer A7,
+    infer A8,
+    infer A9,
+  ]
+    ? [
+        HandleThunkActionCreator<A1>,
+        HandleThunkActionCreator<A2>,
+        HandleThunkActionCreator<A3>,
+        HandleThunkActionCreator<A4>,
+        HandleThunkActionCreator<A5>,
+        HandleThunkActionCreator<A6>,
+        HandleThunkActionCreator<A7>,
+        HandleThunkActionCreator<A8>,
+        HandleThunkActionCreator<A9>,
+      ]
+    : TDispatchProps extends [
+          infer A1,
+          infer A2,
+          infer A3,
+          infer A4,
+          infer A5,
+          infer A6,
+          infer A7,
+          infer A8,
+        ]
+      ? [
+          HandleThunkActionCreator<A1>,
+          HandleThunkActionCreator<A2>,
+          HandleThunkActionCreator<A3>,
+          HandleThunkActionCreator<A4>,
+          HandleThunkActionCreator<A5>,
+          HandleThunkActionCreator<A6>,
+          HandleThunkActionCreator<A7>,
+          HandleThunkActionCreator<A8>,
+        ]
+      : TDispatchProps extends [
+            infer A1,
+            infer A2,
+            infer A3,
+            infer A4,
+            infer A5,
+            infer A6,
+            infer A7,
+          ]
+        ? [
+            HandleThunkActionCreator<A1>,
+            HandleThunkActionCreator<A2>,
+            HandleThunkActionCreator<A3>,
+            HandleThunkActionCreator<A4>,
+            HandleThunkActionCreator<A5>,
+            HandleThunkActionCreator<A6>,
+            HandleThunkActionCreator<A7>,
+          ]
+        : TDispatchProps extends [
+              infer A1,
+              infer A2,
+              infer A3,
+              infer A4,
+              infer A5,
+              infer A6,
+            ]
+          ? [
+              HandleThunkActionCreator<A1>,
+              HandleThunkActionCreator<A2>,
+              HandleThunkActionCreator<A3>,
+              HandleThunkActionCreator<A4>,
+              HandleThunkActionCreator<A5>,
+              HandleThunkActionCreator<A6>,
+            ]
+          : TDispatchProps extends [
+                infer A1,
+                infer A2,
+                infer A3,
+                infer A4,
+                infer A5,
+              ]
+            ? [
+                HandleThunkActionCreator<A1>,
+                HandleThunkActionCreator<A2>,
+                HandleThunkActionCreator<A3>,
+                HandleThunkActionCreator<A4>,
+                HandleThunkActionCreator<A5>,
+              ]
+            : TDispatchProps extends [infer A1, infer A2, infer A3, infer A4]
+              ? [
+                  HandleThunkActionCreator<A1>,
+                  HandleThunkActionCreator<A2>,
+                  HandleThunkActionCreator<A3>,
+                  HandleThunkActionCreator<A4>,
+                ]
+              : TDispatchProps extends [infer A1, infer A2, infer A3]
+                ? [
+                    HandleThunkActionCreator<A1>,
+                    HandleThunkActionCreator<A2>,
+                    HandleThunkActionCreator<A3>,
+                  ]
+                : TDispatchProps extends [infer A1, infer A2]
+                  ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>]
+                  : TDispatchProps extends [infer A1]
+                    ? [HandleThunkActionCreator<A1>]
+                    : TDispatchProps extends Array<infer A>
+                      ? Array<HandleThunkActionCreator<A>>
+                      : TDispatchProps extends ReadonlyArray<infer A>
+                        ? ReadonlyArray<HandleThunkActionCreator<A>>
+                        : never
 
 // @public (undocumented)
 export type ResolveThunks<TDispatchProps> = TDispatchProps extends {
-    [key: string]: any;
-} ? {
-    [C in keyof TDispatchProps]: HandleThunkActionCreator<TDispatchProps[C]>;
-} : TDispatchProps;
+  [key: string]: any
+}
+  ? {
+      [C in keyof TDispatchProps]: HandleThunkActionCreator<TDispatchProps[C]>
+    }
+  : TDispatchProps
 
 // @public (undocumented)
-export type RootStateOrAny = AnyIfEmpty<DefaultRootState>;
+export type RootStateOrAny = AnyIfEmpty<DefaultRootState>
 
 // @public (undocumented)
-export type Selector<S, TProps, TOwnProps = null> = TOwnProps extends null | undefined ? (state: S) => TProps : (state: S, ownProps: TOwnProps) => TProps;
+export type Selector<S, TProps, TOwnProps = null> = TOwnProps extends
+  | null
+  | undefined
+  ? (state: S) => TProps
+  : (state: S, ownProps: TOwnProps) => TProps
 
 // @public (undocumented)
-export type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> = (dispatch: Dispatch<Action>, factoryOptions: TFactoryOptions) => Selector<S, TProps, TOwnProps>;
+export type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> = (
+  dispatch: Dispatch<Action>,
+  factoryOptions: TFactoryOptions,
+) => Selector<S, TProps, TOwnProps>
 
 // @public (undocumented)
-export function shallowEqual(objA: any, objB: any): boolean;
+export function shallowEqual(objA: any, objB: any): boolean
 
 // @public
 export type Shared<InjectedProps, DecorationTargetProps> = {
-    [P in Extract<keyof InjectedProps, keyof DecorationTargetProps>]?: InjectedProps[P] extends DecorationTargetProps[P] ? DecorationTargetProps[P] : never;
-};
+  [P in Extract<
+    keyof InjectedProps,
+    keyof DecorationTargetProps
+  >]?: InjectedProps[P] extends DecorationTargetProps[P]
+    ? DecorationTargetProps[P]
+    : never
+}
 
 // @public
 export interface TypedUseSelectorHook<TState> {
-    // (undocumented)
-    <TSelected>(selector: (state: TState) => TSelected, equalityFn?: (left: TSelected, right: TSelected) => boolean): TSelected;
+  // (undocumented)
+  <TSelected>(
+    selector: (state: TState) => TSelected,
+    equalityFn?: (left: TSelected, right: TSelected) => boolean,
+  ): TSelected
 }
 
 // @public
-export const useDispatch: () => Dispatch<AnyAction>;
+export const useDispatch: () => Dispatch<AnyAction>
 
 // @public
-export const useSelector: <TState = DefaultRootState, Selected = unknown>(selector: (state: TState) => Selected, equalityFn?: EqualityFn<Selected> | undefined) => Selected;
+export const useSelector: <TState = DefaultRootState, Selected = unknown>(
+  selector: (state: TState) => Selected,
+  equalityFn?: EqualityFn<Selected> | undefined,
+) => Selected
 
 // @public
-export const useStore: () => Store<any, AnyAction>;
+export const useStore: () => Store<any, AnyAction>
 
 // (No @packageDocumentation comment for this package)
-
 ```
diff --git a/etc/react-redux.dt-types.api.md b/etc/react-redux.dt-types.api.md
index 418d1175d..6403e9eba 100644
--- a/etc/react-redux.dt-types.api.md
+++ b/etc/react-redux.dt-types.api.md
@@ -3,405 +3,598 @@
 > Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
 
 ```ts
-
-import { Action } from 'redux';
-import { AnyAction } from 'redux';
-import { ClassAttributes } from 'react';
-import { Component } from 'react';
-import { ComponentClass } from 'react';
-import { ComponentType } from 'react';
-import { Context } from 'react';
-import { Dispatch } from 'redux';
-import hoistNonReactStatics = require('hoist-non-react-statics');
-import { NamedExoticComponent } from 'react';
-import { Store } from 'redux';
+import { Action } from 'redux'
+import { AnyAction } from 'redux'
+import { ClassAttributes } from 'react'
+import { Component } from 'react'
+import { ComponentClass } from 'react'
+import { ComponentType } from 'react'
+import { Context } from 'react'
+import { Dispatch } from 'redux'
+import hoistNonReactStatics = require('hoist-non-react-statics')
+import { NamedExoticComponent } from 'react'
+import { Store } from 'redux'
 
 // @public (undocumented)
-export type AdvancedComponentDecorator<TProps, TOwnProps> =
-(component: ComponentType<TProps>) => NamedExoticComponent<TOwnProps>;
+export type AdvancedComponentDecorator<TProps, TOwnProps> = (
+  component: ComponentType<TProps>,
+) => NamedExoticComponent<TOwnProps>
 
 // @public (undocumented)
-export type AnyIfEmpty<T extends object> = keyof T extends never ? any : T;
+export type AnyIfEmpty<T extends object> = keyof T extends never ? any : T
 
 // @public
-export function batch(cb: () => void): void;
+export function batch(cb: () => void): void
 
 // @public
 export interface Connect<DefaultState = DefaultRootState> {
-    // tslint:disable:no-unnecessary-generics
-    // (undocumented)
-    (): InferableComponentEnhancer<DispatchProp>;
+  // tslint:disable:no-unnecessary-generics
+  // (undocumented)
+  (): InferableComponentEnhancer<DispatchProp>
 
-    // (undocumented)
-    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(
-    mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>
-    ): InferableComponentEnhancerWithProps<TStateProps & DispatchProp, TOwnProps>;
+  // (undocumented)
+  <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(
+    mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
+  ): InferableComponentEnhancerWithProps<TStateProps & DispatchProp, TOwnProps>
 
-    // (undocumented)
-    <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
+  // (undocumented)
+  <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
     mapStateToProps: null | undefined,
-    mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>;
+    mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>,
+  ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>
 
-    // (undocumented)
-    <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
+  // (undocumented)
+  <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
     mapStateToProps: null | undefined,
     mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
-    ): InferableComponentEnhancerWithProps<
+  ): InferableComponentEnhancerWithProps<
     ResolveThunks<TDispatchProps>,
     TOwnProps
-    >;
+  >
 
-    // (undocumented)
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(
+  // (undocumented)
+  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(
     mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-    mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>;
+    mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>,
+  ): InferableComponentEnhancerWithProps<
+    TStateProps & TDispatchProps,
+    TOwnProps
+  >
 
-    // (undocumented)
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(
+  // (undocumented)
+  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(
     mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
     mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
-    ): InferableComponentEnhancerWithProps<
+  ): InferableComponentEnhancerWithProps<
     TStateProps & ResolveThunks<TDispatchProps>,
     TOwnProps
-    >;
+  >
 
-    // (undocumented)
-    <no_state = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}>(
+  // (undocumented)
+  <no_state = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}>(
     mapStateToProps: null | undefined,
     mapDispatchToProps: null | undefined,
     mergeProps: MergeProps<undefined, undefined, TOwnProps, TMergedProps>,
-    ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
-
-    // (undocumented)
-    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}, State = DefaultState>(
+  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
+
+  // (undocumented)
+  <
+    TStateProps = {},
+    no_dispatch = {},
+    TOwnProps = {},
+    TMergedProps = {},
+    State = DefaultState,
+  >(
     mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
     mapDispatchToProps: null | undefined,
     mergeProps: MergeProps<TStateProps, undefined, TOwnProps, TMergedProps>,
-    ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
+  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
 
-    // (undocumented)
-    <no_state = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}>(
+  // (undocumented)
+  <no_state = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}>(
     mapStateToProps: null | undefined,
     mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
     mergeProps: MergeProps<undefined, TDispatchProps, TOwnProps, TMergedProps>,
-    ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
+  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
 
-    // (undocumented)
-    <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(
+  // (undocumented)
+  <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = DefaultState>(
     mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
     mapDispatchToProps: null | undefined,
     mergeProps: null | undefined,
-    options: Options<State, TStateProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<DispatchProp & TStateProps, TOwnProps>;
+    options: Options<State, TStateProps, TOwnProps>,
+  ): InferableComponentEnhancerWithProps<DispatchProp & TStateProps, TOwnProps>
 
-    // (undocumented)
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(
+  // (undocumented)
+  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(
     mapStateToProps: null | undefined,
     mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>,
     mergeProps: null | undefined,
-    options: Options<{}, TStateProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>;
+    options: Options<{}, TStateProps, TOwnProps>,
+  ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>
 
-    // (undocumented)
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(
+  // (undocumented)
+  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}>(
     mapStateToProps: null | undefined,
     mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
     mergeProps: null | undefined,
-    options: Options<{}, TStateProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<
+    options: Options<{}, TStateProps, TOwnProps>,
+  ): InferableComponentEnhancerWithProps<
     ResolveThunks<TDispatchProps>,
     TOwnProps
-    >;
+  >
 
-    // (undocumented)
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(
+  // (undocumented)
+  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(
     mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
     mapDispatchToProps: MapDispatchToPropsNonObject<TDispatchProps, TOwnProps>,
     mergeProps: null | undefined,
-    options: Options<State, TStateProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>;
+    options: Options<State, TStateProps, TOwnProps>,
+  ): InferableComponentEnhancerWithProps<
+    TStateProps & TDispatchProps,
+    TOwnProps
+  >
 
-    // (undocumented)
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(
+  // (undocumented)
+  <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = DefaultState>(
     mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
     mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
     mergeProps: null | undefined,
-    options: Options<State, TStateProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<
+    options: Options<State, TStateProps, TOwnProps>,
+  ): InferableComponentEnhancerWithProps<
     TStateProps & ResolveThunks<TDispatchProps>,
     TOwnProps
-    >;
-
-    // (undocumented)
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}, State = DefaultState>(
+  >
+
+  // (undocumented)
+  <
+    TStateProps = {},
+    TDispatchProps = {},
+    TOwnProps = {},
+    TMergedProps = {},
+    State = DefaultState,
+  >(
     mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
     mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
-    mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,
-    options?: Options<State, TStateProps, TOwnProps, TMergedProps>
-    ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
-    // tslint:enable:no-unnecessary-generics
+    mergeProps: MergeProps<
+      TStateProps,
+      TDispatchProps,
+      TOwnProps,
+      TMergedProps
+    >,
+    options?: Options<State, TStateProps, TOwnProps, TMergedProps>,
+  ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>
+  // tslint:enable:no-unnecessary-generics
 }
 
 // @public
-export const connect: Connect;
+export const connect: Connect
 
 // @public
 export function connectAdvanced<S, TProps, TOwnProps, TFactoryOptions = {}>(
-// tslint:disable-next-line no-unnecessary-generics
-selectorFactory: SelectorFactory<S, TProps, TOwnProps, TFactoryOptions>,
-connectOptions?: ConnectOptions & TFactoryOptions
-): AdvancedComponentDecorator<TProps, TOwnProps>;
+  // tslint:disable-next-line no-unnecessary-generics
+  selectorFactory: SelectorFactory<S, TProps, TOwnProps, TFactoryOptions>,
+  connectOptions?: ConnectOptions & TFactoryOptions,
+): AdvancedComponentDecorator<TProps, TOwnProps>
 
 // @public (undocumented)
 export type ConnectedComponent<
-C extends ComponentType<any>,
-P
-> = NamedExoticComponent<JSX.LibraryManagedAttributes<C, P>> & hoistNonReactStatics.NonReactStatics<C> & {
-    WrappedComponent: C;
-};
+  C extends ComponentType<any>,
+  P,
+> = NamedExoticComponent<JSX.LibraryManagedAttributes<C, P>> &
+  hoistNonReactStatics.NonReactStatics<C> & {
+    WrappedComponent: C
+  }
 
 // @public
 export type ConnectedProps<TConnector> =
-TConnector extends InferableComponentEnhancerWithProps<infer TInjectedProps, any>
-? unknown extends TInjectedProps
-? TConnector extends InferableComponentEnhancer<infer TInjectedProps>
-? TInjectedProps
-: never
-: TInjectedProps
-: never;
+  TConnector extends InferableComponentEnhancerWithProps<
+    infer TInjectedProps,
+    any
+  >
+    ? unknown extends TInjectedProps
+      ? TConnector extends InferableComponentEnhancer<infer TInjectedProps>
+        ? TInjectedProps
+        : never
+      : TInjectedProps
+    : never
 
 // @public (undocumented)
 export interface ConnectOptions {
-    context?: Context<ReactReduxContextValue>;
-    getDisplayName?: (componentName: string) => string;
-    methodName?: string;
-    renderCountProp?: string;
-    shouldHandleStateChanges?: boolean;
-    storeKey?: string;
-    // @deprecated (undocumented)
-    withRef?: boolean;
+  context?: Context<ReactReduxContextValue>
+  getDisplayName?: (componentName: string) => string
+  methodName?: string
+  renderCountProp?: string
+  shouldHandleStateChanges?: boolean
+  storeKey?: string
+  // @deprecated (undocumented)
+  withRef?: boolean
 }
 
 // @public
-export function createDispatchHook<S = RootStateOrAny, A extends Action = AnyAction>(
-context?: Context<ReactReduxContextValue<S, A>>,
-): () => Dispatch<A>;
+export function createDispatchHook<
+  S = RootStateOrAny,
+  A extends Action = AnyAction,
+>(context?: Context<ReactReduxContextValue<S, A>>): () => Dispatch<A>
 
 // @public
-export function createSelectorHook<S = RootStateOrAny, A extends Action = AnyAction>(
-context?: Context<ReactReduxContextValue<S, A>>,
+export function createSelectorHook<
+  S = RootStateOrAny,
+  A extends Action = AnyAction,
+>(
+  context?: Context<ReactReduxContextValue<S, A>>,
 ): <Selected extends unknown>(
-selector: (state: S) => Selected,
-equalityFn?: (previous: Selected, next: Selected) => boolean,
-) => Selected;
+  selector: (state: S) => Selected,
+  equalityFn?: (previous: Selected, next: Selected) => boolean,
+) => Selected
 
 // @public
-export function createStoreHook<S = RootStateOrAny, A extends Action = AnyAction>(
-context?: Context<ReactReduxContextValue<S, A>>,
-): () => Store<S, A>;
+export function createStoreHook<
+  S = RootStateOrAny,
+  A extends Action = AnyAction,
+>(context?: Context<ReactReduxContextValue<S, A>>): () => Store<S, A>
 
 // @public
 export interface DefaultRootState {}
 
 // @public (undocumented)
 export interface DispatchProp<A extends Action = AnyAction> {
-    // (undocumented)
-    dispatch: Dispatch<A>;
+  // (undocumented)
+  dispatch: Dispatch<A>
 }
 
 // @public (undocumented)
-export type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit_2<T, K> : never;
+export type DistributiveOmit<T, K extends keyof T> = T extends unknown
+  ? Omit_2<T, K>
+  : never
 
 // @public (undocumented)
-export type GetProps<C> = C extends ComponentType<infer P>
-? C extends ComponentClass<P> ? ClassAttributes<InstanceType<C>> & P : P
-: never;
+export type GetProps<C> =
+  C extends ComponentType<infer P>
+    ? C extends ComponentClass<P>
+      ? ClassAttributes<InstanceType<C>> & P
+      : P
+    : never
 
 // @public (undocumented)
-export type HandleThunkActionCreator<TActionCreator> =
-TActionCreator extends (...args: any[]) => any
-? InferThunkActionCreatorType<TActionCreator>
-: TActionCreator;
+export type HandleThunkActionCreator<TActionCreator> = TActionCreator extends (
+  ...args: any[]
+) => any
+  ? InferThunkActionCreatorType<TActionCreator>
+  : TActionCreator
 
 // @public (undocumented)
 export type InferableComponentEnhancer<TInjectedProps> =
-InferableComponentEnhancerWithProps<TInjectedProps, {}>;
+  InferableComponentEnhancerWithProps<TInjectedProps, {}>
 
 // @public (undocumented)
-export type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> =
-<C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>>(
-component: C
-) => ConnectedComponent<C, DistributiveOmit<GetProps<C>, keyof Shared<TInjectedProps, GetProps<C>>> & TNeedsProps>;
+export type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> = <
+  C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>,
+>(
+  component: C,
+) => ConnectedComponent<
+  C,
+  DistributiveOmit<GetProps<C>, keyof Shared<TInjectedProps, GetProps<C>>> &
+    TNeedsProps
+>
 
 // @public (undocumented)
-export type InferThunkActionCreatorType<TActionCreator extends (...args: any[]) => any> =
-TActionCreator extends (...args: infer TParams) => (...args: any[]) => infer TReturn
-? (...args: TParams) => TReturn
-: TActionCreator;
+export type InferThunkActionCreatorType<
+  TActionCreator extends (...args: any[]) => any,
+> = TActionCreator extends (
+  ...args: infer TParams
+) => (...args: any[]) => infer TReturn
+  ? (...args: TParams) => TReturn
+  : TActionCreator
 
 // @public (undocumented)
 export type MapDispatchToProps<TDispatchProps, TOwnProps> =
-MapDispatchToPropsFunction<TDispatchProps, TOwnProps> | TDispatchProps;
+  | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>
+  | TDispatchProps
 
 // @public (undocumented)
-export type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> =
-(dispatch: Dispatch<Action>, ownProps: TOwnProps) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
+export type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> = (
+  dispatch: Dispatch<Action>,
+  ownProps: TOwnProps,
+) => MapDispatchToPropsFunction<TDispatchProps, TOwnProps>
 
 // @public (undocumented)
-export type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> =
-(dispatch: Dispatch<Action>, ownProps: TOwnProps) => TDispatchProps;
+export type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> = (
+  dispatch: Dispatch<Action>,
+  ownProps: TOwnProps,
+) => TDispatchProps
 
 // @public (undocumented)
-export type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>;
+export type MapDispatchToPropsNonObject<TDispatchProps, TOwnProps> =
+  | MapDispatchToPropsFactory<TDispatchProps, TOwnProps>
+  | MapDispatchToPropsFunction<TDispatchProps, TOwnProps>
 
 // @public (undocumented)
-export type MapDispatchToPropsParam<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToProps<TDispatchProps, TOwnProps>;
+export type MapDispatchToPropsParam<TDispatchProps, TOwnProps> =
+  | MapDispatchToPropsFactory<TDispatchProps, TOwnProps>
+  | MapDispatchToProps<TDispatchProps, TOwnProps>
 
 // @public (undocumented)
-export type MapStateToProps<TStateProps, TOwnProps, State = DefaultRootState> =
-(state: State, ownProps: TOwnProps) => TStateProps;
+export type MapStateToProps<
+  TStateProps,
+  TOwnProps,
+  State = DefaultRootState,
+> = (state: State, ownProps: TOwnProps) => TStateProps
 
 // @public (undocumented)
-export type MapStateToPropsFactory<TStateProps, TOwnProps, State = DefaultRootState> =
-(initialState: State, ownProps: TOwnProps) => MapStateToProps<TStateProps, TOwnProps, State>;
+export type MapStateToPropsFactory<
+  TStateProps,
+  TOwnProps,
+  State = DefaultRootState,
+> = (
+  initialState: State,
+  ownProps: TOwnProps,
+) => MapStateToProps<TStateProps, TOwnProps, State>
 
 // @public (undocumented)
-export type MapStateToPropsParam<TStateProps, TOwnProps, State = DefaultRootState> =
-MapStateToPropsFactory<TStateProps, TOwnProps, State> | MapStateToProps<TStateProps, TOwnProps, State> | null | undefined;
+export type MapStateToPropsParam<
+  TStateProps,
+  TOwnProps,
+  State = DefaultRootState,
+> =
+  | MapStateToPropsFactory<TStateProps, TOwnProps, State>
+  | MapStateToProps<TStateProps, TOwnProps, State>
+  | null
+  | undefined
 
 // @public
 export type Matching<InjectedProps, DecorationTargetProps> = {
-    [P in keyof DecorationTargetProps]: P extends keyof InjectedProps
+  [P in keyof DecorationTargetProps]: P extends keyof InjectedProps
     ? InjectedProps[P] extends DecorationTargetProps[P]
-    ? DecorationTargetProps[P]
-    : InjectedProps[P]
-    : DecorationTargetProps[P];
-};
+      ? DecorationTargetProps[P]
+      : InjectedProps[P]
+    : DecorationTargetProps[P]
+}
 
 // @public (undocumented)
-export type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> =
-(stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps) => TMergedProps;
+export type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> = (
+  stateProps: TStateProps,
+  dispatchProps: TDispatchProps,
+  ownProps: TOwnProps,
+) => TMergedProps
 
 // @public (undocumented)
-type Omit_2<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type Omit_2<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 export { Omit_2 as Omit }
 
 // @public (undocumented)
-export interface Options<State = DefaultRootState, TStateProps = {}, TOwnProps = {}, TMergedProps = {}> extends ConnectOptions {
-    areMergedPropsEqual?: (nextMergedProps: TMergedProps, prevMergedProps: TMergedProps) => boolean;
-
-    areOwnPropsEqual?: (nextOwnProps: TOwnProps, prevOwnProps: TOwnProps) => boolean;
-
-    areStatePropsEqual?: (nextStateProps: TStateProps, prevStateProps: TStateProps) => boolean;
-
-    areStatesEqual?: (nextState: State, prevState: State) => boolean;
-
-    forwardRef?: boolean;
-
-    pure?: boolean;
+export interface Options<
+  State = DefaultRootState,
+  TStateProps = {},
+  TOwnProps = {},
+  TMergedProps = {},
+> extends ConnectOptions {
+  areMergedPropsEqual?: (
+    nextMergedProps: TMergedProps,
+    prevMergedProps: TMergedProps,
+  ) => boolean
+
+  areOwnPropsEqual?: (
+    nextOwnProps: TOwnProps,
+    prevOwnProps: TOwnProps,
+  ) => boolean
+
+  areStatePropsEqual?: (
+    nextStateProps: TStateProps,
+    prevStateProps: TStateProps,
+  ) => boolean
+
+  areStatesEqual?: (nextState: State, prevState: State) => boolean
+
+  forwardRef?: boolean
+
+  pure?: boolean
 }
 
 // @public
-export class Provider<A extends Action = AnyAction> extends Component<ProviderProps<A>> { }
+export class Provider<A extends Action = AnyAction> extends Component<
+  ProviderProps<A>
+> {}
 
 // @public (undocumented)
 export interface ProviderProps<A extends Action = AnyAction> {
-    context?: Context<ReactReduxContextValue>;
-    store: Store<any, A>;
+  context?: Context<ReactReduxContextValue>
+  store: Store<any, A>
 }
 
 // @public
-export const ReactReduxContext: Context<ReactReduxContextValue>;
+export const ReactReduxContext: Context<ReactReduxContextValue>
 
 // @public (undocumented)
-export interface ReactReduxContextValue<SS = any, A extends Action = AnyAction> {
-    // (undocumented)
-    store: Store<SS, A>;
-    // (undocumented)
-    storeState: SS;
+export interface ReactReduxContextValue<
+  SS = any,
+  A extends Action = AnyAction,
+> {
+  // (undocumented)
+  store: Store<SS, A>
+  // (undocumented)
+  storeState: SS
 }
 
 // @public (undocumented)
 export type ResolveArrayThunks<TDispatchProps extends ReadonlyArray<any>> =
-TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, infer A7, infer A8, infer A9]
-? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>,
-HandleThunkActionCreator<A5>, HandleThunkActionCreator<A6>, HandleThunkActionCreator<A7>, HandleThunkActionCreator<A8>, HandleThunkActionCreator<A9>]
-: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, infer A7, infer A8]
-? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>,
-HandleThunkActionCreator<A5>, HandleThunkActionCreator<A6>, HandleThunkActionCreator<A7>, HandleThunkActionCreator<A8>]
-: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, infer A7]
-? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>,
-HandleThunkActionCreator<A5>, HandleThunkActionCreator<A6>, HandleThunkActionCreator<A7>]
-: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6]
-? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>, HandleThunkActionCreator<A5>, HandleThunkActionCreator<A6>]
-: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5]
-? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>, HandleThunkActionCreator<A5>]
-: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4] ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>]
-: TDispatchProps extends [infer A1, infer A2, infer A3] ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>]
-: TDispatchProps extends [infer A1, infer A2] ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>]
-: TDispatchProps extends [infer A1] ? [HandleThunkActionCreator<A1>]
-: TDispatchProps extends Array<infer A> ? Array<HandleThunkActionCreator<A>>
-: TDispatchProps extends ReadonlyArray<infer A> ? ReadonlyArray<HandleThunkActionCreator<A>>
-: never
-;
+  TDispatchProps extends [
+    infer A1,
+    infer A2,
+    infer A3,
+    infer A4,
+    infer A5,
+    infer A6,
+    infer A7,
+    infer A8,
+    infer A9,
+  ]
+    ? [
+        HandleThunkActionCreator<A1>,
+        HandleThunkActionCreator<A2>,
+        HandleThunkActionCreator<A3>,
+        HandleThunkActionCreator<A4>,
+        HandleThunkActionCreator<A5>,
+        HandleThunkActionCreator<A6>,
+        HandleThunkActionCreator<A7>,
+        HandleThunkActionCreator<A8>,
+        HandleThunkActionCreator<A9>,
+      ]
+    : TDispatchProps extends [
+          infer A1,
+          infer A2,
+          infer A3,
+          infer A4,
+          infer A5,
+          infer A6,
+          infer A7,
+          infer A8,
+        ]
+      ? [
+          HandleThunkActionCreator<A1>,
+          HandleThunkActionCreator<A2>,
+          HandleThunkActionCreator<A3>,
+          HandleThunkActionCreator<A4>,
+          HandleThunkActionCreator<A5>,
+          HandleThunkActionCreator<A6>,
+          HandleThunkActionCreator<A7>,
+          HandleThunkActionCreator<A8>,
+        ]
+      : TDispatchProps extends [
+            infer A1,
+            infer A2,
+            infer A3,
+            infer A4,
+            infer A5,
+            infer A6,
+            infer A7,
+          ]
+        ? [
+            HandleThunkActionCreator<A1>,
+            HandleThunkActionCreator<A2>,
+            HandleThunkActionCreator<A3>,
+            HandleThunkActionCreator<A4>,
+            HandleThunkActionCreator<A5>,
+            HandleThunkActionCreator<A6>,
+            HandleThunkActionCreator<A7>,
+          ]
+        : TDispatchProps extends [
+              infer A1,
+              infer A2,
+              infer A3,
+              infer A4,
+              infer A5,
+              infer A6,
+            ]
+          ? [
+              HandleThunkActionCreator<A1>,
+              HandleThunkActionCreator<A2>,
+              HandleThunkActionCreator<A3>,
+              HandleThunkActionCreator<A4>,
+              HandleThunkActionCreator<A5>,
+              HandleThunkActionCreator<A6>,
+            ]
+          : TDispatchProps extends [
+                infer A1,
+                infer A2,
+                infer A3,
+                infer A4,
+                infer A5,
+              ]
+            ? [
+                HandleThunkActionCreator<A1>,
+                HandleThunkActionCreator<A2>,
+                HandleThunkActionCreator<A3>,
+                HandleThunkActionCreator<A4>,
+                HandleThunkActionCreator<A5>,
+              ]
+            : TDispatchProps extends [infer A1, infer A2, infer A3, infer A4]
+              ? [
+                  HandleThunkActionCreator<A1>,
+                  HandleThunkActionCreator<A2>,
+                  HandleThunkActionCreator<A3>,
+                  HandleThunkActionCreator<A4>,
+                ]
+              : TDispatchProps extends [infer A1, infer A2, infer A3]
+                ? [
+                    HandleThunkActionCreator<A1>,
+                    HandleThunkActionCreator<A2>,
+                    HandleThunkActionCreator<A3>,
+                  ]
+                : TDispatchProps extends [infer A1, infer A2]
+                  ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>]
+                  : TDispatchProps extends [infer A1]
+                    ? [HandleThunkActionCreator<A1>]
+                    : TDispatchProps extends Array<infer A>
+                      ? Array<HandleThunkActionCreator<A>>
+                      : TDispatchProps extends ReadonlyArray<infer A>
+                        ? ReadonlyArray<HandleThunkActionCreator<A>>
+                        : never
 
 // @public (undocumented)
-export type ResolveThunks<TDispatchProps> =
-TDispatchProps extends { [key: string]: any }
-? {
-    [C in keyof TDispatchProps]: HandleThunkActionCreator<TDispatchProps[C]>
+export type ResolveThunks<TDispatchProps> = TDispatchProps extends {
+  [key: string]: any
 }
-: TDispatchProps;
+  ? {
+      [C in keyof TDispatchProps]: HandleThunkActionCreator<TDispatchProps[C]>
+    }
+  : TDispatchProps
 
 // @public (undocumented)
-export type RootStateOrAny = AnyIfEmpty<DefaultRootState>;
+export type RootStateOrAny = AnyIfEmpty<DefaultRootState>
 
 // @public (undocumented)
-export type Selector<S, TProps, TOwnProps = null> = TOwnProps extends null | undefined
-? (state: S) => TProps
-: (state: S, ownProps: TOwnProps) => TProps;
+export type Selector<S, TProps, TOwnProps = null> = TOwnProps extends
+  | null
+  | undefined
+  ? (state: S) => TProps
+  : (state: S, ownProps: TOwnProps) => TProps
 
 // @public
-export type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> =
-(dispatch: Dispatch<Action>, factoryOptions: TFactoryOptions) => Selector<S, TProps, TOwnProps>;
+export type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> = (
+  dispatch: Dispatch<Action>,
+  factoryOptions: TFactoryOptions,
+) => Selector<S, TProps, TOwnProps>
 
 // @public
-export function shallowEqual<T>(left: T, right: any): boolean;
+export function shallowEqual<T>(left: T, right: any): boolean
 
 // @public
-export type Shared<
-InjectedProps,
-DecorationTargetProps
-> = {
-    [P in Extract<keyof InjectedProps, keyof DecorationTargetProps>]?: InjectedProps[P] extends DecorationTargetProps[P] ? DecorationTargetProps[P] : never;
-};
+export type Shared<InjectedProps, DecorationTargetProps> = {
+  [P in Extract<
+    keyof InjectedProps,
+    keyof DecorationTargetProps
+  >]?: InjectedProps[P] extends DecorationTargetProps[P]
+    ? DecorationTargetProps[P]
+    : never
+}
 
 // @public
 export interface TypedUseSelectorHook<TState> {
-    // (undocumented)
-    <TSelected>(
+  // (undocumented)
+  <TSelected>(
     selector: (state: TState) => TSelected,
-    equalityFn?: (left: TSelected, right: TSelected) => boolean
-    ): TSelected;
+    equalityFn?: (left: TSelected, right: TSelected) => boolean,
+  ): TSelected
 }
 
 // @public
-export function useDispatch<TDispatch = Dispatch<any>>(): TDispatch;
+export function useDispatch<TDispatch = Dispatch<any>>(): TDispatch
 
 // @public (undocumented)
-export function useDispatch<A extends Action = AnyAction>(): Dispatch<A>;
+export function useDispatch<A extends Action = AnyAction>(): Dispatch<A>
 
 // @public
 export function useSelector<TState = DefaultRootState, TSelected = unknown>(
-selector: (state: TState) => TSelected,
-equalityFn?: (left: TSelected, right: TSelected) => boolean
-): TSelected;
+  selector: (state: TState) => TSelected,
+  equalityFn?: (left: TSelected, right: TSelected) => boolean,
+): TSelected
 
 // @public
-export function useStore<S = RootStateOrAny, A extends Action = AnyAction>(): Store<S, A>;
+export function useStore<
+  S = RootStateOrAny,
+  A extends Action = AnyAction,
+>(): Store<S, A>
 
 // (No @packageDocumentation comment for this package)
-
 ```
diff --git a/examples/publish-ci/rr-rsc-context/app/page.module.css b/examples/publish-ci/rr-rsc-context/app/page.module.css
index 9411a5e6f..06faba876 100644
--- a/examples/publish-ci/rr-rsc-context/app/page.module.css
+++ b/examples/publish-ci/rr-rsc-context/app/page.module.css
@@ -51,7 +51,9 @@
   border-radius: var(--border-radius);
   background: rgba(var(--card-rgb), 0);
   border: 1px solid rgba(var(--card-border-rgb), 0);
-  transition: background 200ms, border 200ms;
+  transition:
+    background 200ms,
+    border 200ms;
 }
 
 .card span {
diff --git a/src/types.ts b/src/types.ts
index 10a443443..23829ef35 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -70,11 +70,12 @@ export type Shared<InjectedProps, DecorationTargetProps> = {
 }
 
 // Infers prop type from component C
-export type GetProps<C> = C extends ComponentType<infer P>
-  ? C extends ComponentClass<P>
-    ? ClassAttributes<InstanceType<C>> & P
-    : P
-  : never
+export type GetProps<C> =
+  C extends ComponentType<infer P>
+    ? C extends ComponentClass<P>
+      ? ClassAttributes<InstanceType<C>> & P
+      : P
+    : never
 
 // Applies LibraryManagedAttributes (proper handling of defaultProps
 // and propTypes).
diff --git a/test/tsconfig.test.json b/test/tsconfig.test.json
index 461da76db..ef31e2046 100644
--- a/test/tsconfig.test.json
+++ b/test/tsconfig.test.json
@@ -13,6 +13,6 @@
     "baseUrl": ".",
     "skipLibCheck": true,
     "noImplicitReturns": false,
-    "experimentalDecorators": true,
+    "experimentalDecorators": true
   }
 }
diff --git a/test/typeTestHelpers.ts b/test/typeTestHelpers.ts
index 36edf7fb1..13b13f31f 100644
--- a/test/typeTestHelpers.ts
+++ b/test/typeTestHelpers.ts
@@ -28,18 +28,13 @@ type Equals<T, U> = IsAny<
   IsAny<U, never, [T] extends [U] ? ([U] extends [T] ? any : never) : never>
 >
 
-export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <
-  G,
->() => G extends B ? 1 : 2
-  ? true
-  : false
+export type IsEqual<A, B> =
+  (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2
+    ? true
+    : false
 
-export type IfEquals<
-  T,
-  U,
-  TypeIfEquals = unknown,
-  TypeIfNotEquals = never,
-> = IsEqual<T, U> extends true ? TypeIfEquals : TypeIfNotEquals
+export type IfEquals<T, U, TypeIfEquals = unknown, TypeIfNotEquals = never> =
+  IsEqual<T, U> extends true ? TypeIfEquals : TypeIfNotEquals
 
 export declare const exactType: <T, U>(
   draft: T & IfEquals<T, U>,
diff --git a/test/typetests/tsconfig.json b/test/typetests/tsconfig.json
index 5d96894d5..ddee7abf2 100644
--- a/test/typetests/tsconfig.json
+++ b/test/typetests/tsconfig.json
@@ -1,7 +1,6 @@
 {
   "extends": "../tsconfig.test.json",
-  "compilerOptions": {
-  },
+  "compilerOptions": {},
   "include": ["./*.ts*"],
   "exclude": []
 }
diff --git a/tsup.config.ts b/tsup.config.ts
index 27625e102..a4dd05844 100644
--- a/tsup.config.ts
+++ b/tsup.config.ts
@@ -11,7 +11,7 @@ if (process.env.NODE_ENV === 'production') {
   module.exports = require('./react-redux.production.min.cjs')
 } else {
   module.exports = require('./react-redux.development.cjs')
-}`
+}`,
   )
 }
 
diff --git a/vitest.setup.ts b/vitest.setup.ts
index b9e762299..a9d0dd31a 100644
--- a/vitest.setup.ts
+++ b/vitest.setup.ts
@@ -1 +1 @@
-import "@testing-library/jest-dom/vitest"
+import '@testing-library/jest-dom/vitest'
diff --git a/website/README.md b/website/README.md
index f3da77ff3..056686194 100644
--- a/website/README.md
+++ b/website/README.md
@@ -2,11 +2,11 @@ This website was created with [Docusaurus](https://docusaurus.io/).
 
 # What's In This Document
 
-* [Get Started in 5 Minutes](#get-started-in-5-minutes)
-* [Directory Structure](#directory-structure)
-* [Editing Content](#editing-content)
-* [Adding Content](#adding-content)
-* [Full Documentation](#full-documentation)
+- [Get Started in 5 Minutes](#get-started-in-5-minutes)
+- [Directory Structure](#directory-structure)
+- [Editing Content](#editing-content)
+- [Adding Content](#adding-content)
+- [Full Documentation](#full-documentation)
 
 # Get Started in 5 Minutes
 
@@ -16,6 +16,7 @@ This website was created with [Docusaurus](https://docusaurus.io/).
 # Install dependencies
 $ yarn
 ```
+
 2. Run your dev server:
 
 ```sh
@@ -72,6 +73,7 @@ For more information about docs, click [here](https://docusaurus.io/docs/en/navi
 Edit blog posts by navigating to `website/blog` and editing the corresponding post:
 
 `website/blog/post-to-be-edited.md`
+
 ```markdown
 ---
 id: post-needs-edit
@@ -121,6 +123,7 @@ For more information about adding new docs, click [here](https://docusaurus.io/d
 1. Make sure there is a header link to your blog in `website/siteConfig.js`:
 
 `website/siteConfig.js`
+
 ```javascript
 headerLinks: [
     ...
@@ -151,6 +154,7 @@ For more information about blog posts, click [here](https://docusaurus.io/docs/e
 1. Add links to docs, custom pages or external links by editing the headerLinks field of `website/siteConfig.js`:
 
 `website/siteConfig.js`
+
 ```javascript
 {
   headerLinks: [
@@ -175,6 +179,7 @@ For more information about the navigation bar, click [here](https://docusaurus.i
 1. If you want your page to show up in your navigation header, you will need to update `website/siteConfig.js` to add to the `headerLinks` element:
 
 `website/siteConfig.js`
+
 ```javascript
 {
   headerLinks: [
diff --git a/website/src/pages/index.js b/website/src/pages/index.js
index fe8679d3d..c129c9e2c 100644
--- a/website/src/pages/index.js
+++ b/website/src/pages/index.js
@@ -125,7 +125,7 @@ function Home() {
             <Link
               className={classnames(
                 'button button--secondary button--lg',
-                styles.getStarted
+                styles.getStarted,
               )}
               to={useBaseUrl('introduction/getting-started')}
             >
diff --git a/website/src/theme/NotFound.js b/website/src/theme/NotFound.js
index 898ae2b96..a5e8e2f2a 100644
--- a/website/src/theme/NotFound.js
+++ b/website/src/theme/NotFound.js
@@ -12,32 +12,37 @@ function NotFound() {
   const context = useDocusaurusContext()
   const { siteConfig = {} } = context
   useEffect(() => {
-    const script = document.createElement("script");
-    script.src = "https://buttons.github.io/buttons.js";
-    script.async = true;
-    document.body.appendChild(script);
+    const script = document.createElement('script')
+    script.src = 'https://buttons.github.io/buttons.js'
+    script.async = true
+    document.body.appendChild(script)
   }, [])
 
   const getTrackingScript = () => {
-    if (!siteConfig.themeConfig || !siteConfig.themeConfig.googleAnalytics || !siteConfig.themeConfig.googleAnalytics.gaTrackingId) {
-      return null;
+    if (
+      !siteConfig.themeConfig ||
+      !siteConfig.themeConfig.googleAnalytics ||
+      !siteConfig.themeConfig.googleAnalytics.gaTrackingId
+    ) {
+      return null
     }
-    
-    return {__html:`
+
+    return {
+      __html: `
       ga('create', "${siteConfig.gaTrackingId}");
       ga('send', {
         hitType: 'event',
         eventCategory: '404 Response',
         eventAction: window.location.href,
         eventLabel: document.referrer
-      });`
+      });`,
     }
-  };
-  const trackingScript = getTrackingScript();
- 
+  }
+  const trackingScript = getTrackingScript()
+
   return (
     <Layout title="Page Not Found">
-      {trackingScript && <script dangerouslySetInnerHTML={trackingScript}/>}
+      {trackingScript && <script dangerouslySetInnerHTML={trackingScript} />}
       <div className="error-page">
         <div className="error-message">
           <div className="error-message-container container">
@@ -48,7 +53,7 @@ function NotFound() {
         </div>
       </div>
     </Layout>
-  );
+  )
 }
 
-export default NotFound;
+export default NotFound
diff --git a/website/static/css/404.css b/website/static/css/404.css
index f94a536c0..33ae8a39e 100644
--- a/website/static/css/404.css
+++ b/website/static/css/404.css
@@ -1,33 +1,33 @@
 .error-page .error-message-container {
-    margin-left: auto;
-    margin-right: auto;
-    padding-top: 40px;
-    max-width: 1400px;
-    width: 87%;
+  margin-left: auto;
+  margin-right: auto;
+  padding-top: 40px;
+  max-width: 1400px;
+  width: 87%;
 }
- .error-page .error-message {
-    min-height: 100vh;
-    background: var(--ifm-blockquote-color);
+.error-page .error-message {
+  min-height: 100vh;
+  background: var(--ifm-blockquote-color);
 }
- .error-page .error-message span {
-    color: var(--ifm-color-primary);
-    font-size: 8.8em;
-    font-weight: 700;
-    display: inline-block;
-    margin-top: 10vh;
-    text-align: center;
-    display: block;
+.error-page .error-message span {
+  color: var(--ifm-color-primary);
+  font-size: 8.8em;
+  font-weight: 700;
+  display: inline-block;
+  margin-top: 10vh;
+  text-align: center;
+  display: block;
 }
- .error-page .error-message p {
-    margin-top: 50px;
-    font-size: 1.6em;
-    text-align: center;
+.error-page .error-message p {
+  margin-top: 50px;
+  font-size: 1.6em;
+  text-align: center;
 }
 
 .error-page .error-message a {
-   margin-bottom: 50px;
-   font-size: 1.6em;
-   text-align: center;
-   display: block;
-   text-decoration: underline;
+  margin-bottom: 50px;
+  font-size: 1.6em;
+  text-align: center;
+  display: block;
+  text-decoration: underline;
 }
diff --git a/website/static/css/codeblock.css b/website/static/css/codeblock.css
index bd9572964..6e295df35 100644
--- a/website/static/css/codeblock.css
+++ b/website/static/css/codeblock.css
@@ -13,7 +13,7 @@ pre .btnIcon {
   color: #fff;
   background-color: transparent;
   height: 30px;
-  transition: all .25s ease-out;
+  transition: all 0.25s ease-out;
 }
 
 pre .btnIcon:hover {
@@ -27,7 +27,7 @@ pre .btnIcon:hover {
 
 .btnIcon svg {
   fill: currentColor;
-  margin-right: .4em;
+  margin-right: 0.4em;
 }
 
 .btnIcon__label {
@@ -36,4 +36,4 @@ pre .btnIcon:hover {
 
 .btnClipboard {
   right: 10px;
-}
\ No newline at end of file
+}
diff --git a/website/static/css/custom.css b/website/static/css/custom.css
index 86bdda91f..5c7f107d7 100644
--- a/website/static/css/custom.css
+++ b/website/static/css/custom.css
@@ -174,12 +174,16 @@ a:visited {
   transform: rotateZ(180deg);
   -webkit-transition: -webkit-transform 0.2s linear;
   transition: -webkit-transform 0.2s linear;
-  transition-property: transform, -webkit-transform;
+  transition-property:
+    transform,
+    -webkit-transform;
   transition-duration: 0.2s, 0.2s;
   transition-timing-function: linear, linear;
   transition-delay: 0s, 0s;
   transition: transform 0.2s linear;
-  transition: transform 0.2s linear, -webkit-transform 0.2s linear;
+  transition:
+    transform 0.2s linear,
+    -webkit-transform 0.2s linear;
 }
 
 .menu .menu__list-item.menu__list-item--collapsed .menu__link--sublist:after {
diff --git a/website/static/scripts/codeblock.js b/website/static/scripts/codeblock.js
index 990d63390..1b1543cda 100644
--- a/website/static/scripts/codeblock.js
+++ b/website/static/scripts/codeblock.js
@@ -1,45 +1,45 @@
-window.addEventListener('load', function() {
+window.addEventListener('load', function () {
   function button(label, ariaLabel, icon, className) {
-    const btn = document.createElement('button');
-    btn.classList.add('btnIcon', className);
-    btn.setAttribute('type', 'button');
-    btn.setAttribute('aria-label', ariaLabel);
+    const btn = document.createElement('button')
+    btn.classList.add('btnIcon', className)
+    btn.setAttribute('type', 'button')
+    btn.setAttribute('aria-label', ariaLabel)
     btn.innerHTML =
       '<div class="btnIcon__body">' +
       icon +
       '<strong class="btnIcon__label">' +
       label +
       '</strong>' +
-      '</div>';
-    return btn;
+      '</div>'
+    return btn
   }
 
   function addButtons(codeBlockSelector, btn) {
-    document.querySelectorAll(codeBlockSelector).forEach(function(code) {
-      code.parentNode.appendChild(btn.cloneNode(true));
-    });
+    document.querySelectorAll(codeBlockSelector).forEach(function (code) {
+      code.parentNode.appendChild(btn.cloneNode(true))
+    })
   }
 
   const copyIcon =
-    '<svg width="12" height="12" viewBox="340 364 14 15" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M342 375.974h4v.998h-4v-.998zm5-5.987h-5v.998h5v-.998zm2 2.994v-1.995l-3 2.993 3 2.994v-1.996h5v-1.995h-5zm-4.5-.997H342v.998h2.5v-.997zm-2.5 2.993h2.5v-.998H342v.998zm9 .998h1v1.996c-.016.28-.11.514-.297.702-.187.187-.422.28-.703.296h-10c-.547 0-1-.452-1-.998v-10.976c0-.546.453-.998 1-.998h3c0-1.107.89-1.996 2-1.996 1.11 0 2 .89 2 1.996h3c.547 0 1 .452 1 .998v4.99h-1v-2.995h-10v8.98h10v-1.996zm-9-7.983h8c0-.544-.453-.996-1-.996h-1c-.547 0-1-.453-1-.998 0-.546-.453-.998-1-.998-.547 0-1 .452-1 .998 0 .545-.453.998-1 .998h-1c-.547 0-1 .452-1 .997z" fill-rule="evenodd"/></svg>';
+    '<svg width="12" height="12" viewBox="340 364 14 15" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M342 375.974h4v.998h-4v-.998zm5-5.987h-5v.998h5v-.998zm2 2.994v-1.995l-3 2.993 3 2.994v-1.996h5v-1.995h-5zm-4.5-.997H342v.998h2.5v-.997zm-2.5 2.993h2.5v-.998H342v.998zm9 .998h1v1.996c-.016.28-.11.514-.297.702-.187.187-.422.28-.703.296h-10c-.547 0-1-.452-1-.998v-10.976c0-.546.453-.998 1-.998h3c0-1.107.89-1.996 2-1.996 1.11 0 2 .89 2 1.996h3c.547 0 1 .452 1 .998v4.99h-1v-2.995h-10v8.98h10v-1.996zm-9-7.983h8c0-.544-.453-.996-1-.996h-1c-.547 0-1-.453-1-.998 0-.546-.453-.998-1-.998-.547 0-1 .452-1 .998 0 .545-.453.998-1 .998h-1c-.547 0-1 .452-1 .997z" fill-rule="evenodd"/></svg>'
 
   addButtons(
     '.hljs',
     button('Copy', 'Copy code to clipboard', copyIcon, 'btnClipboard'),
-  );
+  )
 
   const clipboard = new ClipboardJS('.btnClipboard', {
-    target: function(trigger) {
-      return trigger.parentNode.querySelector('code');
+    target: function (trigger) {
+      return trigger.parentNode.querySelector('code')
     },
-  });
+  })
 
-  clipboard.on('success', function(event) {
-    event.clearSelection();
-    const textEl = event.trigger.querySelector('.btnIcon__label');
-    textEl.textContent = 'Copied';
-    setTimeout(function() {
-      textEl.textContent = 'Copy';
-    }, 2000);
-  });
-});
\ No newline at end of file
+  clipboard.on('success', function (event) {
+    event.clearSelection()
+    const textEl = event.trigger.querySelector('.btnIcon__label')
+    textEl.textContent = 'Copied'
+    setTimeout(function () {
+      textEl.textContent = 'Copy'
+    }, 2000)
+  })
+})
diff --git a/website/static/scripts/monokaiTheme.js b/website/static/scripts/monokaiTheme.js
index 8b5ffb46b..bd3eebd14 100644
--- a/website/static/scripts/monokaiTheme.js
+++ b/website/static/scripts/monokaiTheme.js
@@ -1,62 +1,62 @@
 module.exports = {
   plain: {
     color: '#f8f8f2',
-    backgroundColor: '#272822'
+    backgroundColor: '#272822',
   },
   styles: [
     {
       types: ['comment', 'prolog', 'doctype', 'cdata'],
       style: {
-        color: '#778090'
-      }
+        color: '#778090',
+      },
     },
     {
       types: ['punctuation'],
       style: {
-        color: '#F8F8F2'
-      }
+        color: '#F8F8F2',
+      },
     },
     {
       types: ['property', 'tag', 'constant', 'symbol', 'deleted'],
       style: {
-        color: '#F92672'
-      }
+        color: '#F92672',
+      },
     },
     {
       types: ['boolean', 'number'],
       style: {
-        color: '#AE81FF'
-      }
+        color: '#AE81FF',
+      },
     },
     {
       types: ['selector', 'attr-name', 'string', 'char', 'builtin', 'inserted'],
       style: {
-        color: '#a6e22e'
-      }
+        color: '#a6e22e',
+      },
     },
     {
       types: ['operator', 'entity', 'url', 'variable'],
       style: {
-        color: '#F8F8F2'
-      }
+        color: '#F8F8F2',
+      },
     },
     {
       types: ['atrule', 'attr-value', 'function'],
       style: {
-        color: '#E6D874'
-      }
+        color: '#E6D874',
+      },
     },
     {
       types: ['keyword'],
       style: {
-        color: '#F92672'
-      }
+        color: '#F92672',
+      },
     },
     {
       types: ['regex', 'important'],
       style: {
-        color: '#FD971F'
-      }
-    }
-  ]
+        color: '#FD971F',
+      },
+    },
+  ],
 }
diff --git a/website/static/scripts/sidebarScroll.js b/website/static/scripts/sidebarScroll.js
index af71fccd1..8625f9405 100644
--- a/website/static/scripts/sidebarScroll.js
+++ b/website/static/scripts/sidebarScroll.js
@@ -1,16 +1,19 @@
 document.addEventListener('DOMContentLoaded', () => {
   // Find the active nav item in the sidebar
-  const item = document.getElementsByClassName('navListItemActive')[0];
-  if (!item) { return; }
-  const bounding = item.getBoundingClientRect();
+  const item = document.getElementsByClassName('navListItemActive')[0]
+  if (!item) {
+    return
+  }
+  const bounding = item.getBoundingClientRect()
   if (
     bounding.top >= 0 &&
-    bounding.bottom <= (window.innerHeight || document.documentElement.clientHeight)
+    bounding.bottom <=
+      (window.innerHeight || document.documentElement.clientHeight)
   ) {
     // Already visible.  Do nothing.
   } else {
     // Not visible.  Scroll sidebar.
-    item.scrollIntoView({block: 'center', inline: 'nearest'});
-    document.body.scrollTop = document.documentElement.scrollTop = 0;
+    item.scrollIntoView({ block: 'center', inline: 'nearest' })
+    document.body.scrollTop = document.documentElement.scrollTop = 0
   }
-});
+})
diff --git a/website/versioned_docs/version-5.x/api.md b/website/versioned_docs/version-5.x/api.md
index 155d7b444..ed9cec494 100644
--- a/website/versioned_docs/version-5.x/api.md
+++ b/website/versioned_docs/version-5.x/api.md
@@ -8,16 +8,17 @@ hide_title: true
 # API
 
 <a id="provider"></a>
+
 ## Provider
 
 Makes the Redux store available to the `connect()` calls in the component hierarchy below. Normally, you can’t use `connect()` without wrapping a parent or ancestor component in `<Provider>`.
 
-If you *really* need to, you can manually pass `store` as a prop to every `connect()`ed component, but we only recommend to do this for stubbing `store` in unit tests, or in non-fully-React codebases. Normally, you should just use `<Provider>`.
+If you _really_ need to, you can manually pass `store` as a prop to every `connect()`ed component, but we only recommend to do this for stubbing `store` in unit tests, or in non-fully-React codebases. Normally, you should just use `<Provider>`.
 
 ### Props
 
-* `store` (*[Redux Store](https://redux.js.org/api-reference/store)*): The single Redux store in your application.
-* `children` (*ReactElement*) The root of your component hierarchy.
+- `store` (_[Redux Store](https://redux.js.org/api-reference/store)_): The single Redux store in your application.
+- `children` (_ReactElement_) The root of your component hierarchy.
 
 ### Example
 
@@ -28,7 +29,7 @@ ReactDOM.render(
   <Provider store={store}>
     <MyRootComponent />
   </Provider>,
-  rootEl
+  rootEl,
 )
 ```
 
@@ -39,16 +40,15 @@ ReactDOM.render(
   <Provider store={store}>
     <Router history={history}>
       <Route path="/" component={App}>
-        <Route path="foo" component={Foo}/>
-        <Route path="bar" component={Bar}/>
+        <Route path="foo" component={Foo} />
+        <Route path="bar" component={Bar} />
       </Route>
     </Router>
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
 
-
 ## connect
 
 ```
@@ -57,37 +57,37 @@ connect([mapStateToProps], [mapDispatchToProps], [mergeProps], [options])
 
 Connects a React component to a Redux store. `connect` is a facade around `connectAdvanced`, providing a convenient API for the most common use cases.
 
-It does not modify the component class passed to it; instead, it *returns* a new, connected component class for you to use.
+It does not modify the component class passed to it; instead, it _returns_ a new, connected component class for you to use.
 
 ### Arguments
 
-* [`mapStateToProps(state, [ownProps]): stateProps`] \(*Function*): If this argument is specified, the new component will subscribe to Redux store updates. This means that any time the store is updated, `mapStateToProps` will be called. The results of `mapStateToProps` must be a plain object, which will be merged into the component’s props. If you don't want to subscribe to store updates, pass `null` or `undefined` in place of `mapStateToProps`.
+- [`mapStateToProps(state, [ownProps]): stateProps`] \(_Function_): If this argument is specified, the new component will subscribe to Redux store updates. This means that any time the store is updated, `mapStateToProps` will be called. The results of `mapStateToProps` must be a plain object, which will be merged into the component’s props. If you don't want to subscribe to store updates, pass `null` or `undefined` in place of `mapStateToProps`.
 
-  If your `mapStateToProps` function is declared as taking two parameters, it will be called with the store state as the first parameter and the props passed to the connected component as the second parameter, and will also be re-invoked whenever the connected component receives new props as determined by shallow equality comparisons.  (The second parameter is normally referred to as `ownProps` by convention.)
+  If your `mapStateToProps` function is declared as taking two parameters, it will be called with the store state as the first parameter and the props passed to the connected component as the second parameter, and will also be re-invoked whenever the connected component receives new props as determined by shallow equality comparisons. (The second parameter is normally referred to as `ownProps` by convention.)
 
-  >Note: in advanced scenarios where you need more control over the rendering performance, `mapStateToProps()` can also return a function. In this case, *that* function will be used as `mapStateToProps()` for a particular component instance. This allows you to do per-instance memoization. You can refer to [#279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds for more details. Most apps never need this.
+  > Note: in advanced scenarios where you need more control over the rendering performance, `mapStateToProps()` can also return a function. In this case, _that_ function will be used as `mapStateToProps()` for a particular component instance. This allows you to do per-instance memoization. You can refer to [#279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds for more details. Most apps never need this.
 
-  >The `mapStateToProps` function's first argument is the entire Redux store’s state and it returns an object to be passed as props. It is often called a **selector**. Use [reselect](https://github.com/reduxjs/reselect) to efficiently compose selectors and [compute derived data](https://redux.js.org/recipes/computing-derived-data).
+  > The `mapStateToProps` function's first argument is the entire Redux store’s state and it returns an object to be passed as props. It is often called a **selector**. Use [reselect](https://github.com/reduxjs/reselect) to efficiently compose selectors and [compute derived data](https://redux.js.org/recipes/computing-derived-data).
 
-* [`mapDispatchToProps(dispatch, [ownProps]): dispatchProps`] \(*Object* or *Function*): If an object is passed, each function inside it is assumed to be a Redux action creator. An object with the same function names, but with every action creator wrapped into a `dispatch` call so they may be invoked directly, will be merged into the component’s props.  
+- [`mapDispatchToProps(dispatch, [ownProps]): dispatchProps`] \(_Object_ or _Function_): If an object is passed, each function inside it is assumed to be a Redux action creator. An object with the same function names, but with every action creator wrapped into a `dispatch` call so they may be invoked directly, will be merged into the component’s props.
 
-  If a function is passed, it will be given `dispatch` as the first parameter.  It’s up to you to return an object that somehow uses `dispatch` to bind action creators in your own way. (Tip: you may use the [`bindActionCreators()`](https://redux.js.org/api-reference/bindactioncreators) helper from Redux.)  
+  If a function is passed, it will be given `dispatch` as the first parameter. It’s up to you to return an object that somehow uses `dispatch` to bind action creators in your own way. (Tip: you may use the [`bindActionCreators()`](https://redux.js.org/api-reference/bindactioncreators) helper from Redux.)
 
-  If your `mapDispatchToProps` function is declared as taking two parameters, it will be called with `dispatch` as the first parameter and the props passed to the connected component as the second parameter, and will be re-invoked whenever the connected component receives new props.  (The second parameter is normally referred to as `ownProps` by convention.)
+  If your `mapDispatchToProps` function is declared as taking two parameters, it will be called with `dispatch` as the first parameter and the props passed to the connected component as the second parameter, and will be re-invoked whenever the connected component receives new props. (The second parameter is normally referred to as `ownProps` by convention.)
 
   If you do not supply your own `mapDispatchToProps` function or object full of action creators, the default `mapDispatchToProps` implementation just injects `dispatch` into your component’s props.
 
-  >Note: in advanced scenarios where you need more control over the rendering performance, `mapDispatchToProps()` can also return a function. In this case, *that* function will be used as `mapDispatchToProps()` for a particular component instance. This allows you to do per-instance memoization. You can refer to [#279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds for more details. Most apps never need this.
+  > Note: in advanced scenarios where you need more control over the rendering performance, `mapDispatchToProps()` can also return a function. In this case, _that_ function will be used as `mapDispatchToProps()` for a particular component instance. This allows you to do per-instance memoization. You can refer to [#279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds for more details. Most apps never need this.
 
-* [`mergeProps(stateProps, dispatchProps, ownProps): props`] \(*Function*): If specified, it is passed the result of `mapStateToProps()`, `mapDispatchToProps()`, and the parent `props`. The plain object you return from it will be passed as props to the wrapped component. You may specify this function to select a slice of the state based on props, or to bind action creators to a particular variable from props. If you omit it, `Object.assign({}, ownProps, stateProps, dispatchProps)` is used by default.
+- [`mergeProps(stateProps, dispatchProps, ownProps): props`] \(_Function_): If specified, it is passed the result of `mapStateToProps()`, `mapDispatchToProps()`, and the parent `props`. The plain object you return from it will be passed as props to the wrapped component. You may specify this function to select a slice of the state based on props, or to bind action creators to a particular variable from props. If you omit it, `Object.assign({}, ownProps, stateProps, dispatchProps)` is used by default.
 
-* [`options`] *(Object)* If specified, further customizes the behavior of the connector. In addition to the options passable to `connectAdvanced()` (see those below), `connect()` accepts these additional options:
-  * [`pure`] *(Boolean)*: If true, `connect()` will avoid re-renders and calls to `mapStateToProps`, `mapDispatchToProps`, and `mergeProps` if the relevant state/props objects remain equal based on their respective equality checks. Assumes that the wrapped component is a “pure” component and does not rely on any input or state other than its props and the selected Redux store’s state. Default value: `true`
-  * [`areStatesEqual`] *(Function)*: When pure, compares incoming store state to its previous value. Default value: `strictEqual (===)`
-  * [`areOwnPropsEqual`] *(Function)*: When pure, compares incoming props to its previous value. Default value: `shallowEqual`
-  * [`areStatePropsEqual`] *(Function)*: When pure, compares the result of `mapStateToProps` to its previous value. Default value: `shallowEqual`
-  * [`areMergedPropsEqual`] *(Function)*: When pure, compares the result of `mergeProps` to its previous value. Default value: `shallowEqual`
-  * [`storeKey`] *(String)*: The key of the context from where to read the store. You probably only need this if you are in the inadvisable position of having multiple stores. Default value: `'store'`
+- [`options`] _(Object)_ If specified, further customizes the behavior of the connector. In addition to the options passable to `connectAdvanced()` (see those below), `connect()` accepts these additional options:
+  - [`pure`] _(Boolean)_: If true, `connect()` will avoid re-renders and calls to `mapStateToProps`, `mapDispatchToProps`, and `mergeProps` if the relevant state/props objects remain equal based on their respective equality checks. Assumes that the wrapped component is a “pure” component and does not rely on any input or state other than its props and the selected Redux store’s state. Default value: `true`
+  - [`areStatesEqual`] _(Function)_: When pure, compares incoming store state to its previous value. Default value: `strictEqual (===)`
+  - [`areOwnPropsEqual`] _(Function)_: When pure, compares incoming props to its previous value. Default value: `shallowEqual`
+  - [`areStatePropsEqual`] _(Function)_: When pure, compares the result of `mapStateToProps` to its previous value. Default value: `shallowEqual`
+  - [`areMergedPropsEqual`] _(Function)_: When pure, compares the result of `mergeProps` to its previous value. Default value: `shallowEqual`
+  - [`storeKey`] _(String)_: The key of the context from where to read the store. You probably only need this if you are in the inadvisable position of having multiple stores. Default value: `'store'`
 
 #### The arity of mapStateToProps and mapDispatchToProps determines whether they receive ownProps
 
@@ -95,34 +95,38 @@ It does not modify the component class passed to it; instead, it *returns* a new
 
 ```js
 function mapStateToProps(state) {
-  console.log(state); // state
-  console.log(arguments[1]); // undefined
+  console.log(state) // state
+  console.log(arguments[1]) // undefined
 }
 ```
+
 ```js
 const mapStateToProps = (state, ownProps = {}) => {
-  console.log(state); // state
-  console.log(ownProps); // {}
+  console.log(state) // state
+  console.log(ownProps) // {}
 }
 ```
 
 Functions with no mandatory parameters or two parameters **will receive** `ownProps`.
+
 ```js
 const mapStateToProps = (state, ownProps) => {
-  console.log(state); // state
-  console.log(ownProps); // ownProps
+  console.log(state) // state
+  console.log(ownProps) // ownProps
 }
 ```
+
 ```js
 function mapStateToProps() {
-  console.log(arguments[0]); // state
-  console.log(arguments[1]); // ownProps
+  console.log(arguments[0]) // state
+  console.log(arguments[1]) // ownProps
 }
 ```
+
 ```js
 const mapStateToProps = (...args) => {
-  console.log(args[0]); // state
-  console.log(args[1]); // ownProps
+  console.log(args[0]) // state
+  console.log(args[1]) // ownProps
 }
 ```
 
@@ -130,21 +134,22 @@ const mapStateToProps = (...args) => {
 
 When `options.pure` is true, `connect` performs several equality checks that are used to avoid unnecessary calls to `mapStateToProps`, `mapDispatchToProps`, `mergeProps`, and ultimately to `render`. These include `areStatesEqual`, `areOwnPropsEqual`, `areStatePropsEqual`, and `areMergedPropsEqual`. While the defaults are probably appropriate 99% of the time, you may wish to override them with custom implementations for performance or other reasons. Here are several examples:
 
-* You may wish to override `areStatesEqual` if your `mapStateToProps` function is computationally expensive and is also only concerned with a small slice of your state. For example: `areStatesEqual: (next, prev) => prev.entities.todos === next.entities.todos`; this would effectively ignore state changes for everything but that slice of state.
+- You may wish to override `areStatesEqual` if your `mapStateToProps` function is computationally expensive and is also only concerned with a small slice of your state. For example: `areStatesEqual: (next, prev) => prev.entities.todos === next.entities.todos`; this would effectively ignore state changes for everything but that slice of state.
 
-* You may wish to override `areStatesEqual` to always return false (`areStatesEqual: () => false`) if you have impure reducers that mutate your store state. (This would likely impact the other equality checks as well, depending on your `mapStateToProps` function.)
+- You may wish to override `areStatesEqual` to always return false (`areStatesEqual: () => false`) if you have impure reducers that mutate your store state. (This would likely impact the other equality checks as well, depending on your `mapStateToProps` function.)
 
-* You may wish to override `areOwnPropsEqual` as a way to whitelist incoming props. You'd also have to implement `mapStateToProps`, `mapDispatchToProps` and `mergeProps` to also whitelist props. (It may be simpler to achieve this other ways, for example by using [recompose's mapProps](https://github.com/acdlite/recompose/blob/master/docs/API.md#mapprops).)
+- You may wish to override `areOwnPropsEqual` as a way to whitelist incoming props. You'd also have to implement `mapStateToProps`, `mapDispatchToProps` and `mergeProps` to also whitelist props. (It may be simpler to achieve this other ways, for example by using [recompose's mapProps](https://github.com/acdlite/recompose/blob/master/docs/API.md#mapprops).)
 
-* You may wish to override `areStatePropsEqual` to use `strictEqual` if your `mapStateToProps` uses a memoized selector that will only return a new object if a relevant prop has changed. This would be a very slight performance improvement, since would avoid extra equality checks on individual props each time `mapStateToProps` is called.
+- You may wish to override `areStatePropsEqual` to use `strictEqual` if your `mapStateToProps` uses a memoized selector that will only return a new object if a relevant prop has changed. This would be a very slight performance improvement, since would avoid extra equality checks on individual props each time `mapStateToProps` is called.
 
-* You may wish to override `areMergedPropsEqual` to implement a `deepEqual` if your selectors produce complex props. ex: nested objects, new arrays, etc. (The deep equal check should be faster than just re-rendering.)
+- You may wish to override `areMergedPropsEqual` to implement a `deepEqual` if your selectors produce complex props. ex: nested objects, new arrays, etc. (The deep equal check should be faster than just re-rendering.)
 
 ### Returns
 
 A higher-order React component class that passes state and action creators into your component derived from the supplied arguments. This is created by `connectAdvanced`, and details of this higher-order component are covered there.
 
 <a id="connect-examples"></a>
+
 #### Examples
 
 #### Inject just `dispatch` and don't listen to store
@@ -153,7 +158,7 @@ A higher-order React component class that passes state and action creators into
 export default connect()(TodoApp)
 ```
 
-#### Inject all action creators  (`addTodo`, `completeTodo`, ...) without subscribing to the store
+#### Inject all action creators (`addTodo`, `completeTodo`, ...) without subscribing to the store
 
 ```js
 import * as actionCreators from './actionCreators'
@@ -163,12 +168,12 @@ export default connect(null, actionCreators)(TodoApp)
 
 #### Inject `dispatch` and every field in the global state
 
->Don’t do this! It kills any performance optimizations because `TodoApp` will rerender after every state change.  
->It’s better to have more granular `connect()` on several components in your view hierarchy that each only  
->listen to a relevant slice of the state.
+> Don’t do this! It kills any performance optimizations because `TodoApp` will rerender after every state change.  
+> It’s better to have more granular `connect()` on several components in your view hierarchy that each only  
+> listen to a relevant slice of the state.
 
 ```js
-export default connect(state => state)(TodoApp)
+export default connect((state) => state)(TodoApp)
 ```
 
 #### Inject `dispatch` and `todos`
@@ -210,7 +215,7 @@ function mapDispatchToProps(dispatch) {
 export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
-####  Inject `todos` and a specific action creator (`addTodo`)
+#### Inject `todos` and a specific action creator (`addTodo`)
 
 ```js
 import { addTodo } from './actionCreators'
@@ -227,7 +232,7 @@ function mapDispatchToProps(dispatch) {
 export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
-####  Inject `todos` and specific action creators (`addTodo` and `deleteTodo`) with shorthand syntax
+#### Inject `todos` and specific action creators (`addTodo` and `deleteTodo`) with shorthand syntax
 
 ```js
 import { addTodo, deleteTodo } from './actionCreators'
@@ -238,7 +243,7 @@ function mapStateToProps(state) {
 
 const mapDispatchToProps = {
   addTodo,
-  deleteTodo
+  deleteTodo,
 }
 
 export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
@@ -258,7 +263,7 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return {
     todoActions: bindActionCreators(todoActionCreators, dispatch),
-    counterActions: bindActionCreators(counterActionCreators, dispatch)
+    counterActions: bindActionCreators(counterActionCreators, dispatch),
   }
 }
 
@@ -278,7 +283,10 @@ function mapStateToProps(state) {
 
 function mapDispatchToProps(dispatch) {
   return {
-    actions: bindActionCreators(Object.assign({}, todoActionCreators, counterActionCreators), dispatch)
+    actions: bindActionCreators(
+      Object.assign({}, todoActionCreators, counterActionCreators),
+      dispatch,
+    ),
   }
 }
 
@@ -297,7 +305,10 @@ function mapStateToProps(state) {
 }
 
 function mapDispatchToProps(dispatch) {
-  return bindActionCreators(Object.assign({}, todoActionCreators, counterActionCreators), dispatch)
+  return bindActionCreators(
+    Object.assign({}, todoActionCreators, counterActionCreators),
+    dispatch,
+  )
 }
 
 export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
@@ -327,7 +338,7 @@ function mapStateToProps(state) {
 function mergeProps(stateProps, dispatchProps, ownProps) {
   return Object.assign({}, ownProps, {
     todos: stateProps.todos[ownProps.userId],
-    addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text)
+    addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text),
   })
 }
 
@@ -376,27 +387,27 @@ connectAdvanced(selectorFactory, [connectOptions])
 
 Connects a React component to a Redux store. It is the base for `connect()` but is less opinionated about how to combine `state`, `props`, and `dispatch` into your final props. It makes no assumptions about defaults or memoization of results, leaving those responsibilities to the caller.
 
-It does not modify the component class passed to it; instead, it *returns* a new, connected component class for you to use.
+It does not modify the component class passed to it; instead, it _returns_ a new, connected component class for you to use.
 
 ### Arguments
 
-* `selectorFactory(dispatch, factoryOptions): selector(state, ownProps): props` \(*Function*): Initializes a selector function (during each instance's constructor). That selector function is called any time the connector component needs to compute new props, as a result of a store state change or receiving new props. The result of `selector` is expected to be a plain object, which is passed as the props to the wrapped component. If a consecutive call to `selector` returns the same object (`===`) as its previous call, the component will not be re-rendered. It's the responsibility of `selector` to return that previous object when appropriate.
+- `selectorFactory(dispatch, factoryOptions): selector(state, ownProps): props` \(_Function_): Initializes a selector function (during each instance's constructor). That selector function is called any time the connector component needs to compute new props, as a result of a store state change or receiving new props. The result of `selector` is expected to be a plain object, which is passed as the props to the wrapped component. If a consecutive call to `selector` returns the same object (`===`) as its previous call, the component will not be re-rendered. It's the responsibility of `selector` to return that previous object when appropriate.
 
-* [`connectOptions`] *(Object)* If specified, further customizes the behavior of the connector.
+- [`connectOptions`] _(Object)_ If specified, further customizes the behavior of the connector.
 
-  * [`getDisplayName`] *(Function)*: computes the connector component's displayName property relative to that of the wrapped component. Usually overridden by wrapper functions. Default value: `name => 'ConnectAdvanced('+name+')'`
+  - [`getDisplayName`] _(Function)_: computes the connector component's displayName property relative to that of the wrapped component. Usually overridden by wrapper functions. Default value: `name => 'ConnectAdvanced('+name+')'`
 
-  * [`methodName`] *(String)*: shown in error messages. Usually overridden by wrapper functions. Default value: `'connectAdvanced'`
+  - [`methodName`] _(String)_: shown in error messages. Usually overridden by wrapper functions. Default value: `'connectAdvanced'`
 
-  * [`renderCountProp`] *(String)*: if defined, a property named this value will be added to the props passed to the wrapped component. Its value will be the number of times the component has been rendered, which can be useful for tracking down unnecessary re-renders. Default value: `undefined`
+  - [`renderCountProp`] _(String)_: if defined, a property named this value will be added to the props passed to the wrapped component. Its value will be the number of times the component has been rendered, which can be useful for tracking down unnecessary re-renders. Default value: `undefined`
 
-  * [`shouldHandleStateChanges`] *(Boolean)*: controls whether the connector component subscribes to redux store state changes. If set to false, it will only re-render when parent component re-renders. Default value:  `true`
+  - [`shouldHandleStateChanges`] _(Boolean)_: controls whether the connector component subscribes to redux store state changes. If set to false, it will only re-render when parent component re-renders. Default value: `true`
 
-  * [`storeKey`] *(String)*: the key of props/context to get the store. You probably only need this if you are in the inadvisable position of having multiple stores. Default value: `'store'`
+  - [`storeKey`] _(String)_: the key of props/context to get the store. You probably only need this if you are in the inadvisable position of having multiple stores. Default value: `'store'`
 
-  * [`withRef`] *(Boolean)*: If true, stores a ref to the wrapped component instance and makes it available via `getWrappedInstance()` method. Default value: `false`
+  - [`withRef`] _(Boolean)_: If true, stores a ref to the wrapped component instance and makes it available via `getWrappedInstance()` method. Default value: `false`
 
-  * Additionally, any extra options passed via `connectOptions` will be passed through to your `selectorFactory` in the `factoryOptions` argument.
+  - Additionally, any extra options passed via `connectOptions` will be passed through to your `selectorFactory` in the `factoryOptions` argument.
 
 <a id="connectAdvanced-returns"></a>
 
@@ -406,7 +417,7 @@ A higher-order React component class that builds props from the store state and
 
 #### Static Properties
 
-* `WrappedComponent` *(Component)*: The original component class passed to `connectAdvanced(...)(Component)`.
+- `WrappedComponent` _(Component)_: The original component class passed to `connectAdvanced(...)(Component)`.
 
 #### Static Methods
 
@@ -420,11 +431,12 @@ Returns the wrapped component instance. Only available if you pass `{ withRef: t
 
 ### Remarks
 
-* Since `connectAdvanced` returns a higher-order component, it needs to be invoked two times. The first time with its arguments as described above, and a second time, with the component: `connectAdvanced(selectorFactory)(MyComponent)`.
+- Since `connectAdvanced` returns a higher-order component, it needs to be invoked two times. The first time with its arguments as described above, and a second time, with the component: `connectAdvanced(selectorFactory)(MyComponent)`.
 
-* `connectAdvanced` does not modify the passed React component. It returns a new, connected component, that you should use instead.
+- `connectAdvanced` does not modify the passed React component. It returns a new, connected component, that you should use instead.
 
 <a id="connectAdvanced-examples"></a>
+
 #### Examples
 
 #### Inject `todos` of a specific user depending on props, and inject `props.userId` into the action
@@ -459,13 +471,14 @@ Creates a new `<Provider>` which will set the Redux Store on the passed key of t
 
 ### Arguments
 
-* [`storeKey`] (*String*): The key of the context on which to set the store. Default value: `'store'`
+- [`storeKey`] (_String_): The key of the context on which to set the store. Default value: `'store'`
 
 ### Examples
+
 Before creating multiple stores, please go through this FAQ: [Can or should I create multiple stores?](http://redux.js.org/docs/faq/StoreSetup.html#can-or-should-i-create-multiple-stores-can-i-import-my-store-directly-and-use-it-in-components-myself)
 
 ```js
-import {connect, createProvider} from 'react-redux'
+import { connect, createProvider } from 'react-redux'
 
 const STORE_KEY = 'componentStore'
 
@@ -475,17 +488,13 @@ function connectExtended(
   mapStateToProps,
   mapDispatchToProps,
   mergeProps,
-  options = {}
+  options = {},
 ) {
   options.storeKey = STORE_KEY
-  return connect(
-    mapStateToProps,
-    mapDispatchToProps,
-    mergeProps,
-    options
-  )
+  return connect(mapStateToProps, mapDispatchToProps, mergeProps, options)
 }
 
-export {connectExtended as connect}
+export { connectExtended as connect }
 ```
+
 Now you can import the above `Provider` and `connect` and use them.
diff --git a/website/versioned_docs/version-5.x/api/Provider.md b/website/versioned_docs/version-5.x/api/Provider.md
index f62ef41cf..d24d10c66 100644
--- a/website/versioned_docs/version-5.x/api/Provider.md
+++ b/website/versioned_docs/version-5.x/api/Provider.md
@@ -24,7 +24,6 @@ The single Redux `store` in your application.
 `children` (ReactElement)
 The root of your component hierarchy.
 
-
 ### Example Usage
 
 In the example below, the `<App />` component is our root-level component. This means it’s at the very top of our component hierarchy.
@@ -32,51 +31,50 @@ In the example below, the `<App />` component is our root-level component. This
 **Vanilla React Example**
 
 ```jsx
-    import React from 'react';
-    import ReactDOM from 'react-dom';
-    import { Provider } from 'react-redux';
-
-    import { App } from './App';
-    import createStore from './createReduxStore';
+import React from 'react'
+import ReactDOM from 'react-dom'
+import { Provider } from 'react-redux'
 
-    const store = createStore();
+import { App } from './App'
+import createStore from './createReduxStore'
 
-    ReactDOM.render(
-      <Provider store={store}>
-        <App />
-      </Provider>,
-      document.getElementById('root')
-    )
-```    
+const store = createStore()
 
+ReactDOM.render(
+  <Provider store={store}>
+    <App />
+  </Provider>,
+  document.getElementById('root'),
+)
+```
 
 **Usage with React Router**
 
 ```jsx
-    import React from 'react';
-    import ReactDOM from 'react-dom';
-    import { Provider } from 'react-redux';
-    import { Router, Route } from 'react-router-dom';
-
-    import { App } from './App';
-    import { Foo } from './Foo';
-    import { Bar } from './Bar';
-    import createStore from './createReduxStore';
-
-    const store = createStore();
-
-    ReactDOM.render(
-      <Provider store={store}>
-        <Router history={history}>
-          <Route path="/" component={App}>
-            <Route path="foo" component={Foo}/>
-            <Route path="bar" component={Bar}/>
-          </Route>
-        </Router>
-      </Provider>,
-      document.getElementById('root')
-    )
-```    
+import React from 'react'
+import ReactDOM from 'react-dom'
+import { Provider } from 'react-redux'
+import { Router, Route } from 'react-router-dom'
+
+import { App } from './App'
+import { Foo } from './Foo'
+import { Bar } from './Bar'
+import createStore from './createReduxStore'
+
+const store = createStore()
+
+ReactDOM.render(
+  <Provider store={store}>
+    <Router history={history}>
+      <Route path="/" component={App}>
+        <Route path="foo" component={Foo} />
+        <Route path="bar" component={Bar} />
+      </Route>
+    </Router>
+  </Provider>,
+  document.getElementById('root'),
+)
+```
 
 ## createProvider
 
@@ -88,13 +86,14 @@ Creates a new `<Provider>` which will set the Redux Store on the passed key of t
 
 ### Arguments
 
-* [`storeKey`] (*String*): The key of the context on which to set the store. Default value: `'store'`
+- [`storeKey`] (_String_): The key of the context on which to set the store. Default value: `'store'`
 
 ### Examples
+
 Before creating multiple stores, please go through this FAQ: [Can or should I create multiple stores?](http://redux.js.org/docs/faq/StoreSetup.html#can-or-should-i-create-multiple-stores-can-i-import-my-store-directly-and-use-it-in-components-myself)
 
 ```js
-import {connect, createProvider} from 'react-redux'
+import { connect, createProvider } from 'react-redux'
 
 const STORE_KEY = 'componentStore'
 
@@ -104,17 +103,13 @@ function connectExtended(
   mapStateToProps,
   mapDispatchToProps,
   mergeProps,
-  options = {}
+  options = {},
 ) {
   options.storeKey = STORE_KEY
-  return connect(
-    mapStateToProps,
-    mapDispatchToProps,
-    mergeProps,
-    options
-  )
+  return connect(mapStateToProps, mapDispatchToProps, mergeProps, options)
 }
 
-export {connectExtended as connect}
+export { connectExtended as connect }
 ```
+
 Now you can import the above `Provider` and `connect` and use them.
diff --git a/website/versioned_docs/version-5.x/api/api.md b/website/versioned_docs/version-5.x/api/api.md
index 0e4c1e441..4173fec0f 100644
--- a/website/versioned_docs/version-5.x/api/api.md
+++ b/website/versioned_docs/version-5.x/api/api.md
@@ -8,16 +8,17 @@ hide_title: true
 # API
 
 <a id="provider"></a>
+
 ## Provider
 
 Makes the Redux store available to the `connect()` calls in the component hierarchy below. Normally, you can’t use `connect()` without wrapping a parent or ancestor component in `<Provider>`.
 
-If you *really* need to, you can manually pass `store` as a prop to every `connect()`ed component, but we only recommend to do this for stubbing `store` in unit tests, or in non-fully-React codebases. Normally, you should just use `<Provider>`.
+If you _really_ need to, you can manually pass `store` as a prop to every `connect()`ed component, but we only recommend to do this for stubbing `store` in unit tests, or in non-fully-React codebases. Normally, you should just use `<Provider>`.
 
 ### Props
 
-* `store` (*[Redux Store](https://redux.js.org/api-reference/store)*): The single Redux store in your application.
-* `children` (*ReactElement*) The root of your component hierarchy.
+- `store` (_[Redux Store](https://redux.js.org/api-reference/store)_): The single Redux store in your application.
+- `children` (_ReactElement_) The root of your component hierarchy.
 
 ### Example
 
@@ -28,7 +29,7 @@ ReactDOM.render(
   <Provider store={store}>
     <MyRootComponent />
   </Provider>,
-  rootEl
+  rootEl,
 )
 ```
 
@@ -39,12 +40,11 @@ ReactDOM.render(
   <Provider store={store}>
     <Router history={history}>
       <Route path="/" component={App}>
-        <Route path="foo" component={Foo}/>
-        <Route path="bar" component={Bar}/>
+        <Route path="foo" component={Foo} />
+        <Route path="bar" component={Bar} />
       </Route>
     </Router>
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
-
diff --git a/website/versioned_docs/version-5.x/api/connect-advanced.md b/website/versioned_docs/version-5.x/api/connect-advanced.md
index d2bf78105..b08e5030c 100644
--- a/website/versioned_docs/version-5.x/api/connect-advanced.md
+++ b/website/versioned_docs/version-5.x/api/connect-advanced.md
@@ -13,27 +13,27 @@ connectAdvanced(selectorFactory, [connectOptions])
 
 Connects a React component to a Redux store. It is the base for `connect()` but is less opinionated about how to combine `state`, `props`, and `dispatch` into your final props. It makes no assumptions about defaults or memoization of results, leaving those responsibilities to the caller.
 
-It does not modify the component class passed to it; instead, it *returns* a new, connected component class for you to use.
+It does not modify the component class passed to it; instead, it _returns_ a new, connected component class for you to use.
 
 ### Arguments
 
-* `selectorFactory(dispatch, factoryOptions): selector(state, ownProps): props` \(*Function*): Initializes a selector function (during each instance's constructor). That selector function is called any time the connector component needs to compute new props, as a result of a store state change or receiving new props. The result of `selector` is expected to be a plain object, which is passed as the props to the wrapped component. If a consecutive call to `selector` returns the same object (`===`) as its previous call, the component will not be re-rendered. It's the responsibility of `selector` to return that previous object when appropriate.
+- `selectorFactory(dispatch, factoryOptions): selector(state, ownProps): props` \(_Function_): Initializes a selector function (during each instance's constructor). That selector function is called any time the connector component needs to compute new props, as a result of a store state change or receiving new props. The result of `selector` is expected to be a plain object, which is passed as the props to the wrapped component. If a consecutive call to `selector` returns the same object (`===`) as its previous call, the component will not be re-rendered. It's the responsibility of `selector` to return that previous object when appropriate.
 
-* [`connectOptions`] *(Object)* If specified, further customizes the behavior of the connector.
+- [`connectOptions`] _(Object)_ If specified, further customizes the behavior of the connector.
 
-  * [`getDisplayName`] *(Function)*: computes the connector component's displayName property relative to that of the wrapped component. Usually overridden by wrapper functions. Default value: `name => 'ConnectAdvanced('+name+')'`
+  - [`getDisplayName`] _(Function)_: computes the connector component's displayName property relative to that of the wrapped component. Usually overridden by wrapper functions. Default value: `name => 'ConnectAdvanced('+name+')'`
 
-  * [`methodName`] *(String)*: shown in error messages. Usually overridden by wrapper functions. Default value: `'connectAdvanced'`
+  - [`methodName`] _(String)_: shown in error messages. Usually overridden by wrapper functions. Default value: `'connectAdvanced'`
 
-  * [`renderCountProp`] *(String)*: if defined, a property named this value will be added to the props passed to the wrapped component. Its value will be the number of times the component has been rendered, which can be useful for tracking down unnecessary re-renders. Default value: `undefined`
+  - [`renderCountProp`] _(String)_: if defined, a property named this value will be added to the props passed to the wrapped component. Its value will be the number of times the component has been rendered, which can be useful for tracking down unnecessary re-renders. Default value: `undefined`
 
-  * [`shouldHandleStateChanges`] *(Boolean)*: controls whether the connector component subscribes to redux store state changes. If set to false, it will only re-render when parent component re-renders. Default value:  `true`
+  - [`shouldHandleStateChanges`] _(Boolean)_: controls whether the connector component subscribes to redux store state changes. If set to false, it will only re-render when parent component re-renders. Default value: `true`
 
-  * [`storeKey`] *(String)*: the key of props/context to get the store. You probably only need this if you are in the inadvisable position of having multiple stores. Default value: `'store'`
+  - [`storeKey`] _(String)_: the key of props/context to get the store. You probably only need this if you are in the inadvisable position of having multiple stores. Default value: `'store'`
 
-  * [`withRef`] *(Boolean)*: If true, stores a ref to the wrapped component instance and makes it available via `getWrappedInstance()` method. Default value: `false`
+  - [`withRef`] _(Boolean)_: If true, stores a ref to the wrapped component instance and makes it available via `getWrappedInstance()` method. Default value: `false`
 
-  * Additionally, any extra options passed via `connectOptions` will be passed through to your `selectorFactory` in the `factoryOptions` argument.
+  - Additionally, any extra options passed via `connectOptions` will be passed through to your `selectorFactory` in the `factoryOptions` argument.
 
 <a id="connectAdvanced-returns"></a>
 
@@ -43,7 +43,7 @@ A higher-order React component class that builds props from the store state and
 
 #### Static Properties
 
-* `WrappedComponent` *(Component)*: The original component class passed to `connectAdvanced(...)(Component)`.
+- `WrappedComponent` _(Component)_: The original component class passed to `connectAdvanced(...)(Component)`.
 
 #### Static Methods
 
@@ -57,11 +57,12 @@ Returns the wrapped component instance. Only available if you pass `{ withRef: t
 
 ### Remarks
 
-* Since `connectAdvanced` returns a higher-order component, it needs to be invoked two times. The first time with its arguments as described above, and a second time, with the component: `connectAdvanced(selectorFactory)(MyComponent)`.
+- Since `connectAdvanced` returns a higher-order component, it needs to be invoked two times. The first time with its arguments as described above, and a second time, with the component: `connectAdvanced(selectorFactory)(MyComponent)`.
 
-* `connectAdvanced` does not modify the passed React component. It returns a new, connected component, that you should use instead.
+- `connectAdvanced` does not modify the passed React component. It returns a new, connected component, that you should use instead.
 
 <a id="connectAdvanced-examples"></a>
+
 #### Examples
 
 #### Inject `todos` of a specific user depending on props, and inject `props.userId` into the action
diff --git a/website/versioned_docs/version-5.x/api/connect.md b/website/versioned_docs/version-5.x/api/connect.md
index c3b955526..5d05e616c 100644
--- a/website/versioned_docs/version-5.x/api/connect.md
+++ b/website/versioned_docs/version-5.x/api/connect.md
@@ -12,37 +12,37 @@ connect([mapStateToProps], [mapDispatchToProps], [mergeProps], [options])
 
 Connects a React component to a Redux store. `connect` is a facade around `connectAdvanced`, providing a convenient API for the most common use cases.
 
-It does not modify the component class passed to it; instead, it *returns* a new, connected component class for you to use.
+It does not modify the component class passed to it; instead, it _returns_ a new, connected component class for you to use.
 
 ### Arguments
 
-* [`mapStateToProps(state, [ownProps]): stateProps`] \(*Function*): If this argument is specified, the new component will subscribe to Redux store updates. This means that any time the store is updated, `mapStateToProps` will be called. The results of `mapStateToProps` must be a plain object, which will be merged into the component’s props. If you don't want to subscribe to store updates, pass `null` or `undefined` in place of `mapStateToProps`.
+- [`mapStateToProps(state, [ownProps]): stateProps`] \(_Function_): If this argument is specified, the new component will subscribe to Redux store updates. This means that any time the store is updated, `mapStateToProps` will be called. The results of `mapStateToProps` must be a plain object, which will be merged into the component’s props. If you don't want to subscribe to store updates, pass `null` or `undefined` in place of `mapStateToProps`.
 
-  If your `mapStateToProps` function is declared as taking two parameters, it will be called with the store state as the first parameter and the props passed to the connected component as the second parameter, and will also be re-invoked whenever the connected component receives new props as determined by shallow equality comparisons.  (The second parameter is normally referred to as `ownProps` by convention.)
+  If your `mapStateToProps` function is declared as taking two parameters, it will be called with the store state as the first parameter and the props passed to the connected component as the second parameter, and will also be re-invoked whenever the connected component receives new props as determined by shallow equality comparisons. (The second parameter is normally referred to as `ownProps` by convention.)
 
-  >Note: in advanced scenarios where you need more control over the rendering performance, `mapStateToProps()` can also return a function. In this case, *that* function will be used as `mapStateToProps()` for a particular component instance. This allows you to do per-instance memoization. You can refer to [#279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds for more details. Most apps never need this.
+  > Note: in advanced scenarios where you need more control over the rendering performance, `mapStateToProps()` can also return a function. In this case, _that_ function will be used as `mapStateToProps()` for a particular component instance. This allows you to do per-instance memoization. You can refer to [#279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds for more details. Most apps never need this.
 
-  >The `mapStateToProps` function's first argument is the entire Redux store’s state and it returns an object to be passed as props. It is often called a **selector**. Use [reselect](https://github.com/reduxjs/reselect) to efficiently compose selectors and [compute derived data](https://redux.js.org/recipes/computing-derived-data).
+  > The `mapStateToProps` function's first argument is the entire Redux store’s state and it returns an object to be passed as props. It is often called a **selector**. Use [reselect](https://github.com/reduxjs/reselect) to efficiently compose selectors and [compute derived data](https://redux.js.org/recipes/computing-derived-data).
 
-* [`mapDispatchToProps(dispatch, [ownProps]): dispatchProps`] \(*Object* or *Function*): If an object is passed, each function inside it is assumed to be a Redux action creator. An object with the same function names, but with every action creator wrapped into a `dispatch` call so they may be invoked directly, will be merged into the component’s props.  
+- [`mapDispatchToProps(dispatch, [ownProps]): dispatchProps`] \(_Object_ or _Function_): If an object is passed, each function inside it is assumed to be a Redux action creator. An object with the same function names, but with every action creator wrapped into a `dispatch` call so they may be invoked directly, will be merged into the component’s props.
 
-  If a function is passed, it will be given `dispatch` as the first parameter.  It’s up to you to return an object that somehow uses `dispatch` to bind action creators in your own way. (Tip: you may use the [`bindActionCreators()`](https://redux.js.org/api-reference/bindactioncreators) helper from Redux.)  
+  If a function is passed, it will be given `dispatch` as the first parameter. It’s up to you to return an object that somehow uses `dispatch` to bind action creators in your own way. (Tip: you may use the [`bindActionCreators()`](https://redux.js.org/api-reference/bindactioncreators) helper from Redux.)
 
-  If your `mapDispatchToProps` function is declared as taking two parameters, it will be called with `dispatch` as the first parameter and the props passed to the connected component as the second parameter, and will be re-invoked whenever the connected component receives new props.  (The second parameter is normally referred to as `ownProps` by convention.)
+  If your `mapDispatchToProps` function is declared as taking two parameters, it will be called with `dispatch` as the first parameter and the props passed to the connected component as the second parameter, and will be re-invoked whenever the connected component receives new props. (The second parameter is normally referred to as `ownProps` by convention.)
 
   If you do not supply your own `mapDispatchToProps` function or object full of action creators, the default `mapDispatchToProps` implementation just injects `dispatch` into your component’s props.
 
-  >Note: in advanced scenarios where you need more control over the rendering performance, `mapDispatchToProps()` can also return a function. In this case, *that* function will be used as `mapDispatchToProps()` for a particular component instance. This allows you to do per-instance memoization. You can refer to [#279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds for more details. Most apps never need this.
+  > Note: in advanced scenarios where you need more control over the rendering performance, `mapDispatchToProps()` can also return a function. In this case, _that_ function will be used as `mapDispatchToProps()` for a particular component instance. This allows you to do per-instance memoization. You can refer to [#279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds for more details. Most apps never need this.
 
-* [`mergeProps(stateProps, dispatchProps, ownProps): props`] \(*Function*): If specified, it is passed the result of `mapStateToProps()`, `mapDispatchToProps()`, and the parent `props`. The plain object you return from it will be passed as props to the wrapped component. You may specify this function to select a slice of the state based on props, or to bind action creators to a particular variable from props. If you omit it, `Object.assign({}, ownProps, stateProps, dispatchProps)` is used by default.
+- [`mergeProps(stateProps, dispatchProps, ownProps): props`] \(_Function_): If specified, it is passed the result of `mapStateToProps()`, `mapDispatchToProps()`, and the parent `props`. The plain object you return from it will be passed as props to the wrapped component. You may specify this function to select a slice of the state based on props, or to bind action creators to a particular variable from props. If you omit it, `Object.assign({}, ownProps, stateProps, dispatchProps)` is used by default.
 
-* [`options`] *(Object)* If specified, further customizes the behavior of the connector. In addition to the options passable to `connectAdvanced()` (see those below), `connect()` accepts these additional options:
-  * [`pure`] *(Boolean)*: If true, `connect()` will avoid re-renders and calls to `mapStateToProps`, `mapDispatchToProps`, and `mergeProps` if the relevant state/props objects remain equal based on their respective equality checks. Assumes that the wrapped component is a “pure” component and does not rely on any input or state other than its props and the selected Redux store’s state. Default value: `true`
-  * [`areStatesEqual`] *(Function)*: When pure, compares incoming store state to its previous value. Default value: `strictEqual (===)`
-  * [`areOwnPropsEqual`] *(Function)*: When pure, compares incoming props to its previous value. Default value: `shallowEqual`
-  * [`areStatePropsEqual`] *(Function)*: When pure, compares the result of `mapStateToProps` to its previous value. Default value: `shallowEqual`
-  * [`areMergedPropsEqual`] *(Function)*: When pure, compares the result of `mergeProps` to its previous value. Default value: `shallowEqual`
-  * [`storeKey`] *(String)*: The key of the context from where to read the store. You probably only need this if you are in the inadvisable position of having multiple stores. Default value: `'store'`
+- [`options`] _(Object)_ If specified, further customizes the behavior of the connector. In addition to the options passable to `connectAdvanced()` (see those below), `connect()` accepts these additional options:
+  - [`pure`] _(Boolean)_: If true, `connect()` will avoid re-renders and calls to `mapStateToProps`, `mapDispatchToProps`, and `mergeProps` if the relevant state/props objects remain equal based on their respective equality checks. Assumes that the wrapped component is a “pure” component and does not rely on any input or state other than its props and the selected Redux store’s state. Default value: `true`
+  - [`areStatesEqual`] _(Function)_: When pure, compares incoming store state to its previous value. Default value: `strictEqual (===)`
+  - [`areOwnPropsEqual`] _(Function)_: When pure, compares incoming props to its previous value. Default value: `shallowEqual`
+  - [`areStatePropsEqual`] _(Function)_: When pure, compares the result of `mapStateToProps` to its previous value. Default value: `shallowEqual`
+  - [`areMergedPropsEqual`] _(Function)_: When pure, compares the result of `mergeProps` to its previous value. Default value: `shallowEqual`
+  - [`storeKey`] _(String)_: The key of the context from where to read the store. You probably only need this if you are in the inadvisable position of having multiple stores. Default value: `'store'`
 
 #### The arity of mapStateToProps and mapDispatchToProps determines whether they receive ownProps
 
@@ -50,34 +50,38 @@ It does not modify the component class passed to it; instead, it *returns* a new
 
 ```js
 function mapStateToProps(state) {
-  console.log(state); // state
-  console.log(arguments[1]); // undefined
+  console.log(state) // state
+  console.log(arguments[1]) // undefined
 }
 ```
+
 ```js
 const mapStateToProps = (state, ownProps = {}) => {
-  console.log(state); // state
-  console.log(ownProps); // {}
+  console.log(state) // state
+  console.log(ownProps) // {}
 }
 ```
 
 Functions with no mandatory parameters or two parameters **will receive** `ownProps`.
+
 ```js
 const mapStateToProps = (state, ownProps) => {
-  console.log(state); // state
-  console.log(ownProps); // ownProps
+  console.log(state) // state
+  console.log(ownProps) // ownProps
 }
 ```
+
 ```js
 function mapStateToProps() {
-  console.log(arguments[0]); // state
-  console.log(arguments[1]); // ownProps
+  console.log(arguments[0]) // state
+  console.log(arguments[1]) // ownProps
 }
 ```
+
 ```js
 const mapStateToProps = (...args) => {
-  console.log(args[0]); // state
-  console.log(args[1]); // ownProps
+  console.log(args[0]) // state
+  console.log(args[1]) // ownProps
 }
 ```
 
@@ -85,21 +89,22 @@ const mapStateToProps = (...args) => {
 
 When `options.pure` is true, `connect` performs several equality checks that are used to avoid unnecessary calls to `mapStateToProps`, `mapDispatchToProps`, `mergeProps`, and ultimately to `render`. These include `areStatesEqual`, `areOwnPropsEqual`, `areStatePropsEqual`, and `areMergedPropsEqual`. While the defaults are probably appropriate 99% of the time, you may wish to override them with custom implementations for performance or other reasons. Here are several examples:
 
-* You may wish to override `areStatesEqual` if your `mapStateToProps` function is computationally expensive and is also only concerned with a small slice of your state. For example: `areStatesEqual: (next, prev) => prev.entities.todos === next.entities.todos`; this would effectively ignore state changes for everything but that slice of state.
+- You may wish to override `areStatesEqual` if your `mapStateToProps` function is computationally expensive and is also only concerned with a small slice of your state. For example: `areStatesEqual: (next, prev) => prev.entities.todos === next.entities.todos`; this would effectively ignore state changes for everything but that slice of state.
 
-* You may wish to override `areStatesEqual` to always return false (`areStatesEqual: () => false`) if you have impure reducers that mutate your store state. (This would likely impact the other equality checks as well, depending on your `mapStateToProps` function.)
+- You may wish to override `areStatesEqual` to always return false (`areStatesEqual: () => false`) if you have impure reducers that mutate your store state. (This would likely impact the other equality checks as well, depending on your `mapStateToProps` function.)
 
-* You may wish to override `areOwnPropsEqual` as a way to whitelist incoming props. You'd also have to implement `mapStateToProps`, `mapDispatchToProps` and `mergeProps` to also whitelist props. (It may be simpler to achieve this other ways, for example by using [recompose's mapProps](https://github.com/acdlite/recompose/blob/master/docs/API.md#mapprops).)
+- You may wish to override `areOwnPropsEqual` as a way to whitelist incoming props. You'd also have to implement `mapStateToProps`, `mapDispatchToProps` and `mergeProps` to also whitelist props. (It may be simpler to achieve this other ways, for example by using [recompose's mapProps](https://github.com/acdlite/recompose/blob/master/docs/API.md#mapprops).)
 
-* You may wish to override `areStatePropsEqual` to use `strictEqual` if your `mapStateToProps` uses a memoized selector that will only return a new object if a relevant prop has changed. This would be a very slight performance improvement, since would avoid extra equality checks on individual props each time `mapStateToProps` is called.
+- You may wish to override `areStatePropsEqual` to use `strictEqual` if your `mapStateToProps` uses a memoized selector that will only return a new object if a relevant prop has changed. This would be a very slight performance improvement, since would avoid extra equality checks on individual props each time `mapStateToProps` is called.
 
-* You may wish to override `areMergedPropsEqual` to implement a `deepEqual` if your selectors produce complex props. ex: nested objects, new arrays, etc. (The deep equal check should be faster than just re-rendering.)
+- You may wish to override `areMergedPropsEqual` to implement a `deepEqual` if your selectors produce complex props. ex: nested objects, new arrays, etc. (The deep equal check should be faster than just re-rendering.)
 
 ### Returns
 
 A higher-order React component class that passes state and action creators into your component derived from the supplied arguments. This is created by `connectAdvanced`, and details of this higher-order component are covered there.
 
 <a id="connect-examples"></a>
+
 #### Examples
 
 #### Inject just `dispatch` and don't listen to store
@@ -108,7 +113,7 @@ A higher-order React component class that passes state and action creators into
 export default connect()(TodoApp)
 ```
 
-#### Inject all action creators  (`addTodo`, `completeTodo`, ...) without subscribing to the store
+#### Inject all action creators (`addTodo`, `completeTodo`, ...) without subscribing to the store
 
 ```js
 import * as actionCreators from './actionCreators'
@@ -118,12 +123,12 @@ export default connect(null, actionCreators)(TodoApp)
 
 #### Inject `dispatch` and every field in the global state
 
->Don’t do this! It kills any performance optimizations because `TodoApp` will rerender after every state change.  
->It’s better to have more granular `connect()` on several components in your view hierarchy that each only  
->listen to a relevant slice of the state.
+> Don’t do this! It kills any performance optimizations because `TodoApp` will rerender after every state change.  
+> It’s better to have more granular `connect()` on several components in your view hierarchy that each only  
+> listen to a relevant slice of the state.
 
 ```js
-export default connect(state => state)(TodoApp)
+export default connect((state) => state)(TodoApp)
 ```
 
 #### Inject `dispatch` and `todos`
@@ -165,7 +170,7 @@ function mapDispatchToProps(dispatch) {
 export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
-####  Inject `todos` and a specific action creator (`addTodo`)
+#### Inject `todos` and a specific action creator (`addTodo`)
 
 ```js
 import { addTodo } from './actionCreators'
@@ -182,7 +187,7 @@ function mapDispatchToProps(dispatch) {
 export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
-####  Inject `todos` and specific action creators (`addTodo` and `deleteTodo`) with shorthand syntax
+#### Inject `todos` and specific action creators (`addTodo` and `deleteTodo`) with shorthand syntax
 
 ```js
 import { addTodo, deleteTodo } from './actionCreators'
@@ -193,7 +198,7 @@ function mapStateToProps(state) {
 
 const mapDispatchToProps = {
   addTodo,
-  deleteTodo
+  deleteTodo,
 }
 
 export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
@@ -213,7 +218,7 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return {
     todoActions: bindActionCreators(todoActionCreators, dispatch),
-    counterActions: bindActionCreators(counterActionCreators, dispatch)
+    counterActions: bindActionCreators(counterActionCreators, dispatch),
   }
 }
 
@@ -233,7 +238,10 @@ function mapStateToProps(state) {
 
 function mapDispatchToProps(dispatch) {
   return {
-    actions: bindActionCreators(Object.assign({}, todoActionCreators, counterActionCreators), dispatch)
+    actions: bindActionCreators(
+      Object.assign({}, todoActionCreators, counterActionCreators),
+      dispatch,
+    ),
   }
 }
 
@@ -252,7 +260,10 @@ function mapStateToProps(state) {
 }
 
 function mapDispatchToProps(dispatch) {
-  return bindActionCreators(Object.assign({}, todoActionCreators, counterActionCreators), dispatch)
+  return bindActionCreators(
+    Object.assign({}, todoActionCreators, counterActionCreators),
+    dispatch,
+  )
 }
 
 export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
@@ -282,7 +293,7 @@ function mapStateToProps(state) {
 function mergeProps(stateProps, dispatchProps, ownProps) {
   return Object.assign({}, ownProps, {
     todos: stateProps.todos[ownProps.userId],
-    addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text)
+    addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text),
   })
 }
 
diff --git a/website/versioned_docs/version-5.x/introduction/basic-tutorial.md b/website/versioned_docs/version-5.x/introduction/basic-tutorial.md
index 1daa49c17..4ca9a4495 100644
--- a/website/versioned_docs/version-5.x/introduction/basic-tutorial.md
+++ b/website/versioned_docs/version-5.x/introduction/basic-tutorial.md
@@ -74,20 +74,20 @@ First we need to make the `store` available to our app. To do this, we wrap our
 
 ```jsx
 // index.js
-import React from "react";
-import ReactDOM from "react-dom";
-import TodoApp from "./TodoApp";
+import React from 'react'
+import ReactDOM from 'react-dom'
+import TodoApp from './TodoApp'
 
-import { Provider } from "react-redux";
-import store from "./redux/store";
+import { Provider } from 'react-redux'
+import store from './redux/store'
 
-const rootElement = document.getElementById("root");
+const rootElement = document.getElementById('root')
 ReactDOM.render(
   <Provider store={store}>
     <TodoApp />
   </Provider>,
-  rootElement
-);
+  rootElement,
+)
 ```
 
 Notice how our `<TodoApp />` is now wrapped with the `<Provider />` with `store` passed in as a prop.
@@ -96,7 +96,7 @@ Notice how our `<TodoApp />` is now wrapped with the `<Provider />` with `store`
 
 ### Connecting the Components
 
-React-Redux provides a `connect` function for you to read values from the Redux store (and re-read the values when the store updates). 
+React-Redux provides a `connect` function for you to read values from the Redux store (and re-read the values when the store updates).
 
 The `connect` function takes two arguments, both optional:
 
@@ -111,25 +111,19 @@ Normally, you’ll call `connect` in this way:
 ```js
 const mapStateToProps = (state, ownProps) => ({
   // ... computed data from state and optionally ownProps
-});
+})
 
 const mapDispatchToProps = {
   // ... normally is an object full of action creators
-};
+}
 
 // `connect` returns a new function that accepts the component to wrap:
-const connectToStore = connect(
-  mapStateToProps,
-  mapDispatchToProps
-);
+const connectToStore = connect(mapStateToProps, mapDispatchToProps)
 // and that function returns the connected, wrapper component:
-const ConnectedComponent = connectToStore(Component);
+const ConnectedComponent = connectToStore(Component)
 
 // We normally do both in one step, like this:
-connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(Component);
+connect(mapStateToProps, mapDispatchToProps)(Component)
 ```
 
 Let’s work on `<AddTodo />` first. It needs to trigger changes to the `store` to add new todos. Therefore, it needs to be able to `dispatch` actions to the store. Here’s how we do it.
@@ -138,16 +132,16 @@ Our `addTodo` action creator looks like this:
 
 ```js
 // redux/actions.js
-import { ADD_TODO } from "./actionTypes";
+import { ADD_TODO } from './actionTypes'
 
-let nextTodoId = 0;
-export const addTodo = content => ({
+let nextTodoId = 0
+export const addTodo = (content) => ({
   type: ADD_TODO,
   payload: {
     id: ++nextTodoId,
-    content
-  }
-});
+    content,
+  },
+})
 
 // ... other actions
 ```
@@ -158,17 +152,14 @@ By passing it to `connect`, our component receives it as a prop, and it will aut
 // components/AddTodo.js
 
 // ... other imports
-import { connect } from "react-redux";
-import { addTodo } from "../redux/actions";
+import { connect } from 'react-redux'
+import { addTodo } from '../redux/actions'
 
 class AddTodo extends React.Component {
   // ... component implementation
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo);
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Notice now that `<AddTodo />` is wrapped with a parent component called `<Connect(AddTodo) />`. Meanwhile, `<AddTodo />` now gains one prop: the `addTodo` action.
@@ -180,40 +171,37 @@ We also need to implement the `handleAddTodo` function to let it dispatch the `a
 ```jsx
 // components/AddTodo.js
 
-import React from "react";
-import { connect } from "react-redux";
-import { addTodo } from "../redux/actions";
+import React from 'react'
+import { connect } from 'react-redux'
+import { addTodo } from '../redux/actions'
 
 class AddTodo extends React.Component {
   // ...
 
   handleAddTodo = () => {
     // dispatches actions to add todo
-    this.props.addTodo(this.state.input);
+    this.props.addTodo(this.state.input)
 
     // sets state back to empty string
-    this.setState({ input: "" });
-  };
+    this.setState({ input: '' })
+  }
 
   render() {
     return (
       <div>
         <input
-          onChange={e => this.updateInput(e.target.value)}
+          onChange={(e) => this.updateInput(e.target.value)}
           value={this.state.input}
         />
         <button className="add-todo" onClick={this.handleAddTodo}>
           Add Todo
         </button>
       </div>
-    );
+    )
   }
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo);
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Now our `<AddTodo />` is connected to the store. When we add a todo it would dispatch an action to change the store. We are not seeing it in the app because the other components are not connected yet. If you have the Redux DevTools Extension hooked up, you should see the action being dispatched:
@@ -253,16 +241,16 @@ Luckily we have a selector that does exactly this. We may simply import the sele
 ```js
 // redux/selectors.js
 
-export const getTodosState = store => store.todos;
+export const getTodosState = (store) => store.todos
 
-export const getTodoList = store =>
-  getTodosState(store) ? getTodosState(store).allIds : [];
+export const getTodoList = (store) =>
+  getTodosState(store) ? getTodosState(store).allIds : []
 
 export const getTodoById = (store, id) =>
-  getTodosState(store) ? { ...getTodosState(store).byIds[id], id } : {};
+  getTodosState(store) ? { ...getTodosState(store).byIds[id], id } : {}
 
-export const getTodos = store =>
-  getTodoList(store).map(id => getTodoById(store, id));
+export const getTodos = (store) =>
+  getTodoList(store).map((id) => getTodoById(store, id))
 ```
 
 ```js
@@ -303,7 +291,7 @@ If you call `connect` without providing any arguments, your component will:
 
 ```js
 // ... Component
-export default connect()(Component); // Component will receive `dispatch` (just like our <TodoList />!)
+export default connect()(Component) // Component will receive `dispatch` (just like our <TodoList />!)
 ```
 
 #### Subscribe to the store and do not inject action creators
@@ -315,8 +303,8 @@ If you call `connect` with only `mapStateToProps`, your component will:
 
 ```js
 // ... Component
-const mapStateToProps = state => state.partOfState;
-export default connect(mapStateToProps)(Component);
+const mapStateToProps = (state) => state.partOfState
+export default connect(mapStateToProps)(Component)
 ```
 
 #### Do not subscribe to the store and inject action creators
@@ -327,12 +315,9 @@ If you call `connect` with only `mapDispatchToProps`, your component will:
 - receive each of the action creators you inject with `mapDispatchToProps` as props and automatically dispatch the actions upon being called
 
 ```js
-import { addTodo } from "./actionCreators";
+import { addTodo } from './actionCreators'
 // ... Component
-export default connect(
-  null,
-  { addTodo }
-)(Component);
+export default connect(null, { addTodo })(Component)
 ```
 
 #### Subscribe to the store and inject action creators
@@ -343,13 +328,10 @@ If you call `connect` with both `mapStateToProps` and `mapDispatchToProps`, your
 - receive all of the action creators you inject with `mapDispatchToProps` as props and automatically dispatch the actions upon being called.
 
 ```js
-import * as actionCreators from "./actionCreators";
+import * as actionCreators from './actionCreators'
 // ... Component
-const mapStateToProps = state => state.partOfState;
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(Component);
+const mapStateToProps = (state) => state.partOfState
+export default connect(mapStateToProps, actionCreators)(Component)
 ```
 
 These four cases cover the most basic usages of `connect`. To read more about `connect`, continue reading our [API section](../api/api.md) that explains it in more detail.
@@ -410,17 +392,17 @@ Meanwhile, we also need to update our `<TodoList />` component to filter todos a
 
 // ... other selectors
 export const getTodosByVisibilityFilter = (store, visibilityFilter) => {
-  const allTodos = getTodos(store);
+  const allTodos = getTodos(store)
   switch (visibilityFilter) {
     case VISIBILITY_FILTERS.COMPLETED:
-      return allTodos.filter(todo => todo.completed);
+      return allTodos.filter((todo) => todo.completed)
     case VISIBILITY_FILTERS.INCOMPLETE:
-      return allTodos.filter(todo => !todo.completed);
+      return allTodos.filter((todo) => !todo.completed)
     case VISIBILITY_FILTERS.ALL:
     default:
-      return allTodos;
+      return allTodos
   }
-};
+}
 ```
 
 And connecting to the store with the help of the selector:
@@ -430,13 +412,13 @@ And connecting to the store with the help of the selector:
 
 // ...
 
-const mapStateToProps = state => {
-  const { visibilityFilter } = state;
-  const todos = getTodosByVisibilityFilter(state, visibilityFilter);
-  return { todos };
-};
+const mapStateToProps = (state) => {
+  const { visibilityFilter } = state
+  const todos = getTodosByVisibilityFilter(state, visibilityFilter)
+  return { todos }
+}
 
-export default connect(mapStateToProps)(TodoList);
+export default connect(mapStateToProps)(TodoList)
 ```
 
 Now we've finished a very simple example of a todo app with React-Redux. All our components are connected! Isn't that nice? 🎉🎊
diff --git a/website/versioned_docs/version-5.x/introduction/quick-start.md b/website/versioned_docs/version-5.x/introduction/quick-start.md
index e137ab718..ca8bfb388 100644
--- a/website/versioned_docs/version-5.x/introduction/quick-start.md
+++ b/website/versioned_docs/version-5.x/introduction/quick-start.md
@@ -28,21 +28,21 @@ yarn add react-redux
 React-Redux provides `<Provider />`, which makes the Redux store available to the rest of your app:
 
 ```js
-import React from "react";
-import ReactDOM from "react-dom";
+import React from 'react'
+import ReactDOM from 'react-dom'
 
-import { Provider } from "react-redux";
-import store from "./store";
+import { Provider } from 'react-redux'
+import store from './store'
 
-import App from "./App";
+import App from './App'
 
-const rootElement = document.getElementById("root");
+const rootElement = document.getElementById('root')
 ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  rootElement
-);
+  rootElement,
+)
 ```
 
 React-Redux provides a `connect` function for you to connect your component to the store.
@@ -50,21 +50,18 @@ React-Redux provides a `connect` function for you to connect your component to t
 Normally, you’ll call `connect` in this way:
 
 ```js
-import { connect } from "react-redux";
-import { increment, decrement, reset } from "./actionCreators";
+import { connect } from 'react-redux'
+import { increment, decrement, reset } from './actionCreators'
 
 // const Counter = ...
 
 const mapStateToProps = (state /*, ownProps*/) => {
   return {
-    counter: state.counter
-  };
-};
+    counter: state.counter,
+  }
+}
 
-const mapDispatchToProps = { increment, decrement, reset };
+const mapDispatchToProps = { increment, decrement, reset }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(Counter);
+export default connect(mapStateToProps, mapDispatchToProps)(Counter)
 ```
diff --git a/website/versioned_docs/version-5.x/troubleshooting.md b/website/versioned_docs/version-5.x/troubleshooting.md
index 83270fa47..7490c7386 100644
--- a/website/versioned_docs/version-5.x/troubleshooting.md
+++ b/website/versioned_docs/version-5.x/troubleshooting.md
@@ -10,7 +10,8 @@ hide_title: true
 Make sure to check out [Troubleshooting Redux](http://redux.js.org/docs/Troubleshooting.html) first.
 
 ### I'm getting the following alert: Accessing PropTypes via the main React package is deprecated. Use the prop-types package from npm instead.
-This warning is shown when using react 15.5.*. Basically, now it's just a warning, but in react16 the application might break. the PropTypes should now be imported from 'prop-types' package, and not from the react package.
+
+This warning is shown when using react 15.5.\*. Basically, now it's just a warning, but in react16 the application might break. the PropTypes should now be imported from 'prop-types' package, and not from the react package.
 
 Update to the latest version of react-redux.
 
@@ -19,8 +20,8 @@ Update to the latest version of react-redux.
 See the link above.
 In short,
 
-* Reducers should never mutate state, they must return new objects, or React Redux won’t see the updates.
-* Make sure you either bind action creators with the `mapDispatchToProps` argument to `connect()` or with the `bindActionCreators()` method, or that you manually call `dispatch()`. Just calling your `MyActionCreators.addTodo()` function won’t work because it just *returns* an action, but does not *dispatch* it.
+- Reducers should never mutate state, they must return new objects, or React Redux won’t see the updates.
+- Make sure you either bind action creators with the `mapDispatchToProps` argument to `connect()` or with the `bindActionCreators()` method, or that you manually call `dispatch()`. Just calling your `MyActionCreators.addTodo()` function won’t work because it just _returns_ an action, but does not _dispatch_ it.
 
 ### My views aren’t updating on route change with React Router 0.13
 
@@ -29,13 +30,14 @@ If you’re using React Router 0.13, you might [bump into this problem](https://
 Root view:
 
 ```jsx
-Router.run(routes, Router.HistoryLocation, (Handler, routerState) => { // note "routerState" here
+Router.run(routes, Router.HistoryLocation, (Handler, routerState) => {
+  // note "routerState" here
   ReactDOM.render(
     <Provider store={store}>
       {/* note "routerState" here */}
       <Handler routerState={routerState} />
     </Provider>,
-    document.getElementById('root')
+    document.getElementById('root'),
   )
 })
 ```
@@ -56,7 +58,7 @@ You can also upgrade to React Router 1.0 which shouldn’t have this problem. (L
 
 If your views depend on global state or [React “context”](http://facebook.github.io/react/docs/context.html), you might find that views decorated with `connect()` will fail to update.
 
->This is because `connect()` implements [shouldComponentUpdate](https://facebook.github.io/react/docs/component-specs.html#updating-shouldcomponentupdate) by default, assuming that your component will produce the same results given the same props and state. This is a similar concept to React’s [PureRenderMixin](https://facebook.github.io/react/docs/pure-render-mixin.html).
+> This is because `connect()` implements [shouldComponentUpdate](https://facebook.github.io/react/docs/component-specs.html#updating-shouldcomponentupdate) by default, assuming that your component will produce the same results given the same props and state. This is a similar concept to React’s [PureRenderMixin](https://facebook.github.io/react/docs/pure-render-mixin.html).
 
 The _best_ solution to this is to make sure that your components are pure and pass any external state to them via props. This will ensure that your views do not re-render unless they actually need to re-render and will greatly speed up your application.
 
@@ -68,7 +70,7 @@ function mapStateToProps(state) {
 }
 
 export default connect(mapStateToProps, null, null, {
-  pure: false
+  pure: false,
 })(TodoApp)
 ```
 
diff --git a/website/versioned_docs/version-5.x/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md b/website/versioned_docs/version-5.x/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
index a236e5265..1d6879ad9 100644
--- a/website/versioned_docs/version-5.x/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
+++ b/website/versioned_docs/version-5.x/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapdispatch
-title: "Connect: Dispatching Actions with mapDispatchToProps"
+title: 'Connect: Dispatching Actions with mapDispatchToProps'
 hide_title: true
-sidebar_label: "Connect: Dispatching Actions with mapDispatchToProps"
+sidebar_label: 'Connect: Dispatching Actions with mapDispatchToProps'
 ---
 
 # Connect: Dispatching Actions with `mapDispatchToProps`
@@ -27,15 +27,12 @@ The `mapDispatchToProps` functions are normally referred to as `mapDispatch` for
 If you don't specify the second argument to `connect()`, your component will receive `dispatch` by default. For example:
 
 ```js
-connect()(MyComponent);
+connect()(MyComponent)
 // which is equivalent with
-connect(
-  null,
-  null
-)(MyComponent);
+connect(null, null)(MyComponent)
 
 // or
-connect(mapStateToProps /** no second argument */)(MyComponent);
+connect(mapStateToProps /** no second argument */)(MyComponent)
 ```
 
 Once you have connected your component in this way, your component receives `props.dispatch`. You may use it to dispatch actions to the store.
@@ -44,12 +41,12 @@ Once you have connected your component in this way, your component receives `pro
 function Counter({ count, dispatch }) {
   return (
     <div>
-      <button onClick={() => dispatch({ type: "DECREMENT" })}>-</button>
+      <button onClick={() => dispatch({ type: 'DECREMENT' })}>-</button>
       <span>{count}</span>
-      <button onClick={() => dispatch({ type: "INCREMENT" })}>+</button>
-      <button onClick={() => dispatch({ type: "RESET" })}>reset</button>
+      <button onClick={() => dispatch({ type: 'INCREMENT' })}>+</button>
+      <button onClick={() => dispatch({ type: 'RESET' })}>reset</button>
     </div>
-  );
+  )
 }
 ```
 
@@ -85,11 +82,11 @@ This allows more components to dispatch actions, while keeping them "unaware" of
 // making Todo able to dispatch the toggleTodo action
 const TodoList = ({ todos, toggleTodo }) => (
   <div>
-    {todos.map(todo => (
+    {todos.map((todo) => (
       <Todo todo={todo} onClick={toggleTodo} />
     ))}
   </div>
-);
+)
 ```
 
 This is what React-Redux’s `connect` does — it encapsulates the logic of talking to the Redux store and lets you not worry about it. And this is what you should totally make full use of in your implementation.
@@ -120,29 +117,29 @@ The `mapDispatchToProps` function will be called with `dispatch` as the first ar
 You will normally make use of this by returning new functions that call `dispatch()` inside themselves, and either pass in a plain action object directly or pass in the result of an action creator.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
-    increment: () => dispatch({ type: "INCREMENT" }),
-    decrement: () => dispatch({ type: "DECREMENT" }),
-    reset: () => dispatch({ type: "RESET" })
-  };
-};
+    increment: () => dispatch({ type: 'INCREMENT' }),
+    decrement: () => dispatch({ type: 'DECREMENT' }),
+    reset: () => dispatch({ type: 'RESET' }),
+  }
+}
 ```
 
 You will also likely want to forward arguments to your action creators:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // explicitly forwarding arguments
-    onClick: event => dispatch(trackClick(event)),
+    onClick: (event) => dispatch(trackClick(event)),
 
     // implicitly forwarding arguments
     onReceiveImpressions: (...impressions) =>
-      dispatch(trackImpressions(impressions))
-  };
-};
+      dispatch(trackImpressions(impressions)),
+  }
+}
 ```
 
 **`ownProps` ( optional )**
@@ -153,12 +150,12 @@ This means, instead of re-binding new `props` to action dispatchers upon compone
 
 ```js
 // binds on component re-rendering
-<button onClick={() => this.props.toggleTodo(this.props.todoId)} />;
+;<button onClick={() => this.props.toggleTodo(this.props.todoId)} />
 
 // binds on `props` change
 const mapDispatchToProps = (dispatch, ownProps) => {
-  toggleTodo: () => dispatch(toggleTodo(ownProps.todoId));
-};
+  toggleTodo: () => dispatch(toggleTodo(ownProps.todoId))
+}
 ```
 
 ### Return
@@ -169,18 +166,18 @@ Your `mapDispatchToProps` function should return a plain object:
 - If you use action creators ( as oppose to plain object actions ) inside `dispatch`, it is a convention to simply name the field key the same name as the action creator:
 
 ```js
-const increment = () => ({ type: "INCREMENT" });
-const decrement = () => ({ type: "DECREMENT" });
-const reset = () => ({ type: "RESET" });
+const increment = () => ({ type: 'INCREMENT' })
+const decrement = () => ({ type: 'DECREMENT' })
+const reset = () => ({ type: 'RESET' })
 
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching actions returned by action creators
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
-    reset: () => dispatch(reset())
-  };
-};
+    reset: () => dispatch(reset()),
+  }
+}
 ```
 
 The return of the `mapDispatchToProps` function will be merged to your connected component as props. You may call them directly to dispatch its action.
@@ -194,7 +191,7 @@ function Counter({ count, increment, decrement, reset }) {
       <button onClick={increment}>+</button>
       <button onClick={reset}>reset</button>
     </div>
-  );
+  )
 }
 ```
 
@@ -214,18 +211,21 @@ Wrapping these functions by hand is tedious, so Redux provides a function to sim
 The wrapper functions generated by `bindActionCreators` will automatically forward all of their arguments, so you don't need to do that by hand.
 
 ```js
-import { bindActionCreators } from "redux";
+import { bindActionCreators } from 'redux'
 
-const increment = () => ({ type: "INCREMENT" });
-const decrement = () => ({ type: "DECREMENT" });
-const reset = () => ({ type: "RESET" });
+const increment = () => ({ type: 'INCREMENT' })
+const decrement = () => ({ type: 'DECREMENT' })
+const reset = () => ({ type: 'RESET' })
 
 // binding an action creator
 // returns (...args) => dispatch(increment(...args))
-const boundIncrement = bindActionCreators(increment, dispatch);
+const boundIncrement = bindActionCreators(increment, dispatch)
 
 // binding an object full of action creators
-const boundActionCreators = bindActionCreators({ increment, decrement, reset }, dispatch);
+const boundActionCreators = bindActionCreators(
+  { increment, decrement, reset },
+  dispatch,
+)
 // returns
 // {
 //   increment: (...args) => dispatch(increment(...args)),
@@ -237,18 +237,15 @@ const boundActionCreators = bindActionCreators({ increment, decrement, reset },
 To use `bindActionCreators` in our `mapDispatchToProps` function:
 
 ```js
-import { bindActionCreators } from "redux";
+import { bindActionCreators } from 'redux'
 // ...
 
 function mapDispatchToProps(dispatch) {
-  return bindActionCreators({ increment, decrement, reset }, dispatch);
+  return bindActionCreators({ increment, decrement, reset }, dispatch)
 }
 
 // component receives props.increment, props.decrement, props.reset
-connect(
-  null,
-  mapDispatchToProps
-)(Counter);
+connect(null, mapDispatchToProps)(Counter)
 ```
 
 ### Manually Injecting `dispatch`
@@ -256,14 +253,14 @@ connect(
 If the `mapDispatchToProps` argument is supplied, the component will no longer receive the default `dispatch`. You may bring it back by adding it manually to the return of your `mapDispatchToProps`, although most of the time you shouldn’t need to do this:
 
 ```js
-import { bindActionCreators } from "redux";
+import { bindActionCreators } from 'redux'
 // ...
 
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
-  };
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
+  }
 }
 ```
 
@@ -282,7 +279,7 @@ Note that:
 
 ```js
 // React-Redux does this for you automatically:
-dispatch => bindActionCreators(mapDispatchToProps, dispatch);
+;(dispatch) => bindActionCreators(mapDispatchToProps, dispatch)
 ```
 
 Therefore, our `mapDispatchToProps` can simply be:
@@ -291,8 +288,8 @@ Therefore, our `mapDispatchToProps` can simply be:
 const mapDispatchToProps = {
   increment,
   decrement,
-  reset
-};
+  reset,
+}
 ```
 
 Since the actual name of the variable is up to you, you might want to give it a name like `actionCreators`, or even define the object inline in the call to `connect`:
@@ -337,7 +334,7 @@ In another words, if you do:
 
 ```js
 // component receives `dispatch`
-connect(mapStateToProps /** no second argument*/)(Component);
+connect(mapStateToProps /** no second argument*/)(Component)
 ```
 
 **2. Your customized `mapDispatchToProps` function return specifically contains `dispatch`**
@@ -345,26 +342,26 @@ connect(mapStateToProps /** no second argument*/)(Component);
 You may bring back `dispatch` by providing your customized `mapDispatchToProps` function:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
     reset: () => dispatch(reset()),
-    dispatch
-  };
-};
+    dispatch,
+  }
+}
 ```
 
 Or alternatively, with `bindActionCreators`:
 
 ```js
-import { bindActionCreators } from "redux";
+import { bindActionCreators } from 'redux'
 
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
-  };
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
+  }
 }
 ```
 
@@ -377,10 +374,7 @@ There are discussions regarding whether to provide `dispatch` to your components
 Yes. You can skip the first parameter by passing `undefined` or `null`. Your component will not subscribe to the store, and will still receive the dispatch props defined by `mapStateToProps`.
 
 ```js
-connect(
-  null,
-  mapDispatchToProps
-)(MyComponent);
+connect(null, mapDispatchToProps)(MyComponent)
 ```
 
 ### Can I call `store.dispatch`?
diff --git a/website/versioned_docs/version-5.x/using-react-redux/connect-extracting-data-with-mapStateToProps.md b/website/versioned_docs/version-5.x/using-react-redux/connect-extracting-data-with-mapStateToProps.md
index 89f3357c5..28b500a83 100644
--- a/website/versioned_docs/version-5.x/using-react-redux/connect-extracting-data-with-mapStateToProps.md
+++ b/website/versioned_docs/version-5.x/using-react-redux/connect-extracting-data-with-mapStateToProps.md
@@ -1,17 +1,17 @@
 ---
 id: connect-mapstate
-title: "Connect: Extracting Data with mapStateToProps"
+title: 'Connect: Extracting Data with mapStateToProps'
 hide_title: true
-sidebar_label: "Connect: Extracting Data with mapStateToProps"
+sidebar_label: 'Connect: Extracting Data with mapStateToProps'
 ---
 
 # Connect: Extracting Data with `mapStateToProps`
+
 As the first argument passed in to `connect`, `mapStateToProps` is used for selecting the part of the data from the store that the connected component needs. It’s frequently referred to as just `mapState` for short.
 
 - It is called every time the store state changes.
 - It receives the entire store state, and should return an object of data this component needs.
 
-
 ## Defining `mapStateToProps`
 
 `mapStateToProps` should be defined as a function:
@@ -33,47 +33,47 @@ This function should be passed as the first argument to `connect`, and will be c
 
 #### `state`
 
-The first argument to a `mapStateToProps` function is the entire Redux store state (the same value returned by a call to `store.getState()`).  Because of this, the first argument is traditionally just called `state`.  (While you can give the argument any name you want, calling it `store` would be incorrect - it's the "state value", not the "store instance".)
+The first argument to a `mapStateToProps` function is the entire Redux store state (the same value returned by a call to `store.getState()`). Because of this, the first argument is traditionally just called `state`. (While you can give the argument any name you want, calling it `store` would be incorrect - it's the "state value", not the "store instance".)
 
-The `mapStateToProps` function should always be written with at least `state` passed in. 
+The `mapStateToProps` function should always be written with at least `state` passed in.
 
 ```js
-// TodoList.js 
+// TodoList.js
 
 function mapStateToProps(state) {
-  const { todos } = state;
-  return { todoList: todos.allIds };
-};
-    
-export default connect(mapStateToProps)(TodoList);
+  const { todos } = state
+  return { todoList: todos.allIds }
+}
+
+export default connect(mapStateToProps)(TodoList)
 ```
 
 #### `ownProps` (optional)
 
-You may define the function with a second argument, `ownProps`, if your component needs the data from its own props to retrieve data from the store.  This argument will contain all of the props given to the wrapper component that was generated by `connect`.
+You may define the function with a second argument, `ownProps`, if your component needs the data from its own props to retrieve data from the store. This argument will contain all of the props given to the wrapper component that was generated by `connect`.
 
 ```js
 // Todo.js
 
 function mapStateToProps(state, ownProps) {
-  const { visibilityFilter } = state;
-  const { id } = ownProps;
-  const todo = getTodoById(state, id);
+  const { visibilityFilter } = state
+  const { id } = ownProps
+  const todo = getTodoById(state, id)
 
   // component receives additionally:
-  return { todo, visibilityFilter };
-};
+  return { todo, visibilityFilter }
+}
 
 // Later, in your application, a parent component renders:
-<ConnectedTodo id={123} />
+;<ConnectedTodo id={123} />
 // and your component receives props.id, props.todo, and props.visibilityFilter
 ```
 
-You do not need to include values from `ownProps` in the object returned from `mapStateToProps`.  `connect` will automatically merge those different prop sources into a final set of props.
+You do not need to include values from `ownProps` in the object returned from `mapStateToProps`. `connect` will automatically merge those different prop sources into a final set of props.
 
 ### Return
 
-Your  `mapStateToProps` function should return a plain object that contains the data the component needs:
+Your `mapStateToProps` function should return a plain object that contains the data the component needs:
 
 - Each field in the object will become a prop for your actual component
 - The values in the fields will be used to determine if your component needs to re-render
@@ -83,52 +83,42 @@ For example:
 ```js
 function mapStateToProps(state) {
   return {
-    a : 42,
-    todos : state.todos,
-    filter : state.visibilityFilter
+    a: 42,
+    todos: state.todos,
+    filter: state.visibilityFilter,
   }
 }
 
 // component will receive: props.a, props.todos, and props.filter
 ```
 
-
-> Note: In advanced scenarios where you need more control over the rendering performance, `mapStateToProps` can also return a function. In this case, that function will be used as the final `mapStateToProps` for a particular component instance. This allows you to do per-instance memoization. See the [Advanced Usage](./) section of the docs for more details, as well as  [PR #279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds. Most apps never need this.
-
+> Note: In advanced scenarios where you need more control over the rendering performance, `mapStateToProps` can also return a function. In this case, that function will be used as the final `mapStateToProps` for a particular component instance. This allows you to do per-instance memoization. See the [Advanced Usage](./) section of the docs for more details, as well as [PR #279](https://github.com/reduxjs/react-redux/pull/279) and the tests it adds. Most apps never need this.
 
 ## Usage Guidelines
 
-
 ### Let `mapStateToProps` Reshape the Data from the Store
 
-`mapStateToProps` functions can, and should, do a lot more than just `return state.someSlice`.  **They have the responsibility of "re-shaping" store data as needed for that component.**  This may include returning a value as a specific prop name, combining pieces of data from different parts of the state tree, and transforming the store data in different ways.
-
+`mapStateToProps` functions can, and should, do a lot more than just `return state.someSlice`. **They have the responsibility of "re-shaping" store data as needed for that component.** This may include returning a value as a specific prop name, combining pieces of data from different parts of the state tree, and transforming the store data in different ways.
 
 ### Use Selector Functions to Extract and Transform Data
 
-We highly encourage the use of "selector" functions to help encapsulate the process of extracting values from specific locations in the state tree.  Memoized selector functions also play a key role in improving application performance (see the following sections in this page and the [Advanced Usage: Performance](./) page for more details on why and how to use selectors.)
-
+We highly encourage the use of "selector" functions to help encapsulate the process of extracting values from specific locations in the state tree. Memoized selector functions also play a key role in improving application performance (see the following sections in this page and the [Advanced Usage: Performance](./) page for more details on why and how to use selectors.)
 
 ### `mapStateToProps` Functions Should Be Fast
 
-Whenever the store changes, all of the `mapStateToProps` functions of all of the connected components will run. Because of this, your `mapStateToProps` functions should run as fast as possible.  This also means that a slow `mapStateToProps` function can be a potential bottleneck for your application.
-
-As part of the "re-shaping data" idea, `mapStateToProps` functions frequently need to transform data in various ways (such as filtering an array, mapping an array of IDs to their corresponding objects, or extracting plain JS values from Immutable.js objects).  These transformations can often be expensive, both in terms of cost to execute the transformation, and whether the component re-renders as a result.  If performance is a concern, ensure that these transformations are only run if the input values have changed.
+Whenever the store changes, all of the `mapStateToProps` functions of all of the connected components will run. Because of this, your `mapStateToProps` functions should run as fast as possible. This also means that a slow `mapStateToProps` function can be a potential bottleneck for your application.
 
+As part of the "re-shaping data" idea, `mapStateToProps` functions frequently need to transform data in various ways (such as filtering an array, mapping an array of IDs to their corresponding objects, or extracting plain JS values from Immutable.js objects). These transformations can often be expensive, both in terms of cost to execute the transformation, and whether the component re-renders as a result. If performance is a concern, ensure that these transformations are only run if the input values have changed.
 
 ### `mapStateToProps` Functions Should Be Pure and Synchronous
 
-Much like a Redux reducer, a `mapStateToProps` function should always be 100% pure and synchronous.  It should simply take `state` (and `ownProps`) as arguments, and return the data the component needs as props.  It should _not_ be used to trigger asynchronous behavior like AJAX calls for data fetching, and the functions should not be declared as `async`.
-
-
+Much like a Redux reducer, a `mapStateToProps` function should always be 100% pure and synchronous. It should simply take `state` (and `ownProps`) as arguments, and return the data the component needs as props. It should _not_ be used to trigger asynchronous behavior like AJAX calls for data fetching, and the functions should not be declared as `async`.
 
 ## `mapStateToProps` and Performance
 
-
 ### Return Values Determine If Your Component Re-Renders
 
-React-Redux internally implements the `shouldComponentUpdate` method such that the wrapper component re-renders precisely when the data your component needs has changed. By default, React-Redux decides whether the contents of the object returned from `mapStateToProps` are different using `===` comparison (a "shallow equality" check) on each fields of the returned object. If any of the fields have changed, then your component will be re-rendered so it can receive the updated values as props.  Note that returning a mutated object of the same reference is a common mistake that can result in your component not re-rendering when expected.
-
+React-Redux internally implements the `shouldComponentUpdate` method such that the wrapper component re-renders precisely when the data your component needs has changed. By default, React-Redux decides whether the contents of the object returned from `mapStateToProps` are different using `===` comparison (a "shallow equality" check) on each fields of the returned object. If any of the fields have changed, then your component will be re-rendered so it can receive the updated values as props. Note that returning a mutated object of the same reference is a common mistake that can result in your component not re-rendering when expected.
 
 To summarize the behavior of the component wrapped by `connect` with `mapStateToProps` to extract data from the store:
 
@@ -137,10 +127,9 @@ To summarize the behavior of the component wrapped by `connect` with `mapStateTo
 | `mapStateToProps` runs when: | store `state` changes                  | store `state` changes <br /> or <br />any field of `ownProps` is different                   |
 | component re-renders when:   | any field of `stateProps` is different | any field of `stateProps` is different <br /> or <br /> any field of `ownProps` is different |
 
-
 ### Only Return New Object References If Needed
 
-React-Redux does shallow comparisons to see if the `mapStateToProps` results have changed.  It’s easy to accidentally return new object or array references every time, which would cause your component to re-render even if the data is actually the same.
+React-Redux does shallow comparisons to see if the `mapStateToProps` results have changed. It’s easy to accidentally return new object or array references every time, which would cause your component to re-render even if the data is actually the same.
 
 Many common operations result in new object or array references being created:
 
@@ -150,13 +139,11 @@ Many common operations result in new object or array references being created:
 - Copying values with `Object.assign`
 - Copying values with the spread operator `{ ...oldState, ...newData }`
 
-Put these operations in [memoized selector functions](https://redux.js.org/recipes/computing-derived-data#creating-a-memoized-selector) to ensure that they only run if the input values have changed.  This will also ensure that if the input values _haven't_ changed, `mapStateToProps` will still return the same result values as before, and `connect` can skip re-rendering.
-
-
+Put these operations in [memoized selector functions](https://redux.js.org/recipes/computing-derived-data#creating-a-memoized-selector) to ensure that they only run if the input values have changed. This will also ensure that if the input values _haven't_ changed, `mapStateToProps` will still return the same result values as before, and `connect` can skip re-rendering.
 
 ### Only Perform Expensive Operations When Data Changes
 
-Transforming data can often be expensive (_and_ usually results in new object references being created).  In order for your `mapStateToProps` function to be as fast as possible, you should only re-run these complex transformations when the relevant data has changed.
+Transforming data can often be expensive (_and_ usually results in new object references being created). In order for your `mapStateToProps` function to be as fast as possible, you should only re-run these complex transformations when the relevant data has changed.
 
 There are a few ways to approach this:
 
@@ -164,7 +151,6 @@ There are a few ways to approach this:
 - Transformations can also be done in a component's `render()` method
 - If the transformation does need to be done in a `mapStateToProps` function, then we recommend using [memoized selector functions](https://redux.js.org/recipes/computing-derived-data#creating-a-memoized-selector) to ensure the transformation is only run when the input values have changed.
 
-
 #### Immutable.js Performance Concerns
 
 Immutable.js author Lee Byron on Twitter [explicitly advises avoiding `toJS` when performance is a concern](https://twitter.com/leeb/status/746733697093668864?lang=en):
@@ -173,18 +159,13 @@ Immutable.js author Lee Byron on Twitter [explicitly advises avoiding `toJS` whe
 
 There's several other performance concerns to take into consideration with Immutable.js - see the list of links at the end of this page for more information.
 
-
-
 ## Behavior and Gotchas
 
-
 ### `mapStateToProps` Will Not Run if the Store State is the Same
 
-The wrapper component generated by `connect` subscribes to the Redux store.  Every time an action is dispatched, it calls `store.getState()` and checks to see if `lastState === currentState`.  If the two state values are identical by reference, then it will _not_ re-run your `mapStateToProps` function, because it assumes that the rest of the store state hasn't changed either.
-
-The Redux `combineReducers` utility function tries to optimize for this.  If none of the slice reducers returned a new value, then `combineReducers` returns the old state object instead of a new one.  This means that mutation in a reducer can lead to the root state object not being updated, and thus the UI won't re-render.
-
+The wrapper component generated by `connect` subscribes to the Redux store. Every time an action is dispatched, it calls `store.getState()` and checks to see if `lastState === currentState`. If the two state values are identical by reference, then it will _not_ re-run your `mapStateToProps` function, because it assumes that the rest of the store state hasn't changed either.
 
+The Redux `combineReducers` utility function tries to optimize for this. If none of the slice reducers returned a new value, then `combineReducers` returns the old state object instead of a new one. This means that mutation in a reducer can lead to the root state object not being updated, and thus the UI won't re-render.
 
 ### The Number of Declared Arguments Affects Behavior
 
@@ -192,19 +173,18 @@ With just `(state)`, the function runs whenever the root store state object is d
 
 This means that **you should not add the `ownProps` argument unless you actually need to use it**, or your `mapStateToProps` function will run more often than it needs to.
 
-
-There are some edge cases around this behavior.  **The number of mandatory arguments determines whether `mapStateToProps` will receive `ownProps`**.
+There are some edge cases around this behavior. **The number of mandatory arguments determines whether `mapStateToProps` will receive `ownProps`**.
 
 If the formal definition of the function contains one mandatory parameter, `mapStateToProps` will _not_ receive `ownProps`:
 
 ```js
 function mapStateToProps(state) {
-  console.log(state);        // state
-  console.log(arguments[1]); // undefined
+  console.log(state) // state
+  console.log(arguments[1]) // undefined
 }
 const mapStateToProps = (state, ownProps = {}) => {
-  console.log(state);    // state
-  console.log(ownProps); // undefined
+  console.log(state) // state
+  console.log(ownProps) // undefined
 }
 ```
 
@@ -212,18 +192,18 @@ It _will_ receive `ownProps` when the formal definition of the function contains
 
 ```js
 function mapStateToProps(state, ownProps) {
-  console.log(state);    // state
-  console.log(ownProps); // ownProps
+  console.log(state) // state
+  console.log(ownProps) // ownProps
 }
 
 function mapStateToProps() {
-  console.log(arguments[0]); // state
-  console.log(arguments[1]); // ownProps
+  console.log(arguments[0]) // state
+  console.log(arguments[1]) // ownProps
 }
 
 function mapStateToProps(...args) {
-  console.log(args[0]); // state
-  console.log(args[1]); // ownProps
+  console.log(args[0]) // state
+  console.log(args[1]) // ownProps
 }
 ```
 
diff --git a/website/versioned_docs/version-6.x/api/Provider.md b/website/versioned_docs/version-6.x/api/Provider.md
index 1f7d96d04..9ccf3ef31 100644
--- a/website/versioned_docs/version-6.x/api/Provider.md
+++ b/website/versioned_docs/version-6.x/api/Provider.md
@@ -68,7 +68,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
 
@@ -95,6 +95,6 @@ ReactDOM.render(
       <Route path="/bar" component={Bar} />
     </Router>
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
diff --git a/website/versioned_docs/version-6.x/api/connect-advanced.md b/website/versioned_docs/version-6.x/api/connect-advanced.md
index ff65f1d25..13ba120b8 100644
--- a/website/versioned_docs/version-6.x/api/connect-advanced.md
+++ b/website/versioned_docs/version-6.x/api/connect-advanced.md
@@ -72,7 +72,7 @@ function selectorFactory(dispatch) {
   let result = {}
 
   const actions = bindActionCreators(actionCreators, dispatch)
-  const addTodo = text => actions.addTodo(ownProps.userId, text)
+  const addTodo = (text) => actions.addTodo(ownProps.userId, text)
 
   return (nextState, nextOwnProps) => {
     const todos = nextState.todos[nextOwnProps.userId]
diff --git a/website/versioned_docs/version-6.x/api/connect.md b/website/versioned_docs/version-6.x/api/connect.md
index 39105ade6..acc083778 100644
--- a/website/versioned_docs/version-6.x/api/connect.md
+++ b/website/versioned_docs/version-6.x/api/connect.md
@@ -48,7 +48,7 @@ A `mapStateToProps` function takes a maximum of two parameters. The number of de
 If your `mapStateToProps` function is declared as taking one parameter, it will be called whenever the store state changes, and given the store state as the only parameter.
 
 ```js
-const mapStateToProps = state => ({ todos: state.todos })
+const mapStateToProps = (state) => ({ todos: state.todos })
 ```
 
 ##### `ownProps`
@@ -59,7 +59,7 @@ The second parameter is normally referred to as `ownProps` by convention.
 
 ```js
 const mapStateToProps = (state, ownProps) => ({
-  todo: state.todos[ownProps.id]
+  todo: state.todos[ownProps.id],
 })
 ```
 
@@ -83,12 +83,7 @@ Your component will receive `dispatch` by default, i.e., when you do not supply
 // do not pass `mapDispatchToProps`
 connect()(MyComponent)
 connect(mapState)(MyComponent)
-connect(
-  mapState,
-  null,
-  mergeProps,
-  options
-)(MyComponent)
+connect(mapState, null, mergeProps, options)(MyComponent)
 ```
 
 If you define a `mapDispatchToProps` as a function, it will be called with a maximum of two parameters.
@@ -103,12 +98,12 @@ If you define a `mapDispatchToProps` as a function, it will be called with a max
 If your `mapDispatchToProps` is declared as a function taking one parameter, it will be given the `dispatch` of your `store`.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
     increment: () => dispatch({ type: 'INCREMENT' }),
     decrement: () => dispatch({ type: 'DECREMENT' }),
-    reset: () => dispatch({ type: 'RESET' })
+    reset: () => dispatch({ type: 'RESET' }),
   }
 }
 ```
@@ -121,7 +116,7 @@ The second parameter is normally referred to as `ownProps` by convention.
 
 ```js
 // binds on component re-rendering
-<button onClick={() => this.props.toggleTodo(this.props.todoId)} />
+;<button onClick={() => this.props.toggleTodo(this.props.todoId)} />
 
 // binds on `props` change
 const mapDispatchToProps = (dispatch, ownProps) => {
@@ -146,7 +141,7 @@ const mapDispatchToProps = (dispatch, ownProps) => {
     dispatchActionCreatedByActionCreator: () => dispatch(createMyAction()),
     ...boundActions,
     // you may return dispatch here
-    dispatch
+    dispatch,
   }
 }
 ```
@@ -165,13 +160,10 @@ import { addTodo, deleteTodo, toggleTodo } from './actionCreators'
 const mapDispatchToProps = {
   addTodo,
   deleteTodo,
-  toggleTodo
+  toggleTodo,
 }
 
-export default connect(
-  null,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(null, mapDispatchToProps)(TodoApp)
 ```
 
 In this case, React-Redux binds the `dispatch` of your store to each of the action creators using `bindActionCreators`. The result will be regarded as `dispatchProps`, which will be either directly merged to your connected components, or supplied to `mergeProps` as the second argument.
@@ -226,12 +218,9 @@ You may pass the context to your connected component either by passing it here a
 
 ```js
 // const MyContext = React.createContext();
-connect(
-  mapStateToProps,
-  mapDispatchToProps,
-  null,
-  { context: MyContext }
-)(MyComponent)
+connect(mapStateToProps, mapDispatchToProps, null, { context: MyContext })(
+  MyComponent,
+)
 ```
 
 #### `pure: boolean`
@@ -308,14 +297,11 @@ The return of `connect()` is a wrapper function that takes your component and re
 ```js
 import { login, logout } from './actionCreators'
 
-const mapState = state => state.user
+const mapState = (state) => state.user
 const mapDispatch = { login, logout }
 
 // first call: returns a hoc that you can use to wrap any component
-const connectUser = connect(
-  mapState,
-  mapDispatch
-)
+const connectUser = connect(mapState, mapDispatch)
 
 // second call: returns the wrapper component with mergedProps
 // you may use the hoc to enable different components to get the same behavior
@@ -328,16 +314,13 @@ In most cases, the wrapper function will be called right away, without being sav
 ```js
 import { login, logout } from './actionCreators'
 
-const mapState = state => state.user
+const mapState = (state) => state.user
 const mapDispatch = { login, logout }
 
 // call connect to generate the wrapper function, and immediately call
 // the wrapper function to generate the final wrapper component.
 
-export default connect(
-  mapState,
-  mapDispatch
-)(Login)
+export default connect(mapState, mapDispatch)(Login)
 ```
 
 ## Example Usage
@@ -355,10 +338,7 @@ export default connect()(TodoApp)
 ```js
 import * as actionCreators from './actionCreators'
 
-export default connect(
-  null,
-  actionCreators
-)(TodoApp)
+export default connect(null, actionCreators)(TodoApp)
 ```
 
 - Inject `dispatch` and every field in the global state
@@ -368,7 +348,7 @@ export default connect(
 
 ```js
 // don't do this!
-export default connect(state => state)(TodoApp)
+export default connect((state) => state)(TodoApp)
 ```
 
 - Inject `dispatch` and `todos`
@@ -390,10 +370,7 @@ function mapStateToProps(state) {
   return { todos: state.todos }
 }
 
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(TodoApp)
+export default connect(mapStateToProps, actionCreators)(TodoApp)
 ```
 
 - Inject `todos` and all action creators (`addTodo`, `completeTodo`, ...) as `actions`
@@ -410,10 +387,7 @@ function mapDispatchToProps(dispatch) {
   return { actions: bindActionCreators(actionCreators, dispatch) }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` and a specific action creator (`addTodo`)
@@ -430,10 +404,7 @@ function mapDispatchToProps(dispatch) {
   return bindActionCreators({ addTodo }, dispatch)
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` and specific action creators (`addTodo` and `deleteTodo`) with shorthand syntax
@@ -447,13 +418,10 @@ function mapStateToProps(state) {
 
 const mapDispatchToProps = {
   addTodo,
-  deleteTodo
+  deleteTodo,
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, `todoActionCreators` as `todoActions`, and `counterActionCreators` as `counterActions`
@@ -470,14 +438,11 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return {
     todoActions: bindActionCreators(todoActionCreators, dispatch),
-    counterActions: bindActionCreators(counterActionCreators, dispatch)
+    counterActions: bindActionCreators(counterActionCreators, dispatch),
   }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, and todoActionCreators and counterActionCreators together as `actions`
@@ -495,15 +460,12 @@ function mapDispatchToProps(dispatch) {
   return {
     actions: bindActionCreators(
       { ...todoActionCreators, ...counterActionCreators },
-      dispatch
-    )
+      dispatch,
+    ),
   }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, and all `todoActionCreators` and `counterActionCreators` directly as props
@@ -520,14 +482,11 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return bindActionCreators(
     { ...todoActionCreators, ...counterActionCreators },
-    dispatch
+    dispatch,
   )
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` of a specific user depending on props
@@ -554,15 +513,11 @@ function mapStateToProps(state) {
 function mergeProps(stateProps, dispatchProps, ownProps) {
   return Object.assign({}, ownProps, {
     todos: stateProps.todos[ownProps.userId],
-    addTodo: text => dispatchProps.addTodo(ownProps.userId, text)
+    addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text),
   })
 }
 
-export default connect(
-  mapStateToProps,
-  actionCreators,
-  mergeProps
-)(TodoApp)
+export default connect(mapStateToProps, actionCreators, mergeProps)(TodoApp)
 ```
 
 ## Notes
@@ -612,11 +567,8 @@ The factory functions are commonly used with memoized selectors. This gives you
 
 ```js
 const makeUniqueSelectorInstance = () =>
-  createSelector(
-    [selectItems, selectItemId],
-    (items, itemId) => items[itemId]
-  )
-const makeMapState = state => {
+  createSelector([selectItems, selectItemId], (items, itemId) => items[itemId])
+const makeMapState = (state) => {
   const selectItemForThisComponent = makeUniqueSelectorInstance()
   return function realMapState(state, ownProps) {
     const item = selectItemForThisComponent(state, ownProps.itemId)
diff --git a/website/versioned_docs/version-6.x/introduction/basic-tutorial.md b/website/versioned_docs/version-6.x/introduction/basic-tutorial.md
index 069e50d62..4721bac2e 100644
--- a/website/versioned_docs/version-6.x/introduction/basic-tutorial.md
+++ b/website/versioned_docs/version-6.x/introduction/basic-tutorial.md
@@ -86,7 +86,7 @@ ReactDOM.render(
   <Provider store={store}>
     <TodoApp />
   </Provider>,
-  rootElement
+  rootElement,
 )
 ```
 
@@ -118,18 +118,12 @@ const mapDispatchToProps = {
 }
 
 // `connect` returns a new function that accepts the component to wrap:
-const connectToStore = connect(
-  mapStateToProps,
-  mapDispatchToProps
-)
+const connectToStore = connect(mapStateToProps, mapDispatchToProps)
 // and that function returns the connected, wrapper component:
 const ConnectedComponent = connectToStore(Component)
 
 // We normally do both in one step, like this:
-connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(Component)
+connect(mapStateToProps, mapDispatchToProps)(Component)
 ```
 
 Let’s work on `<AddTodo />` first. It needs to trigger changes to the `store` to add new todos. Therefore, it needs to be able to `dispatch` actions to the store. Here’s how we do it.
@@ -141,12 +135,12 @@ Our `addTodo` action creator looks like this:
 import { ADD_TODO } from './actionTypes'
 
 let nextTodoId = 0
-export const addTodo = content => ({
+export const addTodo = (content) => ({
   type: ADD_TODO,
   payload: {
     id: ++nextTodoId,
-    content
-  }
+    content,
+  },
 })
 
 // ... other actions
@@ -165,10 +159,7 @@ class AddTodo extends React.Component {
   // ... component implementation
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo)
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Notice now that `<AddTodo />` is wrapped with a parent component called `<Connect(AddTodo) />`. Meanwhile, `<AddTodo />` now gains one prop: the `addTodo` action.
@@ -199,7 +190,7 @@ class AddTodo extends React.Component {
     return (
       <div>
         <input
-          onChange={e => this.updateInput(e.target.value)}
+          onChange={(e) => this.updateInput(e.target.value)}
           value={this.state.input}
         />
         <button className="add-todo" onClick={this.handleAddTodo}>
@@ -210,10 +201,7 @@ class AddTodo extends React.Component {
   }
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo)
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Now our `<AddTodo />` is connected to the store. When we add a todo it would dispatch an action to change the store. We are not seeing it in the app because the other components are not connected yet. If you have the Redux DevTools Extension hooked up, you should see the action being dispatched:
@@ -253,16 +241,16 @@ Luckily we have a selector that does exactly this. We may simply import the sele
 ```js
 // redux/selectors.js
 
-export const getTodosState = store => store.todos
+export const getTodosState = (store) => store.todos
 
-export const getTodoList = store =>
+export const getTodoList = (store) =>
   getTodosState(store) ? getTodosState(store).allIds : []
 
 export const getTodoById = (store, id) =>
   getTodosState(store) ? { ...getTodosState(store).byIds[id], id } : {}
 
-export const getTodos = store =>
-  getTodoList(store).map(id => getTodoById(store, id))
+export const getTodos = (store) =>
+  getTodoList(store).map((id) => getTodoById(store, id))
 ```
 
 ```js
@@ -315,7 +303,7 @@ If you call `connect` with only `mapStateToProps`, your component will:
 
 ```js
 // ... Component
-const mapStateToProps = state => state.partOfState
+const mapStateToProps = (state) => state.partOfState
 export default connect(mapStateToProps)(Component)
 ```
 
@@ -329,10 +317,7 @@ If you call `connect` with only `mapDispatchToProps`, your component will:
 ```js
 import { addTodo } from './actionCreators'
 // ... Component
-export default connect(
-  null,
-  { addTodo }
-)(Component)
+export default connect(null, { addTodo })(Component)
 ```
 
 #### Subscribe to the store and inject action creators
@@ -345,11 +330,8 @@ If you call `connect` with both `mapStateToProps` and `mapDispatchToProps`, your
 ```js
 import * as actionCreators from './actionCreators'
 // ... Component
-const mapStateToProps = state => state.partOfState
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(Component)
+const mapStateToProps = (state) => state.partOfState
+export default connect(mapStateToProps, actionCreators)(Component)
 ```
 
 These four cases cover the most basic usages of `connect`. To read more about `connect`, continue reading our [API section](../api/connect.md) that explains it in more detail.
@@ -413,9 +395,9 @@ export const getTodosByVisibilityFilter = (store, visibilityFilter) => {
   const allTodos = getTodos(store)
   switch (visibilityFilter) {
     case VISIBILITY_FILTERS.COMPLETED:
-      return allTodos.filter(todo => todo.completed)
+      return allTodos.filter((todo) => todo.completed)
     case VISIBILITY_FILTERS.INCOMPLETE:
-      return allTodos.filter(todo => !todo.completed)
+      return allTodos.filter((todo) => !todo.completed)
     case VISIBILITY_FILTERS.ALL:
     default:
       return allTodos
@@ -430,7 +412,7 @@ And connecting to the store with the help of the selector:
 
 // ...
 
-const mapStateToProps = state => {
+const mapStateToProps = (state) => {
   const { visibilityFilter } = state
   const todos = getTodosByVisibilityFilter(state, visibilityFilter)
   return { todos }
diff --git a/website/versioned_docs/version-6.x/introduction/quick-start.md b/website/versioned_docs/version-6.x/introduction/quick-start.md
index f7a5fa60c..e899daa75 100644
--- a/website/versioned_docs/version-6.x/introduction/quick-start.md
+++ b/website/versioned_docs/version-6.x/introduction/quick-start.md
@@ -45,7 +45,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  rootElement
+  rootElement,
 )
 ```
 
diff --git a/website/versioned_docs/version-6.x/troubleshooting.md b/website/versioned_docs/version-6.x/troubleshooting.md
index d52a29924..7490c7386 100644
--- a/website/versioned_docs/version-6.x/troubleshooting.md
+++ b/website/versioned_docs/version-6.x/troubleshooting.md
@@ -37,7 +37,7 @@ Router.run(routes, Router.HistoryLocation, (Handler, routerState) => {
       {/* note "routerState" here */}
       <Handler routerState={routerState} />
     </Provider>,
-    document.getElementById('root')
+    document.getElementById('root'),
   )
 })
 ```
@@ -69,14 +69,9 @@ function mapStateToProps(state) {
   return { todos: state.todos }
 }
 
-export default connect(
-  mapStateToProps,
-  null,
-  null,
-  {
-    pure: false
-  }
-)(TodoApp)
+export default connect(mapStateToProps, null, null, {
+  pure: false,
+})(TodoApp)
 ```
 
 This will remove the assumption that `TodoApp` is pure and cause it to update whenever its parent component renders. Note that this will make your application less performant, so only do this if you have no other option.
diff --git a/website/versioned_docs/version-6.x/using-react-redux/accessing-store.md b/website/versioned_docs/version-6.x/using-react-redux/accessing-store.md
index c7d509d7f..126f2cde2 100644
--- a/website/versioned_docs/version-6.x/using-react-redux/accessing-store.md
+++ b/website/versioned_docs/version-6.x/using-react-redux/accessing-store.md
@@ -42,21 +42,15 @@ After you’ve supplied the custom context to `<Provider />`, you will need to s
 
 ```js
 // You can pass the context as an option to connect
-export default connect(
-  mapState,
-  mapDispatch,
-  null,
-  { context: MyContext }
-)(MyComponent);
+export default connect(mapState, mapDispatch, null, { context: MyContext })(
+  MyComponent,
+)
 
 // or, call connect as normal to start
-const ConnectedComponent = connect(
-  mapState,
-  mapDispatch
-)(MyComponent);
+const ConnectedComponent = connect(mapState, mapDispatch)(MyComponent)
 
 // Later, pass the custom context as a prop to the connected component
-<ConnectedComponent context={MyContext} />
+;<ConnectedComponent context={MyContext} />
 ```
 
 The following runtime error occurs when React Redux does not find a store in the context it is looking. For example:
@@ -132,7 +126,7 @@ function MyConnectedComponent() {
         // component where it can be used in lifecycle methods
       }}
     </ReactReduxContext.Consumer>
-  );
+  )
 }
 ```
 
diff --git a/website/versioned_docs/version-6.x/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md b/website/versioned_docs/version-6.x/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
index 49606c22e..4acdb06a1 100644
--- a/website/versioned_docs/version-6.x/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
+++ b/website/versioned_docs/version-6.x/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapdispatch
-title: "Connect: Dispatching Actions with mapDispatchToProps"
+title: 'Connect: Dispatching Actions with mapDispatchToProps'
 hide_title: true
-sidebar_label: "Connect: Dispatching Actions with mapDispatchToProps"
+sidebar_label: 'Connect: Dispatching Actions with mapDispatchToProps'
 ---
 
 # Connect: Dispatching Actions with `mapDispatchToProps`
@@ -29,10 +29,7 @@ If you don't specify the second argument to `connect()`, your component will rec
 ```js
 connect()(MyComponent)
 // which is equivalent with
-connect(
-  null,
-  null
-)(MyComponent)
+connect(null, null)(MyComponent)
 
 // or
 connect(mapStateToProps /** no second argument */)(MyComponent)
@@ -85,7 +82,7 @@ This allows more components to dispatch actions, while keeping them "unaware" of
 // making Todo able to dispatch the toggleTodo action
 const TodoList = ({ todos, toggleTodo }) => (
   <div>
-    {todos.map(todo => (
+    {todos.map((todo) => (
       <Todo todo={todo} onClick={toggleTodo} />
     ))}
   </div>
@@ -120,12 +117,12 @@ The `mapDispatchToProps` function will be called with `dispatch` as the first ar
 You will normally make use of this by returning new functions that call `dispatch()` inside themselves, and either pass in a plain action object directly or pass in the result of an action creator.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
     increment: () => dispatch({ type: 'INCREMENT' }),
     decrement: () => dispatch({ type: 'DECREMENT' }),
-    reset: () => dispatch({ type: 'RESET' })
+    reset: () => dispatch({ type: 'RESET' }),
   }
 }
 ```
@@ -133,14 +130,14 @@ const mapDispatchToProps = dispatch => {
 You will also likely want to forward arguments to your action creators:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // explicitly forwarding arguments
-    onClick: event => dispatch(trackClick(event)),
+    onClick: (event) => dispatch(trackClick(event)),
 
     // implicitly forwarding arguments
     onReceiveImpressions: (...impressions) =>
-      dispatch(trackImpressions(impressions))
+      dispatch(trackImpressions(impressions)),
   }
 }
 ```
@@ -173,12 +170,12 @@ const increment = () => ({ type: 'INCREMENT' })
 const decrement = () => ({ type: 'DECREMENT' })
 const reset = () => ({ type: 'RESET' })
 
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching actions returned by action creators
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
-    reset: () => dispatch(reset())
+    reset: () => dispatch(reset()),
   }
 }
 ```
@@ -227,7 +224,7 @@ const boundIncrement = bindActionCreators(increment, dispatch)
 // binding an object full of action creators
 const boundActionCreators = bindActionCreators(
   { increment, decrement, reset },
-  dispatch
+  dispatch,
 )
 // returns
 // {
@@ -248,10 +245,7 @@ function mapDispatchToProps(dispatch) {
 }
 
 // component receives props.increment, props.decrement, props.reset
-connect(
-  null,
-  mapDispatchToProps
-)(Counter)
+connect(null, mapDispatchToProps)(Counter)
 ```
 
 ### Manually Injecting `dispatch`
@@ -265,7 +259,7 @@ import { bindActionCreators } from 'redux'
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
   }
 }
 ```
@@ -285,7 +279,7 @@ Note that:
 
 ```js
 // React Redux does this for you automatically:
-dispatch => bindActionCreators(mapDispatchToProps, dispatch)
+;(dispatch) => bindActionCreators(mapDispatchToProps, dispatch)
 ```
 
 Therefore, our `mapDispatchToProps` can simply be:
@@ -294,7 +288,7 @@ Therefore, our `mapDispatchToProps` can simply be:
 const mapDispatchToProps = {
   increment,
   decrement,
-  reset
+  reset,
 }
 ```
 
@@ -348,12 +342,12 @@ connect(mapStateToProps /** no second argument*/)(Component)
 You may bring back `dispatch` by providing your customized `mapDispatchToProps` function:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
     reset: () => dispatch(reset()),
-    dispatch
+    dispatch,
   }
 }
 ```
@@ -366,7 +360,7 @@ import { bindActionCreators } from 'redux'
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
   }
 }
 ```
@@ -380,10 +374,7 @@ There are discussions regarding whether to provide `dispatch` to your components
 Yes. You can skip the first parameter by passing `undefined` or `null`. Your component will not subscribe to the store, and will still receive the dispatch props defined by `mapDispatchToProps`.
 
 ```js
-connect(
-  null,
-  mapDispatchToProps
-)(MyComponent)
+connect(null, mapDispatchToProps)(MyComponent)
 ```
 
 ### Can I call `store.dispatch`?
diff --git a/website/versioned_docs/version-6.x/using-react-redux/connect-extracting-data-with-mapStateToProps.md b/website/versioned_docs/version-6.x/using-react-redux/connect-extracting-data-with-mapStateToProps.md
index 9b8df6c5e..265126652 100644
--- a/website/versioned_docs/version-6.x/using-react-redux/connect-extracting-data-with-mapStateToProps.md
+++ b/website/versioned_docs/version-6.x/using-react-redux/connect-extracting-data-with-mapStateToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapstate
-title: "Connect: Extracting Data with mapStateToProps"
+title: 'Connect: Extracting Data with mapStateToProps'
 hide_title: true
-sidebar_label: "Connect: Extracting Data with mapStateToProps"
+sidebar_label: 'Connect: Extracting Data with mapStateToProps'
 ---
 
 # Connect: Extracting Data with `mapStateToProps`
@@ -85,7 +85,7 @@ function mapStateToProps(state) {
   return {
     a: 42,
     todos: state.todos,
-    filter: state.visibilityFilter
+    filter: state.visibilityFilter,
   }
 }
 
diff --git a/website/versioned_docs/version-7.0/api/Provider.md b/website/versioned_docs/version-7.0/api/Provider.md
index 1f7d96d04..9ccf3ef31 100644
--- a/website/versioned_docs/version-7.0/api/Provider.md
+++ b/website/versioned_docs/version-7.0/api/Provider.md
@@ -68,7 +68,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
 
@@ -95,6 +95,6 @@ ReactDOM.render(
       <Route path="/bar" component={Bar} />
     </Router>
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
diff --git a/website/versioned_docs/version-7.0/api/batch.md b/website/versioned_docs/version-7.0/api/batch.md
index 63f55bc48..51da0102c 100644
--- a/website/versioned_docs/version-7.0/api/batch.md
+++ b/website/versioned_docs/version-7.0/api/batch.md
@@ -16,16 +16,16 @@ React's `unstable_batchedUpdate()` API allows any React updates in an event loop
 Since React-Redux needs to work in both ReactDOM and React Native environments, we've taken care of importing this API from the correct renderer at build time for our own use. We also now re-export this function publicly ourselves, renamed to `batch()`. You can use it to ensure that multiple actions dispatched outside of React only result in a single render update, like this:
 
 ```js
-import { batch } from "react-redux";
+import { batch } from 'react-redux'
 
 function myThunk() {
-    return (dispatch, getState) => {
-        // should only result in one combined re-render, not two
-        batch(() => {
-            dispatch(increment());
-            dispatch(increment());
-        })
-    }
+  return (dispatch, getState) => {
+    // should only result in one combined re-render, not two
+    batch(() => {
+      dispatch(increment())
+      dispatch(increment())
+    })
+  }
 }
 ```
 
diff --git a/website/versioned_docs/version-7.0/api/connect-advanced.md b/website/versioned_docs/version-7.0/api/connect-advanced.md
index ff65f1d25..13ba120b8 100644
--- a/website/versioned_docs/version-7.0/api/connect-advanced.md
+++ b/website/versioned_docs/version-7.0/api/connect-advanced.md
@@ -72,7 +72,7 @@ function selectorFactory(dispatch) {
   let result = {}
 
   const actions = bindActionCreators(actionCreators, dispatch)
-  const addTodo = text => actions.addTodo(ownProps.userId, text)
+  const addTodo = (text) => actions.addTodo(ownProps.userId, text)
 
   return (nextState, nextOwnProps) => {
     const todos = nextState.todos[nextOwnProps.userId]
diff --git a/website/versioned_docs/version-7.0/api/connect.md b/website/versioned_docs/version-7.0/api/connect.md
index 4ad61e58c..acc083778 100644
--- a/website/versioned_docs/version-7.0/api/connect.md
+++ b/website/versioned_docs/version-7.0/api/connect.md
@@ -48,7 +48,7 @@ A `mapStateToProps` function takes a maximum of two parameters. The number of de
 If your `mapStateToProps` function is declared as taking one parameter, it will be called whenever the store state changes, and given the store state as the only parameter.
 
 ```js
-const mapStateToProps = state => ({ todos: state.todos })
+const mapStateToProps = (state) => ({ todos: state.todos })
 ```
 
 ##### `ownProps`
@@ -59,7 +59,7 @@ The second parameter is normally referred to as `ownProps` by convention.
 
 ```js
 const mapStateToProps = (state, ownProps) => ({
-  todo: state.todos[ownProps.id]
+  todo: state.todos[ownProps.id],
 })
 ```
 
@@ -83,12 +83,7 @@ Your component will receive `dispatch` by default, i.e., when you do not supply
 // do not pass `mapDispatchToProps`
 connect()(MyComponent)
 connect(mapState)(MyComponent)
-connect(
-  mapState,
-  null,
-  mergeProps,
-  options
-)(MyComponent)
+connect(mapState, null, mergeProps, options)(MyComponent)
 ```
 
 If you define a `mapDispatchToProps` as a function, it will be called with a maximum of two parameters.
@@ -103,12 +98,12 @@ If you define a `mapDispatchToProps` as a function, it will be called with a max
 If your `mapDispatchToProps` is declared as a function taking one parameter, it will be given the `dispatch` of your `store`.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
     increment: () => dispatch({ type: 'INCREMENT' }),
     decrement: () => dispatch({ type: 'DECREMENT' }),
-    reset: () => dispatch({ type: 'RESET' })
+    reset: () => dispatch({ type: 'RESET' }),
   }
 }
 ```
@@ -146,7 +141,7 @@ const mapDispatchToProps = (dispatch, ownProps) => {
     dispatchActionCreatedByActionCreator: () => dispatch(createMyAction()),
     ...boundActions,
     // you may return dispatch here
-    dispatch
+    dispatch,
   }
 }
 ```
@@ -165,13 +160,10 @@ import { addTodo, deleteTodo, toggleTodo } from './actionCreators'
 const mapDispatchToProps = {
   addTodo,
   deleteTodo,
-  toggleTodo
+  toggleTodo,
 }
 
-export default connect(
-  null,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(null, mapDispatchToProps)(TodoApp)
 ```
 
 In this case, React-Redux binds the `dispatch` of your store to each of the action creators using `bindActionCreators`. The result will be regarded as `dispatchProps`, which will be either directly merged to your connected components, or supplied to `mergeProps` as the second argument.
@@ -226,12 +218,9 @@ You may pass the context to your connected component either by passing it here a
 
 ```js
 // const MyContext = React.createContext();
-connect(
-  mapStateToProps,
-  mapDispatchToProps,
-  null,
-  { context: MyContext }
-)(MyComponent)
+connect(mapStateToProps, mapDispatchToProps, null, { context: MyContext })(
+  MyComponent,
+)
 ```
 
 #### `pure: boolean`
@@ -308,14 +297,11 @@ The return of `connect()` is a wrapper function that takes your component and re
 ```js
 import { login, logout } from './actionCreators'
 
-const mapState = state => state.user
+const mapState = (state) => state.user
 const mapDispatch = { login, logout }
 
 // first call: returns a hoc that you can use to wrap any component
-const connectUser = connect(
-  mapState,
-  mapDispatch
-)
+const connectUser = connect(mapState, mapDispatch)
 
 // second call: returns the wrapper component with mergedProps
 // you may use the hoc to enable different components to get the same behavior
@@ -328,16 +314,13 @@ In most cases, the wrapper function will be called right away, without being sav
 ```js
 import { login, logout } from './actionCreators'
 
-const mapState = state => state.user
+const mapState = (state) => state.user
 const mapDispatch = { login, logout }
 
 // call connect to generate the wrapper function, and immediately call
 // the wrapper function to generate the final wrapper component.
 
-export default connect(
-  mapState,
-  mapDispatch
-)(Login)
+export default connect(mapState, mapDispatch)(Login)
 ```
 
 ## Example Usage
@@ -355,10 +338,7 @@ export default connect()(TodoApp)
 ```js
 import * as actionCreators from './actionCreators'
 
-export default connect(
-  null,
-  actionCreators
-)(TodoApp)
+export default connect(null, actionCreators)(TodoApp)
 ```
 
 - Inject `dispatch` and every field in the global state
@@ -368,7 +348,7 @@ export default connect(
 
 ```js
 // don't do this!
-export default connect(state => state)(TodoApp)
+export default connect((state) => state)(TodoApp)
 ```
 
 - Inject `dispatch` and `todos`
@@ -390,10 +370,7 @@ function mapStateToProps(state) {
   return { todos: state.todos }
 }
 
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(TodoApp)
+export default connect(mapStateToProps, actionCreators)(TodoApp)
 ```
 
 - Inject `todos` and all action creators (`addTodo`, `completeTodo`, ...) as `actions`
@@ -410,10 +387,7 @@ function mapDispatchToProps(dispatch) {
   return { actions: bindActionCreators(actionCreators, dispatch) }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` and a specific action creator (`addTodo`)
@@ -430,10 +404,7 @@ function mapDispatchToProps(dispatch) {
   return bindActionCreators({ addTodo }, dispatch)
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` and specific action creators (`addTodo` and `deleteTodo`) with shorthand syntax
@@ -447,13 +418,10 @@ function mapStateToProps(state) {
 
 const mapDispatchToProps = {
   addTodo,
-  deleteTodo
+  deleteTodo,
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, `todoActionCreators` as `todoActions`, and `counterActionCreators` as `counterActions`
@@ -470,14 +438,11 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return {
     todoActions: bindActionCreators(todoActionCreators, dispatch),
-    counterActions: bindActionCreators(counterActionCreators, dispatch)
+    counterActions: bindActionCreators(counterActionCreators, dispatch),
   }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, and todoActionCreators and counterActionCreators together as `actions`
@@ -495,15 +460,12 @@ function mapDispatchToProps(dispatch) {
   return {
     actions: bindActionCreators(
       { ...todoActionCreators, ...counterActionCreators },
-      dispatch
-    )
+      dispatch,
+    ),
   }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, and all `todoActionCreators` and `counterActionCreators` directly as props
@@ -520,14 +482,11 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return bindActionCreators(
     { ...todoActionCreators, ...counterActionCreators },
-    dispatch
+    dispatch,
   )
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` of a specific user depending on props
@@ -554,15 +513,11 @@ function mapStateToProps(state) {
 function mergeProps(stateProps, dispatchProps, ownProps) {
   return Object.assign({}, ownProps, {
     todos: stateProps.todos[ownProps.userId],
-    addTodo: text => dispatchProps.addTodo(ownProps.userId, text)
+    addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text),
   })
 }
 
-export default connect(
-  mapStateToProps,
-  actionCreators,
-  mergeProps
-)(TodoApp)
+export default connect(mapStateToProps, actionCreators, mergeProps)(TodoApp)
 ```
 
 ## Notes
@@ -612,11 +567,8 @@ The factory functions are commonly used with memoized selectors. This gives you
 
 ```js
 const makeUniqueSelectorInstance = () =>
-  createSelector(
-    [selectItems, selectItemId],
-    (items, itemId) => items[itemId]
-  )
-const makeMapState = state => {
+  createSelector([selectItems, selectItemId], (items, itemId) => items[itemId])
+const makeMapState = (state) => {
   const selectItemForThisComponent = makeUniqueSelectorInstance()
   return function realMapState(state, ownProps) {
     const item = selectItemForThisComponent(state, ownProps.itemId)
diff --git a/website/versioned_docs/version-7.0/introduction/basic-tutorial.md b/website/versioned_docs/version-7.0/introduction/basic-tutorial.md
index 069e50d62..4721bac2e 100644
--- a/website/versioned_docs/version-7.0/introduction/basic-tutorial.md
+++ b/website/versioned_docs/version-7.0/introduction/basic-tutorial.md
@@ -86,7 +86,7 @@ ReactDOM.render(
   <Provider store={store}>
     <TodoApp />
   </Provider>,
-  rootElement
+  rootElement,
 )
 ```
 
@@ -118,18 +118,12 @@ const mapDispatchToProps = {
 }
 
 // `connect` returns a new function that accepts the component to wrap:
-const connectToStore = connect(
-  mapStateToProps,
-  mapDispatchToProps
-)
+const connectToStore = connect(mapStateToProps, mapDispatchToProps)
 // and that function returns the connected, wrapper component:
 const ConnectedComponent = connectToStore(Component)
 
 // We normally do both in one step, like this:
-connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(Component)
+connect(mapStateToProps, mapDispatchToProps)(Component)
 ```
 
 Let’s work on `<AddTodo />` first. It needs to trigger changes to the `store` to add new todos. Therefore, it needs to be able to `dispatch` actions to the store. Here’s how we do it.
@@ -141,12 +135,12 @@ Our `addTodo` action creator looks like this:
 import { ADD_TODO } from './actionTypes'
 
 let nextTodoId = 0
-export const addTodo = content => ({
+export const addTodo = (content) => ({
   type: ADD_TODO,
   payload: {
     id: ++nextTodoId,
-    content
-  }
+    content,
+  },
 })
 
 // ... other actions
@@ -165,10 +159,7 @@ class AddTodo extends React.Component {
   // ... component implementation
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo)
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Notice now that `<AddTodo />` is wrapped with a parent component called `<Connect(AddTodo) />`. Meanwhile, `<AddTodo />` now gains one prop: the `addTodo` action.
@@ -199,7 +190,7 @@ class AddTodo extends React.Component {
     return (
       <div>
         <input
-          onChange={e => this.updateInput(e.target.value)}
+          onChange={(e) => this.updateInput(e.target.value)}
           value={this.state.input}
         />
         <button className="add-todo" onClick={this.handleAddTodo}>
@@ -210,10 +201,7 @@ class AddTodo extends React.Component {
   }
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo)
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Now our `<AddTodo />` is connected to the store. When we add a todo it would dispatch an action to change the store. We are not seeing it in the app because the other components are not connected yet. If you have the Redux DevTools Extension hooked up, you should see the action being dispatched:
@@ -253,16 +241,16 @@ Luckily we have a selector that does exactly this. We may simply import the sele
 ```js
 // redux/selectors.js
 
-export const getTodosState = store => store.todos
+export const getTodosState = (store) => store.todos
 
-export const getTodoList = store =>
+export const getTodoList = (store) =>
   getTodosState(store) ? getTodosState(store).allIds : []
 
 export const getTodoById = (store, id) =>
   getTodosState(store) ? { ...getTodosState(store).byIds[id], id } : {}
 
-export const getTodos = store =>
-  getTodoList(store).map(id => getTodoById(store, id))
+export const getTodos = (store) =>
+  getTodoList(store).map((id) => getTodoById(store, id))
 ```
 
 ```js
@@ -315,7 +303,7 @@ If you call `connect` with only `mapStateToProps`, your component will:
 
 ```js
 // ... Component
-const mapStateToProps = state => state.partOfState
+const mapStateToProps = (state) => state.partOfState
 export default connect(mapStateToProps)(Component)
 ```
 
@@ -329,10 +317,7 @@ If you call `connect` with only `mapDispatchToProps`, your component will:
 ```js
 import { addTodo } from './actionCreators'
 // ... Component
-export default connect(
-  null,
-  { addTodo }
-)(Component)
+export default connect(null, { addTodo })(Component)
 ```
 
 #### Subscribe to the store and inject action creators
@@ -345,11 +330,8 @@ If you call `connect` with both `mapStateToProps` and `mapDispatchToProps`, your
 ```js
 import * as actionCreators from './actionCreators'
 // ... Component
-const mapStateToProps = state => state.partOfState
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(Component)
+const mapStateToProps = (state) => state.partOfState
+export default connect(mapStateToProps, actionCreators)(Component)
 ```
 
 These four cases cover the most basic usages of `connect`. To read more about `connect`, continue reading our [API section](../api/connect.md) that explains it in more detail.
@@ -413,9 +395,9 @@ export const getTodosByVisibilityFilter = (store, visibilityFilter) => {
   const allTodos = getTodos(store)
   switch (visibilityFilter) {
     case VISIBILITY_FILTERS.COMPLETED:
-      return allTodos.filter(todo => todo.completed)
+      return allTodos.filter((todo) => todo.completed)
     case VISIBILITY_FILTERS.INCOMPLETE:
-      return allTodos.filter(todo => !todo.completed)
+      return allTodos.filter((todo) => !todo.completed)
     case VISIBILITY_FILTERS.ALL:
     default:
       return allTodos
@@ -430,7 +412,7 @@ And connecting to the store with the help of the selector:
 
 // ...
 
-const mapStateToProps = state => {
+const mapStateToProps = (state) => {
   const { visibilityFilter } = state
   const todos = getTodosByVisibilityFilter(state, visibilityFilter)
   return { todos }
diff --git a/website/versioned_docs/version-7.0/introduction/quick-start.md b/website/versioned_docs/version-7.0/introduction/quick-start.md
index 9df6d9aed..d8f62d8ca 100644
--- a/website/versioned_docs/version-7.0/introduction/quick-start.md
+++ b/website/versioned_docs/version-7.0/introduction/quick-start.md
@@ -45,7 +45,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  rootElement
+  rootElement,
 )
 ```
 
diff --git a/website/versioned_docs/version-7.0/troubleshooting.md b/website/versioned_docs/version-7.0/troubleshooting.md
index d52a29924..7490c7386 100644
--- a/website/versioned_docs/version-7.0/troubleshooting.md
+++ b/website/versioned_docs/version-7.0/troubleshooting.md
@@ -37,7 +37,7 @@ Router.run(routes, Router.HistoryLocation, (Handler, routerState) => {
       {/* note "routerState" here */}
       <Handler routerState={routerState} />
     </Provider>,
-    document.getElementById('root')
+    document.getElementById('root'),
   )
 })
 ```
@@ -69,14 +69,9 @@ function mapStateToProps(state) {
   return { todos: state.todos }
 }
 
-export default connect(
-  mapStateToProps,
-  null,
-  null,
-  {
-    pure: false
-  }
-)(TodoApp)
+export default connect(mapStateToProps, null, null, {
+  pure: false,
+})(TodoApp)
 ```
 
 This will remove the assumption that `TodoApp` is pure and cause it to update whenever its parent component renders. Note that this will make your application less performant, so only do this if you have no other option.
diff --git a/website/versioned_docs/version-7.0/using-react-redux/accessing-store.md b/website/versioned_docs/version-7.0/using-react-redux/accessing-store.md
index 38e1e98f3..126f2cde2 100644
--- a/website/versioned_docs/version-7.0/using-react-redux/accessing-store.md
+++ b/website/versioned_docs/version-7.0/using-react-redux/accessing-store.md
@@ -42,18 +42,12 @@ After you’ve supplied the custom context to `<Provider />`, you will need to s
 
 ```js
 // You can pass the context as an option to connect
-export default connect(
-  mapState,
-  mapDispatch,
-  null,
-  { context: MyContext }
-)(MyComponent)
+export default connect(mapState, mapDispatch, null, { context: MyContext })(
+  MyComponent,
+)
 
 // or, call connect as normal to start
-const ConnectedComponent = connect(
-  mapState,
-  mapDispatch
-)(MyComponent)
+const ConnectedComponent = connect(mapState, mapDispatch)(MyComponent)
 
 // Later, pass the custom context as a prop to the connected component
 ;<ConnectedComponent context={MyContext} />
diff --git a/website/versioned_docs/version-7.0/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md b/website/versioned_docs/version-7.0/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
index 49606c22e..4acdb06a1 100644
--- a/website/versioned_docs/version-7.0/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
+++ b/website/versioned_docs/version-7.0/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapdispatch
-title: "Connect: Dispatching Actions with mapDispatchToProps"
+title: 'Connect: Dispatching Actions with mapDispatchToProps'
 hide_title: true
-sidebar_label: "Connect: Dispatching Actions with mapDispatchToProps"
+sidebar_label: 'Connect: Dispatching Actions with mapDispatchToProps'
 ---
 
 # Connect: Dispatching Actions with `mapDispatchToProps`
@@ -29,10 +29,7 @@ If you don't specify the second argument to `connect()`, your component will rec
 ```js
 connect()(MyComponent)
 // which is equivalent with
-connect(
-  null,
-  null
-)(MyComponent)
+connect(null, null)(MyComponent)
 
 // or
 connect(mapStateToProps /** no second argument */)(MyComponent)
@@ -85,7 +82,7 @@ This allows more components to dispatch actions, while keeping them "unaware" of
 // making Todo able to dispatch the toggleTodo action
 const TodoList = ({ todos, toggleTodo }) => (
   <div>
-    {todos.map(todo => (
+    {todos.map((todo) => (
       <Todo todo={todo} onClick={toggleTodo} />
     ))}
   </div>
@@ -120,12 +117,12 @@ The `mapDispatchToProps` function will be called with `dispatch` as the first ar
 You will normally make use of this by returning new functions that call `dispatch()` inside themselves, and either pass in a plain action object directly or pass in the result of an action creator.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
     increment: () => dispatch({ type: 'INCREMENT' }),
     decrement: () => dispatch({ type: 'DECREMENT' }),
-    reset: () => dispatch({ type: 'RESET' })
+    reset: () => dispatch({ type: 'RESET' }),
   }
 }
 ```
@@ -133,14 +130,14 @@ const mapDispatchToProps = dispatch => {
 You will also likely want to forward arguments to your action creators:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // explicitly forwarding arguments
-    onClick: event => dispatch(trackClick(event)),
+    onClick: (event) => dispatch(trackClick(event)),
 
     // implicitly forwarding arguments
     onReceiveImpressions: (...impressions) =>
-      dispatch(trackImpressions(impressions))
+      dispatch(trackImpressions(impressions)),
   }
 }
 ```
@@ -173,12 +170,12 @@ const increment = () => ({ type: 'INCREMENT' })
 const decrement = () => ({ type: 'DECREMENT' })
 const reset = () => ({ type: 'RESET' })
 
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching actions returned by action creators
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
-    reset: () => dispatch(reset())
+    reset: () => dispatch(reset()),
   }
 }
 ```
@@ -227,7 +224,7 @@ const boundIncrement = bindActionCreators(increment, dispatch)
 // binding an object full of action creators
 const boundActionCreators = bindActionCreators(
   { increment, decrement, reset },
-  dispatch
+  dispatch,
 )
 // returns
 // {
@@ -248,10 +245,7 @@ function mapDispatchToProps(dispatch) {
 }
 
 // component receives props.increment, props.decrement, props.reset
-connect(
-  null,
-  mapDispatchToProps
-)(Counter)
+connect(null, mapDispatchToProps)(Counter)
 ```
 
 ### Manually Injecting `dispatch`
@@ -265,7 +259,7 @@ import { bindActionCreators } from 'redux'
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
   }
 }
 ```
@@ -285,7 +279,7 @@ Note that:
 
 ```js
 // React Redux does this for you automatically:
-dispatch => bindActionCreators(mapDispatchToProps, dispatch)
+;(dispatch) => bindActionCreators(mapDispatchToProps, dispatch)
 ```
 
 Therefore, our `mapDispatchToProps` can simply be:
@@ -294,7 +288,7 @@ Therefore, our `mapDispatchToProps` can simply be:
 const mapDispatchToProps = {
   increment,
   decrement,
-  reset
+  reset,
 }
 ```
 
@@ -348,12 +342,12 @@ connect(mapStateToProps /** no second argument*/)(Component)
 You may bring back `dispatch` by providing your customized `mapDispatchToProps` function:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
     reset: () => dispatch(reset()),
-    dispatch
+    dispatch,
   }
 }
 ```
@@ -366,7 +360,7 @@ import { bindActionCreators } from 'redux'
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
   }
 }
 ```
@@ -380,10 +374,7 @@ There are discussions regarding whether to provide `dispatch` to your components
 Yes. You can skip the first parameter by passing `undefined` or `null`. Your component will not subscribe to the store, and will still receive the dispatch props defined by `mapDispatchToProps`.
 
 ```js
-connect(
-  null,
-  mapDispatchToProps
-)(MyComponent)
+connect(null, mapDispatchToProps)(MyComponent)
 ```
 
 ### Can I call `store.dispatch`?
diff --git a/website/versioned_docs/version-7.0/using-react-redux/connect-extracting-data-with-mapStateToProps.md b/website/versioned_docs/version-7.0/using-react-redux/connect-extracting-data-with-mapStateToProps.md
index 9b8df6c5e..265126652 100644
--- a/website/versioned_docs/version-7.0/using-react-redux/connect-extracting-data-with-mapStateToProps.md
+++ b/website/versioned_docs/version-7.0/using-react-redux/connect-extracting-data-with-mapStateToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapstate
-title: "Connect: Extracting Data with mapStateToProps"
+title: 'Connect: Extracting Data with mapStateToProps'
 hide_title: true
-sidebar_label: "Connect: Extracting Data with mapStateToProps"
+sidebar_label: 'Connect: Extracting Data with mapStateToProps'
 ---
 
 # Connect: Extracting Data with `mapStateToProps`
@@ -85,7 +85,7 @@ function mapStateToProps(state) {
   return {
     a: 42,
     todos: state.todos,
-    filter: state.visibilityFilter
+    filter: state.visibilityFilter,
   }
 }
 
diff --git a/website/versioned_docs/version-7.1/api/Provider.md b/website/versioned_docs/version-7.1/api/Provider.md
index 1f7d96d04..9ccf3ef31 100644
--- a/website/versioned_docs/version-7.1/api/Provider.md
+++ b/website/versioned_docs/version-7.1/api/Provider.md
@@ -68,7 +68,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
 
@@ -95,6 +95,6 @@ ReactDOM.render(
       <Route path="/bar" component={Bar} />
     </Router>
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
diff --git a/website/versioned_docs/version-7.1/api/connect-advanced.md b/website/versioned_docs/version-7.1/api/connect-advanced.md
index ff65f1d25..13ba120b8 100644
--- a/website/versioned_docs/version-7.1/api/connect-advanced.md
+++ b/website/versioned_docs/version-7.1/api/connect-advanced.md
@@ -72,7 +72,7 @@ function selectorFactory(dispatch) {
   let result = {}
 
   const actions = bindActionCreators(actionCreators, dispatch)
-  const addTodo = text => actions.addTodo(ownProps.userId, text)
+  const addTodo = (text) => actions.addTodo(ownProps.userId, text)
 
   return (nextState, nextOwnProps) => {
     const todos = nextState.todos[nextOwnProps.userId]
diff --git a/website/versioned_docs/version-7.1/api/connect.md b/website/versioned_docs/version-7.1/api/connect.md
index 39105ade6..acc083778 100644
--- a/website/versioned_docs/version-7.1/api/connect.md
+++ b/website/versioned_docs/version-7.1/api/connect.md
@@ -48,7 +48,7 @@ A `mapStateToProps` function takes a maximum of two parameters. The number of de
 If your `mapStateToProps` function is declared as taking one parameter, it will be called whenever the store state changes, and given the store state as the only parameter.
 
 ```js
-const mapStateToProps = state => ({ todos: state.todos })
+const mapStateToProps = (state) => ({ todos: state.todos })
 ```
 
 ##### `ownProps`
@@ -59,7 +59,7 @@ The second parameter is normally referred to as `ownProps` by convention.
 
 ```js
 const mapStateToProps = (state, ownProps) => ({
-  todo: state.todos[ownProps.id]
+  todo: state.todos[ownProps.id],
 })
 ```
 
@@ -83,12 +83,7 @@ Your component will receive `dispatch` by default, i.e., when you do not supply
 // do not pass `mapDispatchToProps`
 connect()(MyComponent)
 connect(mapState)(MyComponent)
-connect(
-  mapState,
-  null,
-  mergeProps,
-  options
-)(MyComponent)
+connect(mapState, null, mergeProps, options)(MyComponent)
 ```
 
 If you define a `mapDispatchToProps` as a function, it will be called with a maximum of two parameters.
@@ -103,12 +98,12 @@ If you define a `mapDispatchToProps` as a function, it will be called with a max
 If your `mapDispatchToProps` is declared as a function taking one parameter, it will be given the `dispatch` of your `store`.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
     increment: () => dispatch({ type: 'INCREMENT' }),
     decrement: () => dispatch({ type: 'DECREMENT' }),
-    reset: () => dispatch({ type: 'RESET' })
+    reset: () => dispatch({ type: 'RESET' }),
   }
 }
 ```
@@ -121,7 +116,7 @@ The second parameter is normally referred to as `ownProps` by convention.
 
 ```js
 // binds on component re-rendering
-<button onClick={() => this.props.toggleTodo(this.props.todoId)} />
+;<button onClick={() => this.props.toggleTodo(this.props.todoId)} />
 
 // binds on `props` change
 const mapDispatchToProps = (dispatch, ownProps) => {
@@ -146,7 +141,7 @@ const mapDispatchToProps = (dispatch, ownProps) => {
     dispatchActionCreatedByActionCreator: () => dispatch(createMyAction()),
     ...boundActions,
     // you may return dispatch here
-    dispatch
+    dispatch,
   }
 }
 ```
@@ -165,13 +160,10 @@ import { addTodo, deleteTodo, toggleTodo } from './actionCreators'
 const mapDispatchToProps = {
   addTodo,
   deleteTodo,
-  toggleTodo
+  toggleTodo,
 }
 
-export default connect(
-  null,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(null, mapDispatchToProps)(TodoApp)
 ```
 
 In this case, React-Redux binds the `dispatch` of your store to each of the action creators using `bindActionCreators`. The result will be regarded as `dispatchProps`, which will be either directly merged to your connected components, or supplied to `mergeProps` as the second argument.
@@ -226,12 +218,9 @@ You may pass the context to your connected component either by passing it here a
 
 ```js
 // const MyContext = React.createContext();
-connect(
-  mapStateToProps,
-  mapDispatchToProps,
-  null,
-  { context: MyContext }
-)(MyComponent)
+connect(mapStateToProps, mapDispatchToProps, null, { context: MyContext })(
+  MyComponent,
+)
 ```
 
 #### `pure: boolean`
@@ -308,14 +297,11 @@ The return of `connect()` is a wrapper function that takes your component and re
 ```js
 import { login, logout } from './actionCreators'
 
-const mapState = state => state.user
+const mapState = (state) => state.user
 const mapDispatch = { login, logout }
 
 // first call: returns a hoc that you can use to wrap any component
-const connectUser = connect(
-  mapState,
-  mapDispatch
-)
+const connectUser = connect(mapState, mapDispatch)
 
 // second call: returns the wrapper component with mergedProps
 // you may use the hoc to enable different components to get the same behavior
@@ -328,16 +314,13 @@ In most cases, the wrapper function will be called right away, without being sav
 ```js
 import { login, logout } from './actionCreators'
 
-const mapState = state => state.user
+const mapState = (state) => state.user
 const mapDispatch = { login, logout }
 
 // call connect to generate the wrapper function, and immediately call
 // the wrapper function to generate the final wrapper component.
 
-export default connect(
-  mapState,
-  mapDispatch
-)(Login)
+export default connect(mapState, mapDispatch)(Login)
 ```
 
 ## Example Usage
@@ -355,10 +338,7 @@ export default connect()(TodoApp)
 ```js
 import * as actionCreators from './actionCreators'
 
-export default connect(
-  null,
-  actionCreators
-)(TodoApp)
+export default connect(null, actionCreators)(TodoApp)
 ```
 
 - Inject `dispatch` and every field in the global state
@@ -368,7 +348,7 @@ export default connect(
 
 ```js
 // don't do this!
-export default connect(state => state)(TodoApp)
+export default connect((state) => state)(TodoApp)
 ```
 
 - Inject `dispatch` and `todos`
@@ -390,10 +370,7 @@ function mapStateToProps(state) {
   return { todos: state.todos }
 }
 
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(TodoApp)
+export default connect(mapStateToProps, actionCreators)(TodoApp)
 ```
 
 - Inject `todos` and all action creators (`addTodo`, `completeTodo`, ...) as `actions`
@@ -410,10 +387,7 @@ function mapDispatchToProps(dispatch) {
   return { actions: bindActionCreators(actionCreators, dispatch) }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` and a specific action creator (`addTodo`)
@@ -430,10 +404,7 @@ function mapDispatchToProps(dispatch) {
   return bindActionCreators({ addTodo }, dispatch)
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` and specific action creators (`addTodo` and `deleteTodo`) with shorthand syntax
@@ -447,13 +418,10 @@ function mapStateToProps(state) {
 
 const mapDispatchToProps = {
   addTodo,
-  deleteTodo
+  deleteTodo,
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, `todoActionCreators` as `todoActions`, and `counterActionCreators` as `counterActions`
@@ -470,14 +438,11 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return {
     todoActions: bindActionCreators(todoActionCreators, dispatch),
-    counterActions: bindActionCreators(counterActionCreators, dispatch)
+    counterActions: bindActionCreators(counterActionCreators, dispatch),
   }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, and todoActionCreators and counterActionCreators together as `actions`
@@ -495,15 +460,12 @@ function mapDispatchToProps(dispatch) {
   return {
     actions: bindActionCreators(
       { ...todoActionCreators, ...counterActionCreators },
-      dispatch
-    )
+      dispatch,
+    ),
   }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, and all `todoActionCreators` and `counterActionCreators` directly as props
@@ -520,14 +482,11 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return bindActionCreators(
     { ...todoActionCreators, ...counterActionCreators },
-    dispatch
+    dispatch,
   )
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` of a specific user depending on props
@@ -554,15 +513,11 @@ function mapStateToProps(state) {
 function mergeProps(stateProps, dispatchProps, ownProps) {
   return Object.assign({}, ownProps, {
     todos: stateProps.todos[ownProps.userId],
-    addTodo: text => dispatchProps.addTodo(ownProps.userId, text)
+    addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text),
   })
 }
 
-export default connect(
-  mapStateToProps,
-  actionCreators,
-  mergeProps
-)(TodoApp)
+export default connect(mapStateToProps, actionCreators, mergeProps)(TodoApp)
 ```
 
 ## Notes
@@ -612,11 +567,8 @@ The factory functions are commonly used with memoized selectors. This gives you
 
 ```js
 const makeUniqueSelectorInstance = () =>
-  createSelector(
-    [selectItems, selectItemId],
-    (items, itemId) => items[itemId]
-  )
-const makeMapState = state => {
+  createSelector([selectItems, selectItemId], (items, itemId) => items[itemId])
+const makeMapState = (state) => {
   const selectItemForThisComponent = makeUniqueSelectorInstance()
   return function realMapState(state, ownProps) {
     const item = selectItemForThisComponent(state, ownProps.itemId)
diff --git a/website/versioned_docs/version-7.1/api/hooks.md b/website/versioned_docs/version-7.1/api/hooks.md
index e049a307f..fc532df2a 100644
--- a/website/versioned_docs/version-7.1/api/hooks.md
+++ b/website/versioned_docs/version-7.1/api/hooks.md
@@ -32,7 +32,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
 
@@ -107,7 +107,7 @@ import React from 'react'
 import { useSelector } from 'react-redux'
 
 export const CounterComponent = () => {
-  const counter = useSelector(state => state.counter)
+  const counter = useSelector((state) => state.counter)
   return <div>{counter}</div>
 }
 ```
@@ -118,8 +118,8 @@ Using props via closure to determine what to extract:
 import React from 'react'
 import { useSelector } from 'react-redux'
 
-export const TodoListItem = props => {
-  const todo = useSelector(state => state.todos[props.id])
+export const TodoListItem = (props) => {
+  const todo = useSelector((state) => state.todos[props.id])
   return <div>{todo.text}</div>
 }
 ```
@@ -136,8 +136,8 @@ import { useSelector } from 'react-redux'
 import { createSelector } from 'reselect'
 
 const selectNumCompletedTodos = createSelector(
-  state => state.todos,
-  todos => todos.filter(todo => todo.completed).length
+  (state) => state.todos,
+  (todos) => todos.filter((todo) => todo.completed).length,
 )
 
 export const CompletedTodosCounter = () => {
@@ -163,15 +163,15 @@ import { useSelector } from 'react-redux'
 import { createSelector } from 'reselect'
 
 const selectCompletedTodosCount = createSelector(
-  state => state.todos,
+  (state) => state.todos,
   (_, completed) => completed,
   (todos, completed) =>
-    todos.filter(todo => todo.completed === completed).length
+    todos.filter((todo) => todo.completed === completed).length,
 )
 
 export const CompletedTodosCount = ({ completed }) => {
-  const matchingCount = useSelector(state =>
-    selectCompletedTodosCount(state, completed)
+  const matchingCount = useSelector((state) =>
+    selectCompletedTodosCount(state, completed),
   )
 
   return <div>{matchingCount}</div>
@@ -196,17 +196,17 @@ import { createSelector } from 'reselect'
 
 const makeSelectCompletedTodosCount = () =>
   createSelector(
-    state => state.todos,
+    (state) => state.todos,
     (_, completed) => completed,
     (todos, completed) =>
-      todos.filter(todo => todo.completed === completed).length
+      todos.filter((todo) => todo.completed === completed).length,
   )
 
 export const CompletedTodosCount = ({ completed }) => {
   const selectCompletedTodosCount = useMemo(makeSelectCompletedTodosCount, [])
 
-  const matchingCount = useSelector(state =>
-    selectCompletedTodosCount(state, completed)
+  const matchingCount = useSelector((state) =>
+    selectCompletedTodosCount(state, completed),
   )
 
   return <div>{matchingCount}</div>
@@ -224,7 +224,6 @@ export const App = () => {
 }
 ```
 
-
 ## `useDispatch()`
 
 ```js
@@ -233,7 +232,6 @@ const dispatch = useDispatch()
 
 This hook returns a reference to the `dispatch` function from the Redux store. You may use it to dispatch actions as needed.
 
-
 #### Examples
 
 ```jsx
@@ -264,7 +262,7 @@ export const CounterComponent = ({ value }) => {
   const dispatch = useDispatch()
   const incrementCounter = useCallback(
     () => dispatch({ type: 'increment-counter' }),
-    [dispatch]
+    [dispatch],
   )
 
   return (
@@ -446,3 +444,4 @@ export function useShallowEqualSelector(selector) {
 ### Additional considerations when using hooks
 
 There are some architectural trade offs to take into consideration when deciding whether to use hooks or not. Mark Erikson summarizes these nicely in his two blog posts [Thoughts on React Hooks, Redux, and Separation of Concerns](https://blog.isquaredsoftware.com/2019/07/blogged-answers-thoughts-on-hooks/) and [Hooks, HOCs, and Tradeoffs](https://blog.isquaredsoftware.com/2019/09/presentation-hooks-hocs-tradeoffs/).
+````
diff --git a/website/versioned_docs/version-7.1/introduction/basic-tutorial.md b/website/versioned_docs/version-7.1/introduction/basic-tutorial.md
index 069e50d62..4721bac2e 100644
--- a/website/versioned_docs/version-7.1/introduction/basic-tutorial.md
+++ b/website/versioned_docs/version-7.1/introduction/basic-tutorial.md
@@ -86,7 +86,7 @@ ReactDOM.render(
   <Provider store={store}>
     <TodoApp />
   </Provider>,
-  rootElement
+  rootElement,
 )
 ```
 
@@ -118,18 +118,12 @@ const mapDispatchToProps = {
 }
 
 // `connect` returns a new function that accepts the component to wrap:
-const connectToStore = connect(
-  mapStateToProps,
-  mapDispatchToProps
-)
+const connectToStore = connect(mapStateToProps, mapDispatchToProps)
 // and that function returns the connected, wrapper component:
 const ConnectedComponent = connectToStore(Component)
 
 // We normally do both in one step, like this:
-connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(Component)
+connect(mapStateToProps, mapDispatchToProps)(Component)
 ```
 
 Let’s work on `<AddTodo />` first. It needs to trigger changes to the `store` to add new todos. Therefore, it needs to be able to `dispatch` actions to the store. Here’s how we do it.
@@ -141,12 +135,12 @@ Our `addTodo` action creator looks like this:
 import { ADD_TODO } from './actionTypes'
 
 let nextTodoId = 0
-export const addTodo = content => ({
+export const addTodo = (content) => ({
   type: ADD_TODO,
   payload: {
     id: ++nextTodoId,
-    content
-  }
+    content,
+  },
 })
 
 // ... other actions
@@ -165,10 +159,7 @@ class AddTodo extends React.Component {
   // ... component implementation
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo)
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Notice now that `<AddTodo />` is wrapped with a parent component called `<Connect(AddTodo) />`. Meanwhile, `<AddTodo />` now gains one prop: the `addTodo` action.
@@ -199,7 +190,7 @@ class AddTodo extends React.Component {
     return (
       <div>
         <input
-          onChange={e => this.updateInput(e.target.value)}
+          onChange={(e) => this.updateInput(e.target.value)}
           value={this.state.input}
         />
         <button className="add-todo" onClick={this.handleAddTodo}>
@@ -210,10 +201,7 @@ class AddTodo extends React.Component {
   }
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo)
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Now our `<AddTodo />` is connected to the store. When we add a todo it would dispatch an action to change the store. We are not seeing it in the app because the other components are not connected yet. If you have the Redux DevTools Extension hooked up, you should see the action being dispatched:
@@ -253,16 +241,16 @@ Luckily we have a selector that does exactly this. We may simply import the sele
 ```js
 // redux/selectors.js
 
-export const getTodosState = store => store.todos
+export const getTodosState = (store) => store.todos
 
-export const getTodoList = store =>
+export const getTodoList = (store) =>
   getTodosState(store) ? getTodosState(store).allIds : []
 
 export const getTodoById = (store, id) =>
   getTodosState(store) ? { ...getTodosState(store).byIds[id], id } : {}
 
-export const getTodos = store =>
-  getTodoList(store).map(id => getTodoById(store, id))
+export const getTodos = (store) =>
+  getTodoList(store).map((id) => getTodoById(store, id))
 ```
 
 ```js
@@ -315,7 +303,7 @@ If you call `connect` with only `mapStateToProps`, your component will:
 
 ```js
 // ... Component
-const mapStateToProps = state => state.partOfState
+const mapStateToProps = (state) => state.partOfState
 export default connect(mapStateToProps)(Component)
 ```
 
@@ -329,10 +317,7 @@ If you call `connect` with only `mapDispatchToProps`, your component will:
 ```js
 import { addTodo } from './actionCreators'
 // ... Component
-export default connect(
-  null,
-  { addTodo }
-)(Component)
+export default connect(null, { addTodo })(Component)
 ```
 
 #### Subscribe to the store and inject action creators
@@ -345,11 +330,8 @@ If you call `connect` with both `mapStateToProps` and `mapDispatchToProps`, your
 ```js
 import * as actionCreators from './actionCreators'
 // ... Component
-const mapStateToProps = state => state.partOfState
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(Component)
+const mapStateToProps = (state) => state.partOfState
+export default connect(mapStateToProps, actionCreators)(Component)
 ```
 
 These four cases cover the most basic usages of `connect`. To read more about `connect`, continue reading our [API section](../api/connect.md) that explains it in more detail.
@@ -413,9 +395,9 @@ export const getTodosByVisibilityFilter = (store, visibilityFilter) => {
   const allTodos = getTodos(store)
   switch (visibilityFilter) {
     case VISIBILITY_FILTERS.COMPLETED:
-      return allTodos.filter(todo => todo.completed)
+      return allTodos.filter((todo) => todo.completed)
     case VISIBILITY_FILTERS.INCOMPLETE:
-      return allTodos.filter(todo => !todo.completed)
+      return allTodos.filter((todo) => !todo.completed)
     case VISIBILITY_FILTERS.ALL:
     default:
       return allTodos
@@ -430,7 +412,7 @@ And connecting to the store with the help of the selector:
 
 // ...
 
-const mapStateToProps = state => {
+const mapStateToProps = (state) => {
   const { visibilityFilter } = state
   const todos = getTodosByVisibilityFilter(state, visibilityFilter)
   return { todos }
diff --git a/website/versioned_docs/version-7.1/introduction/quick-start.md b/website/versioned_docs/version-7.1/introduction/quick-start.md
index 22083490b..e8f3c73b6 100644
--- a/website/versioned_docs/version-7.1/introduction/quick-start.md
+++ b/website/versioned_docs/version-7.1/introduction/quick-start.md
@@ -45,7 +45,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  rootElement
+  rootElement,
 )
 ```
 
diff --git a/website/versioned_docs/version-7.1/troubleshooting.md b/website/versioned_docs/version-7.1/troubleshooting.md
index d52a29924..7490c7386 100644
--- a/website/versioned_docs/version-7.1/troubleshooting.md
+++ b/website/versioned_docs/version-7.1/troubleshooting.md
@@ -37,7 +37,7 @@ Router.run(routes, Router.HistoryLocation, (Handler, routerState) => {
       {/* note "routerState" here */}
       <Handler routerState={routerState} />
     </Provider>,
-    document.getElementById('root')
+    document.getElementById('root'),
   )
 })
 ```
@@ -69,14 +69,9 @@ function mapStateToProps(state) {
   return { todos: state.todos }
 }
 
-export default connect(
-  mapStateToProps,
-  null,
-  null,
-  {
-    pure: false
-  }
-)(TodoApp)
+export default connect(mapStateToProps, null, null, {
+  pure: false,
+})(TodoApp)
 ```
 
 This will remove the assumption that `TodoApp` is pure and cause it to update whenever its parent component renders. Note that this will make your application less performant, so only do this if you have no other option.
diff --git a/website/versioned_docs/version-7.1/using-react-redux/accessing-store.md b/website/versioned_docs/version-7.1/using-react-redux/accessing-store.md
index 38e1e98f3..126f2cde2 100644
--- a/website/versioned_docs/version-7.1/using-react-redux/accessing-store.md
+++ b/website/versioned_docs/version-7.1/using-react-redux/accessing-store.md
@@ -42,18 +42,12 @@ After you’ve supplied the custom context to `<Provider />`, you will need to s
 
 ```js
 // You can pass the context as an option to connect
-export default connect(
-  mapState,
-  mapDispatch,
-  null,
-  { context: MyContext }
-)(MyComponent)
+export default connect(mapState, mapDispatch, null, { context: MyContext })(
+  MyComponent,
+)
 
 // or, call connect as normal to start
-const ConnectedComponent = connect(
-  mapState,
-  mapDispatch
-)(MyComponent)
+const ConnectedComponent = connect(mapState, mapDispatch)(MyComponent)
 
 // Later, pass the custom context as a prop to the connected component
 ;<ConnectedComponent context={MyContext} />
diff --git a/website/versioned_docs/version-7.1/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md b/website/versioned_docs/version-7.1/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
index 49606c22e..4acdb06a1 100644
--- a/website/versioned_docs/version-7.1/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
+++ b/website/versioned_docs/version-7.1/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapdispatch
-title: "Connect: Dispatching Actions with mapDispatchToProps"
+title: 'Connect: Dispatching Actions with mapDispatchToProps'
 hide_title: true
-sidebar_label: "Connect: Dispatching Actions with mapDispatchToProps"
+sidebar_label: 'Connect: Dispatching Actions with mapDispatchToProps'
 ---
 
 # Connect: Dispatching Actions with `mapDispatchToProps`
@@ -29,10 +29,7 @@ If you don't specify the second argument to `connect()`, your component will rec
 ```js
 connect()(MyComponent)
 // which is equivalent with
-connect(
-  null,
-  null
-)(MyComponent)
+connect(null, null)(MyComponent)
 
 // or
 connect(mapStateToProps /** no second argument */)(MyComponent)
@@ -85,7 +82,7 @@ This allows more components to dispatch actions, while keeping them "unaware" of
 // making Todo able to dispatch the toggleTodo action
 const TodoList = ({ todos, toggleTodo }) => (
   <div>
-    {todos.map(todo => (
+    {todos.map((todo) => (
       <Todo todo={todo} onClick={toggleTodo} />
     ))}
   </div>
@@ -120,12 +117,12 @@ The `mapDispatchToProps` function will be called with `dispatch` as the first ar
 You will normally make use of this by returning new functions that call `dispatch()` inside themselves, and either pass in a plain action object directly or pass in the result of an action creator.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
     increment: () => dispatch({ type: 'INCREMENT' }),
     decrement: () => dispatch({ type: 'DECREMENT' }),
-    reset: () => dispatch({ type: 'RESET' })
+    reset: () => dispatch({ type: 'RESET' }),
   }
 }
 ```
@@ -133,14 +130,14 @@ const mapDispatchToProps = dispatch => {
 You will also likely want to forward arguments to your action creators:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // explicitly forwarding arguments
-    onClick: event => dispatch(trackClick(event)),
+    onClick: (event) => dispatch(trackClick(event)),
 
     // implicitly forwarding arguments
     onReceiveImpressions: (...impressions) =>
-      dispatch(trackImpressions(impressions))
+      dispatch(trackImpressions(impressions)),
   }
 }
 ```
@@ -173,12 +170,12 @@ const increment = () => ({ type: 'INCREMENT' })
 const decrement = () => ({ type: 'DECREMENT' })
 const reset = () => ({ type: 'RESET' })
 
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching actions returned by action creators
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
-    reset: () => dispatch(reset())
+    reset: () => dispatch(reset()),
   }
 }
 ```
@@ -227,7 +224,7 @@ const boundIncrement = bindActionCreators(increment, dispatch)
 // binding an object full of action creators
 const boundActionCreators = bindActionCreators(
   { increment, decrement, reset },
-  dispatch
+  dispatch,
 )
 // returns
 // {
@@ -248,10 +245,7 @@ function mapDispatchToProps(dispatch) {
 }
 
 // component receives props.increment, props.decrement, props.reset
-connect(
-  null,
-  mapDispatchToProps
-)(Counter)
+connect(null, mapDispatchToProps)(Counter)
 ```
 
 ### Manually Injecting `dispatch`
@@ -265,7 +259,7 @@ import { bindActionCreators } from 'redux'
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
   }
 }
 ```
@@ -285,7 +279,7 @@ Note that:
 
 ```js
 // React Redux does this for you automatically:
-dispatch => bindActionCreators(mapDispatchToProps, dispatch)
+;(dispatch) => bindActionCreators(mapDispatchToProps, dispatch)
 ```
 
 Therefore, our `mapDispatchToProps` can simply be:
@@ -294,7 +288,7 @@ Therefore, our `mapDispatchToProps` can simply be:
 const mapDispatchToProps = {
   increment,
   decrement,
-  reset
+  reset,
 }
 ```
 
@@ -348,12 +342,12 @@ connect(mapStateToProps /** no second argument*/)(Component)
 You may bring back `dispatch` by providing your customized `mapDispatchToProps` function:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
     reset: () => dispatch(reset()),
-    dispatch
+    dispatch,
   }
 }
 ```
@@ -366,7 +360,7 @@ import { bindActionCreators } from 'redux'
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
   }
 }
 ```
@@ -380,10 +374,7 @@ There are discussions regarding whether to provide `dispatch` to your components
 Yes. You can skip the first parameter by passing `undefined` or `null`. Your component will not subscribe to the store, and will still receive the dispatch props defined by `mapDispatchToProps`.
 
 ```js
-connect(
-  null,
-  mapDispatchToProps
-)(MyComponent)
+connect(null, mapDispatchToProps)(MyComponent)
 ```
 
 ### Can I call `store.dispatch`?
diff --git a/website/versioned_docs/version-7.1/using-react-redux/connect-extracting-data-with-mapStateToProps.md b/website/versioned_docs/version-7.1/using-react-redux/connect-extracting-data-with-mapStateToProps.md
index 9b8df6c5e..265126652 100644
--- a/website/versioned_docs/version-7.1/using-react-redux/connect-extracting-data-with-mapStateToProps.md
+++ b/website/versioned_docs/version-7.1/using-react-redux/connect-extracting-data-with-mapStateToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapstate
-title: "Connect: Extracting Data with mapStateToProps"
+title: 'Connect: Extracting Data with mapStateToProps'
 hide_title: true
-sidebar_label: "Connect: Extracting Data with mapStateToProps"
+sidebar_label: 'Connect: Extracting Data with mapStateToProps'
 ---
 
 # Connect: Extracting Data with `mapStateToProps`
@@ -85,7 +85,7 @@ function mapStateToProps(state) {
   return {
     a: 42,
     todos: state.todos,
-    filter: state.visibilityFilter
+    filter: state.visibilityFilter,
   }
 }
 
diff --git a/website/versioned_docs/version-7.1/using-react-redux/static-types.md b/website/versioned_docs/version-7.1/using-react-redux/static-types.md
index 5f0b2eafb..d6532322f 100644
--- a/website/versioned_docs/version-7.1/using-react-redux/static-types.md
+++ b/website/versioned_docs/version-7.1/using-react-redux/static-types.md
@@ -22,7 +22,7 @@ Both `mapState` and `useSelector` depend on declaring the type of the complete R
 export const rootReducer = combineReducers({
   posts: postsReducer,
   comments: commentsReducer,
-  users: usersReducer
+  users: usersReducer,
 })
 
 export type RootState = ReturnType<typeof rootReducer>
@@ -60,7 +60,7 @@ export const useTypedSelector: TypedUseSelectorHook<RootState> = useSelector
 // my-component.tsx
 import { useTypedSelector } from './reducer.ts'
 
-const isOn = useTypedSelector(state => state.isOn)
+const isOn = useTypedSelector((state) => state.isOn)
 ```
 
 ### Typing the `useDispatch` hook
@@ -105,11 +105,11 @@ interface OwnProps {
 type Props = StateProps & DispatchProps & OwnProps
 
 const mapState = (state: RootState) => ({
-  isOn: state.isOn
+  isOn: state.isOn,
 })
 
 const mapDispatch = {
-  toggleOn: () => ({ type: 'TOGGLE_IS_ON' })
+  toggleOn: () => ({ type: 'TOGGLE_IS_ON' }),
 }
 
 const MyComponent = (props: Props) => (
@@ -123,7 +123,7 @@ const MyComponent = (props: Props) => (
 // Typical usage: `connect` is called after the component is defined
 export default connect<StateProps, DispatchProps, OwnProps>(
   mapState,
-  mapDispatch
+  mapDispatch,
 )(MyComponent)
 ```
 
@@ -131,11 +131,11 @@ It is also possible to shorten this somewhat, by inferring the types of `mapStat
 
 ```ts
 const mapState = (state: RootState) => ({
-  isOn: state.isOn
+  isOn: state.isOn,
 })
 
 const mapDispatch = {
-  toggleOn: () => ({ type: 'TOGGLE_IS_ON' })
+  toggleOn: () => ({ type: 'TOGGLE_IS_ON' }),
 }
 
 type StateProps = ReturnType<typeof mapState>
@@ -160,17 +160,14 @@ interface RootState {
 }
 
 const mapState = (state: RootState) => ({
-  isOn: state.isOn
+  isOn: state.isOn,
 })
 
 const mapDispatch = {
-  toggleOn: () => ({ type: 'TOGGLE_IS_ON' })
+  toggleOn: () => ({ type: 'TOGGLE_IS_ON' }),
 }
 
-const connector = connect(
-  mapState,
-  mapDispatch
-)
+const connector = connect(mapState, mapDispatch)
 
 // The inferred type will look like:
 // {isOn: boolean, toggleOn: () => void}
diff --git a/website/versioned_docs/version-7.2/api/Provider.md b/website/versioned_docs/version-7.2/api/Provider.md
index 1f7d96d04..9ccf3ef31 100644
--- a/website/versioned_docs/version-7.2/api/Provider.md
+++ b/website/versioned_docs/version-7.2/api/Provider.md
@@ -68,7 +68,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
 
@@ -95,6 +95,6 @@ ReactDOM.render(
       <Route path="/bar" component={Bar} />
     </Router>
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
diff --git a/website/versioned_docs/version-7.2/api/connect-advanced.md b/website/versioned_docs/version-7.2/api/connect-advanced.md
index ff65f1d25..13ba120b8 100644
--- a/website/versioned_docs/version-7.2/api/connect-advanced.md
+++ b/website/versioned_docs/version-7.2/api/connect-advanced.md
@@ -72,7 +72,7 @@ function selectorFactory(dispatch) {
   let result = {}
 
   const actions = bindActionCreators(actionCreators, dispatch)
-  const addTodo = text => actions.addTodo(ownProps.userId, text)
+  const addTodo = (text) => actions.addTodo(ownProps.userId, text)
 
   return (nextState, nextOwnProps) => {
     const todos = nextState.todos[nextOwnProps.userId]
diff --git a/website/versioned_docs/version-7.2/api/connect.md b/website/versioned_docs/version-7.2/api/connect.md
index 4392ebe1b..bc759a8dd 100644
--- a/website/versioned_docs/version-7.2/api/connect.md
+++ b/website/versioned_docs/version-7.2/api/connect.md
@@ -48,7 +48,7 @@ A `mapStateToProps` function takes a maximum of two parameters. The number of de
 If your `mapStateToProps` function is declared as taking one parameter, it will be called whenever the store state changes, and given the store state as the only parameter.
 
 ```js
-const mapStateToProps = state => ({ todos: state.todos })
+const mapStateToProps = (state) => ({ todos: state.todos })
 ```
 
 ##### `ownProps`
@@ -59,7 +59,7 @@ The second parameter is normally referred to as `ownProps` by convention.
 
 ```js
 const mapStateToProps = (state, ownProps) => ({
-  todo: state.todos[ownProps.id]
+  todo: state.todos[ownProps.id],
 })
 ```
 
@@ -83,12 +83,7 @@ Your component will receive `dispatch` by default, i.e., when you do not supply
 // do not pass `mapDispatchToProps`
 connect()(MyComponent)
 connect(mapState)(MyComponent)
-connect(
-  mapState,
-  null,
-  mergeProps,
-  options
-)(MyComponent)
+connect(mapState, null, mergeProps, options)(MyComponent)
 ```
 
 If you define a `mapDispatchToProps` as a function, it will be called with a maximum of two parameters.
@@ -103,12 +98,12 @@ If you define a `mapDispatchToProps` as a function, it will be called with a max
 If your `mapDispatchToProps` is declared as a function taking one parameter, it will be given the `dispatch` of your `store`.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
     increment: () => dispatch({ type: 'INCREMENT' }),
     decrement: () => dispatch({ type: 'DECREMENT' }),
-    reset: () => dispatch({ type: 'RESET' })
+    reset: () => dispatch({ type: 'RESET' }),
   }
 }
 ```
@@ -121,7 +116,7 @@ The second parameter is normally referred to as `ownProps` by convention.
 
 ```js
 // binds on component re-rendering
-<button onClick={() => this.props.toggleTodo(this.props.todoId)} />
+;<button onClick={() => this.props.toggleTodo(this.props.todoId)} />
 
 // binds on `props` change
 const mapDispatchToProps = (dispatch, ownProps) => {
@@ -146,7 +141,7 @@ const mapDispatchToProps = (dispatch, ownProps) => {
     dispatchActionCreatedByActionCreator: () => dispatch(createMyAction()),
     ...boundActions,
     // you may return dispatch here
-    dispatch
+    dispatch,
   }
 }
 ```
@@ -165,13 +160,10 @@ import { addTodo, deleteTodo, toggleTodo } from './actionCreators'
 const mapDispatchToProps = {
   addTodo,
   deleteTodo,
-  toggleTodo
+  toggleTodo,
 }
 
-export default connect(
-  null,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(null, mapDispatchToProps)(TodoApp)
 ```
 
 In this case, React-Redux binds the `dispatch` of your store to each of the action creators using `bindActionCreators`. The result will be regarded as `dispatchProps`, which will be either directly merged to your connected components, or supplied to `mergeProps` as the second argument.
@@ -226,12 +218,9 @@ You may pass the context to your connected component either by passing it here a
 
 ```js
 // const MyContext = React.createContext();
-connect(
-  mapStateToProps,
-  mapDispatchToProps,
-  null,
-  { context: MyContext }
-)(MyComponent)
+connect(mapStateToProps, mapDispatchToProps, null, { context: MyContext })(
+  MyComponent,
+)
 ```
 
 #### `pure: boolean`
@@ -308,14 +297,11 @@ The return of `connect()` is a wrapper function that takes your component and re
 ```js
 import { login, logout } from './actionCreators'
 
-const mapState = state => state.user
+const mapState = (state) => state.user
 const mapDispatch = { login, logout }
 
 // first call: returns a hoc that you can use to wrap any component
-const connectUser = connect(
-  mapState,
-  mapDispatch
-)
+const connectUser = connect(mapState, mapDispatch)
 
 // second call: returns the wrapper component with mergedProps
 // you may use the hoc to enable different components to get the same behavior
@@ -328,16 +314,13 @@ In most cases, the wrapper function will be called right away, without being sav
 ```js
 import { login, logout } from './actionCreators'
 
-const mapState = state => state.user
+const mapState = (state) => state.user
 const mapDispatch = { login, logout }
 
 // call connect to generate the wrapper function, and immediately call
 // the wrapper function to generate the final wrapper component.
 
-export default connect(
-  mapState,
-  mapDispatch
-)(Login)
+export default connect(mapState, mapDispatch)(Login)
 ```
 
 ## Example Usage
@@ -355,10 +338,7 @@ export default connect()(TodoApp)
 ```js
 import * as actionCreators from './actionCreators'
 
-export default connect(
-  null,
-  actionCreators
-)(TodoApp)
+export default connect(null, actionCreators)(TodoApp)
 ```
 
 - Inject `dispatch` and every field in the global state
@@ -368,7 +348,7 @@ export default connect(
 
 ```js
 // don't do this!
-export default connect(state => state)(TodoApp)
+export default connect((state) => state)(TodoApp)
 ```
 
 - Inject `dispatch` and `todos`
@@ -390,10 +370,7 @@ function mapStateToProps(state) {
   return { todos: state.todos }
 }
 
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(TodoApp)
+export default connect(mapStateToProps, actionCreators)(TodoApp)
 ```
 
 - Inject `todos` and all action creators (`addTodo`, `completeTodo`, ...) as `actions`
@@ -410,10 +387,7 @@ function mapDispatchToProps(dispatch) {
   return { actions: bindActionCreators(actionCreators, dispatch) }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` and a specific action creator (`addTodo`)
@@ -430,10 +404,7 @@ function mapDispatchToProps(dispatch) {
   return bindActionCreators({ addTodo }, dispatch)
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` and specific action creators (`addTodo` and `deleteTodo`) with shorthand syntax
@@ -447,13 +418,10 @@ function mapStateToProps(state) {
 
 const mapDispatchToProps = {
   addTodo,
-  deleteTodo
+  deleteTodo,
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, `todoActionCreators` as `todoActions`, and `counterActionCreators` as `counterActions`
@@ -470,14 +438,11 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return {
     todoActions: bindActionCreators(todoActionCreators, dispatch),
-    counterActions: bindActionCreators(counterActionCreators, dispatch)
+    counterActions: bindActionCreators(counterActionCreators, dispatch),
   }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, and todoActionCreators and counterActionCreators together as `actions`
@@ -495,15 +460,12 @@ function mapDispatchToProps(dispatch) {
   return {
     actions: bindActionCreators(
       { ...todoActionCreators, ...counterActionCreators },
-      dispatch
-    )
+      dispatch,
+    ),
   }
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos`, and all `todoActionCreators` and `counterActionCreators` directly as props
@@ -520,14 +482,11 @@ function mapStateToProps(state) {
 function mapDispatchToProps(dispatch) {
   return bindActionCreators(
     { ...todoActionCreators, ...counterActionCreators },
-    dispatch
+    dispatch,
   )
 }
 
-export default connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(TodoApp)
+export default connect(mapStateToProps, mapDispatchToProps)(TodoApp)
 ```
 
 - Inject `todos` of a specific user depending on props
@@ -554,15 +513,11 @@ function mapStateToProps(state) {
 function mergeProps(stateProps, dispatchProps, ownProps) {
   return Object.assign({}, ownProps, {
     todos: stateProps.todos[ownProps.userId],
-    addTodo: text => dispatchProps.addTodo(ownProps.userId, text)
+    addTodo: (text) => dispatchProps.addTodo(ownProps.userId, text),
   })
 }
 
-export default connect(
-  mapStateToProps,
-  actionCreators,
-  mergeProps
-)(TodoApp)
+export default connect(mapStateToProps, actionCreators, mergeProps)(TodoApp)
 ```
 
 ## Notes
@@ -612,11 +567,8 @@ The factory functions are commonly used with memoized selectors. This gives you
 
 ```js
 const makeUniqueSelectorInstance = () =>
-  createSelector(
-    [selectItems, selectItemId],
-    (items, itemId) => items[itemId]
-  )
-const makeMapState = state => {
+  createSelector([selectItems, selectItemId], (items, itemId) => items[itemId])
+const makeMapState = (state) => {
   const selectItemForThisComponent = makeUniqueSelectorInstance()
   return function realMapState(state, ownProps) {
     const item = selectItemForThisComponent(state, ownProps.itemId)
diff --git a/website/versioned_docs/version-7.2/api/hooks.md b/website/versioned_docs/version-7.2/api/hooks.md
index 9efa8ccbc..a757b0f3c 100644
--- a/website/versioned_docs/version-7.2/api/hooks.md
+++ b/website/versioned_docs/version-7.2/api/hooks.md
@@ -32,7 +32,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  document.getElementById('root')
+  document.getElementById('root'),
 )
 ```
 
@@ -107,7 +107,7 @@ import React from 'react'
 import { useSelector } from 'react-redux'
 
 export const CounterComponent = () => {
-  const counter = useSelector(state => state.counter)
+  const counter = useSelector((state) => state.counter)
   return <div>{counter}</div>
 }
 ```
@@ -118,8 +118,8 @@ Using props via closure to determine what to extract:
 import React from 'react'
 import { useSelector } from 'react-redux'
 
-export const TodoListItem = props => {
-  const todo = useSelector(state => state.todos[props.id])
+export const TodoListItem = (props) => {
+  const todo = useSelector((state) => state.todos[props.id])
   return <div>{todo.text}</div>
 }
 ```
@@ -136,8 +136,8 @@ import { useSelector } from 'react-redux'
 import { createSelector } from 'reselect'
 
 const selectNumCompletedTodos = createSelector(
-  state => state.todos,
-  todos => todos.filter(todo => todo.completed).length
+  (state) => state.todos,
+  (todos) => todos.filter((todo) => todo.completed).length,
 )
 
 export const CompletedTodosCounter = () => {
@@ -163,15 +163,15 @@ import { useSelector } from 'react-redux'
 import { createSelector } from 'reselect'
 
 const selectCompletedTodosCount = createSelector(
-  state => state.todos,
+  (state) => state.todos,
   (_, completed) => completed,
   (todos, completed) =>
-    todos.filter(todo => todo.completed === completed).length
+    todos.filter((todo) => todo.completed === completed).length,
 )
 
 export const CompletedTodosCount = ({ completed }) => {
-  const matchingCount = useSelector(state =>
-    selectCompletedTodosCount(state, completed)
+  const matchingCount = useSelector((state) =>
+    selectCompletedTodosCount(state, completed),
   )
 
   return <div>{matchingCount}</div>
@@ -196,17 +196,17 @@ import { createSelector } from 'reselect'
 
 const makeSelectCompletedTodosCount = () =>
   createSelector(
-    state => state.todos,
+    (state) => state.todos,
     (_, completed) => completed,
     (todos, completed) =>
-      todos.filter(todo => todo.completed === completed).length
+      todos.filter((todo) => todo.completed === completed).length,
   )
 
 export const CompletedTodosCount = ({ completed }) => {
   const selectCompletedTodosCount = useMemo(makeSelectCompletedTodosCount, [])
 
-  const matchingCount = useSelector(state =>
-    selectCompletedTodosCount(state, completed)
+  const matchingCount = useSelector((state) =>
+    selectCompletedTodosCount(state, completed),
   )
 
   return <div>{matchingCount}</div>
@@ -224,7 +224,6 @@ export const App = () => {
 }
 ```
 
-
 ## `useDispatch()`
 
 ```js
@@ -233,7 +232,6 @@ const dispatch = useDispatch()
 
 This hook returns a reference to the `dispatch` function from the Redux store. You may use it to dispatch actions as needed.
 
-
 #### Examples
 
 ```jsx
@@ -264,7 +262,7 @@ export const CounterComponent = ({ value }) => {
   const dispatch = useDispatch()
   const incrementCounter = useCallback(
     () => dispatch({ type: 'increment-counter' }),
-    [dispatch]
+    [dispatch],
   )
 
   return (
@@ -479,3 +477,4 @@ export function useShallowEqualSelector(selector) {
 ### Additional considerations when using hooks
 
 There are some architectural trade offs to take into consideration when deciding whether to use hooks or not. Mark Erikson summarizes these nicely in his two blog posts [Thoughts on React Hooks, Redux, and Separation of Concerns](https://blog.isquaredsoftware.com/2019/07/blogged-answers-thoughts-on-hooks/) and [Hooks, HOCs, and Tradeoffs](https://blog.isquaredsoftware.com/2019/09/presentation-hooks-hocs-tradeoffs/).
+````
diff --git a/website/versioned_docs/version-7.2/introduction/basic-tutorial.md b/website/versioned_docs/version-7.2/introduction/basic-tutorial.md
index ac25c69ea..0b295be49 100644
--- a/website/versioned_docs/version-7.2/introduction/basic-tutorial.md
+++ b/website/versioned_docs/version-7.2/introduction/basic-tutorial.md
@@ -86,7 +86,7 @@ ReactDOM.render(
   <Provider store={store}>
     <TodoApp />
   </Provider>,
-  rootElement
+  rootElement,
 )
 ```
 
@@ -118,18 +118,12 @@ const mapDispatchToProps = {
 }
 
 // `connect` returns a new function that accepts the component to wrap:
-const connectToStore = connect(
-  mapStateToProps,
-  mapDispatchToProps
-)
+const connectToStore = connect(mapStateToProps, mapDispatchToProps)
 // and that function returns the connected, wrapper component:
 const ConnectedComponent = connectToStore(Component)
 
 // We normally do both in one step, like this:
-connect(
-  mapStateToProps,
-  mapDispatchToProps
-)(Component)
+connect(mapStateToProps, mapDispatchToProps)(Component)
 ```
 
 Let’s work on `<AddTodo />` first. It needs to trigger changes to the `store` to add new todos. Therefore, it needs to be able to `dispatch` actions to the store. Here’s how we do it.
@@ -141,12 +135,12 @@ Our `addTodo` action creator looks like this:
 import { ADD_TODO } from './actionTypes'
 
 let nextTodoId = 0
-export const addTodo = content => ({
+export const addTodo = (content) => ({
   type: ADD_TODO,
   payload: {
     id: ++nextTodoId,
-    content
-  }
+    content,
+  },
 })
 
 // ... other actions
@@ -165,10 +159,7 @@ class AddTodo extends React.Component {
   // ... component implementation
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo)
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Notice now that `<AddTodo />` is wrapped with a parent component called `<Connect(AddTodo) />`. Meanwhile, `<AddTodo />` now gains one prop: the `addTodo` action.
@@ -199,7 +190,7 @@ class AddTodo extends React.Component {
     return (
       <div>
         <input
-          onChange={e => this.updateInput(e.target.value)}
+          onChange={(e) => this.updateInput(e.target.value)}
           value={this.state.input}
         />
         <button className="add-todo" onClick={this.handleAddTodo}>
@@ -210,10 +201,7 @@ class AddTodo extends React.Component {
   }
 }
 
-export default connect(
-  null,
-  { addTodo }
-)(AddTodo)
+export default connect(null, { addTodo })(AddTodo)
 ```
 
 Now our `<AddTodo />` is connected to the store. When we add a todo it would dispatch an action to change the store. We are not seeing it in the app because the other components are not connected yet. If you have the Redux DevTools Extension hooked up, you should see the action being dispatched:
@@ -253,16 +241,16 @@ Luckily we have a selector that does exactly this. We may simply import the sele
 ```js
 // redux/selectors.js
 
-export const getTodosState = store => store.todos
+export const getTodosState = (store) => store.todos
 
-export const getTodoList = store =>
+export const getTodoList = (store) =>
   getTodosState(store) ? getTodosState(store).allIds : []
 
 export const getTodoById = (store, id) =>
   getTodosState(store) ? { ...getTodosState(store).byIds[id], id } : {}
 
-export const getTodos = store =>
-  getTodoList(store).map(id => getTodoById(store, id))
+export const getTodos = (store) =>
+  getTodoList(store).map((id) => getTodoById(store, id))
 ```
 
 ```js
@@ -315,7 +303,7 @@ If you call `connect` with only `mapStateToProps`, your component will:
 
 ```js
 // ... Component
-const mapStateToProps = state => state.partOfState
+const mapStateToProps = (state) => state.partOfState
 export default connect(mapStateToProps)(Component)
 ```
 
@@ -329,10 +317,7 @@ If you call `connect` with only `mapDispatchToProps`, your component will:
 ```js
 import { addTodo } from './actionCreators'
 // ... Component
-export default connect(
-  null,
-  { addTodo }
-)(Component)
+export default connect(null, { addTodo })(Component)
 ```
 
 #### Subscribe to the store and inject action creators
@@ -345,11 +330,8 @@ If you call `connect` with both `mapStateToProps` and `mapDispatchToProps`, your
 ```js
 import * as actionCreators from './actionCreators'
 // ... Component
-const mapStateToProps = state => state.partOfState
-export default connect(
-  mapStateToProps,
-  actionCreators
-)(Component)
+const mapStateToProps = (state) => state.partOfState
+export default connect(mapStateToProps, actionCreators)(Component)
 ```
 
 These four cases cover the most basic usages of `connect`. To read more about `connect`, continue reading our [API section](../api/connect.md) that explains it in more detail.
@@ -413,9 +395,9 @@ export const getTodosByVisibilityFilter = (store, visibilityFilter) => {
   const allTodos = getTodos(store)
   switch (visibilityFilter) {
     case VISIBILITY_FILTERS.COMPLETED:
-      return allTodos.filter(todo => todo.completed)
+      return allTodos.filter((todo) => todo.completed)
     case VISIBILITY_FILTERS.INCOMPLETE:
-      return allTodos.filter(todo => !todo.completed)
+      return allTodos.filter((todo) => !todo.completed)
     case VISIBILITY_FILTERS.ALL:
     default:
       return allTodos
@@ -430,7 +412,7 @@ And connecting to the store with the help of the selector:
 
 // ...
 
-const mapStateToProps = state => {
+const mapStateToProps = (state) => {
   const { visibilityFilter } = state
   const todos = getTodosByVisibilityFilter(state, visibilityFilter)
   return { todos }
diff --git a/website/versioned_docs/version-7.2/introduction/quick-start.md b/website/versioned_docs/version-7.2/introduction/quick-start.md
index 21ec85d55..990999d38 100644
--- a/website/versioned_docs/version-7.2/introduction/quick-start.md
+++ b/website/versioned_docs/version-7.2/introduction/quick-start.md
@@ -45,7 +45,7 @@ ReactDOM.render(
   <Provider store={store}>
     <App />
   </Provider>,
-  rootElement
+  rootElement,
 )
 ```
 
diff --git a/website/versioned_docs/version-7.2/troubleshooting.md b/website/versioned_docs/version-7.2/troubleshooting.md
index 454605f71..0dbc3b492 100644
--- a/website/versioned_docs/version-7.2/troubleshooting.md
+++ b/website/versioned_docs/version-7.2/troubleshooting.md
@@ -37,7 +37,7 @@ Router.run(routes, Router.HistoryLocation, (Handler, routerState) => {
       {/* note "routerState" here */}
       <Handler routerState={routerState} />
     </Provider>,
-    document.getElementById('root')
+    document.getElementById('root'),
   )
 })
 ```
@@ -69,14 +69,9 @@ function mapStateToProps(state) {
   return { todos: state.todos }
 }
 
-export default connect(
-  mapStateToProps,
-  null,
-  null,
-  {
-    pure: false
-  }
-)(TodoApp)
+export default connect(mapStateToProps, null, null, {
+  pure: false,
+})(TodoApp)
 ```
 
 This will remove the assumption that `TodoApp` is pure and cause it to update whenever its parent component renders. Note that this will make your application less performant, so only do this if you have no other option.
diff --git a/website/versioned_docs/version-7.2/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md b/website/versioned_docs/version-7.2/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
index 0671a92e9..b57f9b7ee 100644
--- a/website/versioned_docs/version-7.2/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
+++ b/website/versioned_docs/version-7.2/using-react-redux/connect-dispatching-actions-with-mapDispatchToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapdispatch
-title: "Connect: Dispatching Actions with mapDispatchToProps"
+title: 'Connect: Dispatching Actions with mapDispatchToProps'
 hide_title: true
-sidebar_label: "Connect: Dispatching Actions with mapDispatchToProps"
+sidebar_label: 'Connect: Dispatching Actions with mapDispatchToProps'
 ---
 
 # Connect: Dispatching Actions with `mapDispatchToProps`
@@ -29,10 +29,7 @@ If you don't specify the second argument to `connect()`, your component will rec
 ```js
 connect()(MyComponent)
 // which is equivalent with
-connect(
-  null,
-  null
-)(MyComponent)
+connect(null, null)(MyComponent)
 
 // or
 connect(mapStateToProps /** no second argument */)(MyComponent)
@@ -85,7 +82,7 @@ This allows more components to dispatch actions, while keeping them "unaware" of
 // making Todo able to dispatch the toggleTodo action
 const TodoList = ({ todos, toggleTodo }) => (
   <div>
-    {todos.map(todo => (
+    {todos.map((todo) => (
       <Todo todo={todo} onClick={toggleTodo} />
     ))}
   </div>
@@ -120,12 +117,12 @@ The `mapDispatchToProps` function will be called with `dispatch` as the first ar
 You will normally make use of this by returning new functions that call `dispatch()` inside themselves, and either pass in a plain action object directly or pass in the result of an action creator.
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching plain actions
     increment: () => dispatch({ type: 'INCREMENT' }),
     decrement: () => dispatch({ type: 'DECREMENT' }),
-    reset: () => dispatch({ type: 'RESET' })
+    reset: () => dispatch({ type: 'RESET' }),
   }
 }
 ```
@@ -133,14 +130,14 @@ const mapDispatchToProps = dispatch => {
 You will also likely want to forward arguments to your action creators:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // explicitly forwarding arguments
-    onClick: event => dispatch(trackClick(event)),
+    onClick: (event) => dispatch(trackClick(event)),
 
     // implicitly forwarding arguments
     onReceiveImpressions: (...impressions) =>
-      dispatch(trackImpressions(impressions))
+      dispatch(trackImpressions(impressions)),
   }
 }
 ```
@@ -191,12 +188,12 @@ const increment = () => ({ type: 'INCREMENT' })
 const decrement = () => ({ type: 'DECREMENT' })
 const reset = () => ({ type: 'RESET' })
 
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     // dispatching actions returned by action creators
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
-    reset: () => dispatch(reset())
+    reset: () => dispatch(reset()),
   }
 }
 ```
@@ -245,7 +242,7 @@ const boundIncrement = bindActionCreators(increment, dispatch)
 // binding an object full of action creators
 const boundActionCreators = bindActionCreators(
   { increment, decrement, reset },
-  dispatch
+  dispatch,
 )
 // returns
 // {
@@ -266,10 +263,7 @@ function mapDispatchToProps(dispatch) {
 }
 
 // component receives props.increment, props.decrement, props.reset
-connect(
-  null,
-  mapDispatchToProps
-)(Counter)
+connect(null, mapDispatchToProps)(Counter)
 ```
 
 ### Manually Injecting `dispatch`
@@ -283,7 +277,7 @@ import { bindActionCreators } from 'redux'
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
   }
 }
 ```
@@ -303,7 +297,7 @@ Note that:
 
 ```js
 // React Redux does this for you automatically:
-dispatch => bindActionCreators(mapDispatchToProps, dispatch)
+;(dispatch) => bindActionCreators(mapDispatchToProps, dispatch)
 ```
 
 Therefore, our `mapDispatchToProps` can simply be:
@@ -312,7 +306,7 @@ Therefore, our `mapDispatchToProps` can simply be:
 const mapDispatchToProps = {
   increment,
   decrement,
-  reset
+  reset,
 }
 ```
 
@@ -366,12 +360,12 @@ connect(mapStateToProps /** no second argument*/)(Component)
 You may bring back `dispatch` by providing your customized `mapDispatchToProps` function:
 
 ```js
-const mapDispatchToProps = dispatch => {
+const mapDispatchToProps = (dispatch) => {
   return {
     increment: () => dispatch(increment()),
     decrement: () => dispatch(decrement()),
     reset: () => dispatch(reset()),
-    dispatch
+    dispatch,
   }
 }
 ```
@@ -384,7 +378,7 @@ import { bindActionCreators } from 'redux'
 function mapDispatchToProps(dispatch) {
   return {
     dispatch,
-    ...bindActionCreators({ increment, decrement, reset }, dispatch)
+    ...bindActionCreators({ increment, decrement, reset }, dispatch),
   }
 }
 ```
@@ -398,10 +392,7 @@ There are discussions regarding whether to provide `dispatch` to your components
 Yes. You can skip the first parameter by passing `undefined` or `null`. Your component will not subscribe to the store, and will still receive the dispatch props defined by `mapDispatchToProps`.
 
 ```js
-connect(
-  null,
-  mapDispatchToProps
-)(MyComponent)
+connect(null, mapDispatchToProps)(MyComponent)
 ```
 
 ### Can I call `store.dispatch`?
diff --git a/website/versioned_docs/version-7.2/using-react-redux/connect-extracting-data-with-mapStateToProps.md b/website/versioned_docs/version-7.2/using-react-redux/connect-extracting-data-with-mapStateToProps.md
index 9b8df6c5e..265126652 100644
--- a/website/versioned_docs/version-7.2/using-react-redux/connect-extracting-data-with-mapStateToProps.md
+++ b/website/versioned_docs/version-7.2/using-react-redux/connect-extracting-data-with-mapStateToProps.md
@@ -1,8 +1,8 @@
 ---
 id: connect-mapstate
-title: "Connect: Extracting Data with mapStateToProps"
+title: 'Connect: Extracting Data with mapStateToProps'
 hide_title: true
-sidebar_label: "Connect: Extracting Data with mapStateToProps"
+sidebar_label: 'Connect: Extracting Data with mapStateToProps'
 ---
 
 # Connect: Extracting Data with `mapStateToProps`
@@ -85,7 +85,7 @@ function mapStateToProps(state) {
   return {
     a: 42,
     todos: state.todos,
-    filter: state.visibilityFilter
+    filter: state.visibilityFilter,
   }
 }
 
diff --git a/website/versioned_docs/version-7.2/using-react-redux/static-types.md b/website/versioned_docs/version-7.2/using-react-redux/static-types.md
index 5f0b2eafb..d6532322f 100644
--- a/website/versioned_docs/version-7.2/using-react-redux/static-types.md
+++ b/website/versioned_docs/version-7.2/using-react-redux/static-types.md
@@ -22,7 +22,7 @@ Both `mapState` and `useSelector` depend on declaring the type of the complete R
 export const rootReducer = combineReducers({
   posts: postsReducer,
   comments: commentsReducer,
-  users: usersReducer
+  users: usersReducer,
 })
 
 export type RootState = ReturnType<typeof rootReducer>
@@ -60,7 +60,7 @@ export const useTypedSelector: TypedUseSelectorHook<RootState> = useSelector
 // my-component.tsx
 import { useTypedSelector } from './reducer.ts'
 
-const isOn = useTypedSelector(state => state.isOn)
+const isOn = useTypedSelector((state) => state.isOn)
 ```
 
 ### Typing the `useDispatch` hook
@@ -105,11 +105,11 @@ interface OwnProps {
 type Props = StateProps & DispatchProps & OwnProps
 
 const mapState = (state: RootState) => ({
-  isOn: state.isOn
+  isOn: state.isOn,
 })
 
 const mapDispatch = {
-  toggleOn: () => ({ type: 'TOGGLE_IS_ON' })
+  toggleOn: () => ({ type: 'TOGGLE_IS_ON' }),
 }
 
 const MyComponent = (props: Props) => (
@@ -123,7 +123,7 @@ const MyComponent = (props: Props) => (
 // Typical usage: `connect` is called after the component is defined
 export default connect<StateProps, DispatchProps, OwnProps>(
   mapState,
-  mapDispatch
+  mapDispatch,
 )(MyComponent)
 ```
 
@@ -131,11 +131,11 @@ It is also possible to shorten this somewhat, by inferring the types of `mapStat
 
 ```ts
 const mapState = (state: RootState) => ({
-  isOn: state.isOn
+  isOn: state.isOn,
 })
 
 const mapDispatch = {
-  toggleOn: () => ({ type: 'TOGGLE_IS_ON' })
+  toggleOn: () => ({ type: 'TOGGLE_IS_ON' }),
 }
 
 type StateProps = ReturnType<typeof mapState>
@@ -160,17 +160,14 @@ interface RootState {
 }
 
 const mapState = (state: RootState) => ({
-  isOn: state.isOn
+  isOn: state.isOn,
 })
 
 const mapDispatch = {
-  toggleOn: () => ({ type: 'TOGGLE_IS_ON' })
+  toggleOn: () => ({ type: 'TOGGLE_IS_ON' }),
 }
 
-const connector = connect(
-  mapState,
-  mapDispatch
-)
+const connector = connect(mapState, mapDispatch)
 
 // The inferred type will look like:
 // {isOn: boolean, toggleOn: () => void}
diff --git a/website/versioned_sidebars/version-5.x-sidebars.json b/website/versioned_sidebars/version-5.x-sidebars.json
index deaaca4e3..092a963af 100644
--- a/website/versioned_sidebars/version-5.x-sidebars.json
+++ b/website/versioned_sidebars/version-5.x-sidebars.json
@@ -15,8 +15,6 @@
       "version-5.x/api/connect-advanced",
       "version-5.x/api/provider"
     ],
-    "Guides": [
-      "version-5.x/troubleshooting"
-    ]
+    "Guides": ["version-5.x/troubleshooting"]
   }
 }
diff --git a/website/versioned_sidebars/version-6.x-sidebars.json b/website/versioned_sidebars/version-6.x-sidebars.json
index fff77cfec..1ca96d755 100644
--- a/website/versioned_sidebars/version-6.x-sidebars.json
+++ b/website/versioned_sidebars/version-6.x-sidebars.json
@@ -15,8 +15,6 @@
       "version-6.x/api/provider",
       "version-6.x/api/connect-advanced"
     ],
-    "Guides": [
-      "version-6.x/troubleshooting"
-    ]
+    "Guides": ["version-6.x/troubleshooting"]
   }
 }