Update charted to 0.4.8 and roll

packages/csslib/lib/src/tokenizer.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.
 
 part of csslib.parser;
 
 class Tokenizer extends TokenizerBase {
   /** U+ prefix for unicode characters. */
   final UNICODE_U = 'U'.codeUnitAt(0);
   final UNICODE_LOWER_U = 'u'.codeUnitAt(0);
@@ skipping 79 matching lines @@
       case TokenChar.RBRACK:
         if (_maybeEatChar(TokenChar.RBRACK) &&
             _maybeEatChar(TokenChar.GREATER)) {
           // ]]>
           return next();
         }
         return _finishToken(TokenKind.RBRACK);
       case TokenChar.HASH:
         return _finishToken(TokenKind.HASH);
       case TokenChar.PLUS:
-        if (maybeEatDigit()) return finishNumber();
+        if (_nextCharsAreNumber(ch)) return finishNumber();
         return _finishToken(TokenKind.PLUS);
       case TokenChar.MINUS:
         if (inSelectorExpression || unicodeRange) {
           // If parsing in pseudo function expression then minus is an operator
           // not part of identifier e.g., interval value range (e.g. U+400-4ff)
           // or minus operator in selector expression.
           return _finishToken(TokenKind.MINUS);
-        } else if (maybeEatDigit()) {
+        } else if (_nextCharsAreNumber(ch)) {
           return finishNumber();
         } else if (TokenizerHelpers.isIdentifierStart(ch)) {
           return finishIdentifier();
         }
         return _finishToken(TokenKind.MINUS);
       case TokenChar.GREATER:
         return _finishToken(TokenKind.GREATER);
       case TokenChar.TILDE:
         if (_maybeEatChar(TokenChar.EQUALS)) {
           return _finishToken(TokenKind.INCLUDES); // ~=
@@ skipping 76 matching lines @@
             var t = finishHexNumber();
             // Any question marks then it's a HEX_RANGE not HEX_NUMBER.
             if (maybeEatQuestionMark()) finishUnicodeRange();
             return t;
           } else if (maybeEatQuestionMark()) {
             // HEX_RANGE U+N???
             return finishUnicodeRange();
           } else {
             return _errorToken();
           }
-        } else if ((ch == UNICODE_U || ch == UNICODE_LOWER_U) &&
+        } else if (_inString &&
+            (ch == UNICODE_U || ch == UNICODE_LOWER_U) &&
             (_peekChar() == UNICODE_PLUS)) {
+          // `_inString` is misleading. We actually DON'T want to enter this
+          // block while tokenizing a string, but the parser sets this value to
+          // false while it IS consuming tokens within a string.
+          //
           // Unicode range: U+uNumber[-U+uNumber]
           //   uNumber = 0..10FFFF
           _nextChar(); // Skip +
           _startIndex = _index; // Starts at the number
           return _finishToken(TokenKind.UNICODE_RANGE);
         } else if (varDef(ch)) {
           return _finishToken(TokenKind.VAR_DEFINITION);
         } else if (varUsage(ch)) {
           return _finishToken(TokenKind.VAR_USAGE);
         } else if (TokenizerHelpers.isIdentifierStart(ch)) {
@@ skipping 36 matching lines @@
           ? TokenKind.IMPORTANT
           : -1;
     }
 
     return tokId >= 0 ? tokId : TokenKind.IDENTIFIER;
   }
 
   Token finishIdentifier() {
     // If we encounter an escape sequence, remember it so we can post-process
     // to unescape.
-    var chars = [];
+    var chars = <int>[];
 
     // backup so we can start with the first character
     int validateFrom = _index;
     _index = _startIndex;
     while (_index < _text.length) {
       int ch = _text.codeUnitAt(_index);
 
       // If the previous character was "\" we need to escape. T
       // http://www.w3.org/TR/CSS21/syndata.html#characters
       // if followed by hexadecimal digits, create the appropriate character.
@@ skipping 133 matching lines @@
           if (_maybeEatChar(TokenChar.GREATER)) {
             if (_inString) {
               return next();
             } else {
               return _finishToken(TokenKind.HTML_COMMENT);
             }
           }
         }
       }
     }
-    return _errorToken();
   }
 }
 
 /** Static helper methods. */
 class TokenizerHelpers {
   static bool isIdentifierStart(int c) {
     return isIdentifierStartExpr(c) || c == 45 /*-*/;
   }
 
   static bool isDigit(int c) {
@@ skipping 11 matching lines @@
   }
 
   /** Pseudo function expressions identifiers can't have a minus sign. */
   static bool isIdentifierStartExpr(int c) {
     return ((c >= 97 /*a*/ && c <= 122 /*z*/) ||
         (c >= 65 /*A*/ && c <= 90 /*Z*/) ||
         // Note: Unicode 10646 chars U+00A0 or higher are allowed, see:
         // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
         // http://www.w3.org/TR/CSS21/syndata.html#characters
         // Also, escaped character should be allowed.
-        c == 95 /*_*/ || c >= 0xA0 || c == 92 /*\*/);
+        c == 95 /*_*/ ||
+        c >= 0xA0 ||
+        c == 92 /*\*/);
   }
 
   /** Pseudo function expressions identifiers can't have a minus sign. */
   static bool isIdentifierPartExpr(int c) {
     return (isIdentifierStartExpr(c) || isDigit(c));
   }
 }