anchor.diff:    //
     // ******************************************************************************************************************
   
  -  /// Deprecated. will be removed when [Component] is removed in the `6.0.0` release.
  +  /// Deprecated. Will be removed when [Component] is removed in the `6.0.0` release.
     ///
     /// Replace calls to this method with either:
     ///
     /// - [forceUpdate] (preferred) - forces rerender and bypasses [shouldComponentUpdate]
     /// - `setState({})` - same behavior as this method: causes rerender but goes through [shouldComponentUpdate]
  +  ///
  +  /// See: <https://reactjs.org/docs/react-component.html#forceupdate>
     @override
     @Deprecated('6.0.0')
     void redraw([SetStateCallback callback]) {
  
positive.code:   /// Use this as an opportunity to operate on the [rootNode] (DOM) when the `Component` has been updated as a result
    /// of the values of [prevProps] / [prevState].
    ///
    /// __Note__: React 16 added a third parameter to componentDidUpdate, which
    /// is a custom value returned in [getSnapshotBeforeUpdate]. If a specified
    /// value is not returned in getSnapshotBeforeUpdate, the [snapshot]
    /// parameter in componentDidUpdate will be null.
    ///
    /// See: <https://facebook.github.io/react/docs/react-component.html#updating-componentdidupdate>
    void componentDidUpdate(Map prevProps, Map prevState, [dynamic snapshot]) {}
  
    /// ReactJS lifecycle method that is invoked immediately before a `Component` is unmounted from the DOM.
  
negative.code:   @Deprecated('6.0.0')
    void componentWillMount() => throw _unsupportedLifecycleError('componentWillMount');
  
    /// ReactJS lifecycle method that is invoked when a `Component` is receiving new props ([nextProps]).
    ///
    /// > __DEPRECATED - DO NOT USE__
    /// >
    /// > This will be removed along with [Component] in the `6.0.0` release.
    /// >
    /// > Depending on your use-case, you should use [getDerivedStateFromProps] or [getSnapshotBeforeUpdate] instead.
    /// > _(See the examples below if you're not sure which one to use)_
    ///
    /// __If you used `componentWillReceiveProps` to update instance [state], use [getDerivedStateFromProps]__
    ///
    ///     // Before
    ///     @override
    ///     componentWillReceiveProps(Map nextProps) {
    ///       if (nextProps['someValueUsedToDeriveState'] != props['someValueUsedToDeriveState']) {
    ///         setState({'someDerivedState': nextProps['someValueUsedToDeriveState']});
    ///       }
    ///     }
    ///
    ///     // After
    ///     @override
    ///     getDerivedStateFromProps(Map nextProps, Map prevState) {
    ///       // NOTE: Accessing `props` is not allowed here. Change the comparison to utilize `prevState` instead.
    ///       if (nextProps['someValueUsedToDeriveState'] != prevState['someDerivedState']) {
    ///         // Return a new Map instead of calling `setState` directly.
    ///         return {'someDerivedState': nextProps['someValueUsedToDeriveState']};
    ///       }
    ///       return null;
    ///     }
    ///
    ///
    /// __If you did not use `componentWillReceiveProps` to update instance [state], use [getSnapshotBeforeUpdate]__
    ///
    ///     // Before
    ///     @override
    ///     componentWillReceiveProps(Map nextProps) {
    ///       if (nextProps['someValue'] > props['someValue']) {
    ///         _someInstanceField = deriveNewValueFromNewProps(nextProps['someValue']);
    ///       }
    ///     }
    ///
    ///     // After
    ///     @override
    ///     getSnapshotBeforeUpdate(Map prevProps, Map prevState) {
    ///       // NOTE: Unlike `getDerivedStateFromProps`, accessing `props` is allowed here.
    ///       // * The reference to `nextProps` from `componentWillReceiveProps` should be updated to `props` here
    ///       // * The reference to `props` from `componentWillReceiveProps` should be updated to `prevProps`.
    ///       if (props['someValue'] > prevProps['someValue']) {
    ///         _someInstanceField = deriveNewValueFromNewProps(props['someValue']);
    ///       }
    ///
    ///       // NOTE: You could also return a `snapshot` value from this method for later use in `componentDidUpdate`.
    ///     }
    @mustCallSuper
    @Deprecated('6.0.0')
    void componentWillReceiveProps(Map nextProps) => throw _unsupportedLifecycleError('componentWillReceiveProps');
  
    /// ReactJS lifecycle method that is invoked when a `Component` is receiving
    /// new props ([nextProps]) and/or state ([nextState]).
    ///
    /// > __DEPRECATED - DO NOT USE__
    /// >
    /// > This will be removed along with [Component] in the `6.0.0` release.
    /// >
    /// > Use [getSnapshotBeforeUpdate] instead as shown in the example below.
    ///
    ///     // Before
    ///     @override
    ///     componentWillUpdate(Map nextProps, Map nextState) {
    ///       if (nextProps['someValue'] > props['someValue']) {
    ///         _someInstanceField = deriveNewValueFromNewProps(nextProps['someValue']);
    ///       }
    ///
    ///       if (nextState['someStateValue'] != state['someStateValue']) {
    ///         triggerSomeOtherActionOutsideOfThisComponent(nextState['someStateValue']);
    ///       }
    ///     }
    ///
    ///     // After
    ///     @override
    ///     getSnapshotBeforeUpdate(Map prevProps, Map prevState) {
    ///       // * The reference to `nextProps` from `componentWillUpdate` should be updated to `props` here
    ///       // * The reference to `props` from `componentWillUpdate` should be updated to `prevProps`.
    ///       if (props['someValue'] > prevProps['someValue']) {
    ///         _someInstanceField = deriveNewValueFromNewProps(props['someValue']);
    ///       }
    ///
    ///       // * The reference to `nextState` from `componentWillUpdate` should be updated to `state` here
    ///       // * The reference to `state` from `componentWillUpdate` should be updated to `prevState`.
    ///       if (state['someStateValue'] != prevState['someStateValue']) {
    ///         triggerSomeOtherActionOutsideOfThisComponent(state['someStateValue']);
    ///       }
    ///
    ///       // NOTE: You could also return a `snapshot` value from this method for later use in `componentDidUpdate`.
    ///     }
    @mustCallSuper
    @Deprecated('6.0.0')
    void componentWillUpdate(Map nextProps, Map nextState) => throw _unsupportedLifecycleError('componentWillUpdate');
  