anchor.diff:   */
   class _StringIterator implements Iterator<String> {
     final String input;
  -  int index = -1;
  -  inBounds(i) => i >= 0 && i < input.length;
  -  _StringIterator(this.input);
  -  String get current => inBounds(index) ? input[index] : null;
  -
  -  bool moveNext() => inBounds(++index);
  -  String get peek => inBounds(index + 1) ? input[index + 1] : null;
  +  int nextIndex = 0;
  +  String _current = null;
  +
  +  _StringIterator(input) : input = _validate(input);
  +
  +  String get current => _current;
  +
  +  bool moveNext() {
  +    if (nextIndex >= input.length) {
  +      _current = null;
  +      return false;
  +    }
  +    _current = input[nextIndex++];
  +    return true;
  +  }
  +
  +  String get peek => nextIndex >= input.length ? null : input[nextIndex];
  +
     Iterator<String> get iterator => this;
  +
  +  static String _validate(input) {
  +    if (input is! String) throw new ArgumentError(input);
  +    return input;
  +  }
  +
   }
  
positive.code:    * continue to look for additional trunk characters or false if we have
     * reached the end.
     */
    bool parseTrunkCharacter() {
      var ch = pattern.current;
      switch (ch) {
        case _PATTERN_DIGIT:
  
negative.code:     // If the int part is larger than 2^52 and we're on Javascript (so it's
      // really a float) it will lose precision, so pad out the rest of it
      // with zeros. Check for Javascript by seeing if an integer is double.
      var paddingDigits = '';
      if (1 is double && intValue > _maxInt) {
          var howManyDigitsTooBig = (log(intValue) / LN10).ceil() - 16;
          var divisor = pow(10, howManyDigitsTooBig).round();
          paddingDigits = symbols.ZERO_DIGIT * howManyDigitsTooBig.toInt();
  
          intValue = (intValue / divisor).truncate();
      }
      var integerDigits = "${intValue}${paddingDigits}".codeUnits;
  