docs: function (transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) {
  	    var inst = this._instance;
  	    !(inst != null) ?  false ? invariant(false, 'Attempted to update component `%s` that has already been unmounted (or failed to mount).', this.getName() || 'ReactCompositeComponent') : _prodInvariant('136', this.getName() || 'ReactCompositeComponent') : void 0;
  	
  	    var willReceive = false;
  	    var nextContext;
  	
  	    // Determine if the context has changed or not
  	    if (this._context === nextUnmaskedContext) {
  	      nextContext = inst.context;
  	    } else {
  	      nextContext = this._processContext(nextUnmaskedContext);
  	      willReceive = true;
  	    }
  	
  	    var prevProps = prevParentElement.props;
  	    var nextProps = nextParentElement.props;
  	
  	    // Not a simple state update but a props update
  	    if (prevParentElement !== nextParentElement) {
  	      willReceive = true;
  	    }
  	
  	    // An update here will schedule an update but immediately set
  	    // _pendingStateQueue which will ensure that any state updates gets
  	    // immediately reconciled instead of waiting for the next batch.
  	    if (willReceive && inst.componentWillReceiveProps) {
  	      if (false) {
  	        measureLifeCyclePerf(function () {
  	          return inst.componentWillReceiveProps(nextProps, nextContext);
  	        }, this._debugID, 'componentWillReceiveProps');
  	      } else {
  	        inst.componentWillReceiveProps(nextProps, nextContext);
  	      }
  	    }
  	
  	    var nextState = this._processPendingState(nextProps, nextContext);
  	    var shouldUpdate = true;
  	
  	    if (!this._pendingForceUpdate) {
  	      if (inst.shouldComponentUpdate) {
  	        if (false) {
  	          shouldUpdate = measureLifeCyclePerf(function () {
  	            return inst.shouldComponentUpdate(nextProps, nextState, nextContext);
  	          }, this._debugID, 'shouldComponentUpdate');
  	        } else {
  	          shouldUpdate = inst.shouldComponentUpdate(nextProps, nextState, nextContext);
  	        }
  	      } else {
  	        if (this._compositeType === CompositeTypes.PureClass) {
  	          shouldUpdate = !shallowEqual(prevProps, nextProps) || !shallowEqual(inst.state, nextState);
  	        }
  	      }
  	    }
  	
  	    if (false) {
  	      process.env.NODE_ENV !== 'production' ? warning(shouldUpdate !== undefined, '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', this.getName() || 'ReactCompositeComponent') : void 0;
  	    }
  	
  	    this._updateBatchNumber = null;
  	    if (shouldUpdate) {
  	      this._pendingForceUpdate = false;
  	      // Will set `this.props`, `this.state` and `this.context`.
  	      this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext);
  	    } else {
  	      // If it's determined that a component should not update, we still want
  	      // to set props and state but we shortcut the rest of the update.
  	      this._currentElement = nextParentElement;
  	      this._context = nextUnmaskedContext;
  	      inst.props = nextProps;
  	      inst.state = nextState;
  	      inst.context = nextContext;
  	    }
  	  }