Update charted to 0.4.8 and roll

packages/csslib/lib/src/css_printer.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of csslib.visitor;
 
 /**
  * Visitor that produces a formatted string representation of the CSS tree.
  */
 class CssPrinter extends Visitor {
@@ skipping 36 matching lines @@
   void visitCssComment(CssComment node) {
     emit('/* ${node.comment} */');
   }
 
   void visitCommentDefinition(CommentDefinition node) {
     emit('<!-- ${node.comment} -->');
   }
 
   void visitMediaExpression(MediaExpression node) {
     emit(node.andOperator ? ' AND ' : ' ');
-    emit('(${node.mediaFeature}:');
-    visitExpressions(node.exprs);
+    emit('(${node.mediaFeature}');
+    if (node.exprs.expressions.isNotEmpty) {
+      emit(':');
+      visitExpressions(node.exprs);
+    }
     emit(')');
   }
 
   void visitMediaQuery(MediaQuery query) {
     var unary = query.hasUnary ? ' ${query.unary}' : '';
     var mediaType = query.hasMediaType ? ' ${query.mediaType}' : '';
     emit('$unary$mediaType');
     for (var expression in query.expressions) {
       visitMediaExpression(expression);
     }
   }
 
-  void emitMediaQueries(queries) {
+  void emitMediaQueries(List<MediaQuery> queries) {
     var queriesLen = queries.length;
     for (var i = 0; i < queriesLen; i++) {
       var query = queries[i];
-      if (query.hasMediaType && i > 0) emit(',');
+      if (i > 0) emit(',');
       visitMediaQuery(query);
     }
   }
 
+  void visitDocumentDirective(DocumentDirective node) {
+    emit('$_newLine@-moz-document ');
+    node.functions.first.visit(this);
+    for (var function in node.functions.skip(1)) {
+      emit(',$_sp');
+      function.visit(this);
+    }
+    emit('$_sp{');
+    for (var ruleSet in node.groupRuleBody) {
+      ruleSet.visit(this);
+    }
+    emit('$_newLine}');
+  }
+
+  void visitSupportsDirective(SupportsDirective node) {
+    emit('$_newLine@supports ');
+    node.condition.visit(this);
+    emit('$_sp{');
+    for (var rule in node.groupRuleBody) {
+      rule.visit(this);
+    }
+    emit('$_newLine}');
+  }
+
+  void visitSupportsConditionInParens(SupportsConditionInParens node) {
+    emit('(');
+    node.condition.visit(this);
+    emit(')');
+  }
+
+  void visitSupportsNegation(SupportsNegation node) {
+    emit('not$_sp');
+    node.condition.visit(this);
+  }
+
+  void visitSupportsConjunction(SupportsConjunction node) {
+    node.conditions.first.visit(this);
+    for (var condition in node.conditions.skip(1)) {
+      emit('${_sp}and$_sp');
+      condition.visit(this);
+    }
+  }
+
+  void visitSupportsDisjunction(SupportsDisjunction node) {
+    node.conditions.first.visit(this);
+    for (var condition in node.conditions.skip(1)) {
+      emit('${_sp}or$_sp');
+      condition.visit(this);
+    }
+  }
+
+  void visitViewportDirective(ViewportDirective node) {
+    emit('@${node.name}$_sp{$_newLine');
+    node.declarations.visit(this);
+    emit('}');
+  }
+
   void visitMediaDirective(MediaDirective node) {
-    emit(' @media');
+    emit('$_newLine@media');
     emitMediaQueries(node.mediaQueries);
-    emit(' {');
+    emit('$_sp{');
     for (var ruleset in node.rulesets) {
       ruleset.visit(this);
     }
-    emit('$_newLine\}');
+    emit('$_newLine}');
   }
 
   void visitHostDirective(HostDirective node) {
-    emit('\n@host {');
+    emit('$_newLine@host$_sp{');
     for (var ruleset in node.rulesets) {
       ruleset.visit(this);
     }
-    emit('$_newLine\}');
+    emit('$_newLine}');
   }
 
   /**
    *  @page : pseudoPage {
    *    decls
    *  }
    */
   void visitPageDirective(PageDirective node) {
     emit('$_newLine@page');
     if (node.hasIdent || node.hasPseudoPage) {
       if (node.hasIdent) emit(' ');
       emit(node._ident);
       emit(node.hasPseudoPage ? ':${node._pseudoPage}' : '');
     }
-    emit(' ');
 
     var declsMargin = node._declsMargin;
     var declsMarginLength = declsMargin.length;
+    emit(' {$_newLine');
     for (var i = 0; i < declsMarginLength; i++) {
-      if (i > 0) emit(_newLine);
-      emit('{$_newLine');
       declsMargin[i].visit(this);
-      emit('}');
     }
+    emit('}');
   }
 
   /** @charset "charset encoding" */
   void visitCharsetDirective(CharsetDirective node) {
     emit('$_newLine@charset "${node.charEncoding}";');
   }
 
   void visitImportDirective(ImportDirective node) {
     bool isStartingQuote(String ch) => ('\'"'.indexOf(ch[0]) >= 0);
 
@@ skipping 116 matching lines @@
         TokenKind.idToValue(TokenKind.MARGIN_DIRECTIVES, node.margin_sym);
 
     emit("@$margin_sym_name {$_newLine");
 
     visitDeclarationGroup(node);
 
     emit("}$_newLine");
   }
 
   void visitDeclaration(Declaration node) {
-    String importantAsString() => node.important ? '$_sp!important' : '';
-
-    emit("${node.property}: ");
+    emit('${node.property}:$_sp');
     node._expression.visit(this);
-
-    emit("${importantAsString()}");
+    if (node.important) {
+      emit('$_sp!important');
+    }
   }
 
   void visitVarDefinition(VarDefinition node) {
     emit("var-${node.definedName}: ");
     node._expression.visit(this);
   }
 
   void visitIncludeMixinAtDeclaration(IncludeMixinAtDeclaration node) {
     // Don't emit a new line we're inside of a declaration group.
     visitIncludeDirective(node.include, false);
@@ skipping 47 matching lines @@
   void visitPseudoClassSelector(PseudoClassSelector node) {
     emit(node.toString());
   }
 
   void visitPseudoElementSelector(PseudoElementSelector node) {
     emit(node.toString());
   }
 
   void visitPseudoClassFunctionSelector(PseudoClassFunctionSelector node) {
     emit(":${node.name}(");
-    node.expression.visit(this);
+    node.argument.visit(this);
     emit(')');
   }
 
   void visitPseudoElementFunctionSelector(PseudoElementFunctionSelector node) {
     emit("::${node.name}(");
     node.expression.visit(this);
     emit(')');
   }
 
   void visitNegationSelector(NegationSelector node) {
@@ skipping 173 matching lines @@
 
   void visitWildcard(Wildcard node) {
     emit('*');
   }
 
   void visitDartStyleExpression(DartStyleExpression node) {
     // TODO(terry): TBD
     throw UnimplementedError;
   }
 }