pkg/third_party/html5lib: lots of cleanup

pkg/third_party/html5lib/lib/src/tokenizer.dart

 library tokenizer;
 
 import 'dart:collection';
-import 'dart:math';
 import 'package:html5lib/parser.dart' show HtmlParser;
 import 'package:source_maps/span.dart' show Span, FileSpan;
 import 'constants.dart';
 import 'inputstream.dart';
 import 'token.dart';
 import 'utils.dart';
 
 // Group entities by their first character, for faster lookups
 
 // TODO(jmesserly): we could use a better data structure here like a trie, if
 // we had it implemented in Dart.
 Map<String, List<String>> entitiesByFirstChar = (() {
   var result = {};
-  for (var k in entities.keys) {
+  for (var k in ENTITIES.keys) {
     result.putIfAbsent(k[0], () => []).add(k);
   }
   return result;
 })();
 
 // TODO(jmesserly): lots of ways to make this faster:
 // - use char codes everywhere instead of 1-char strings
 // - use switch instead of contains, indexOf
 // - use switch instead of the sequential if tests
 // - avoid string concat
@@ skipping 167 matching lines @@
     var c = stream.char();
     while (allowed(c) && c != EOF) {
       charStack.add(c);
       c = stream.char();
     }
 
     // Convert the set of characters consumed to an int.
     var charAsInt = parseIntRadix(charStack.join(), radix);
 
     // Certain characters get replaced with others
-    var char = replacementCharacters[charAsInt];
+    var char = REPLACEMENT_CHARACTERS[charAsInt];
     if (char != null) {
       _addToken(new ParseErrorToken(
           "illegal-codepoint-for-numeric-entity",
           messageParams: {"charAsInt": charAsInt}));
     } else if ((0xD800 <= charAsInt && charAsInt <= 0xDFFF)
         || (charAsInt > 0x10FFFF)) {
       char = "\uFFFD";
       _addToken(new ParseErrorToken(
           "illegal-codepoint-for-numeric-entity",
           messageParams: {"charAsInt": charAsInt}));
@@ skipping 81 matching lines @@
       // At this point we have a string that starts with some characters
       // that may match an entity
       String entityName = null;
 
       // Try to find the longest entity the string will match to take care
       // of &noti for instance.
 
       int entityLen;
       for (entityLen = charStack.length - 1; entityLen > 1; entityLen--) {
         var possibleEntityName = charStack.sublist(0, entityLen).join();
-        if (entities.containsKey(possibleEntityName)) {
+        if (ENTITIES.containsKey(possibleEntityName)) {
           entityName = possibleEntityName;
           break;
         }
       }
 
       if (entityName != null) {
         var lastChar = entityName[entityName.length - 1];
         if (lastChar != ";") {
           _addToken(new ParseErrorToken(
               "named-entity-without-semicolon"));
         }
         if (lastChar != ";" && fromAttribute &&
             (isLetterOrDigit(charStack[entityLen]) ||
              charStack[entityLen] == '=')) {
           stream.unget(charStack.removeLast());
           output = "&${charStack.join()}";
         } else {
-          output = entities[entityName];
+          output = ENTITIES[entityName];
           stream.unget(charStack.removeLast());
           output = '${output}${slice(charStack, entityLen).join()}';
         }
       } else {
         _addToken(new ParseErrorToken("expected-named-entity"));
         stream.unget(charStack.removeLast());
         output = "&${charStack.join()}";
       }
     }
     if (fromAttribute) {
@@ skipping 63 matching lines @@
       _addToken(new ParseErrorToken("invalid-codepoint"));
       _addToken(new CharactersToken("\u0000"));
     } else if (data == EOF) {
       // Tokenization ends.
       return false;
     } else if (isWhitespace(data)) {
       // Directly after emitting a token you switch back to the "data
       // state". At that point spaceCharacters are important so they are
       // emitted separately.
       _addToken(new SpaceCharactersToken(
-          '${data}${stream.charsUntil(spaceCharacters, true)}'));
+          '${data}${stream.charsUntil(SPACE_CHARACTERS, true)}'));
       // No need to update lastFourChars here, since the first space will
       // have already been appended to lastFourChars and will have broken
       // any <!-- or --> sequences
     } else {
       var chars = stream.charsUntil("&<\u0000");
       _addToken(new CharactersToken('${data}${chars}'));
     }
     return true;
   }
 
@@ skipping 13 matching lines @@
       // Tokenization ends.
       return false;
     } else if (data == "\u0000") {
       _addToken(new ParseErrorToken("invalid-codepoint"));
       _addToken(new CharactersToken("\uFFFD"));
     } else if (isWhitespace(data)) {
       // Directly after emitting a token you switch back to the "data
       // state". At that point spaceCharacters are important so they are
       // emitted separately.
       _addToken(new SpaceCharactersToken(
-          '${data}${stream.charsUntil(spaceCharacters, true)}'));
+          '${data}${stream.charsUntil(SPACE_CHARACTERS, true)}'));
     } else {
       var chars = stream.charsUntil("&<");
       _addToken(new CharactersToken('${data}${chars}'));
     }
     return true;
   }
 
   bool characterReferenceInRcdata() {
     consumeEntity();
     state = rcdataState;
@@ skipping 536 matching lines @@
     } else {
       stream.unget(data);
       state = scriptDataDoubleEscapedState;
     }
     return true;
   }
 
   bool beforeAttributeNameState() {
     var data = stream.char();
     if (isWhitespace(data)) {
-      stream.charsUntil(spaceCharacters, true);
+      stream.charsUntil(SPACE_CHARACTERS, true);
     } else if (isLetter(data)) {
       _addAttribute(data);
       state = attributeNameState;
     } else if (data == ">") {
       emitCurrentToken();
     } else if (data == "/") {
       state = selfClosingStartTagState;
     } else if (data == EOF) {
       _addToken(new ParseErrorToken("expected-attribute-name-but-got-eof"));
       state = dataState;
@@ skipping 13 matching lines @@
   }
 
   bool attributeNameState() {
     var data = stream.char();
     bool leavingThisState = true;
     bool emitToken = false;
     if (data == "=") {
       state = beforeAttributeValueState;
     } else if (isLetter(data)) {
       _attributeName = '$_attributeName$data'
-          '${stream.charsUntil(asciiLetters, true)}';
+          '${stream.charsUntil(ASCII_LETTERS, true)}';
       leavingThisState = false;
     } else if (data == ">") {
       // XXX If we emit here the attributes are converted to a dict
       // without being checked and when the code below runs we error
       // because data is a dict not a list
       emitToken = true;
     } else if (isWhitespace(data)) {
       state = afterAttributeNameState;
     } else if (data == "/") {
       state = selfClosingStartTagState;
@@ skipping 32 matching lines @@
       if (emitToken) {
         emitCurrentToken();
       }
     }
     return true;
   }
 
   bool afterAttributeNameState() {
     var data = stream.char();
     if (isWhitespace(data)) {
-      stream.charsUntil(spaceCharacters, true);
+      stream.charsUntil(SPACE_CHARACTERS, true);
     } else if (data == "=") {
       state = beforeAttributeValueState;
     } else if (data == ">") {
       emitCurrentToken();
     } else if (isLetter(data)) {
       _addAttribute(data);
       state = attributeNameState;
     } else if (data == "/") {
       state = selfClosingStartTagState;
     } else if (data == "\u0000") {
@@ skipping 10 matching lines @@
     } else {
       _addAttribute(data);
       state = attributeNameState;
     }
     return true;
   }
 
   bool beforeAttributeValueState() {
     var data = stream.char();
     if (isWhitespace(data)) {
-      stream.charsUntil(spaceCharacters, true);
+      stream.charsUntil(SPACE_CHARACTERS, true);
     } else if (data == "\"") {
       _markAttributeValueStart(0);
       state = attributeValueDoubleQuotedState;
     } else if (data == "&") {
       state = attributeValueUnQuotedState;
       stream.unget(data);
       _markAttributeValueStart(0);
     } else if (data == "'") {
       _markAttributeValueStart(0);
       state = attributeValueSingleQuotedState;
@@ skipping 80 matching lines @@
       state = dataState;
     } else if ('"\'=<`'.contains(data)) {
       _addToken(new ParseErrorToken(
           "unexpected-character-in-unquoted-attribute-value"));
       _attributeValue = '$_attributeValue$data';
     } else if (data == "\u0000") {
       _addToken(new ParseErrorToken("invalid-codepoint"));
       _attributeValue = '${_attributeValue}\uFFFD';
     } else {
       _attributeValue = '$_attributeValue$data'
-          '${stream.charsUntil("&>\"\'=<`$spaceCharacters")}';
+          '${stream.charsUntil("&>\"\'=<`$SPACE_CHARACTERS")}';
     }
     return true;
   }
 
   bool afterAttributeValueState() {
     var data = stream.char();
     if (isWhitespace(data)) {
       state = beforeAttributeNameState;
     } else if (data == ">") {
       emitCurrentToken();
@@ skipping 662 matching lines @@
     }
 
     if (data.length > 0) {
       _addToken(new CharactersToken(data.join()));
     }
     state = dataState;
     return true;
   }
 }