anchor.diff:      list.add(new LinkedListValue(node));
     }
   
  -  /*=T*/ _resetStyleRules/*<T>*/(/*=T*/ callback()) {
  -    var oldStyleRules = _styleRules;
  -    _styleRules = [];
  +  /*=T*/ _withStyleRule/*<T>*/(CssStyleRule rule, /*=T*/ callback()) {
  +    var oldStyleRule = _styleRule;
  +    _styleRule = rule;
       var result = callback();
  -    _styleRules = oldStyleRules;
  +    _styleRule = oldStyleRule;
       return result;
     }
   
     /// Like [_collectChildren], but handles bubbling.
     Iterable<CssNode> _atRuleChildren(void callback()) {
  -    if (_styleRules.isEmpty) return _collectChildren(callback);
  +    if (_styleRule == null) return _collectChildren(callback);
   
       return _scope(() {
         _outerChildren = new LinkedList();
  
positive.code:     // rule before any of its children.
      var insertionPoint = _outerChildren.isEmpty ? null : _outerChildren.last;
  
      _styleRules.add(new CssStyleRule(selector, [], span: node.span));
      var children = _collectChildren(() => super.visitStyleRule(node));
      _styleRules.removeLast();
      if (children.isEmpty) return;
  
      var rule = new CssStyleRule(selector, children, span: node.span);
  
negative.code: 
        if (_innerChildren.isNotEmpty) {
          _outerChildren.addFirst(new LinkedListValue(new CssStyleRule(
              _styleRule.selector,
              _innerChildren.map((node) => node.value),
              span: _styleRule.span)));
        }
  
        return _outerChildren.map((node) => node.value);
  