anchor.diff:    }
   }
   
  +/// Update children with implicit keys.
  +///
  +/// Any heuristics that is used in this algorithm is an undefined behaviour,
  +/// external code should not rely on the knowledge of this algorithm, because
  +/// it can be changed in any time.
   void _updateImplicitChildren(VNode parent, List<VNode> a, List<VNode> b, VContext context, bool attached) {
     int aStart = 0;
     int bStart = 0;
  
positive.code:     return this;
    }
  
    bool sameType(VNode other) => (flags == other.flags && tag == other.tag);
  
    void create(VContext context) {
      if ((flags & textFlag) != 0) {
        ref = new html.Text(data);
  
negative.code: import 'vcontext.dart';
  import 'component.dart';
  
  /// Virtual DOM Node.
  class VNode {
    /// Flag indicating that [VNode] is [html.Text].
    static const int textFlag = 1;
    /// Flag indicating that [VNode] is [html.Element].
    static const int elementFlag = 1 << 1;
    /// Flag indicating that [VNode] is [Component].
    static const int componentFlag = 1 << 2;
    /// Flag indicating that [VNode] is root element of the [Component].
    static const int rootFlag = 1 << 3;
    /// Flag indicating that [VNode] represents node that is in svg namespace.
    static const int svgFlag = 1 << 4;
  
    /// Flags.
    final int flags;
  
    /// Key that should be unique among its siblings. If the key is [:null:],
    /// it means that the key is implicit.
    /// When [key] is implicit, all siblings should also have implicit keys,
    /// otherwise it will result in undefined behaviour in "production" mode,
    /// or runtime error in "development" mode.
    final Object key;
  
    /// Tag should contain tag name if [VNode] represents an element, or
    /// reference to the [componentConstructor] if it represents a
    /// [Component].
    final dynamic/*<String | componentConstructor>*/ tag;
  
    /// Data that should be passed to [Component]s. Data is transferred to the
    /// [Component] using `set data(P data)` setter.
    ///
    /// When [VNode] represents an element, [data] is used as a cache for
    /// className string that was built from [type] and [classes] properties.
    dynamic data;
  
    /// Type represents an immutable class name.
    String type;
  
    /// Attributes.
    Map<String, String> attrs;
  
    /// Styles.
    Map<String, String> style;
  
    /// Classes.
    List<String> classes;
  
    /// List of children nodes. When [VNode] represents a [Component], children
    /// nodes are transferred to the [Component] using
    /// `set children(List<VNode> children)` setter.
    List<VNode> children;
  
    /// Reference to the [html.Node]. It will be available after [VNode] is
    /// [create]d or [update]d. Each time [VNode] is updated, reference to the
    /// [html.Node] is passed from the previous node to the new one.
    html.Node ref;
  
    /// Reference to the [Component]. It will be available after [VNode] is
    /// [create]d or [update]d. Each time [VNode] is updated, reference to the
    /// [Component] is passed from the previous node to the new one.
    Component cref;
  
    VNode(this.flags, {this.key, this.tag, this.data, this.type, this.attrs, this.style,
  