anchor.diff:  
   abstract class OutlineItem {
     html.LIElement _element;
  -  data.OutlineEntry _model;
  +  model.OutlineEntry _data;
   
  -  OutlineItem(this._model) {
  +  OutlineItem(this._data) {
       _element = new html.LIElement();
  -    _element.text = _model.name;
  +    _element.text = _data.name;
     }
   }
   
   abstract class OutlineTopLevelItem extends OutlineItem {
  -  OutlineTopLevelItem(data.OutlineTopLevelEntry model) : super(model);
  +  OutlineTopLevelItem(model.OutlineTopLevelEntry data) : super(data);
   }
   
   class OutlineTopLevelVariable extends OutlineTopLevelItem {
  -  OutlineTopLevelVariable(data.OutlineTopLevelVariable model) : super(model);
  +  OutlineTopLevelVariable(model.OutlineTopLevelVariable data) : super(data);
   }
   
   class OutlineTopLevelFunction extends OutlineTopLevelItem {
  -  OutlineTopLevelFunction(data.OutlineTopLevelFunction model) : super(model);
  +  OutlineTopLevelFunction(model.OutlineTopLevelFunction data) : super(data);
   }
   
   class OutlineClass extends OutlineTopLevelItem {
     var _childrenRootElement = new html.UListElement();
     List<OutlineClassMember> members = [];
   
  -  OutlineClass(data.OutlineClass model) : super(model) {
  -    populate(model);
  +  OutlineClass(model.OutlineClass data) : super(data) {
  +    populate(data);
     }
   
     OutlineClassMember _addElement(OutlineClassMember member) {
  
positive.code:         ..opacity = '0.6';
    }
  
    void populate(data.Outline outline) {
      children = [];
  
      if (_rootList != null) {
        _rootList.remove();
      }
      _rootList = new html.UListElement();
      _outlineDiv.append(_rootList);
  
      for (data.OutlineTopLevelEntry model in outline.entries) {
        _create(model);
      }
    }
  
    OutlineTopLevelItem _create(data.OutlineTopLevelEntry model) {
      if (model is data.OutlineClass) {
        return addClass(model);
      } else if (model is data.OutlineTopLevelVariable) {
        return addVariable(model);
      } else if (model is data.OutlineTopLevelFunction) {
        return addFunction(model);
      } else {
        throw new UnimplementedError("Unknown type");
      }
  
negative.code:     return item;
    }
  
    OutlineTopLevelVariable _addVariable(model.OutlineTopLevelVariable data) =>
        _addItem(new OutlineTopLevelVariable(data));
  
    OutlineTopLevelFunction _addFunction(model.OutlineTopLevelFunction data) =>
        _addItem(new OutlineTopLevelFunction(data));
  
    OutlineClass _addClass(model.OutlineClass data) {
      OutlineClass classItem = new OutlineClass(data);
      _addItem(classItem);
      _rootList.append(classItem._childrenRootElement);
      return classItem;
  