function Component(props, context, updater) {

  this.props = props;

  this.context = context;

  // If a component has string refs, we will assign a different object later.

  this.refs = emptyObject;

  // We initialize the default updater but the real one gets injected by the

  // renderer.

  this.updater = updater || ReactNoopUpdateQueue;

}

Component.prototype.isReactComponent = {};

/**

 * Sets a subset of the state. Always use this to mutate

 * state. You should treat `this.state` as immutable.

 *

 * There is no guarantee that `this.state` will be immediately updated, so

 * accessing `this.state` after calling this method may return the old value.

 *

 * There is no guarantee that calls to `setState` will run synchronously,

 * as they may eventually be batched together.  You can provide an optional

 * callback that will be executed when the call to setState is actually

 * completed.

 *

 * When a function is provided to setState, it will be called at some point in

 * the future (not synchronously). It will be called with the up to date

 * component arguments (state, props, context). These values can be different

 * from this.* because your function may be called after receiveProps but before

 * shouldComponentUpdate, and this new state, props, and context will not yet be

 * assigned to this.

 *

 * @param {object|function} partialState Next partial state or function to

 *        produce next partial state to be merged with current state.

 * @param {?function} callback Called after state is updated.

 * @final

 * @protected

 */

Component.prototype.setState = function(partialState, callback) {

  invariant(

    typeof partialState === 'object' ||

      typeof partialState === 'function' ||

      partialState == null,

    'setState(...): takes an object of state variables to update or a ' +

      'function which returns an object of state variables.',

  );

  this.updater.enqueueSetState(this, partialState, callback, 'setState');

};

/**

 * Forces an update. This should only be invoked when it is known with

 * certainty that we are **not** in a DOM transaction.

 *

 * You may want to call this when you know that some deeper aspect of the

 * component's state has changed but `setState` was not called.

 *

 * This will not invoke `shouldComponentUpdate`, but it will invoke

 * `componentWillUpdate` and `componentDidUpdate`.

 *

 * @param {?function} callback Called after update is complete.

 * @final

 * @protected

 */

Component.prototype.forceUpdate = function(callback) {

  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');

};

/**

 * Deprecated APIs. These APIs used to exist on classic React classes but since

 * we would like to deprecate them, we're not going to move them over to this

 * modern base class. Instead, we define a getter that warns if it's accessed.

 */

if (__DEV__) {

  const deprecatedAPIs = {

    isMounted: [

      'isMounted',

      'Instead, make sure to clean up subscriptions and pending requests in ' +

        'componentWillUnmount to prevent memory leaks.',

    ],

    replaceState: [

      'replaceState',

      'Refactor your code to use setState instead (see ' +

        'https://github.com/facebook/react/issues/3236).',

    ],

  };

  const defineDeprecationWarning = function(methodName, info) {

    Object.defineProperty(Component.prototype, methodName, {

      get: function() {

        lowPriorityWarning(

          false,

          '%s(...) is deprecated in plain JavaScript React classes. %s',

          info[0],

          info[1],

        );

        return undefined;

      },

    });

  };

  for (const fnName in deprecatedAPIs) {

    if (deprecatedAPIs.hasOwnProperty(fnName)) {

      defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);

    }

  }

}

function ComponentDummy() {}

ComponentDummy.prototype = Component.prototype;

/**

 * Convenience component with default shallow equality check for sCU.

 */

function PureComponent(props, context, updater) {

  this.props = props;

  this.context = context;

  // If a component has string refs, we will assign a different object later.

  this.refs = emptyObject;

  this.updater = updater || ReactNoopUpdateQueue;

}

const pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());

pureComponentPrototype.constructor = PureComponent;

// Avoid an extra prototype jump for these methods.

Object.assign(pureComponentPrototype, Component.prototype);

pureComponentPrototype.isPureReactComponent = true;