anchor.diff:      updated();
     }
   
  +  /// Lifecycle method [updateState].
  +  ///
  +  /// update internal state, it should return [:bool:] value that indicates
  +  /// if the state is changed.
  +  ///
  +  /// Invoked during the [Scheduler] writeDom phase.
     bool updateState() => true;
  +
  +  /// Lifecycle method [updateState].
  +  ///
  +  /// update view.
  +  ///
  +  /// Invoked during the [Scheduler] writeDom phase.
     Future updateView();
   
  +  /// update internal tree using virtual dom representation.
     void updateRoot(VNode n) {
       assert(n != null);
       if (_root == null) {
  
positive.code:     }
    }
  
    VNode get root => _root;
  
    bool get isDirty => (flags & dirtyFlag) != 0;
    bool get isAttached => (flags & attachedFlag) != 0;
    bool get isSvg => (flags & svgFlag) != 0;
    bool get isMounting => (flags & mountingFlag) != 0;
  
    void create() {
      element = html.document.createElement(tag);
    }
  
    void mount(html.Element e) {
      flags |= mountingFlag;
      element = e;
    }
  
    void init() {}
  
    void update([_]) {
      if ((flags & shouldUpdateViewFlags) == shouldUpdateViewFlags) {
        Future future;
  
negative.code: import 'vnode.dart';
  import 'env.dart';
  
  /// uix [Component] is a basic block to build user interfaces.
  ///
  /// Example:
  ///
  /// ```dart
  /// @ComponentMeta()
  /// class Button extends Component<String> {
  ///   updateView() {
  ///     updateRoot(vRoot(type: 'Button')(data));
  ///   }
  /// }
  /// ```
  abstract class Component<P> extends RevisionedNode with StreamListenerNode implements VContext {
    /// Flag indicating that [Component] is dirty and should be updated.
    static const int dirtyFlag = 1;
  
    /// Flag indicating that [Component] is attached to the html document.
    static const int attachedFlag = 1 << 1;
  
    /// Flag indicating that [Component]s [element] in svg namespace.
    static const int svgFlag = 1 << 2;
  
    /// Flag indicating that [Component] in the process of mounting on top of existing html nodes.
    static const int mountingFlag = 1 << 3;
  
    /// Set of flags indicating that [Component]s should be updated.
    static const int shouldUpdateViewFlags = dirtyFlag | attachedFlag;
  
    /// Tag name of the root [element].
    final String tag = 'div';
  
    /// Flags.
    int flags = dirtyFlag;
  
    /// Depth relative to other [Component]s.
    ///
    /// It is used as a priority for dom write tasks. [Component]s with the
    /// lowest depth have highest priority.
    int depth = 0;
  
    /// Reference to the [html.Element].
    html.Element element;
  
    /// Protected property that contains data input.
    P data_;
  
    /// Protected property that contains children input.
    List<VNode> children_;
  
    Component _parent;
    VNode _root;
  
    /// Parent [Component].
    Component get parent => _parent;
    set parent(Component newParent) {
      _parent = newParent;
      depth = newParent == null ? 0 : newParent.depth + 1;
    }
  
    /// Data input.
    P get data => data_;
    set data(P newData) {
      if (data_ != newData) {
  