anchor.diff:      }
       return sum;
     }
  -  
  +
     String _categorySelector(String category, int itemCount) {
       if (category == 'size' || category == 'errorCount') {
         List<int> maxField = cuttoffs[category];
         int counter = 0;
  -      while(counter < maxField.length) {
  +      while (counter < maxField.length) {
           if (itemCount < maxField[counter]) {
             return '${category}-${counter}';
           }
           counter++;
         }
         return '${category}-${counter - 1}';
  -    }
  -    else {
  +    } else {
         return null;
       }
     }
  -  
  +
     String _wordSelector(String category) {
       if (categories.containsKey(category)) {
         List<String> returnSet = categories[category];
         return returnSet.elementAt(randomizer % returnSet.length);
  -    }
  -    else {
  +    } else {
         return null;
       }
     }
  -  
  +
     String _sentenceFiller(String word, [int size]) {
       if (size != null) {
         return _wordSelector(_categorySelector(word, size));
  -    }
  -    else {
  +    } else {
         return _wordSelector(word);
       }
     }
  -  
  +
     String _additionList(List<String> list) {
       if (list.length == 0) return '';
  -        String englishList = ' Also, mentions ';
  -        for (int i = 0; i < list.length; i++) {
  -          englishList += list[i];
  -          if (i < list.length - 2) {
  -            englishList += ', ';
  -          }
  -          if (i == list.length - 2) {
  -            if (i != 0) {
  -              englishList += ',';
  -            }
  -            englishList += ' and ';
  -          }
  +    String englishList = ' Also, mentions ';
  +    for (int i = 0; i < list.length; i++) {
  +      englishList += list[i];
  +      if (i < list.length - 2) {
  +        englishList += ', ';
  +      }
  +      if (i == list.length - 2) {
  +        if (i != 0) {
  +          englishList += ',';
           }
  -        englishList += '. ';
  -        return englishList;
  -  }
  -  
  +        englishList += ' and ';
  +      }
  +    }
  +    englishList += '. ';
  +    return englishList;
  +  }
  +
     List<String> _additionSearch() {
       List<String> features = new List<String>();
  -    for (String feature in  additionKeyWords.keys) {
  +    for (String feature in additionKeyWords.keys) {
         if (_code.contains(feature)) {
           features.add(additionKeyWords[feature]);
         }
       }
       return features;
     }
  -  
  +
     List<String> _codeSearch() {
       List<String> features = new List<String>();
  -    for (String feature in  codeKeyWords.keys) {
  +    for (String feature in codeKeyWords.keys) {
         if (_code.contains(feature)) {
           features.add(codeKeyWords[feature]);
         }
       }
       return features;
     }
  -  
  -  String _featureList (List<String> list) {
  +
  +  String _featureList(List<String> list) {
       if (list.length == 0) return '. ';
       String englishList = ', and ${_sentenceFiller('use')} use of ';
       for (int i = 0; i < list.length; i++) {
  
positive.code:   Source at ${issue.sourceName}.\n
    Located at line: ${issue.line}.\n
    ''';
      }
    }
  
  class _SummarizeToken {
    int linesCode;
  
negative.code:   String _html;
    bool resultsPresent;
    int randomizer;
  
    static Map<String, List<int>> cuttoffs = {
      'size': [8, 30, 1000], //0-7 = small, 8 - 29 = decent, 29+ = gigantic
      'errorCount': [1, 5, 100]
    };
  
    static Map<String, String> codeKeyWords = {
      'await': 'await',
      'async': 'async',
      'rpc': 'RESTful serverside app'
    };
  
    static Map<String, String> additionKeyWords = {
      'pirate': 'pirates',
      'bird': 'birds',
      'llama': 'llamas',
    };
  
    static Map<String, List<String>> categories = {
      /// This [size] [codeQuantifier] contains [error] errors and warnings.
      'size-2': [
        'gigantic',
        'Jupiterian sized',
        'immense',
        'massive',
        'enormous',
        'huge',
        'epic',
        'humongous'
      ],
      'size-1': [
        'decently sized',
        'exceptional',
        'awesome',
        'amazing',
        'visionary',
        'legendary'
      ],
      'size-0': ['itty-bitty', 'miniature', 'tiny', 'pint-sized'],
      'compiledQuantifier': ['DART program', 'pad'],
      'failedQuantifier': [
        'assemblage of characters',
        'series of strings',
        'grouping of letters'
      ],
      'errorCount-2': [
        'many',
        'a motherload of',
        'copious amounts of',
        'unholy quantities of'
      ],
      'errorCount-1': [
        'some',
        'a few',
        'sparse amounts of',
        'very few instances of'
      ],
      'errorCount-0': ['zero', 'no', 'a nonexistent amount of', '0.0000', '0'],
      'use': ['demonstrates', 'contains', 'illustrates', 'depicts'],
      'code-0': ['it'],
      'code-1': ['It'],
    };
  
    Summarizer(String input,
        {String html, String css, AnalysisResults analysis}) {
      if (input == null) throw new ArgumentError('Input cannot be null.');
      resultsPresent = !(analysis == null);
      _code = input;
  