pkg/csslib: formatting

lib/parser.dart

 // Copyright (c) 2012, 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.
 
 library csslib.parser;
 
 import 'dart:math' as math;
 
 import 'package:source_span/source_span.dart';
 
 import "visitor.dart";
 import 'src/messages.dart';
 import 'src/options.dart';
 
 part 'src/analyzer.dart';
 part 'src/polyfill.dart';
 part 'src/property.dart';
 part 'src/token.dart';
 part 'src/tokenizer_base.dart';
 part 'src/tokenizer.dart';
 part 'src/tokenkind.dart';
 
-
 /** Used for parser lookup ahead (used for nested selectors Less support). */
 class ParserState extends TokenizerState {
   final Token peekToken;
   final Token previousToken;
 
   ParserState(this.peekToken, this.previousToken, Tokenizer tokenizer)
       : super(tokenizer);
 }
 
 // TODO(jmesserly): this should not be global
 void _createMessages({List<Message> errors, List<String> options}) {
   if (errors == null) errors = [];
 
   if (options == null) {
     options = ['--no-colors', 'memory'];
   }
   var opt = PreprocessorOptions.parse(options);
   messages = new Messages(options: opt, printHandler: errors.add);
 }
 
 /** CSS checked mode enabled. */
 bool get isChecked => messages.options.checked;
 
 // TODO(terry): Remove nested name parameter.
 /** Parse and analyze the CSS file. */
 StyleSheet compile(input, {List<Message> errors, List<String> options,
-    bool nested: true,
-    bool polyfill: false,
-    List<StyleSheet> includes: null}) {
-
+    bool nested: true, bool polyfill: false, List<StyleSheet> includes: null}) {
   if (includes == null) {
     includes = [];
   }
 
   var source = _inputAsString(input);
 
   _createMessages(errors: errors, options: options);
 
   var file = new SourceFile(source);
 
   var tree = new _Parser(file, source).parse();
 
   analyze([tree], errors: errors, options: options);
 
   if (polyfill) {
     var processCss = new PolyFill(messages, true);
     processCss.process(tree, includes: includes);
   }
 
   return tree;
 }
 
 /** Analyze the CSS file. */
 void analyze(List<StyleSheet> styleSheets,
     {List<Message> errors, List<String> options}) {
-
   _createMessages(errors: errors, options: options);
   new Analyzer(styleSheets, messages).run();
 }
 
 /**
  * Parse the [input] CSS stylesheet into a tree. The [input] can be a [String],
  * or [List<int>] of bytes and returns a [StyleSheet] AST.  The optional
  * [errors] list will contain each error/warning as a [Message].
  */
 StyleSheet parse(input, {List<Message> errors, List<String> options}) {
@@ skipping 10 matching lines @@
  * or [List<int>] of bytes and returns a [StyleSheet] AST.  The optional
  * [errors] list will contain each error/warning as a [Message].
  */
 // TODO(jmesserly): should rename "parseSelector" and return Selector
 StyleSheet selector(input, {List<Message> errors}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors);
 
   var file = new SourceFile(source);
-  return (new _Parser(file, source)
-      ..tokenizer.inSelector = true)
+  return (new _Parser(file, source)..tokenizer.inSelector = true)
       .parseSelector();
 }
 
 SelectorGroup parseSelectorGroup(input, {List<Message> errors}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors);
 
   var file = new SourceFile(source);
   return (new _Parser(file, source)
-      // TODO(jmesserly): this fix should be applied to the parser. It's tricky
-      // because by the time the flag is set one token has already been fetched.
-      ..tokenizer.inSelector = true)
-      .processSelectorGroup();
+    // TODO(jmesserly): this fix should be applied to the parser. It's tricky
+    // because by the time the flag is set one token has already been fetched.
+    ..tokenizer.inSelector = true).processSelectorGroup();
 }
 
 String _inputAsString(input) {
   String source;
 
   if (input is String) {
     source = input;
   } else if (input is List) {
     // TODO(terry): The parse function needs an "encoding" argument and will
     //              default to whatever encoding CSS defaults to.
@@ skipping 20 matching lines @@
   return source;
 }
 
 // TODO(terry): Consider removing this class when all usages can be eliminated
 //               or replaced with compile API.
 /** Public parsing interface for csslib. */
 class Parser {
   final _Parser _parser;
 
   // TODO(jmesserly): having file and text is redundant.
-  Parser(SourceFile file, String text, {int start: 0, String baseUrl}) :
-    _parser = new _Parser(file, text, start: start, baseUrl: baseUrl);
+  Parser(SourceFile file, String text, {int start: 0, String baseUrl})
+      : _parser = new _Parser(file, text, start: start, baseUrl: baseUrl);
 
   StyleSheet parse() => _parser.parse();
 }
 
 /** A simple recursive descent parser for CSS. */
 class _Parser {
   final Tokenizer tokenizer;
 
   /** Base url of CSS file. */
   final String _baseUrl;
@@ skipping 78 matching lines @@
     }
   }
 
   ///////////////////////////////////////////////////////////////////
   // Basic support methods
   ///////////////////////////////////////////////////////////////////
   int _peek() {
     return _peekToken.kind;
   }
 
-  Token _next({unicodeRange : false}) {
+  Token _next({unicodeRange: false}) {
     _previousToken = _peekToken;
     _peekToken = tokenizer.next(unicodeRange: unicodeRange);
     return _previousToken;
   }
 
   bool _peekKind(int kind) {
     return _peekToken.kind == kind;
   }
 
   /* Is the next token a legal identifier?  This includes pseudo-keywords. */
   bool _peekIdentifier() {
     return TokenKind.isIdentifier(_peekToken.kind);
   }
 
   /** Marks the parser/tokenizer look ahead to support Less nested selectors. */
   ParserState get _mark =>
       new ParserState(_peekToken, _previousToken, tokenizer);
 
   /** Restores the parser/tokenizer state to state remembered by _mark. */
   void _restore(ParserState markedData) {
     tokenizer.restore(markedData);
     _peekToken = markedData.peekToken;
     _previousToken = markedData.previousToken;
   }
 
-  bool _maybeEat(int kind, {unicodeRange : false}) {
+  bool _maybeEat(int kind, {unicodeRange: false}) {
     if (_peekToken.kind == kind) {
       _previousToken = _peekToken;
       _peekToken = tokenizer.next(unicodeRange: unicodeRange);
       return true;
     } else {
       return false;
     }
   }
 
-  void _eat(int kind, {unicodeRange : false}) {
+  void _eat(int kind, {unicodeRange: false}) {
     if (!_maybeEat(kind, unicodeRange: unicodeRange)) {
       _errorExpected(TokenKind.kindToString(kind));
     }
   }
 
   void _eatSemicolon() {
     _eat(TokenKind.SEMICOLON);
   }
 
   void _errorExpected(String expected) {
@@ skipping 79 matching lines @@
     //          [ AND S* MediaExpr ]* | MediaExpr [ AND S* MediaExpr ]*
 
     var start = _peekToken.span;
 
     // Is it a unary media operator?
     var op = _peekToken.text;
     var opLen = op.length;
     var unaryOp = TokenKind.matchMediaOperator(op, 0, opLen);
     if (unaryOp != -1) {
       if (isChecked) {
-        if (startQuery &&
-            unaryOp != TokenKind.MEDIA_OP_NOT ||
+        if (startQuery && unaryOp != TokenKind.MEDIA_OP_NOT ||
             unaryOp != TokenKind.MEDIA_OP_ONLY) {
           _warning("Only the unary operators NOT and ONLY allowed",
               _makeSpan(start));
         }
         if (!startQuery && unaryOp != TokenKind.MEDIA_OP_AND) {
           _warning("Only the binary AND operator allowed", _makeSpan(start));
         }
       }
       _next();
       start = _peekToken.span;
@@ skipping 27 matching lines @@
       return new MediaQuery(unaryOp, type, exprs, _makeSpan(start));
     }
   }
 
   MediaExpression processMediaExpression([bool andOperator = false]) {
     var start = _peekToken.span;
 
     // Grammar: '(' S* media_feature S* [ ':' S* expr ]? ')' S*
     if (_maybeEat(TokenKind.LPAREN)) {
       if (_peekIdentifier()) {
-        var feature = identifier();           // Media feature.
+        var feature = identifier(); // Media feature.
         while (_maybeEat(TokenKind.COLON)) {
           var startExpr = _peekToken.span;
           var exprs = processExpr();
           if (_maybeEat(TokenKind.RPAREN)) {
-            return new MediaExpression(andOperator, feature, exprs,
-                _makeSpan(startExpr));
+            return new MediaExpression(
+                andOperator, feature, exprs, _makeSpan(startExpr));
           } else if (isChecked) {
             _warning("Missing parenthesis around media expression",
                 _makeSpan(start));
             return null;
           }
         }
       } else if (isChecked) {
         _warning("Missing media feature in media expression", _makeSpan(start));
         return null;
       }
@@ skipping 114 matching lines @@
         }
 
         // Any pseudo page?
         var pseudoPage;
         if (_maybeEat(TokenKind.COLON)) {
           if (_peekIdentifier()) {
             pseudoPage = identifier();
             // TODO(terry): Normalize pseudoPage to lowercase.
             if (isChecked &&
                 !(pseudoPage.name == 'left' ||
-                  pseudoPage.name == 'right' ||
-                  pseudoPage.name == 'first')) {
-              _warning("Pseudo page must be left, top or first",
-                  pseudoPage.span);
+                    pseudoPage.name == 'right' ||
+                    pseudoPage.name == 'first')) {
+              _warning(
+                  "Pseudo page must be left, top or first", pseudoPage.span);
               return null;
             }
           }
         }
 
         String pseudoName = pseudoPage is Identifier ? pseudoPage.name : '';
         String ident = name is Identifier ? name.name : '';
-        return new PageDirective(ident, pseudoName,
-            processMarginsDeclarations(), _makeSpan(start));
+        return new PageDirective(
+            ident, pseudoName, processMarginsDeclarations(), _makeSpan(start));
 
       case TokenKind.DIRECTIVE_CHARSET:
         // @charset S* STRING S* ';'
         _next();
 
         var charEncoding = processQuotedString(false);
         if (isChecked && charEncoding == null) {
           // Missing character encoding.
           _warning('missing character encoding string', _makeSpan(start));
         }
@@ skipping 18 matching lines @@
       */
       case TokenKind.DIRECTIVE_KEYFRAMES:
       case TokenKind.DIRECTIVE_WEB_KIT_KEYFRAMES:
       case TokenKind.DIRECTIVE_MOZ_KEYFRAMES:
       case TokenKind.DIRECTIVE_O_KEYFRAMES:
       // TODO(terry): Remove workaround when bug 8270 is fixed.
       case TokenKind.DIRECTIVE_MS_KEYFRAMES:
         if (tokId == TokenKind.DIRECTIVE_MS_KEYFRAMES && isChecked) {
           _warning('@-ms-keyframes should be @keyframes', _makeSpan(start));
         }
-      // TODO(terry): End of workaround.
+        // TODO(terry): End of workaround.
 
         /*  Key frames grammar:
          *
          *  @[browser]? keyframes [IDENT|STRING] '{' keyframes-blocks '}';
          *
          *  browser: [-webkit-, -moz-, -ms-, -o-]
          *
          *  keyframes-blocks:
          *    [keyframe-selectors '{' declarations '}']* ;
          *
@@ skipping 15 matching lines @@
           Expressions selectors = new Expressions(_makeSpan(start));
 
           do {
             var term = processTerm();
 
             // TODO(terry): Only allow from, to and PERCENTAGE ...
 
             selectors.add(term);
           } while (_maybeEat(TokenKind.COMMA));
 
-          keyframe.add(new KeyFrameBlock(selectors, processDeclarations(),
-              _makeSpan(start)));
-
+          keyframe.add(new KeyFrameBlock(
+              selectors, processDeclarations(), _makeSpan(start)));
         } while (!_maybeEat(TokenKind.RBRACE) && !isPrematureEndOfFile());
 
         return keyframe;
 
       case TokenKind.DIRECTIVE_FONTFACE:
         _next();
         return new FontFaceDirective(processDeclarations(), _makeSpan(start));
 
       case TokenKind.DIRECTIVE_STYLET:
         /* Stylet grammar:
@@ skipping 54 matching lines @@
             if (func is UriTerm) {
               // @namespace url("");
               namespaceUri = func.text;
               prefix = null;
             }
           } else {
             namespaceUri = processQuotedString(false);
           }
         }
 
-        return new NamespaceDirective(prefix != null ? prefix.name : '',
-            namespaceUri, _makeSpan(start));
+        return new NamespaceDirective(
+            prefix != null ? prefix.name : '', namespaceUri, _makeSpan(start));
 
       case TokenKind.DIRECTIVE_MIXIN:
         return processMixin();
 
       case TokenKind.DIRECTIVE_INCLUDE:
-        return processInclude( _makeSpan(start));
+        return processInclude(_makeSpan(start));
 
       case TokenKind.DIRECTIVE_CONTENT:
         // TODO(terry): TBD
         _warning("@content not implemented.", _makeSpan(start));
         return null;
     }
     return null;
   }
 
   /**
@@ skipping 42 matching lines @@
     while (!_maybeEat(TokenKind.END_OF_FILE)) {
       var directive = processDirective();
       if (directive != null) {
         productions.add(directive);
         continue;
       }
 
       var declGroup = processDeclarations(checkBrace: false);
       var decls = [];
       if (declGroup.declarations.any((decl) {
-        return decl is Declaration &&
-            decl is! IncludeMixinAtDeclaration;
+        return decl is Declaration && decl is! IncludeMixinAtDeclaration;
       })) {
         var newDecls = [];
         productions.forEach((include) {
           // If declGroup has items that are declarations then we assume
           // this mixin is a declaration mixin not a top-level mixin.
           if (include is IncludeDirective) {
-            newDecls.add(new IncludeMixinAtDeclaration(include,
-                include.span));
+            newDecls.add(new IncludeMixinAtDeclaration(include, include.span));
           } else {
             _warning("Error mixing of top-level vs declarations mixins",
                 _makeSpan(include.span));
           }
         });
         declGroup.declarations.insertAll(0, newDecls);
         productions = [];
       } else {
         // Declarations are just @includes make it a list of productions
         // not a declaration group (anything else is a ruleset).  Make it a
         // list of productions, not a declaration group.
         for (var decl in declGroup.declarations) {
-          productions.add(decl is IncludeMixinAtDeclaration ?
-              decl.include : decl);
-        };
+          productions
+              .add(decl is IncludeMixinAtDeclaration ? decl.include : decl);
+        }
+        ;
         declGroup.declarations.clear();
       }
 
       if (declGroup.declarations.isNotEmpty) {
         if (productions.isEmpty) {
-          mixinDirective = new MixinDeclarationDirective(name.name, params,
-              false, declGroup, _makeSpan(start));
+          mixinDirective = new MixinDeclarationDirective(
+              name.name, params, false, declGroup, _makeSpan(start));
           break;
         } else {
           for (var decl in declGroup.declarations) {
-            productions.add(decl is IncludeMixinAtDeclaration ?
-                decl.include : decl);
+            productions
+                .add(decl is IncludeMixinAtDeclaration ? decl.include : decl);
           }
         }
       } else {
-        mixinDirective = new MixinRulesetDirective(name.name, params,
-            false, productions, _makeSpan(start));
+        mixinDirective = new MixinRulesetDirective(
+            name.name, params, false, productions, _makeSpan(start));
         break;
       }
     }
 
     if (productions.isNotEmpty) {
-      mixinDirective = new MixinRulesetDirective(name.name, params,
-          false, productions, _makeSpan(start));
+      mixinDirective = new MixinRulesetDirective(
+          name.name, params, false, productions, _makeSpan(start));
     }
 
     _eat(TokenKind.RBRACE);
 
     return mixinDirective;
   }
 
   /**
    * Returns a VarDefinitionDirective or VarDefinition if a varaible otherwise
    * return the token id of a directive or -1 if neither.
@@ skipping 102 matching lines @@
     }
 
     return new IncludeDirective(name.name, params, span);
   }
 
   RuleSet processRuleSet([SelectorGroup selectorGroup]) {
     if (selectorGroup == null) {
       selectorGroup = processSelectorGroup();
     }
     if (selectorGroup != null) {
-      return new RuleSet(selectorGroup, processDeclarations(),
-          selectorGroup.span);
+      return new RuleSet(
+          selectorGroup, processDeclarations(), selectorGroup.span);
     }
   }
 
   /**
    * Look ahead to see if what should be a declaration is really a selector.
    * If it's a selector than it's a nested selector.  This support's Less'
    * nested selector syntax (requires a look ahead). E.g.,
    *
    *    div {
    *      width : 20px;
@@ skipping 15 matching lines @@
    */
   SelectorGroup _nestedSelector() {
     Messages oldMessages = messages;
     _createMessages();
 
     var markedData = _mark;
 
     // Look a head do we have a nested selector instead of a declaration?
     SelectorGroup selGroup = processSelectorGroup();
 
-    var nestedSelector = selGroup != null && _peekKind(TokenKind.LBRACE) &&
+    var nestedSelector = selGroup != null &&
+        _peekKind(TokenKind.LBRACE) &&
         messages.messages.isEmpty;
 
     if (!nestedSelector) {
       // Not a selector so restore the world.
       _restore(markedData);
       messages = oldMessages;
       return null;
     } else {
       // Remember any messages from look ahead.
       oldMessages.mergeMessages(messages);
       messages = oldMessages;
       return selGroup;
     }
   }
 
   DeclarationGroup processDeclarations({bool checkBrace: true}) {
     var start = _peekToken.span;
 
     if (checkBrace) _eat(TokenKind.LBRACE);
 
     List decls = [];
-    List dartStyles = [];             // List of latest styles exposed to Dart.
+    List dartStyles = []; // List of latest styles exposed to Dart.
 
     do {
       var selectorGroup = _nestedSelector();
       while (selectorGroup != null) {
         // Nested selector so process as a ruleset.
         var ruleset = processRuleSet(selectorGroup);
         decls.add(ruleset);
         selectorGroup = _nestedSelector();
       }
 
@@ skipping 37 matching lines @@
   }
 
   List<DeclarationGroup> processMarginsDeclarations() {
     List groups = [];
 
     var start = _peekToken.span;
 
     _eat(TokenKind.LBRACE);
 
     List<Declaration> decls = [];
-    List dartStyles = [];             // List of latest styles exposed to Dart.
+    List dartStyles = []; // List of latest styles exposed to Dart.
 
     do {
       switch (_peek()) {
         case TokenKind.MARGIN_DIRECTIVE_TOPLEFTCORNER:
         case TokenKind.MARGIN_DIRECTIVE_TOPLEFT:
         case TokenKind.MARGIN_DIRECTIVE_TOPCENTER:
         case TokenKind.MARGIN_DIRECTIVE_TOPRIGHT:
         case TokenKind.MARGIN_DIRECTIVE_TOPRIGHTCORNER:
         case TokenKind.MARGIN_DIRECTIVE_BOTTOMLEFTCORNER:
         case TokenKind.MARGIN_DIRECTIVE_BOTTOMLEFT:
@@ skipping 10 matching lines @@
           //   margin :
           //      margin_sym S* '{' declaration [ ';' S* declaration? ]* '}' S*
           //
           //      margin_sym : @top-left-corner, @top-left, @bottom-left, etc.
           var marginSym = _peek();
 
           _next();
 
           var declGroup = processDeclarations();
           if (declGroup != null) {
-            groups.add(new MarginGroup(marginSym, declGroup.declarations,
-                _makeSpan(start)));
+            groups.add(new MarginGroup(
+                marginSym, declGroup.declarations, _makeSpan(start)));
           }
           break;
         default:
           Declaration decl = processDeclaration(dartStyles);
           if (decl != null) {
             if (decl.hasDartStyle) {
               var newDartStyle = decl.dartStyle;
 
               // Replace or add latest Dart style.
               bool replaced = false;
@@ skipping 84 matching lines @@
         combinatorType = TokenKind.COMBINATOR_GREATER;
         break;
       case TokenKind.TILDE:
         _eat(TokenKind.TILDE);
         combinatorType = TokenKind.COMBINATOR_TILDE;
         break;
       case TokenKind.AMPERSAND:
         _eat(TokenKind.AMPERSAND);
         thisOperator = true;
         break;
-      }
+    }
 
     // Check if WHITESPACE existed between tokens if so we're descendent.
     if (combinatorType == TokenKind.COMBINATOR_NONE && !forceCombinatorNone) {
       if (this._previousToken != null &&
           this._previousToken.end != this._peekToken.start) {
         combinatorType = TokenKind.COMBINATOR_DESCENDANT;
       }
     }
 
     var span = _makeSpan(start);
-    var simpleSel = thisOperator ?
-        new ElementSelector(new ThisOperator(span), span) : simpleSelector();
+    var simpleSel = thisOperator
+        ? new ElementSelector(new ThisOperator(span), span)
+        : simpleSelector();
     if (simpleSel == null &&
         (combinatorType == TokenKind.COMBINATOR_PLUS ||
-        combinatorType == TokenKind.COMBINATOR_GREATER ||
-        combinatorType == TokenKind.COMBINATOR_TILDE)) {
+            combinatorType == TokenKind.COMBINATOR_GREATER ||
+            combinatorType == TokenKind.COMBINATOR_TILDE)) {
       // For "+ &", "~ &" or "> &" a selector sequence with no name is needed
       // so that the & will have a combinator too.  This is needed to
       // disambiguate selector expressions:
       //    .foo&:hover     combinator before & is NONE
       //    .foo &          combinator before & is DESCDENDANT
       //    .foo > &        combinator before & is GREATER
-      simpleSel =  new ElementSelector(new Identifier("", span), span);
+      simpleSel = new ElementSelector(new Identifier("", span), span);
     }
     if (simpleSel != null) {
       return new SimpleSelectorSequence(simpleSel, span, combinatorType);
     }
   }
 
   /**
    * Simple selector grammar:
    *
    *    simple_selector_sequence
@@ skipping 50 matching lines @@
           break;
         case TokenKind.IDENTIFIER:
           element = identifier();
           break;
         default:
           _error('expected element name or universal(*), but found $_peekToken',
               _peekToken.span);
           break;
       }
 
-      return new NamespaceSelector(first,
-          new ElementSelector(element, element.span), _makeSpan(start));
+      return new NamespaceSelector(
+          first, new ElementSelector(element, element.span), _makeSpan(start));
     } else if (first != null) {
       return new ElementSelector(first, _makeSpan(start));
     } else {
       // Check for HASH | class | attrib | pseudo | negation
       return simpleSelectorTail();
     }
   }
 
   bool _anyWhiteSpaceBeforePeekToken(int kind) {
-    if (_previousToken != null && _peekToken != null &&
+    if (_previousToken != null &&
+        _peekToken != null &&
         _previousToken.kind == kind) {
       // If end of previous token isn't same as the start of peek token then
       // there's something between these tokens probably whitespace.
       return _previousToken.end != _peekToken.start;
     }
 
     return false;
   }
 
   /**
@@ skipping 60 matching lines @@
     var pseudoName;
     if (_peekIdentifier()) {
       pseudoName = identifier();
     } else {
       return null;
     }
 
     // Functional pseudo?
 
     if (_peekToken.kind == TokenKind.LPAREN) {
-
       if (!pseudoElement && pseudoName.name.toLowerCase() == 'not') {
         _eat(TokenKind.LPAREN);
 
         // Negation :   ':NOT(' S* negation_arg S* ')'
         var negArg = simpleSelector();
 
         _eat(TokenKind.RPAREN);
         return new NegationSelector(negArg, _makeSpan(start));
       } else {
         // Special parsing for expressions in pseudo functions.  Minus is used
@@ skipping 11 matching lines @@
         tokenizer.inSelectorExpression = false;
 
         // Used during selector look-a-head if not a SelectorExpression is
         // bad.
         if (expr is! SelectorExpression) {
           _errorExpected("CSS expression");
           return null;
         }
 
         _eat(TokenKind.RPAREN);
-        return (pseudoElement) ?
-            new PseudoElementFunctionSelector(pseudoName, expr, span) :
-              new PseudoClassFunctionSelector(pseudoName, expr, span);
+        return (pseudoElement)
+            ? new PseudoElementFunctionSelector(pseudoName, expr, span)
+            : new PseudoClassFunctionSelector(pseudoName, expr, span);
       }
     }
 
     // TODO(terry): Need to handle specific pseudo class/element name and
     // backward compatible names that are : as well as :: as well as
     // parameters.  Current, spec uses :: for pseudo-element and : for
     // pseudo-class.  However, CSS2.1 allows for : to specify old
     // pseudo-elements (:first-line, :first-letter, :before and :after) any
     // new pseudo-elements defined would require a ::.
-    return pseudoElement ?
-        new PseudoElementSelector(pseudoName, _makeSpan(start)) :
-          new PseudoClassSelector(pseudoName, _makeSpan(start));
+    return pseudoElement
+        ? new PseudoElementSelector(pseudoName, _makeSpan(start))
+        : new PseudoClassSelector(pseudoName, _makeSpan(start));
   }
 
   /**
    *  In CSS3, the expressions are identifiers, strings, or of the form "an+b".
    *
    *    : [ [ PLUS | '-' | DIMENSION | NUMBER | STRING | IDENT ] S* ]+
    *
    *    num               [0-9]+|[0-9]*\.[0-9]+
    *    PLUS              '+'
    *    DIMENSION         {num}{ident}
@@ skipping 30 matching lines @@
           break;
         case TokenKind.SINGLE_QUOTE:
           value = processQuotedString(false);
           value = "'${_escapeString(value, single: true)}'";
           return new LiteralTerm(value, value, _makeSpan(start));
         case TokenKind.DOUBLE_QUOTE:
           value = processQuotedString(false);
           value = '"${_escapeString(value)}"';
           return new LiteralTerm(value, value, _makeSpan(start));
         case TokenKind.IDENTIFIER:
-          value = identifier();   // Snarf up the ident we'll remap, maybe.
+          value = identifier(); // Snarf up the ident we'll remap, maybe.
           break;
         default:
           keepParsing = false;
       }
 
       if (keepParsing && value != null) {
         var unitTerm;
         // Don't process the dimension if MINUS or PLUS is next.
         if (_peek() != TokenKind.MINUS && _peek() != TokenKind.PLUS) {
           unitTerm = processDimension(termToken, value, _makeSpan(start));
@@ skipping 30 matching lines @@
   //
   //
   AttributeSelector processAttribute() {
     var start = _peekToken.span;
 
     if (_maybeEat(TokenKind.LBRACK)) {
       var attrName = identifier();
 
       int op;
       switch (_peek()) {
-      case TokenKind.EQUALS:
-      case TokenKind.INCLUDES:        // ~=
-      case TokenKind.DASH_MATCH:      // |=
-      case TokenKind.PREFIX_MATCH:    // ^=
-      case TokenKind.SUFFIX_MATCH:    // $=
-      case TokenKind.SUBSTRING_MATCH: // *=
-        op = _peek();
-        _next();
-        break;
-      default:
-        op = TokenKind.NO_MATCH;
+        case TokenKind.EQUALS:
+        case TokenKind.INCLUDES: // ~=
+        case TokenKind.DASH_MATCH: // |=
+        case TokenKind.PREFIX_MATCH: // ^=
+        case TokenKind.SUFFIX_MATCH: // $=
+        case TokenKind.SUBSTRING_MATCH: // *=
+          op = _peek();
+          _next();
+          break;
+        default:
+          op = TokenKind.NO_MATCH;
       }
 
       var value;
       if (op != TokenKind.NO_MATCH) {
         // Operator hit so we require a value too.
         if (_peekIdentifier()) {
           value = identifier();
         } else {
           value = processQuotedString(false);
         }
@@ skipping 41 matching lines @@
 
       _eat(TokenKind.COLON);
 
       Expressions exprs = processExpr(ieFilterProperty);
 
       var dartComposite = _styleForDart(propertyIdent, exprs, dartStyles);
 
       // Handle !important (prio)
       var importantPriority = _maybeEat(TokenKind.IMPORTANT);
 
-      decl = new Declaration(propertyIdent, exprs, dartComposite,
-          _makeSpan(start), important: importantPriority, ie7: ie7);
+      decl = new Declaration(
+          propertyIdent, exprs, dartComposite, _makeSpan(start),
+          important: importantPriority, ie7: ie7);
     } else if (_peekToken.kind == TokenKind.VAR_DEFINITION) {
       _next();
       var definedName;
       if (_peekIdentifier()) definedName = identifier();
 
       _eat(TokenKind.COLON);
 
       Expressions exprs = processExpr();
 
       decl = new VarDefinition(definedName, exprs, _makeSpan(start));
@@ skipping 22 matching lines @@
           _warning("not a valid selector", span);
         }
       }
       decl = new ExtendDeclaration(simpleSequences, span);
     }
 
     return decl;
   }
 
   /** List of styles exposed to the Dart UI framework. */
-  static const int _fontPartFont= 0;
+  static const int _fontPartFont = 0;
   static const int _fontPartVariant = 1;
   static const int _fontPartWeight = 2;
   static const int _fontPartSize = 3;
   static const int _fontPartFamily = 4;
   static const int _fontPartStyle = 5;
   static const int _marginPartMargin = 6;
   static const int _marginPartLeft = 7;
   static const int _marginPartTop = 8;
   static const int _marginPartRight = 9;
   static const int _marginPartBottom = 10;
@@ skipping 10 matching lines @@
   static const int _borderPartBottomWidth = 21;
   static const int _heightPart = 22;
   static const int _widthPart = 23;
   static const int _paddingPartPadding = 24;
   static const int _paddingPartLeft = 25;
   static const int _paddingPartTop = 26;
   static const int _paddingPartRight = 27;
   static const int _paddingPartBottom = 28;
 
   static const Map<String, int> _stylesToDart = const {
-    'font':                 _fontPartFont,
-    'font-family':          _fontPartFamily,
-    'font-size':            _fontPartSize,
-    'font-style':           _fontPartStyle,
-    'font-variant':         _fontPartVariant,
-    'font-weight':          _fontPartWeight,
-    'line-height':          _lineHeightPart,
-    'margin':               _marginPartMargin,
-    'margin-left':          _marginPartLeft,
-    'margin-right':         _marginPartRight,
-    'margin-top':           _marginPartTop,
-    'margin-bottom':        _marginPartBottom,
-    'border':               _borderPartBorder,
-    'border-left':          _borderPartLeft,
-    'border-right':         _borderPartRight,
-    'border-top':           _borderPartTop,
-    'border-bottom':        _borderPartBottom,
-    'border-width':         _borderPartWidth,
-    'border-left-width':    _borderPartLeftWidth,
-    'border-top-width':     _borderPartTopWidth,
-    'border-right-width':   _borderPartRightWidth,
-    'border-bottom-width':  _borderPartBottomWidth,
-    'height':               _heightPart,
-    'width':                _widthPart,
-    'padding':              _paddingPartPadding,
-    'padding-left':         _paddingPartLeft,
-    'padding-top':          _paddingPartTop,
-    'padding-right':        _paddingPartRight,
-    'padding-bottom':       _paddingPartBottom
+    'font': _fontPartFont,
+    'font-family': _fontPartFamily,
+    'font-size': _fontPartSize,
+    'font-style': _fontPartStyle,
+    'font-variant': _fontPartVariant,
+    'font-weight': _fontPartWeight,
+    'line-height': _lineHeightPart,
+    'margin': _marginPartMargin,
+    'margin-left': _marginPartLeft,
+    'margin-right': _marginPartRight,
+    'margin-top': _marginPartTop,
+    'margin-bottom': _marginPartBottom,
+    'border': _borderPartBorder,
+    'border-left': _borderPartLeft,
+    'border-right': _borderPartRight,
+    'border-top': _borderPartTop,
+    'border-bottom': _borderPartBottom,
+    'border-width': _borderPartWidth,
+    'border-left-width': _borderPartLeftWidth,
+    'border-top-width': _borderPartTopWidth,
+    'border-right-width': _borderPartRightWidth,
+    'border-bottom-width': _borderPartBottomWidth,
+    'height': _heightPart,
+    'width': _widthPart,
+    'padding': _paddingPartPadding,
+    'padding-left': _paddingPartLeft,
+    'padding-top': _paddingPartTop,
+    'padding-right': _paddingPartRight,
+    'padding-bottom': _paddingPartBottom
   };
 
   static const Map<String, int> _nameToFontWeight = const {
-    'bold' : FontWeight.bold,
-    'normal' : FontWeight.normal
+    'bold': FontWeight.bold,
+    'normal': FontWeight.normal
   };
 
   static int _findStyle(String styleName) => _stylesToDart[styleName];
 
-  DartStyleExpression _styleForDart(Identifier property, Expressions exprs,
-      List dartStyles) {
+  DartStyleExpression _styleForDart(
+      Identifier property, Expressions exprs, List dartStyles) {
     var styleType = _findStyle(property.name.toLowerCase());
     if (styleType != null) {
       return buildDartStyleNode(styleType, exprs, dartStyles);
     }
   }
 
   FontExpression _mergeFontStyles(FontExpression fontExpr, List dartStyles) {
     // Merge all font styles for this class selector.
     for (var dartStyle in dartStyles) {
       if (dartStyle.isFont) {
         fontExpr = new FontExpression.merge(dartStyle, fontExpr);
       }
     }
 
     return fontExpr;
   }
 
-  DartStyleExpression buildDartStyleNode(int styleType, Expressions exprs,
-      List dartStyles) {
-
+  DartStyleExpression buildDartStyleNode(
+      int styleType, Expressions exprs, List dartStyles) {
     switch (styleType) {
       /*
        * Properties in order:
        *
        *   font-style font-variant font-weight font-size/line-height font-family
        *
        * The font-size and font-family values are required. If other values are
        * missing; a default, if it exist, will be used.
        */
-       case _fontPartFont:
-         var processor = new ExpressionsProcessor(exprs);
-         return _mergeFontStyles(processor.processFont(), dartStyles);
+      case _fontPartFont:
+        var processor = new ExpressionsProcessor(exprs);
+        return _mergeFontStyles(processor.processFont(), dartStyles);
       case _fontPartFamily:
         var processor = new ExpressionsProcessor(exprs);
 
         try {
           return _mergeFontStyles(processor.processFontFamily(), dartStyles);
         } catch (fontException) {
           _error(fontException, _peekToken.span);
         }
         break;
       case _fontPartSize:
@@ skipping 23 matching lines @@
          *   bolder
          *   lighter
          *   100 - 900
          *   inherit
          */
         // TODO(terry): Only 'normal', 'bold', or values of 100-900 supoorted
         //              need to handle bolder, lighter, and inherit.  See
         //              https://github.com/dart-lang/csslib/issues/1
         var expr = exprs.expressions[0];
         if (expr is NumberTerm) {
-          var fontExpr = new FontExpression(expr.span,
-              weight: expr.value);
+          var fontExpr = new FontExpression(expr.span, weight: expr.value);
           return _mergeFontStyles(fontExpr, dartStyles);
         } else if (expr is LiteralTerm) {
           int weight = _nameToFontWeight[expr.value.toString()];
           if (weight != null) {
             var fontExpr = new FontExpression(expr.span, weight: weight);
             return _mergeFontStyles(fontExpr, dartStyles);
           }
         }
         break;
       case _lineHeightPart:
         num lineHeight;
         if (exprs.expressions.length == 1) {
           var expr = exprs.expressions[0];
           if (expr is UnitTerm) {
             UnitTerm unitTerm = expr;
             // TODO(terry): Need to handle other units and LiteralTerm normal
             //              See https://github.com/dart-lang/csslib/issues/2.
             if (unitTerm.unit == TokenKind.UNIT_LENGTH_PX ||
-                   unitTerm.unit == TokenKind.UNIT_LENGTH_PT) {
+                unitTerm.unit == TokenKind.UNIT_LENGTH_PT) {
               var fontExpr = new FontExpression(expr.span,
                   lineHeight: new LineHeight(expr.value, inPixels: true));
               return _mergeFontStyles(fontExpr, dartStyles);
             } else if (isChecked) {
               _warning("Unexpected unit for line-height", expr.span);
             }
           } else if (expr is NumberTerm) {
             var fontExpr = new FontExpression(expr.span,
                 lineHeight: new LineHeight(expr.value, inPixels: false));
             return _mergeFontStyles(fontExpr, dartStyles);
@@ skipping 14 matching lines @@
         }
         break;
       case _borderPartWidth:
         var v = marginValue(exprs.expressions[0]);
         if (v != null) {
           final box = new BoxEdge.uniform(v);
           return new BorderExpression.boxEdge(exprs.span, box);
         }
         break;
       case _paddingPartPadding:
-        return new PaddingExpression.boxEdge(exprs.span,
-            processFourNums(exprs));
+        return new PaddingExpression.boxEdge(
+            exprs.span, processFourNums(exprs));
       case _marginPartLeft:
       case _marginPartTop:
       case _marginPartRight:
       case _marginPartBottom:
       case _borderPartLeft:
       case _borderPartTop:
       case _borderPartRight:
       case _borderPartBottom:
       case _borderPartLeftWidth:
       case _borderPartTopWidth:
@@ skipping 79 matching lines @@
         top = marginValue(exprs.expressions[0]);
         right = top;
         bottom = top;
         left = top;
         break;
       case 2:
         top = marginValue(exprs.expressions[0]);
         bottom = top;
         right = marginValue(exprs.expressions[1]);
         left = right;
-       break;
+        break;
       case 3:
         top = marginValue(exprs.expressions[0]);
         right = marginValue(exprs.expressions[1]);
         left = right;
         bottom = marginValue(exprs.expressions[2]);
         break;
       case 4:
         top = marginValue(exprs.expressions[0]);
         right = marginValue(exprs.expressions[1]);
         bottom = marginValue(exprs.expressions[2]);
@@ skipping 25 matching lines @@
     var expressions = new Expressions(_makeSpan(start));
 
     var keepGoing = true;
     var expr;
     while (keepGoing && (expr = processTerm(ieFilter)) != null) {
       var op;
 
       var opStart = _peekToken.span;
 
       switch (_peek()) {
-      case TokenKind.SLASH:
-        op = new OperatorSlash(_makeSpan(opStart));
-        break;
-      case TokenKind.COMMA:
-        op = new OperatorComma(_makeSpan(opStart));
-        break;
-      case TokenKind.BACKSLASH:
-        // Backslash outside of string; detected IE8 or older signaled by \9 at
-        // end of an expression.
-        var ie8Start = _peekToken.span;
+        case TokenKind.SLASH:
+          op = new OperatorSlash(_makeSpan(opStart));
+          break;
+        case TokenKind.COMMA:
+          op = new OperatorComma(_makeSpan(opStart));
+          break;
+        case TokenKind.BACKSLASH:
+          // Backslash outside of string; detected IE8 or older signaled by \9 at
+          // end of an expression.
+          var ie8Start = _peekToken.span;
 
-        _next();
-        if (_peekKind(TokenKind.INTEGER)) {
-          var numToken = _next();
-          var value = int.parse(numToken.text);
-          if (value == 9) {
-            op = new IE8Term(_makeSpan(ie8Start));
-          } else if (isChecked) {
-            _warning("\$value is not valid in an expression", _makeSpan(start));
+          _next();
+          if (_peekKind(TokenKind.INTEGER)) {
+            var numToken = _next();
+            var value = int.parse(numToken.text);
+            if (value == 9) {
+              op = new IE8Term(_makeSpan(ie8Start));
+            } else if (isChecked) {
+              _warning(
+                  "\$value is not valid in an expression", _makeSpan(start));
+            }
           }
-        }
-        break;
+          break;
       }
 
       if (expr != null) {
         if (expr is List) {
           expr.forEach((exprItem) {
             expressions.add(exprItem);
           });
         } else {
           expressions.add(expr);
         }
@@ skipping 32 matching lines @@
   //  LENGTH:       {num}['px' | 'cm' | 'mm' | 'in' | 'pt' | 'pc']
   //  EMS:          {num}'em'
   //  EXS:          {num}'ex'
   //  ANGLE:        {num}['deg' | 'rad' | 'grad']
   //  TIME:         {num}['ms' | 's']
   //  FREQ:         {num}['hz' | 'khz']
   //  function:     IDENT '(' expr ')'
   //
   processTerm([bool ieFilter = false]) {
     var start = _peekToken.span;
-    Token t;                          // token for term's value
-    var value;                        // value of term (numeric values)
+    Token t; // token for term's value
+    var value; // value of term (numeric values)
 
     var unary = "";
     switch (_peek()) {
-    case TokenKind.HASH:
-      this._eat(TokenKind.HASH);
-      if (!_anyWhiteSpaceBeforePeekToken(TokenKind.HASH)) {
-        String hexText;
-        if (_peekKind(TokenKind.INTEGER)) {
-          String hexText1 = _peekToken.text;
-          _next();
-          if (_peekIdentifier()) {
-            hexText = '$hexText1${identifier().name}';
+      case TokenKind.HASH:
+        this._eat(TokenKind.HASH);
+        if (!_anyWhiteSpaceBeforePeekToken(TokenKind.HASH)) {
+          String hexText;
+          if (_peekKind(TokenKind.INTEGER)) {
+            String hexText1 = _peekToken.text;
+            _next();
+            if (_peekIdentifier()) {
+              hexText = '$hexText1${identifier().name}';
+            } else {
+              hexText = hexText1;
+            }
+          } else if (_peekIdentifier()) {
+            hexText = identifier().name;
+          }
+          if (hexText != null) {
+            return _parseHex(hexText, _makeSpan(start));
+          }
+        }
+
+        if (isChecked) {
+          _warning("Expected hex number", _makeSpan(start));
+        }
+        // Construct the bad hex value with a #<space>number.
+        return _parseHex(" ${processTerm().text}", _makeSpan(start));
+      case TokenKind.INTEGER:
+        t = _next();
+        value = int.parse("${unary}${t.text}");
+        break;
+      case TokenKind.DOUBLE:
+        t = _next();
+        value = double.parse("${unary}${t.text}");
+        break;
+      case TokenKind.SINGLE_QUOTE:
+        value = processQuotedString(false);
+        value = "'${_escapeString(value, single: true)}'";
+        return new LiteralTerm(value, value, _makeSpan(start));
+      case TokenKind.DOUBLE_QUOTE:
+        value = processQuotedString(false);
+        value = '"${_escapeString(value)}"';
+        return new LiteralTerm(value, value, _makeSpan(start));
+      case TokenKind.LPAREN:
+        _next();
+
+        GroupTerm group = new GroupTerm(_makeSpan(start));
+
+        var term;
+        do {
+          term = processTerm();
+          if (term != null && term is LiteralTerm) {
+            group.add(term);
+          }
+        } while (term != null &&
+            !_maybeEat(TokenKind.RPAREN) &&
+            !isPrematureEndOfFile());
+
+        return group;
+      case TokenKind.LBRACK:
+        _next();
+
+        var term = processTerm();
+        if (!(term is NumberTerm)) {
+          _error('Expecting a positive number', _makeSpan(start));
+        }
+
+        _eat(TokenKind.RBRACK);
+
+        return new ItemTerm(term.value, term.text, _makeSpan(start));
+      case TokenKind.IDENTIFIER:
+        var nameValue = identifier(); // Snarf up the ident we'll remap, maybe.
+
+        if (!ieFilter && _maybeEat(TokenKind.LPAREN)) {
+          // FUNCTION
+          return processFunction(nameValue);
+        }
+        if (ieFilter) {
+          if (_maybeEat(TokenKind.COLON) &&
+              nameValue.name.toLowerCase() == 'progid') {
+            // IE filter:progid:
+            return processIEFilter(start);
           } else {
-            hexText = hexText1;
+            // Handle filter:<name> where name is any filter e.g., alpha, chroma,
+            // Wave, blur, etc.
+            return processIEFilter(start);
           }
-        } else if (_peekIdentifier()) {
-          hexText = identifier().name;
         }
-        if (hexText != null) {
-          return _parseHex(hexText, _makeSpan(start));
+
+        // TODO(terry): Need to have a list of known identifiers today only
+        //              'from' is special.
+        if (nameValue.name == 'from') {
+          return new LiteralTerm(nameValue, nameValue.name, _makeSpan(start));
         }
-      }
 
-      if (isChecked) {
-        _warning("Expected hex number", _makeSpan(start));
-      }
-      // Construct the bad hex value with a #<space>number.
-      return _parseHex(" ${processTerm().text}", _makeSpan(start));
-    case TokenKind.INTEGER:
-      t = _next();
-      value = int.parse("${unary}${t.text}");
-      break;
-    case TokenKind.DOUBLE:
-      t = _next();
-      value = double.parse("${unary}${t.text}");
-      break;
-    case TokenKind.SINGLE_QUOTE:
-      value = processQuotedString(false);
-      value = "'${_escapeString(value, single: true)}'";
-      return new LiteralTerm(value, value, _makeSpan(start));
-    case TokenKind.DOUBLE_QUOTE:
-      value = processQuotedString(false);
-      value = '"${_escapeString(value)}"';
-      return new LiteralTerm(value, value, _makeSpan(start));
-    case TokenKind.LPAREN:
-      _next();
+        // What kind of identifier is it, named color?
+        var colorEntry = TokenKind.matchColorName(nameValue.name);
+        if (colorEntry == null) {
+          if (isChecked) {
+            var propName = nameValue.name;
+            var errMsg = TokenKind.isPredefinedName(propName)
+                ? "Improper use of property value ${propName}"
+                : "Unknown property value ${propName}";
+            _warning(errMsg, _makeSpan(start));
+          }
+          return new LiteralTerm(nameValue, nameValue.name, _makeSpan(start));
+        }
 
-      GroupTerm group = new GroupTerm(_makeSpan(start));
-
-      var term;
-      do {
-        term = processTerm();
-        if (term != null && term is LiteralTerm) {
-          group.add(term);
-        }
-      } while (term != null && !_maybeEat(TokenKind.RPAREN) &&
-          !isPrematureEndOfFile());
-
-      return group;
-    case TokenKind.LBRACK:
-      _next();
-
-      var term = processTerm();
-      if (!(term is NumberTerm)) {
-        _error('Expecting a positive number', _makeSpan(start));
-      }
-
-      _eat(TokenKind.RBRACK);
-
-      return new ItemTerm(term.value, term.text, _makeSpan(start));
-    case TokenKind.IDENTIFIER:
-      var nameValue = identifier();   // Snarf up the ident we'll remap, maybe.
-
-      if (!ieFilter && _maybeEat(TokenKind.LPAREN)) {
-        // FUNCTION
-        return processFunction(nameValue);
-      } if (ieFilter) {
-         if (_maybeEat(TokenKind.COLON) &&
-           nameValue.name.toLowerCase() == 'progid') {
-           // IE filter:progid:
-           return processIEFilter(start);
-         } else {
-           // Handle filter:<name> where name is any filter e.g., alpha, chroma,
-           // Wave, blur, etc.
-           return processIEFilter(start);
-         }
-      }
-
-      // TODO(terry): Need to have a list of known identifiers today only
-      //              'from' is special.
-      if (nameValue.name == 'from') {
-        return new LiteralTerm(nameValue, nameValue.name, _makeSpan(start));
-      }
-
-      // What kind of identifier is it, named color?
-      var colorEntry = TokenKind.matchColorName(nameValue.name);
-      if (colorEntry == null) {
-        if (isChecked) {
-          var propName = nameValue.name;
-          var errMsg = TokenKind.isPredefinedName(propName) ?
-              "Improper use of property value ${propName}" :
-              "Unknown property value ${propName}";
-          _warning(errMsg, _makeSpan(start));
-        }
-        return new LiteralTerm(nameValue, nameValue.name, _makeSpan(start));
-      }
-
-      // Yes, process the color as an RGB value.
-      var rgbColor =
-          TokenKind.decimalToHex(TokenKind.colorValue(colorEntry), 6);
-      return _parseHex(rgbColor, _makeSpan(start));
-    case TokenKind.UNICODE_RANGE:
-      var first;
-      var second;
-      var firstNumber;
-      var secondNumber;
-      _eat(TokenKind.UNICODE_RANGE, unicodeRange: true);
-      if (_maybeEat(TokenKind.HEX_INTEGER, unicodeRange: true)) {
-        first = _previousToken.text;
-        firstNumber = int.parse('0x$first');
-        if (firstNumber > MAX_UNICODE) {
-          _error("unicode range must be less than 10FFFF", _makeSpan(start));
-        }
-        if (_maybeEat(TokenKind.MINUS, unicodeRange: true)) {
-          if (_maybeEat(TokenKind.HEX_INTEGER, unicodeRange: true)) {
-            second = _previousToken.text;
-            secondNumber = int.parse('0x$second');
-            if (secondNumber > MAX_UNICODE) {
-              _error("unicode range must be less than 10FFFF",
-                  _makeSpan(start));
-            }
-            if (firstNumber > secondNumber) {
-              _error("unicode first range can not be greater than last",
-                  _makeSpan(start));
+        // Yes, process the color as an RGB value.
+        var rgbColor =
+            TokenKind.decimalToHex(TokenKind.colorValue(colorEntry), 6);
+        return _parseHex(rgbColor, _makeSpan(start));
+      case TokenKind.UNICODE_RANGE:
+        var first;
+        var second;
+        var firstNumber;
+        var secondNumber;
+        _eat(TokenKind.UNICODE_RANGE, unicodeRange: true);
+        if (_maybeEat(TokenKind.HEX_INTEGER, unicodeRange: true)) {
+          first = _previousToken.text;
+          firstNumber = int.parse('0x$first');
+          if (firstNumber > MAX_UNICODE) {
+            _error("unicode range must be less than 10FFFF", _makeSpan(start));
+          }
+          if (_maybeEat(TokenKind.MINUS, unicodeRange: true)) {
+            if (_maybeEat(TokenKind.HEX_INTEGER, unicodeRange: true)) {
+              second = _previousToken.text;
+              secondNumber = int.parse('0x$second');
+              if (secondNumber > MAX_UNICODE) {
+                _error(
+                    "unicode range must be less than 10FFFF", _makeSpan(start));
+              }
+              if (firstNumber > secondNumber) {
+                _error("unicode first range can not be greater than last",
+                    _makeSpan(start));
+              }
             }
           }
-        }
-      } else if (_maybeEat(TokenKind.HEX_RANGE, unicodeRange: true)) {
-        first = _previousToken.text;
-      }
-
-      return new UnicodeRangeTerm(first, second, _makeSpan(start));
-    case TokenKind.AT:
-      if (messages.options.lessSupport) {
-        _next();
-
-        var expr = processExpr();
-        if (isChecked && expr.expressions.length > 1) {
-          _error("only @name for Less syntax", _peekToken.span);
+        } else if (_maybeEat(TokenKind.HEX_RANGE, unicodeRange: true)) {
+          first = _previousToken.text;
         }
 
-        var param = expr.expressions[0];
-        var varUsage = new VarUsage(param.text, [], _makeSpan(start));
-        expr.expressions[0] = varUsage;
-        return expr.expressions;
-      }
-      break;
+        return new UnicodeRangeTerm(first, second, _makeSpan(start));
+      case TokenKind.AT:
+        if (messages.options.lessSupport) {
+          _next();
+
+          var expr = processExpr();
+          if (isChecked && expr.expressions.length > 1) {
+            _error("only @name for Less syntax", _peekToken.span);
+          }
+
+          var param = expr.expressions[0];
+          var varUsage = new VarUsage(param.text, [], _makeSpan(start));
+          expr.expressions[0] = varUsage;
+          return expr.expressions;
+        }
+        break;
     }
 
     return processDimension(t, value, _makeSpan(start));
   }
 
   /** Process all dimension units. */
   LiteralTerm processDimension(Token t, var value, SourceSpan span) {
     LiteralTerm term;
     var unitType = this._peek();
 
     switch (unitType) {
-    case TokenKind.UNIT_EM:
-      term = new EmTerm(value, t.text, span);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.UNIT_EX:
-      term = new ExTerm(value, t.text, span);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.UNIT_LENGTH_PX:
-    case TokenKind.UNIT_LENGTH_CM:
-    case TokenKind.UNIT_LENGTH_MM:
-    case TokenKind.UNIT_LENGTH_IN:
-    case TokenKind.UNIT_LENGTH_PT:
-    case TokenKind.UNIT_LENGTH_PC:
-      term = new LengthTerm(value, t.text, span, unitType);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.UNIT_ANGLE_DEG:
-    case TokenKind.UNIT_ANGLE_RAD:
-    case TokenKind.UNIT_ANGLE_GRAD:
-    case TokenKind.UNIT_ANGLE_TURN:
-      term = new AngleTerm(value, t.text, span, unitType);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.UNIT_TIME_MS:
-    case TokenKind.UNIT_TIME_S:
-      term = new TimeTerm(value, t.text, span, unitType);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.UNIT_FREQ_HZ:
-    case TokenKind.UNIT_FREQ_KHZ:
-      term = new FreqTerm(value, t.text, span, unitType);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.PERCENT:
-      term = new PercentageTerm(value, t.text, span);
-      _next();    // Skip the %
-      break;
-    case TokenKind.UNIT_FRACTION:
-      term = new FractionTerm(value, t.text, span);
-      _next();     // Skip the unit
-      break;
-    case TokenKind.UNIT_RESOLUTION_DPI:
-    case TokenKind.UNIT_RESOLUTION_DPCM:
-    case TokenKind.UNIT_RESOLUTION_DPPX:
-      term = new ResolutionTerm(value, t.text, span, unitType);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.UNIT_CH:
-      term = new ChTerm(value, t.text, span, unitType);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.UNIT_REM:
-      term = new RemTerm(value, t.text, span, unitType);
-      _next();    // Skip the unit
-      break;
-    case TokenKind.UNIT_VIEWPORT_VW:
-    case TokenKind.UNIT_VIEWPORT_VH:
-    case TokenKind.UNIT_VIEWPORT_VMIN:
-    case TokenKind.UNIT_VIEWPORT_VMAX:
-      term = new ViewportTerm(value, t.text, span, unitType);
-      _next();    // Skip the unit
-      break;
-    default:
-      if (value != null && t != null) {
-        term = (value is Identifier)
-            ? new LiteralTerm(value, value.name, span)
-            : new NumberTerm(value, t.text, span);
-      }
-      break;
+      case TokenKind.UNIT_EM:
+        term = new EmTerm(value, t.text, span);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_EX:
+        term = new ExTerm(value, t.text, span);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_LENGTH_PX:
+      case TokenKind.UNIT_LENGTH_CM:
+      case TokenKind.UNIT_LENGTH_MM:
+      case TokenKind.UNIT_LENGTH_IN:
+      case TokenKind.UNIT_LENGTH_PT:
+      case TokenKind.UNIT_LENGTH_PC:
+        term = new LengthTerm(value, t.text, span, unitType);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_ANGLE_DEG:
+      case TokenKind.UNIT_ANGLE_RAD:
+      case TokenKind.UNIT_ANGLE_GRAD:
+      case TokenKind.UNIT_ANGLE_TURN:
+        term = new AngleTerm(value, t.text, span, unitType);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_TIME_MS:
+      case TokenKind.UNIT_TIME_S:
+        term = new TimeTerm(value, t.text, span, unitType);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_FREQ_HZ:
+      case TokenKind.UNIT_FREQ_KHZ:
+        term = new FreqTerm(value, t.text, span, unitType);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.PERCENT:
+        term = new PercentageTerm(value, t.text, span);
+        _next(); // Skip the %
+        break;
+      case TokenKind.UNIT_FRACTION:
+        term = new FractionTerm(value, t.text, span);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_RESOLUTION_DPI:
+      case TokenKind.UNIT_RESOLUTION_DPCM:
+      case TokenKind.UNIT_RESOLUTION_DPPX:
+        term = new ResolutionTerm(value, t.text, span, unitType);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_CH:
+        term = new ChTerm(value, t.text, span, unitType);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_REM:
+        term = new RemTerm(value, t.text, span, unitType);
+        _next(); // Skip the unit
+        break;
+      case TokenKind.UNIT_VIEWPORT_VW:
+      case TokenKind.UNIT_VIEWPORT_VH:
+      case TokenKind.UNIT_VIEWPORT_VMIN:
+      case TokenKind.UNIT_VIEWPORT_VMAX:
+        term = new ViewportTerm(value, t.text, span, unitType);
+        _next(); // Skip the unit
+        break;
+      default:
+        if (value != null && t != null) {
+          term = (value is Identifier)
+              ? new LiteralTerm(value, value.name, span)
+              : new NumberTerm(value, t.text, span);
+        }
+        break;
     }
 
     return term;
   }
 
   String processQuotedString([bool urlString = false]) {
     var start = _peekToken.span;
 
     // URI term sucks up everything inside of quotes(' or ") or between parens
     var stopToken = urlString ? TokenKind.RPAREN : -1;
 
     // Note: disable skipping whitespace tokens inside a string.
     // TODO(jmesserly): the layering here feels wrong.
     var skipWhitespace = tokenizer._skipWhitespace;
     tokenizer._skipWhitespace = false;
 
     switch (_peek()) {
-    case TokenKind.SINGLE_QUOTE:
-      stopToken = TokenKind.SINGLE_QUOTE;
-      _next(); // Skip the SINGLE_QUOTE.
-      start = _peekToken.span;
-      break;
-    case TokenKind.DOUBLE_QUOTE:
-      stopToken = TokenKind.DOUBLE_QUOTE;
-      _next(); // Skip the DOUBLE_QUOTE.
-      start = _peekToken.span;
-      break;
-    default:
-      if (urlString) {
-        if (_peek() == TokenKind.LPAREN) {
-          _next();    // Skip the LPAREN.
-          start = _peekToken.span;
+      case TokenKind.SINGLE_QUOTE:
+        stopToken = TokenKind.SINGLE_QUOTE;
+        _next(); // Skip the SINGLE_QUOTE.
+        start = _peekToken.span;
+        break;
+      case TokenKind.DOUBLE_QUOTE:
+        stopToken = TokenKind.DOUBLE_QUOTE;
+        _next(); // Skip the DOUBLE_QUOTE.
+        start = _peekToken.span;
+        break;
+      default:
+        if (urlString) {
+          if (_peek() == TokenKind.LPAREN) {
+            _next(); // Skip the LPAREN.
+            start = _peekToken.span;
+          }
+          stopToken = TokenKind.RPAREN;
+        } else {
+          _error('unexpected string', _makeSpan(start));
         }
-        stopToken = TokenKind.RPAREN;
-      } else {
-        _error('unexpected string', _makeSpan(start));
-      }
-      break;
+        break;
     }
 
     // Gobble up everything until we hit our stop token.
     var stringValue = new StringBuffer();
     while (_peek() != stopToken && _peek() != TokenKind.END_OF_FILE) {
       stringValue.write(_next().text);
     }
 
     tokenizer._skipWhitespace = skipWhitespace;
 
     // All characters between quotes is the string.
     if (stopToken != TokenKind.RPAREN) {
-      _next();    // Skip the SINGLE_QUOTE or DOUBLE_QUOTE;
+      _next(); // Skip the SINGLE_QUOTE or DOUBLE_QUOTE;
     }
 
     return stringValue.toString();
   }
 
   // TODO(terry): Should probably understand IE's non-standard filter syntax to
   //              fully support calc, var(), etc.
   /**
    * IE's filter property breaks CSS value parsing.  IE's format can be:
    *
    *    filter: progid:DXImageTransform.MS.gradient(Type=0, Color='#9d8b83');
    *
    * We'll just parse everything after the 'progid:' look for the left paren
    * then parse to the right paren ignoring everything in between.
    */
   processIEFilter(FileSpan startAfterProgidColon) {
     var parens = 0;
 
     while (_peek() != TokenKind.END_OF_FILE) {
       switch (_peek()) {
         case TokenKind.LPAREN:
           _eat(TokenKind.LPAREN);
           parens++;
           break;
         case TokenKind.RPAREN:
           _eat(TokenKind.RPAREN);
           if (--parens == 0) {
-            var tok = tokenizer.makeIEFilter(startAfterProgidColon.start.offset,
-                _peekToken.start);
+            var tok = tokenizer.makeIEFilter(
+                startAfterProgidColon.start.offset, _peekToken.start);
             return new LiteralTerm(tok.text, tok.text, tok.span);
           }
           break;
         default:
           _eat(_peek());
       }
     }
   }
 
   //  Function grammar:
   //
   //  function:     IDENT '(' expr ')'
   //
   processFunction(Identifier func) {
     var start = _peekToken.span;
 
     var name = func.name;
 
     switch (name) {
-    case 'url':
-      // URI term sucks up everything inside of quotes(' or ") or between parens
-      var urlParam = processQuotedString(true);
+      case 'url':
+        // URI term sucks up everything inside of quotes(' or ") or between parens
+        var urlParam = processQuotedString(true);
 
-      // TODO(terry): Better error messge and checking for mismatched quotes.
-      if (_peek() == TokenKind.END_OF_FILE) {
-        _error("problem parsing URI", _peekToken.span);
-      }
+        // TODO(terry): Better error messge and checking for mismatched quotes.
+        if (_peek() == TokenKind.END_OF_FILE) {
+          _error("problem parsing URI", _peekToken.span);
+        }
 
-      if (_peek() == TokenKind.RPAREN) {
-        _next();
-      }
+        if (_peek() == TokenKind.RPAREN) {
+          _next();
+        }
 
-      return new UriTerm(urlParam, _makeSpan(start));
-    case 'calc':
-      // TODO(terry): Implement expression handling...
-      break;
-    case 'var':
-      // TODO(terry): Consider handling var in IE specific filter/progid.  This
-      //              will require parsing entire IE specific syntax e.g.,
-      //              param = value or progid:com_id, etc. for example:
-      //
-      //    var-blur: Blur(Add = 0, Direction = 225, Strength = 10);
-      //    var-gradient: progid:DXImageTransform.Microsoft.gradient"
-      //      (GradientType=0,StartColorStr='#9d8b83', EndColorStr='#847670');
-      var expr = processExpr();
-      if (!_maybeEat(TokenKind.RPAREN)) {
-        _error("problem parsing var expected ), ", _peekToken.span);
-      }
-      if (isChecked &&
-          expr.expressions.where((e) => e is OperatorComma).length > 1) {
-        _error("too many parameters to var()", _peekToken.span);
-      }
+        return new UriTerm(urlParam, _makeSpan(start));
+      case 'calc':
+        // TODO(terry): Implement expression handling...
+        break;
+      case 'var':
+        // TODO(terry): Consider handling var in IE specific filter/progid.  This
+        //              will require parsing entire IE specific syntax e.g.,
+        //              param = value or progid:com_id, etc. for example:
+        //
+        //    var-blur: Blur(Add = 0, Direction = 225, Strength = 10);
+        //    var-gradient: progid:DXImageTransform.Microsoft.gradient"
+        //      (GradientType=0,StartColorStr='#9d8b83', EndColorStr='#847670');
+        var expr = processExpr();
+        if (!_maybeEat(TokenKind.RPAREN)) {
+          _error("problem parsing var expected ), ", _peekToken.span);
+        }
+        if (isChecked &&
+            expr.expressions.where((e) => e is OperatorComma).length > 1) {
+          _error("too many parameters to var()", _peekToken.span);
+        }
 
-      var paramName = expr.expressions[0].text;
+        var paramName = expr.expressions[0].text;
 
-      // [0] - var name, [1] - OperatorComma, [2] - default value.
-      var defaultValues = expr.expressions.length >= 3
-          ? expr.expressions.sublist(2) : [];
-      return new VarUsage(paramName, defaultValues, _makeSpan(start));
-    default:
-      var expr = processExpr();
-      if (!_maybeEat(TokenKind.RPAREN)) {
-        _error("problem parsing function expected ), ", _peekToken.span);
-      }
+        // [0] - var name, [1] - OperatorComma, [2] - default value.
+        var defaultValues =
+            expr.expressions.length >= 3 ? expr.expressions.sublist(2) : [];
+        return new VarUsage(paramName, defaultValues, _makeSpan(start));
+      default:
+        var expr = processExpr();
+        if (!_maybeEat(TokenKind.RPAREN)) {
+          _error("problem parsing function expected ), ", _peekToken.span);
+        }
 
-      return new FunctionTerm(name, name, expr, _makeSpan(start));
+        return new FunctionTerm(name, name, expr, _makeSpan(start));
     }
 
     return null;
   }
 
   Identifier identifier() {
     var tok = _next();
 
     if (!TokenKind.isIdentifier(tok.kind) &&
         !TokenKind.isKindIdentifier(tok.kind)) {
       if (isChecked) {
         _warning('expected identifier, but found $tok', tok.span);
       }
       return new Identifier("", _makeSpan(tok.span));
     }
 
     return new Identifier(tok.text, _makeSpan(tok.span));
   }
 
   // TODO(terry): Move this to base <= 36 and into shared code.
   static int _hexDigit(int c) {
-    if (c >= 48/*0*/ && c <= 57/*9*/) {
+    if (c >= 48 /*0*/ && c <= 57 /*9*/) {
       return c - 48;
-    } else if (c >= 97/*a*/ && c <= 102/*f*/) {
+    } else if (c >= 97 /*a*/ && c <= 102 /*f*/) {
       return c - 87;
-    } else if (c >= 65/*A*/ && c <= 70/*F*/) {
+    } else if (c >= 65 /*A*/ && c <= 70 /*F*/) {
       return c - 55;
     } else {
       return -1;
     }
   }
 
   HexColorTerm _parseHex(String hexText, SourceSpan span) {
     var hexValue = 0;
 
-     for (var i = 0; i < hexText.length; i++) {
+    for (var i = 0; i < hexText.length; i++) {
       var digit = _hexDigit(hexText.codeUnitAt(i));
       if (digit < 0) {
         _warning('Bad hex number', span);
         return new HexColorTerm(new BAD_HEX_VALUE(), hexText, span);
       }
       hexValue = (hexValue << 4) + digit;
     }
 
     // Make 3 character hex value #RRGGBB => #RGB iff:
     // high/low nibble of RR is the same, high/low nibble of GG is the same and
@@ skipping 127 matching lines @@
  * Escapes [text] for use in a CSS string.
  * [single] specifies single quote `'` vs double quote `"`.
  */
 String _escapeString(String text, {bool single: false}) {
   StringBuffer result = null;
 
   for (int i = 0; i < text.length; i++) {
     var code = text.codeUnitAt(i);
     String replace = null;
     switch (code) {
-      case 34/*'"'*/:  if (!single) replace = r'\"'; break;
-      case 39/*"'"*/:  if (single) replace = r"\'"; break;
+      case 34 /*'"'*/ :
+        if (!single) replace = r'\"';
+        break;
+      case 39 /*"'"*/ :
+        if (single) replace = r"\'";
+        break;
     }
 
     if (replace != null && result == null) {
       result = new StringBuffer(text.substring(0, i));
     }
 
     if (result != null) result.write(replace != null ? replace : text[i]);
   }
 
   return result == null ? text : result.toString();
 }