anchor.diff:    /**
      * Gets the character (as a single-code-unit [String]) at the given [index].
      *
  -   * The returned string represents exactly one UTF-16 code unit which may be
  -   * half of a surrogate pair. 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 the index-operator on this string yields
  -   * a String with half of a surrogate pair:
  -   *
  -   *     var clef = "\u{1D11E}";
  -   *     clef.length;  // => 2
  -   *     clef.runes.first == 0x1D11E;  // => true
  -   *     clef.runes.length;  // => 1
  -   *     clef.codeUnitAt(0);  // => 0xD834
  -   *     clef.codeUnitAt(1);  // => 0xDD1E
  -   *     // The following strings are halves of a UTF-16 surrogate pair and
  -   *     // thus invalid UTF-16 strings:
  -   *     clef[0];  // => a string of length 1 with code-unit value 0xD834.
  -   *     clef[1];  // => a string of length 1 with code-unit value 0xDD1E.
  +   * The returned string represents exactly one UTF-16 code unit, which may be
  +   * half of a surrogate pair. A single member of a surrogate pair is an
  +   * invalid UTF-16 string:
  +   *
  +   *     var clef = '\u{1D11E}';
  +   *     // These represent invalid UTF-16 strings.
  +   *     clef[0].codeUnits;      // [0xD834]
  +   *     clef[1].codeUnits;      // [0xDD1E]
      *
      * This method is equivalent to
      * `new String.fromCharCode(this.codeUnitAt(index))`.
  
positive.code:    * The length of the string.
     *
     * Returns the number of UTF-16 code units in this string. The number
     * of [runes] might be less, if the string contains characters outside
     * the basic multilingual plane (plane 0).
     */
    int get length;
  
    /**
     * Returns whether the two strings are equal.
     *
     * This method compares each individual code unit of the strings.
     * Equivalently (for strings that are well-formed UTF-16) it compares each
     * individual rune (code point).  It does not check for Unicode equivalence.
     * For example the two following strings both represent the string "Amélie"
     * but, due to their different encoding will not return equal.
     *
     *     "Am\xe9lie"
     *     "Ame\u{301}lie"
     *
     * In the first string the "é" is encoded as a single unicode code unit (also
     * a single rune), whereas the second string encodes it as "e" with the
     * combining accent character "◌́".
     */
    bool operator ==(var other);
  
    /**
     * Returns whether this string ends with [other].
     */
    bool endsWith(String other);
  
    /**
     * Returns whether this string starts with a match of [pattern].
     *
     * If [index] is provided, instead check if the substring starting
     * at that index starts with a match of [pattern].
     *
     * It is an error if [index] is negative or greater than [length].
     *
     * A [RegExp] containing "^" will not match if the [index] is greater than
     * zero. The pattern works on the string as a whole, and does not extract
     * a substring starting at [index] first. That is.
     *     "abc".startsWith(new RegExp("^.", 1)) == false
     */
    bool startsWith(Pattern pattern, [int index = 0]);
  
    /**
     * Returns the first position of a match of [pattern] in this string,
     * starting at [start] (inclusive).
     *
     * Returns -1 if a match could not be found.
     *
     * It is an error if start is negative or greater than [length].
     */
    int indexOf(Pattern pattern, [int start]);
  
    /**
     * Returns the last position of a match [pattern] in this string, searching
     * backward starting at [start] (inclusive).
     *
     * Returns -1 if [other] could not be found.
     *
     * It is an error if start is negative or greater than [length].
     */
    int lastIndexOf(Pattern pattern, [int start]);
  
    /**
     * Returns whether this string is empty.
     */
    bool get isEmpty;
  
    /**
     * Returns whether this string is not empty.
     */
    bool get isNotEmpty;
  
    /**
     * Creates a new string by concatenating this string with [other].
     *
     * A sequence of strings can be concatenated by using [Iterable.join]:
     *
     *     var strings = ['foo', 'bar', 'geez'];
     *     var concatenated = strings.join();
     */
    String operator +(String other);
  
    /**
     * Returns a substring of this string in the given range.
     * [startIndex] is inclusive and [endIndex] is exclusive.
     */
    String substring(int startIndex, [int endIndex]);
  
    /**
     * Removes leading and trailing whitespace from a string.
     *
     * If the string contains leading or trailing whitespace a new string with no
     * leading and no trailing whitespace is returned. Otherwise, the string
     * itself is returned.
     *
     * Whitespace is defined by the Unicode White_Space property (as defined in
     * version 6.2 or later) and the BOM character, 0xFEFF.
  
negative.code:   String replaceAll(Pattern from, String replace);
  
    /**
     * Replace all substrings that match [from] by a string computed from the
     * match.
     *
     * Returns a new string in which the non-overlapping substrings that match
     * [from] (the ones iterated by `from.allMatches(thisString)`) are replaced
     * by the result of calling [replace] on the corresponding [Match] object.
     *
     * This can be used to replace matches with new content that depends on the
     * match, unlike [replaceAll] where the replacement string is always the same.
     *
     * The [replace] function is called with the [Match] generated
     * by the pattern, and its result is used as replacement.
     *
     * The function defined below converts each word in a string to simplified
     * 'pig latin' using [replaceAllMapped]:
     *
     *     pigLatin(String words) => words.replaceAllMapped(
     *         new RegExp(r'\b(\w*?)([aeiou]\w*)', caseSensitive: false),
     *         (Match m) => "${m[2]}${m[1]}${m[1].isEmpty ? 'way' : 'ay'}");
     *
     *     pigLatin('I have a secret now!'); // 'Iway avehay away ecretsay ownay!'
     */
    String replaceAllMapped(Pattern from, String replace(Match match));
  
    /**
     * Splits the string at matches of [pattern]. Returns
     * a list of substrings.
     *
     * Splitting with an empty string pattern (`''`) splits at UTF-16 code unit
     * boundaries and not at rune boundaries:
     *
     *     var string = 'Pub';
     *     string.split('');                       // ['P', 'u', 'b']
     *
     *     string.codeUnits.map((unit) {
     *       return new String.fromCharCode(unit);
     *     }).toList();                            // ['P', 'u', 'b']
     *
     *     // String made up of two code units, but one rune.
     *     string = '\u{1D11E}';
     *     string.split('').length;                 // 2
     *
     * You should [map] the runes unless you are certain that the string is in
     * the basic multilingual plane (meaning that each code unit represents a
     * rune):
     *
     *     string.runes.map((rune) => new String.fromCharCode(rune));
     */
    List<String> split(Pattern pattern);
  
    /**
     * Splits the string, converts its parts, and combines them into a new
     * string.
     *
     * [pattern] is used to split the string into parts and separating matches.
     *
     * Each match is converted to a string by calling [onMatch]. If [onMatch]
     * is omitted, the matched string is used.
  