anchor.diff:  
     int get last {
       if (string.length == 0) {
  -      throw new StateError("No elements.");
  +      throw new StateError('No elements.');
       }
       int length = string.length;
       int code = string.codeUnitAt(length - 1);
  
positive.code:    * [onNonMatch] is omitted, the non-matching part is used.
     *
     * Then all the converted parts are combined into the resulting string.
     */
    String splitMapJoin(Pattern pattern,
                        {String onMatch(Match match),
  
negative.code: part of dart.core;
  
  /**
   * A sequence of characters.
   *
   * A string can be either single or multiline. Single line strings are
   * written using matching single or double quotes, and multiline strings are
   * written using triple quotes. The following are all valid Dart strings:
   *
   *     'Single quotes';
   *     "Double quotes";
   *     'Double quotes in "single" quotes';
   *     "Single quotes in 'double' quotes";
   *
   *     '''A
   *     multiline
   *     string''';
   *
   *     """
   *     Another
   *     multiline
   *     string""";
   *
   * Strings are immutable. Although you cannot change a string, you can perform
   * an operation on a string and assign the result to a new string:
   *
   *     var string = 'Dart is fun';
   *     var newString = string.substring(0, 5);
   *
   * You can use the plus (`+`) operator to concatenate strings:
   *
   *     'Dart ' + 'is ' + 'fun!'; // 'Dart is fun!'
   *
   * You can also use adjacent string literals for concatenation:
   *
   *     'Dart ' 'is ' 'fun!';    // 'Dart is fun!'
   *
   * You can use `${}` to interpolate the value of Dart expressions
   * within strings. The curly braces can be omitted when evaluating identifiers:
   *
   *     string = 'dartlang';
   *     '$string has ${string.length} letters'; // 'dartlang has 8 letters'
   *
   * A string is represented by a sequence of Unicode UTF-16 code units
   * accessible through the [codeUnitAt] or the [codeUnits] members:
   *
   *     string = 'Dart';
   *     string.codeUnitAt(0); // 68
   *     string.codeUnits;     // [68, 97, 114, 116]
   *
   * The string representation of code units is accessible through the index
   * operator:
   *
   *     string[0];            // 'D'
   *
   * The characters of a string are encoded in UTF-16. Decoding UTF-16, which
   * combines surrogate pairs, yields Unicode code points. Following a similar
   * terminology to Go, we use the name 'rune' for an integer representing a
   * Unicode code point. Use the [runes] property to get the runes of a string:
   *
   *     string.runes.toList(); // [68, 97, 114, 116]
   *
   * For a character outside the Basic Multilingual Plane (plane 0) that is
   * composed of a surrogate pair, [runes] combines the pair and returns a
   * single integer.  For example, the Unicode character for a
   * musical G-clef ('𝄞') with rune value 0x1D11E consists of a UTF-16 surrogate
   * pair: `0xD834` and `0xDD1E`. Using [codeUnits] returns the surrogate pair,
   * and using `runes` returns their combined value:
   *
   *     var clef = '\u{1D11E}';
   *     clef.codeUnits;         // [0xD834, 0xDD1E]
   *     clef.runes.toList();    // [0x1D11E]
   *
   * The String class can not be extended or implemented. Attempting to do so
   * yields a compile-time error.
   *
   * ## Other resources
   *
   * See [StringBuffer] to efficiently build a string incrementally. See
   * [RegExp] to work with regular expressions.
   *
   * Also see:
  
   * * [Dart Cookbook](https://www.dartlang.org/docs/cookbook/#strings)
   * for String examples and recipes.
   * * [Dart Up and Running]
   * (https://www.dartlang.org/docs/dart-up-and-running/contents/ch03.html#ch03-strings-and-regular-expressions)
   */
  abstract class String implements Comparable<String>, Pattern {
    /**
     * Allocates a new String for the specified [charCodes].
     *
     * The [charCodes] can be UTF-16 code units or runes. If a char-code value is
     * 16-bit, it is copied verbatim:
     *
     *     new String.fromCharCodes([68]); // 'D'
     *
     * If a char-code value is greater than 16-bits, it is decomposed into a
     * surrogate pair:
     *
     *     var clef = new String.fromCharCodes([0x1D11E]);
     *     clef.codeUnitAt(0); // 0xD834
     *     clef.codeUnitAt(1); // 0xDD1E
     */
    external factory String.fromCharCodes(Iterable<int> charCodes);
  
    /**
     * Allocates a new String for the specified [charCode].
     *
     * If the [charCode] can be represented by a single UTF-16 code unit, the new
     * string contains a single code unit. Otherwise, the [length] is 2 and
     * the code units form a surrogate pair. See documentation for
     * [fromCharCodes].
     *
     * Creating a String with half of a surrogate pair is legal but generally
     * discouraged.
     */
    factory String.fromCharCode(int charCode) {
      List<int> charCodes = new List<int>.filled(1, charCode);
  