anchor.diff:      while (oldStartIndex < oldEndIndex) {
         oldNode = oldChildren[oldStartIndex];
         // print('> ${oldNode._key} removing from $oldEndIndex');
  -      oldNode._remove();
  +      oldNode._unmount();
         advanceOldStartIndex();
       }
  -
  -    oldElement._children = null;
  -    return false;
     }
   }
   
  
positive.code:     // syncing the new VDOM against the old one.
      if (oldRendered != null &&
          _vdom.runtimeType != oldRendered.runtimeType) {
        oldRendered._remove();
        oldRendered = null;
      }
  
      if (_vdom._sync(oldRendered, host, insertBefore)) {
        _vdom = oldRendered; // retain stateful component
      }
      _root = _vdom._root;
      assert(_vdom._root is sky.Node);
  
  
negative.code:     _key = key == null ? "$runtimeType" : "$runtimeType-$key";
    }
  
    Node get _emptyNode;
  
    sky.Node _createNode();
  
    void _mount(Node parent, sky.ParentNode host, sky.Node insertBefore) {
      var node = _emptyNode;
      node._parent = parent;
  
      node._root = _createNode();
      assert(node._root != null);
  
      _parentInsertBefore(host, node._root, insertBefore);
  
      _syncNode(node);
    }
  
    bool _sync(Node old, Node parent, sky.ParentNode host,
        sky.Node insertBefore) {
  
      if (old == null) {
        _mount(parent, host, insertBefore);
        return false;
      }
  
      return _syncNode(old);
    }
  
    // Return true IFF the old node has *become* the new node (should be
    // retained because it is stateful)
    bool _syncNode(Node old) {
      assert(!old._defunct);
      _root = old._root;
      _parent = old._parent;
      return false;
    }
  
    void _unmount() {
      assert(_root != null);
      _parent = null;
      _root.remove();
      _defunct = true;
      _root = null;
    }
  }
  
  class Text extends Node {
    final String data;
  
    // Text nodes are special cases of having non-unique keys (which don't need
    // to be assigned as part of the API). Since they are unique in not having
  