anchor.diff:      if ((_U.$a <= next && next <= _U.$z) ||
           (_U.$A <= next && next <= _U.$Z)) {
         if (identical(_U.$r, next)) {
  -        return tokenizeRawStringKeywordOrIdentifier(next);
  -      }
  -      return tokenizeKeywordOrIdentifier(next, true);
  +        return _tokenizeRawStringKeywordOrIdentifier(next);
  +      }
  +      return _tokenizeKeywordOrIdentifier(next, true);
       }
       
       if (identical(next, _U.$DQ) || identical(next, _U.$SQ)) {
  -      return tokenizeString(next, byteOffset, false);
  +      return _tokenizeString(next, _byteOffset, false);
       }
       
       if (identical(next, _U.$SLASH)) {
  -      return tokenizeSlashOrComment(next);
  +      return _tokenizeSlashOrComment(next);
       }
       
       if (identical(next, _U.$EOF)) {
  
positive.code:     }
      
      if (identical(next, _U.$SEMICOLON)) {
        nextTokenIsImportant = false;
      }
      
      // We only need to check for chars we find important.
      return advance(); // Ignore and get next char
    }
    
    int tokenizeRawStringKeywordOrIdentifier(int next) {
      _log("Running tokenizeRawStringKeywordOrIdentifier($next)");
      
      int nextnext = peek();
      if (identical(nextnext, _U.$DQ) || identical(nextnext, _U.$SQ)) {
        int start = byteOffset;
        next = advance();
        return tokenizeString(next, start, true);
      }
      return tokenizeKeywordOrIdentifier(next, true);
    }
    
    int tokenizeKeywordOrIdentifier(int next, bool allowDollar) {
      _log("Running tokenizeKeywordOrIdentifier($next, $allowDollar)");
      
      StringBuffer state = new StringBuffer();
      int start = byteOffset;
      
      while ((_U.$a <= next && next <= _U.$z) || 
             (_U.$A <= next && next <= _U.$Z)) {
        state.writeCharCode(next);
        next = advance();
      }
      
      // BEGIN: Keyword check (we only need: import, part, export
  
negative.code: part of distributed_dart;
  
  /**
   * Simple scanner implementation to scan for dependencies in Dart files. The
   * scanner will automatically stop when no more import statements is possible.
   * More information can be found in the
   * [Dart Language Specification](http://goo.gl/rhiyX).
   * 
   * _Highly inspired by the Dart project's own 
   * [scanner.dart](http://goo.gl/Ut5w7). The main difference is we don't need to
   * scan for the whole language but only need a small subset. Also we want to
   * make it easy to get details like import statements directly without need of
   * parsing tokens._
   */
  class Scanner {
    List<int> _bytes;
    int _byteOffset;
    List<String> _dependencies;
    
    /* This is a primitive way to simulate token system. Because we only need to 
     * know if the next string is an import, export or part operation is should 
     * be enough.
     * 
     * If nextTokenIsImportant is true we need to take the next string. Also, if
     * we find a String and nextTokenIsImportant is false we can stop the scan.
     */
    bool _nextTokenIsImportant;
    
    /**
     * Create new instance of [Scanner] to parse a instance of [Runes]. The 
     * instance of [Runes] should contain the content of a syntax valid Dart file.
     */
    Scanner(Runes sourcecode) {
      _bytes = sourcecode.toList(growable: false);
    }
    
    /**
     * Scan instance of [Runes] given on initialization. Returns a list of Strings
     * where each string is the URI from an import statement. Please notice the
     * possibility to get URI's like 'dart:async'.
     */
    List<String> getDependencies() {
      // Reset scanner instance (if someone want to call getDependencies() twice.
      _dependencies = new List<String>();
      _byteOffset = -1;
      _nextTokenIsImportant = false;
      
      _log("Running _scan()");
      int next = _advance();
      while (!identical(next, _U.$EOF)) {
        next = _bigSwitch(next);
        _log("bigSwich output = $next");
      }
      
      return _dependencies;
    }
    
    int _nextByte() => _byteAt(++_byteOffset);
  
    int _peek() => _byteAt(_byteOffset + 1);
  
    int _byteAt(int index) => _bytes[index];
    
    int _advance() => _bytes[++_byteOffset];
    
    int _bigSwitch(int next) {
      _log("Running _bigSwitch($next)");
      if (identical(next, _U.$SPACE) || identical(next, _U.$TAB)
          || identical(next, _U.$LF) || identical(next, _U.$CR)) {
        // Do nothing as we don't collect white space.
        next = _advance();
        while (identical(next, _U.$SPACE)) {
          next = _advance();
        }
        return next;
      }
  