diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..c078e2b
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,14 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Dart",
+            "program": "bin/main.dart",
+            "request": "launch",
+            "type": "dart"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 456ba84..94d3cc7 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,4 @@
 also know as [Unicode (extended) grapheme clusters](https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries).
 
 The `Characters` class allows access to the individual characters of a string,
-and a way to navigate back and forth between them.
-It also has a set of utility functions for inspecting and modifying strings
-without breaking up graphemes clusters.
+and a way to navigate back and forth between them using a `CharacterRange`.
diff --git a/benchmark/benchmark.dart b/benchmark/benchmark.dart
new file mode 100644
index 0000000..5345b9d
--- /dev/null
+++ b/benchmark/benchmark.dart
@@ -0,0 +1,99 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Benchmark of efficiency of grapheme cluster operations.
+
+import "package:characters/characters.dart";
+
+import "../test/src/text_samples.dart";
+
+double bench(int Function() action, int ms) {
+  int elapsed = 0;
+  int count = 0;
+  var stopwatch = Stopwatch()..start();
+  do {
+    count += action();
+    elapsed = stopwatch.elapsedMilliseconds;
+  } while (elapsed < ms);
+  return count / elapsed;
+}
+
+int iterateIndicesOnly() {
+  int graphemeClusters = 0;
+  var char = Characters(hangul).iterator;
+  while (char.moveNext()) graphemeClusters++;
+  char = Characters(genesis).iterator;
+  while (char.moveNext()) graphemeClusters++;
+  return graphemeClusters;
+}
+
+int iterateStrings() {
+  int codeUnits = 0;
+  var char = Characters(hangul).iterator;
+  while (char.moveNext()) codeUnits += char.current.length;
+  char = Characters(genesis).iterator;
+  while (char.moveNext()) codeUnits += char.current.length;
+  return codeUnits;
+}
+
+int reverseStrings() {
+  var revHangul = reverse(hangul);
+  var rev2Hangul = reverse(revHangul);
+  if (hangul != rev2Hangul || hangul == revHangul) throw "Bad reverse";
+
+  var revGenesis = reverse(genesis);
+  var rev2Genesis = reverse(revGenesis);
+  if (genesis != rev2Genesis || genesis == revGenesis) throw "Bad reverse";
+
+  return (hangul.length + genesis.length) * 2;
+}
+
+int replaceStrings() {
+  int count = 0;
+  {
+    const language = "한글";
+    assert(language.length == 6);
+    var chars = Characters(hangul);
+    var replaced =
+        chars.replaceAll(Characters(language), Characters("Hangul!"));
+    count += replaced.string.length - hangul.length;
+  }
+  {
+    var chars = Characters(genesis);
+    var replaced = chars.replaceAll(Characters("And"), Characters("Also"));
+    count += replaced.string.length - genesis.length;
+  }
+  return count;
+}
+
+String reverse(String input) {
+  var chars = Characters(input);
+  var buffer = StringBuffer();
+  for (var it = chars.iteratorAtEnd; it.moveBack();) {
+    buffer.write(it.current);
+  }
+  return buffer.toString();
+}
+
+void main(List<String> args) {
+  int count = 1;
+  if (args.isNotEmpty) count = int.tryParse(args[0]) ?? 1;
+
+  // Warmup.
+  bench(iterateIndicesOnly, 250);
+  bench(iterateStrings, 250);
+  bench(reverseStrings, 250);
+  bench(replaceStrings, 250);
+
+  for (int i = 0; i < count; i++) {
+    var performance = bench(iterateIndicesOnly, 2000);
+    print("Index Iteration: $performance gc/ms");
+    performance = bench(iterateStrings, 2000);
+    print("String Iteration: $performance cu/ms");
+    performance = bench(reverseStrings, 2000);
+    print("String Reversing: $performance cu/ms");
+    performance = bench(replaceStrings, 2000);
+    print("String Replacing: $performance changes/ms");
+  }
+}
diff --git a/lib/src/characters.dart b/lib/src/characters.dart
index 40ddbd2..3e5170c 100644
--- a/lib/src/characters.dart
+++ b/lib/src/characters.dart
@@ -2,12 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import "dart:collection";
-
-import "grapheme_clusters/constants.dart";
-import "grapheme_clusters/breaks.dart";
-
-part "characters_impl.dart";
+import "characters_impl.dart";
 
 /// The characters of a string.
 ///
@@ -20,30 +15,37 @@
 /// the elements can be computed eagerly, and in that case the
 /// operation returns a new `Characters` object.
 ///
-/// A `Characters` also supports operations based on
-/// string indices into the underlying string.
-///
-/// Inspection operations like [indexOf] or [lastIndexAfter]
-/// returns such indices which are guranteed to be at character
-/// boundaries.
-/// Most such operations use the index as starting point,
-/// but will still only work on entire characters.
-/// A few, like [substring] and [replaceSubstring], work directly
-/// on the underlying string, independently of character
-/// boundaries.
+/// The [iterator] provided by [Characters] is a [CharacterRange]
+/// which allows iterating the independent characters in both directions,
+/// but which also provides ways to select other ranges of characters
+/// in different ways.
 abstract class Characters implements Iterable<String> {
   /// Creates a [Characters] allowing iteration of
   /// the characters of [string].
-  factory Characters(String string) = _Characters;
+  factory Characters(String string) = StringCharacters;
 
   /// The string to iterate over.
   String get string;
 
-  /// A specialized character iterator.
+  /// Iterator over the characters of this string.
+  ///
+  /// Returns [CharacterRange] positioned before the first character
+  /// of this [Characters].
   ///
   /// Allows iterating the characters of [string] as a plain iterator,
-  // as well as controlling the iteration in more detail.
-  Character get iterator;
+  /// using [CharacterRange.moveNext],
+  /// as well as controlling the iteration in more detail.
+  CharacterRange get iterator;
+
+  /// Iterator over the characters of this string.
+  ///
+  /// Returns [CharacterRange] positioned after the last character
+  /// of this [Characters].
+  ///
+  /// Allows iterating the characters of [string] backwards
+  /// using [CharacterRange.movePrevious],
+  /// as well as controlling the iteration in more detail.
+  CharacterRange get iteratorAtEnd;
 
   /// Whether [Character] is an element of this sequence of
   /// characters.
@@ -58,83 +60,32 @@
   /// as a subsequence.
   bool containsAll(Characters other);
 
-  /// Whether [other] is an initial subsequence of this sequence
-  /// of characters.
+  /// Whether this string starts with the characters of [other].
   ///
-  /// If [startIndex] is provided, then checks whether
-  /// [other] is an initial subsequence of the characters
-  /// starting at the character boundary [startIndex].
-  ///
-  /// Returns `true` if [other] is a sub-sequence of this sequence of
-  /// characters startings at the character boundary [startIndex].
-  /// Returns `false` if [startIndex] is not a character boundary,
-  /// or if [other] does not occur at that position.
-  bool startsWith(Characters other, [int startIndex = 0]);
+  /// Returns `true` if [other] the characters of [other]
+  /// are also the first characters of this string,
+  /// and `false` otherwise.
+  bool startsWith(Characters other);
 
-  /// Whether [other] is an trailing subsequence of this sequence
-  /// of characters.
+  /// Whether this string ends with the characters of [other].
   ///
-  /// If [endIndex] is provided, then checks whether
-  /// [other] is a trailing subsequence of the characters
-  /// starting at the character boundary [endIndex].
-  ///
-  /// Returns `true` if [other] is a sub-sequence of this sequence of
-  /// characters startings at the character boundary [endIndex].
-  /// Returns `false` if [endIndex] is not a character boundary,
-  /// or if [other] does not occur at that position.
-  bool endsWith(Characters other, [int endIndex]);
+  /// Returns `true` if [other] the characters of [other]
+  /// are also the last characters of this string,
+  /// and `false` otherwise.
+  bool endsWith(Characters other);
 
-  /// The string index before the first place where [other] occurs as
-  /// a subsequence of these characters.
+  /// Finds the first occurrence of [characters] in this string.
   ///
-  /// Returns the [string] index before first occurrence of the character
-  /// of [other] in the sequence of characters of [string].
-  /// Returns a negative number if there is no such occurrence of [other].
-  ///
-  /// If [startIndex] is supplied, returns the index after the first occurrence
-  /// of [other] in this which starts no earlier than [startIndex], and again
-  /// returns `null` if there is no such occurrence. That is, if the result
-  /// is non-negative, it is greater than or equal to [startIndex].
-  int indexOf(Characters other, [int startIndex]);
+  /// Returns a [CharacterRange] containing the first occurrence of
+  /// [characters] in this string.
+  /// Returns `null` if there is no such occurrence.
+  CharacterRange /*?*/ findFirst(Characters characters);
 
-  /// The string index after the first place [other] occurs as a subsequence of
-  /// these characters.
+  /// Finds the last occurrence of [characters].
   ///
-  /// Returns the [string] index after the first occurrence of the character
-  /// of [other] in the sequence of characters of [string].
-  /// Returns a negative number if there is no such occurrence of [other].
-  ///
-  /// If [startIndex] is supplied, returns the index after the first occurrence
-  /// of [other] in this which starts no earlier than [startIndex], and again
-  /// returns `null` if there is no such occurrence. That is, if the result
-  /// is non-negative, it is greater than or equal to [startIndex].
-  int indexAfter(Characters other, [int startIndex]);
-
-  /// The string index before the last place where [other] occurs as
-  /// a subsequence of these characters.
-  ///
-  /// Returns the [string] index before last occurrence of the character
-  /// of [other] in the sequence of characters of [string].
-  /// Returns a negative number if there is no such occurrence of [other].
-  ///
-  /// If [startIndex] is supplied, returns the before after the first occurrence
-  /// of [other] in this which starts no later than [startIndex], and again
-  /// returns `null` if there is no such occurrence. That is the result
-  /// is less than or equal to [startIndex].
-  int lastIndexOf(Characters other, [int startIndex]);
-
-  /// The string index after the last place where [other] occurs as
-  /// a subsequence of these characters.
-  ///
-  /// Returns the [string] index after the last occurrence of the character
-  /// of [other] in the sequence of characters of [string].
-  /// Returns a negative number if there is no such occurrence of [other].
-  ///
-  /// If [startIndex] is supplied, returns the index after the last occurrence
-  /// of [other] in this which ends no later than [startIndex], and again
-  /// returns `null` if there is no such occurrence. That is the result
-  /// is less than or equal to [startIndex].
-  int lastIndexAfter(Characters other, [int startIndex]);
+  /// Returns a [CharacterRange] containing the last occurrence of
+  /// [characters]. Returns `null` if there is no such occurrence,
+  CharacterRange /*?*/ findLast(Characters characters);
 
   /// Eagerly selects a subset of the characters.
   ///
@@ -170,21 +121,6 @@
   /// is returned.
   Characters takeLast(int count);
 
-  /// Eagerly selects a range of characters.
-  ///
-  /// Both [start] and [end] are offsets of characters,
-  /// not indices into [string].
-  /// The [start] must be non-negative and [end] must be at least
-  /// as large as [start].
-  ///
-  /// If [start] is at least as great as [length], then the result
-  /// is an empty sequence of graphemes.
-  /// If [end] is greater than [length], the count of character
-  /// available, then it acts the same as if it was [length].
-  ///
-  /// A call like `gc.getRange(a, b)` is equivalent to `gc.take(b).skip(a)`.
-  Characters getRange(int start, int end);
-
   /// Eagerly selects a trailing sequence of characters.
   ///
   /// Checks each character, from first to last, against [test],
@@ -240,41 +176,18 @@
   /// of this sequence of strings with any other sequence of strings.
   Characters operator +(Characters other);
 
-  /// The characters of [string] with [other] inserted at [index].
-  ///
-  /// The [index] is a string can be any index into [string].
-  Characters insertAt(int index, Characters other);
-
-  /// The characters of [string] with a substring replaced by other.
-  Characters replaceSubstring(int startIndex, int endIndex, Characters other);
-
-  /// The characters of a substring of [string].
-  ///
-  /// The [startIndex] and [endIndex] must be a valid range of [string]
-  /// (0 &le; `startIndex` &le; `endIndex` &le; `string.length`).
-  /// If [endIndex] is omitted, it defaults to `string.length`.
-  Characters substring(int startIndex, [int endIndex]);
-
-  /// Replaces [source] with [replacement].
+  /// Replaces [pattern] with [replacement].
   ///
   /// Returns a new [GrapehemeClusters] where all occurrences of the
-  /// [source] character sequence are replaced by [replacement],
+  /// [pattern] character sequence are replaced by [replacement],
   /// unless the occurrence overlaps a prior replaced sequence.
-  ///
-  /// If [startIndex] is provided, only replace characters
-  /// starting no earlier than [startIndex] in [string].
-  Characters replaceAll(Characters source, Characters replacement,
-      [int startIndex = 0]);
+  Characters replaceAll(Characters pattern, Characters replacement);
 
-  /// Replaces the first [source] with [replacement].
+  /// Replaces the first [pattern] with [replacement].
   ///
   /// Returns a new [Characters] where the first occurence of the
-  /// [source] character sequence, if any, is replaced by [replacement].
-  ///
-  /// If [startIndex] is provided, replaces the first occurrence
-  /// of [source] starting no earlier than [startIndex] in [string], if any.
-  Characters replaceFirst(Characters source, Characters replacement,
-      [int startIndex = 0]);
+  /// [pattern] character sequence, if any, is replaced by [replacement].
+  Characters replaceFirst(Characters pattern, Characters replacement);
 
   /// The characters of the lower-case version of [string].
   Characters toLowerCase();
@@ -292,79 +205,51 @@
   String toString();
 }
 
-/// Iterator over characters of a string.
+/// A range of characters of a [Characters].
 ///
-/// Characters are Unicode grapheme clusters represented as substrings
-/// of the original string.
+/// A range of consecutive characters in [source],
+/// corresponding to a start and end position in the source sequence.
+/// The range may even be empty, but that will still correspond to a position
+/// where both start and end happen to be the same position.
 ///
-/// The [start] and [end] indices will iterate the grapheme cluster
-/// boundaries of the string while the [Character] is iterating the
-/// grapheme clusters. A string with *n* grapheme clusters will have
-/// *n + 1* boundaries (except when *n* is zero, then there are also
-/// zero boundaries). Those boundaries can be accessed as, for example:
-/// ```dart
-/// Iterable<int> graphemeClusterBoundaries(String string) sync* {
-///   if (string.isEmpty) return;
-///   var char = Characters(string).iterator;
-///   var hasNext = false;
-///   do {
-///     hasNext = char.moveNext();
-///     yield char.start;
-///   } while (hasNext);
-/// }
-/// ```
-abstract class Character implements BidirectionalIterator<String> {
+/// The source sequence can be separated into the *preceeding* characters,
+/// those before the range, the range itself, and the *following* characters,
+/// those after the range.
+///
+/// Some operations inspect or act on the characters of the current range,
+/// and other operations modify the range by moving the start and/or end
+/// position.
+///
+/// In general, an operation with a name starting with `move` will move
+/// both start and end positions, selecting an entirely new range
+/// which does not overlap the current range.
+/// Operations starting with `collapse` reduces the current range to
+/// a sub-range of itself.
+/// Operations starting with `expand` increase the current range
+/// by moving/ the end postion to a later position
+/// or the start position to an earlier position,
+/// and operations starting with `drop` reduce the current range
+/// by moving the start to a later position or the end to an earlier position,
+/// therebyt dropping characters from one or both ends from the current range.
+///
+///
+/// The character range implements [Iterator]
+/// The [moveNext] operation, when called with no argument,
+/// iterates the *next* single characters of the [source] sequence.
+abstract class CharacterRange implements Iterator<String> {
   /// Creates a new character iterator iterating the character
   /// of [string].
-  factory Character(String string) = _Character;
+  factory CharacterRange(String string) = StringCharacterRange;
 
-  /// The beginning of the current character in the underlying string.
-  ///
-  /// This index is always at a cluster boundary unless the iterator
-  /// has been reset to a non-boundary index.
-  ///
-  /// If equal to [end], there is no current character, and [moveNext]
-  /// needs to be called first before accessing [current].
-  /// This is the case at the beginning of iteration,
-  /// after [moveNext] has returned false,
-  /// or after calling [reset].
-  int get start;
+  /// The character sequence that this range is a sub-sequence of.
+  Characters get source;
 
-  /// The end of the current character in the underlying string.
-  ///
-  /// This index is always at a cluster boundary unless the iterator
-  /// has been reset to a non-boundary index.
-  ///
-  /// If equal to [start], there is no current character.
-  int get end;
-
-  /// The code units of the current character.
+  /// The code units of the current character range.
   List<int> get codeUnits;
 
-  /// The code points of the current character.
+  /// The code points of the current character range.
   Runes get runes;
 
-  /// Resets the iterator to the [index] position.
-  ///
-  /// There is no [current] character after a reset,
-  /// a call to [moveNext] is needed to find the end of the character
-  /// at the [index] position.
-  /// A `reset(0)` will reset to the beginning of the string, as for a newly
-  /// created iterator.
-  void reset(int index);
-
-  /// Resets the iterator to the start of the string.
-  ///
-  /// The iterator will be in the same state as a newly created iterator
-  /// from [Characters.iterator].
-  void resetStart();
-
-  /// Resets the iterator to the end of the string.
-  ///
-  /// The iterator will be in the same state as an iterator which has
-  /// performed [moveNext] until it returned false.
-  void resetEnd();
-
   /// Creates a copy of this [Character].
   ///
   /// The copy is in the exact same state as this iterator.
@@ -372,5 +257,385 @@
   /// at the same time. To simply rewind an iterator, remember the
   /// [start] or [end] position and use [reset] to reset the iterator
   /// to that position.
-  Character copy();
+  CharacterRange copy();
+
+  /// Whether the current range is empty.
+  ///
+  /// An empty range has no characters, but still has a position as
+  /// a sub-sequence of the source character sequence.
+  bool get isEmpty;
+
+  /// Whether the current range is not empty.
+  ///
+  /// A non-empty range contains at least one character.
+  bool get isNotEmpty;
+
+  /// Moves the range to be the next [count] characters after the current range.
+  ///
+  /// The new range starts and the end of the current range and includes
+  /// the next [count] characters, or as many as available if there
+  /// are fewer than [count] characters following the current range.
+  ///
+  /// The [count] must not be negative.
+  /// If it is zero, the call has the same effect as [collapseToEnd].
+  ///
+  /// Returns `true` if there were [count] following characters
+  /// and `false` if not.
+  bool moveNext([int count = 1]);
+
+  /// Moves the range to the next occurrence of [target]
+  /// after the current range.
+  ///
+  /// If there is an occurrence of [target] in the characters following
+  /// the current range,
+  /// then the new range contains exactly the first such occurrence of [target].
+  ///
+  /// If there is no occurrence of [target] after the current range,
+  /// the range is not modified.
+  ///
+  /// Returns `true` if the range is modified and `false` if not.
+  bool moveTo(Characters target);
+
+  /// Moves to the range until the next occurrence of [target].
+  ///
+  /// If there is an occurrence of [target] in the characters following
+  /// the current range,
+  /// then the new range contains the characters from the end
+  /// of the current range until, but no including the first such
+  /// occurrence of [target].
+  ///
+  /// If there is no occurrence of [target] after the current range,
+  /// the new range contains all the characters following the current range,
+  /// from the end of the current range until the end of the string.
+  ///
+  /// Returns `true` if there was an occurrence of [target].
+  bool moveUntil(Characters target);
+
+  /// Moves the range to be the last [count] characters before the current
+  /// range.
+  ///
+  /// The new range ends at the start of the current range and includes
+  /// the previous [count] characters, or as many as available if there
+  /// are fewer than [count] characters preceding the current range.
+  ///
+  /// The [count] must not be negative.
+  /// If it is zero, the call has the same effect as [collapseToStart].
+  ///
+  /// Returns `true` if there were [count] preceding characters
+  /// and `false` if not.
+  bool moveBack([int count = 1]);
+
+  /// Moves the range to the last occurrence of [target]
+  /// before the current range.
+  ///
+  /// If there is an occurrence of [target] in the characters preceding
+  /// the current range,
+  /// then the new range contains exactly the last such occurrence of [target].
+  ///
+  /// If there is no occurrence of [target] after the current range,
+  /// the range is not modified.
+  ///
+  /// Returns `true` if the range is modified and `false` if not.
+  bool moveBackTo(Characters target);
+
+  /// Moves to the range after the previous occurence of [target].
+  ///
+  /// If there is an occurrence of [target] in the characters preceding
+  /// the current range,
+  /// then the new range contains the characters after
+  /// the last such occurrence, and up to the start of the current range.
+  ///
+  /// If there is no occurrence of [target] after the current range,
+  /// the new range contains all the characters preceding the current range,
+  /// from the start of the string to the start of the current range.
+  ///
+  /// Returns `true` if there was an occurrence of [target].
+  bool moveBackUntil(Characters target);
+
+  /// Expands the current range with the next [count] characters.
+  ///
+  /// Expands the current range to include the first [count] characters
+  /// following the current range, or as many as are available if
+  /// there are fewer than [count] characters following the current range.
+  ///
+  /// The [count] must not be negative.
+  /// If it is zero, the range does not change.
+  ///
+  /// Returns `true` if there are at least [count] characters following
+  /// the current range, and `false` if not.
+  bool expandNext([int count = 1]);
+
+  /// Expands the range to include the next occurence of [target].
+  ///
+  /// If there is an occurrence of [target] in the characters following
+  /// the current range, the end of the the range is moved to just after
+  /// the first such occurrence.
+  ///
+  /// If there is no such occurrence of [target], the range is not modified.
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  /// Notice that if [target] is empty,
+  /// the result is `true` even though the range is not modified.
+  bool expandTo(Characters target);
+
+  /// Expands the range to include characters until the next [target].
+  ///
+  /// If there is an occurrence of [target] in the characters following
+  /// the current range, the end of the the range is moved to just before
+  /// the first such occurrence.
+  ///
+  /// If there is no such occurrence of [target], the end of the range is
+  /// moved to the end of [source].
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  bool expandUntil(Characters target);
+
+  /// Expands the range with the following characters satisfying [test].
+  ///
+  /// Iterates through the characters following the current range
+  /// and includes them into the range until finding a character that
+  /// [test] returns `false` for.
+  void expandWhile(bool Function(String) test);
+
+  /// Expands the range to the end of [source].
+  void expandAll();
+
+  /// Expands the current range with the preceding [count] characters.
+  ///
+  /// Expands the current range to include the last [count] characters
+  /// preceding the current range, or as many as are available if
+  /// there are fewer than [count] characters preceding the current range.
+  ///
+  /// The [count] must not be negative.
+  /// If it is zero, the range does not change.
+  ///
+  /// Returns `true` if there are at least [count] characters preceding
+  /// the current range, and `false` if not.
+  bool expandBack([int count = 1]);
+
+  /// Expands the range to include the previous occurence of [target].
+  ///
+  /// If there is an occurrence of [target] in the characters preceding
+  /// the current range, the stat of the the range is moved to just before
+  /// the last such occurrence.
+  ///
+  /// If there is no such occurrence of [target], the range is not modified.
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  /// Notice that if [target] is empty,
+  /// the result is `true` even though the range is not modified.
+  bool expandBackTo(Characters target);
+
+  /// Expands the range to include characters back until the previous [target].
+  ///
+  /// If there is an occurrence of [target] in the characters preceding
+  /// the current range, the start of the the range is moved to just after
+  /// the last such occurrence.
+  ///
+  /// If there is no such occurrence of [target], the end of the range is
+  /// moved to the end of [source].
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  bool expandBackUntil(Characters target);
+
+  /// Expands the range with the preceding characters satisffying [test].
+  ///
+  /// Iterates back through the characters preceding the current range
+  /// and includes them into the range until finding a character that
+  /// [test] returns `false` for.
+  void expandBackWhile(bool Function(String) test);
+
+  /// Expands the range back to the start of [source].
+  void expandBackAll();
+
+  /// Collapses the range to its start.
+  ///
+  /// Sets the end of the range to be the same position as the start.
+  /// The new range is empty and positioned at the start of the current range.
+  void collapseToStart();
+
+  /// Collapses to the first occurrence of [target] in the current range.
+  ///
+  /// If there is an occurrence of [target] in the characters of the current
+  /// range, then the new range contains exactly the characters of the
+  /// first such occurrence.
+  ///
+  /// If there is no such occurrence, the range is not changed.
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  bool collapseToFirst(Characters target);
+
+  /// Collapses to the last occurrence of [target] in the current range.
+  ///
+  /// If there is an occurrence of [target] in the characters of the current
+  /// range, then the new range contains exactly the characters of the
+  /// last such occurrence.
+  ///
+  /// If there is no such occurrence, the range is not changed.
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  bool collapseToLast(Characters target);
+
+  /// Collapses the range to its end.
+  ///
+  /// Sets the start of the range to be the same as its end.
+  /// The new range is an empty range positioned at the end
+  /// of the current range.
+  void collapseToEnd();
+
+  /// Drop the first [count] characters from the range.
+  ///
+  /// Advances the start of the range to after the [count] first characters
+  /// of the range, or as many as are available if
+  /// there are fewer than [count] characters in the current range.
+  ///
+  /// The [count] must not be negative.
+  /// If it is zero, the range is not changed.
+  ///
+  /// Returns `true` if there are [count] characters in the range,
+  /// and `false` if there are fewer.
+  bool dropFirst([int count = 1]);
+
+  /// Drops the first occurrence of [target] in the range.
+  ///
+  /// If the range contains any occurrences of [target],
+  /// then all characters before the end of the first such occurrence
+  /// is removed from the range.
+  /// This advances the start of the range to the end of the
+  /// first occurrence of [target].
+  ///
+  /// If there are no occurrences of [target] in the range,
+  /// the range is not changed.
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  bool dropTo(Characters target);
+
+  /// Drops characters from the start of the range until before
+  /// the first occurrence of [target].
+  ///
+  /// If the range contains any occurrences of [target],
+  /// then all characters before the start of the first such occurrence
+  /// is removed from the range.
+  /// This advances the start of the range to the start of the
+  /// first occurrence of [target].
+  ///
+  /// If there are no occurrences of [target] in the range,
+  /// all characteres in the range are removed,
+  /// which gives the same effect as [collapseToEnd].
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  bool dropUntil(Characters target);
+
+  /// Drops characters from the start of the range while they satisfy [test].
+  ///
+  /// Iterates the characters of the current range from the start
+  /// and removes all the iterated characters until one is
+  /// reached for which [test] returns `false`.
+  /// If on such character is found, all characters are removed,
+  /// which gives the same effect as [collapseToEnd].
+  void dropWhile(bool Function(String) test);
+
+  /// Drop the last [count] characters from the range.
+  ///
+  /// Retracts the end of the range to before the [count] last characters
+  /// of the range, or as many as are available if
+  /// there are fewer than [count] characters in the current range.
+  ///
+  /// The [count] must not be negative.
+  /// If it is zero, the range is not changed.
+  ///
+  /// Returns `true` if there are [count] characters in the range,
+  /// and `false` if there are fewer.
+  bool dropLast([int count = 1]);
+
+  /// Drops the last occurrence of [target] in the range.
+  ///
+  /// If the range contains any occurrences of [target],
+  /// then all characters after the start of the first such occurrence
+  /// is removed from the range.
+  /// This retracts the end of the range to the start of the
+  /// last occurrence of [target].
+  ///
+  /// If there are no occurrences of [target] in the range,
+  /// the range is not changed.
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  bool dropBackTo(Characters target);
+
+  /// Drops characters from the end of the range until after
+  /// the last occurrence of [target].
+  ///
+  /// If the range contains any occurrences of [target],
+  /// then all characters after the end of the last such occurrence
+  /// is removed from the range.
+  /// This retracts the end of the range to the end of the
+  /// last occurrence of [target].
+  ///
+  /// If there are no occurrences of [target] in the range,
+  /// all characteres in the range are removed,
+  /// which gives the same effect as [collapseToStart].
+  ///
+  /// Returns `true` if there is an occurrence of [target] and `false` if not.
+  bool dropBackUntil(Characters target);
+
+  /// Drops characters from the end of the range while they satisfy [test].
+  ///
+  /// Iterates the characters of the current range backwards from the end
+  /// and removes all the iterated characters until one is
+  /// reached for which [test] returns `false`.
+  /// If on such character is found, all characters are removed,
+  /// which gives the same effect as [collapseToStart].
+  void dropBackWhile(bool Function(String) test);
+
+  /// Creates a new [Characters] sequence by replacing the current range.
+  ///
+  /// Replaces the current range in [source] with [replacement].
+  ///
+  /// Returns a new [Characters] instance. Since the inserted characters
+  /// may combine with the preceding or following characters, grapheme cluster
+  /// boundaries need to be recomputed from scratch.
+  Characters replaceRange(Characters replacement);
+
+  /// Replaces all occurrences of [pattern] in the range with [replacement].
+  ///
+  /// Replaces the first occurrence of [pattern] in the range, then repeatedly
+  /// finds and replaces the next occurrence which does not overlap with
+  /// the earlier, already replaced, occurrence.
+  ///
+  /// Returns new [Characters] instance for the resulting string.
+  Characters replaceAll(Characters pattern, Characters replacement);
+
+  /// Replaces the first occurrence of [pattern] with [replacement].
+  ///
+  /// Finds the first occurrence of [pattern] in the current range,
+  /// then replaces that occurrence with [replacement] and returns
+  /// the [Characters] of that string.
+  ///
+  /// If there is no first occurrence of [pattern], then the
+  /// characters of the source string is returned.
+  Characters replaceFirst(Characters pattern, Characters replacement);
+
+  /// Whether the current range starts with [characters].
+  ///
+  /// Returns `true` if the characters of the current range starts with
+  /// [characters], `false` if not.
+  bool startsWith(Characters characters);
+
+  /// Whether the current range ends with [characters].
+  ///
+  /// Returns `true` if the characters of the current range ends with
+  /// [characters], `false` if not.
+  bool endsWith(Characters characters);
+
+  /// Whether the current range is preceded by [characters].
+  ///
+  /// Returns `true` if the characters immediately preceding the current
+  /// range are [characters], and `false` if not.
+  bool isPrecededBy(Characters characters);
+
+  /// Whether the current range is followed by [characters].
+  ///
+  /// Returns `true` if the characters immediately following the current
+  /// range are [characters], and `false` if not.
+  bool isFollowedBy(Characters characters);
 }
diff --git a/lib/src/characters_impl.dart b/lib/src/characters_impl.dart
index 2369eb9..109d750 100644
--- a/lib/src/characters_impl.dart
+++ b/lib/src/characters_impl.dart
@@ -2,32 +2,48 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-part of "characters.dart";
+import "dart:collection" show ListBase;
+
+import 'package:characters/src/grapheme_clusters/table.dart';
+
+import "characters.dart";
+import "grapheme_clusters/constants.dart";
+import "grapheme_clusters/breaks.dart";
 
 /// The grapheme clusters of a string.
-class _Characters extends Iterable<String> implements Characters {
+///
+/// Backed by a single string.
+class StringCharacters extends Iterable<String> implements Characters {
   // Try to avoid allocating more empty grapheme clusters.
-  static const Characters _empty = const _Characters._("");
+  static const StringCharacters _empty = const StringCharacters("");
 
   final String string;
 
-  const _Characters._(this.string);
+  const StringCharacters(this.string);
 
-  factory _Characters(String string) =>
-      string.isEmpty ? _empty : _Characters._(string);
+  @override
+  CharacterRange get iterator => StringCharacterRange._(string, 0, 0);
 
-  Character get iterator => _Character(string);
+  @override
+  CharacterRange get iteratorAtEnd =>
+      StringCharacterRange._(string, string.length, string.length);
 
+  StringCharacterRange get _rangeAll =>
+      StringCharacterRange._(string, 0, string.length);
+
+  @override
   String get first => string.isEmpty
       ? throw StateError("No element")
       : string.substring(
           0, Breaks(string, 0, string.length, stateSoTNoBreak).nextBreak());
 
+  @override
   String get last => string.isEmpty
       ? throw StateError("No element")
       : string.substring(
           BackBreaks(string, string.length, 0, stateEoTNoBreak).nextBreak());
 
+  @override
   String get single {
     if (string.isEmpty) throw StateError("No element");
     int firstEnd =
@@ -36,10 +52,13 @@
     throw StateError("Too many elements");
   }
 
+  @override
   bool get isEmpty => string.isEmpty;
 
+  @override
   bool get isNotEmpty => string.isNotEmpty;
 
+  @override
   int get length {
     if (string.isEmpty) return 0;
     var brk = Breaks(string, 0, string.length, stateSoTNoBreak);
@@ -48,6 +67,7 @@
     return length;
   }
 
+  @override
   Iterable<T> whereType<T>() {
     Iterable<Object> self = this;
     if (self is Iterable<T>) {
@@ -56,11 +76,13 @@
     return Iterable<T>.empty();
   }
 
+  @override
   String join([String separator = ""]) {
     if (separator == "") return string;
-    return _explodeReplace(separator, "", 0);
+    return _explodeReplace(string, 0, string.length, separator, "");
   }
 
+  @override
   String lastWhere(bool test(String element), {String orElse()}) {
     int cursor = string.length;
     var brk = BackBreaks(string, cursor, 0, stateEoTNoBreak);
@@ -74,6 +96,7 @@
     throw StateError("no element");
   }
 
+  @override
   String elementAt(int index) {
     RangeError.checkNotNegative(index, "index");
     int count = 0;
@@ -90,162 +113,61 @@
     throw RangeError.index(index, this, "index", null, count);
   }
 
+  @override
   bool contains(Object other) {
     if (other is String) {
       if (other.isEmpty) return false;
       int next = Breaks(other, 0, other.length, stateSoTNoBreak).nextBreak();
       if (next != other.length) return false;
       // [other] is single grapheme cluster.
-      return _indexOf(other, 0) >= 0;
+      return _indexOf(string, other, 0, string.length) >= 0;
     }
     return false;
   }
 
-  int indexOf(Characters other, [int startIndex]) {
+  @override
+  bool startsWith(Characters other) {
     int length = string.length;
-    if (startIndex == null) {
-      startIndex = 0;
-    } else {
-      RangeError.checkValidRange(startIndex, length, length, "startIndex");
-    }
-    return _indexOf(other.string, startIndex);
-  }
-
-  /// Finds first occurrence of [otherString] at grapheme cluster boundaries.
-  ///
-  /// Only finds occurrences starting at or after [startIndex].
-  int _indexOf(String otherString, int startIndex) {
-    int otherLength = otherString.length;
-    if (otherLength == 0) {
-      return nextBreak(string, 0, string.length, startIndex);
-    }
-    int length = string.length;
-    while (startIndex + otherLength <= length) {
-      int matchIndex = string.indexOf(otherString, startIndex);
-      if (matchIndex < 0) return matchIndex;
-      if (isGraphemeClusterBoundary(string, 0, length, matchIndex) &&
-          isGraphemeClusterBoundary(
-              string, 0, length, matchIndex + otherLength)) {
-        return matchIndex;
-      }
-      startIndex = matchIndex + 1;
-    }
-    return -1;
-  }
-
-  /// Finds last occurrence of [otherString] at grapheme cluster boundaries.
-  ///
-  /// Starts searching backwards at [startIndex].
-  int _lastIndexOf(String otherString, int startIndex) {
-    int otherLength = otherString.length;
-    if (otherLength == 0) {
-      return previousBreak(string, 0, string.length, startIndex);
-    }
-    int length = string.length;
-    while (startIndex >= 0) {
-      int matchIndex = string.lastIndexOf(otherString, startIndex);
-      if (matchIndex < 0) return matchIndex;
-      if (isGraphemeClusterBoundary(string, 0, length, matchIndex) &&
-          isGraphemeClusterBoundary(
-              string, 0, length, matchIndex + otherLength)) {
-        return matchIndex;
-      }
-      startIndex = matchIndex - 1;
-    }
-    return -1;
-  }
-
-  bool startsWith(Characters other, [int startIndex = 0]) {
-    int length = string.length;
-    RangeError.checkValueInInterval(startIndex, 0, length, "startIndex");
     String otherString = other.string;
     if (otherString.isEmpty) return true;
-    return string.startsWith(otherString, startIndex) &&
-        isGraphemeClusterBoundary(
-            string, 0, length, startIndex + otherString.length);
+    return string.startsWith(otherString) &&
+        isGraphemeClusterBoundary(string, 0, length, otherString.length);
   }
 
-  bool endsWith(Characters other, [int endIndex]) {
+  @override
+  bool endsWith(Characters other) {
     int length = string.length;
-    if (endIndex == null) {
-      endIndex = length;
-    } else {
-      RangeError.checkValueInInterval(endIndex, 0, length, "endIndex");
-    }
     String otherString = other.string;
     if (otherString.isEmpty) return true;
     int otherLength = otherString.length;
-    int start = endIndex - otherLength;
+    int start = string.length - otherLength;
     return start >= 0 &&
         string.startsWith(otherString, start) &&
-        isGraphemeClusterBoundary(string, 0, endIndex, start);
+        isGraphemeClusterBoundary(string, 0, length, start);
   }
 
-  Characters replaceAll(Characters pattern, Characters replacement,
-      [int startIndex = 0]) {
-    if (startIndex > 0) {
-      RangeError.checkValueInInterval(
-          startIndex, 0, string.length, "startIndex");
-    }
-    if (pattern.string.isEmpty) {
-      if (string.isEmpty) return replacement;
-      var replacementString = replacement.string;
-      return Characters(
-          _explodeReplace(replacementString, replacementString, startIndex));
-    }
-    int start = startIndex;
-    StringBuffer buffer;
-    int next = -1;
-    while ((next = this.indexOf(pattern, start)) >= 0) {
-      (buffer ??= StringBuffer())
-        ..write(string.substring(start, next))
-        ..write(replacement);
-      start = next + pattern.string.length;
-    }
-    if (buffer == null) return this;
-    buffer.write(string.substring(start));
-    return Characters(buffer.toString());
+  @override
+  Characters replaceAll(Characters pattern, Characters replacement) =>
+      _rangeAll.replaceAll(pattern, replacement);
+
+  @override
+  Characters replaceFirst(Characters pattern, Characters replacement) {
+    var range = _rangeAll;
+    if (!range.collapseToFirst(pattern)) return this;
+    return range.replaceRange(replacement);
   }
 
-  // Replaces every internal grapheme cluster boundary with
-  // [internalReplacement] and adds [outerReplacement] at both ends
-  // Starts at [startIndex].
-  String _explodeReplace(
-      String internalReplacement, String outerReplacement, int startIndex) {
-    var buffer = StringBuffer(string.substring(0, startIndex));
-    var breaks = Breaks(string, startIndex, string.length, stateSoTNoBreak);
-    int index = 0;
-    String replacement = outerReplacement;
-    while ((index = breaks.nextBreak()) >= 0) {
-      buffer..write(replacement)..write(string.substring(startIndex, index));
-      startIndex = index;
-      replacement = internalReplacement;
-    }
-    buffer.write(outerReplacement);
-    return buffer.toString();
-  }
+  @override
+  bool containsAll(Characters other) =>
+      _indexOf(string, other.string, 0, string.length) >= 0;
 
-  Characters replaceFirst(Characters source, Characters replacement,
-      [int startIndex = 0]) {
-    if (startIndex != 0) {
-      RangeError.checkValueInInterval(
-          startIndex, 0, string.length, "startIndex");
-    }
-    int index = _indexOf(source.string, startIndex);
-    if (index < 0) return this;
-    return Characters(string.replaceRange(
-        index, index + source.string.length, replacement.string));
-  }
-
-  bool containsAll(Characters other) {
-    return _indexOf(other.string, 0) >= 0;
-  }
-
+  @override
   Characters skip(int count) {
     RangeError.checkNotNegative(count, "count");
     if (count == 0) return this;
     if (string.isNotEmpty) {
-      var breaks = Breaks(string, 0, string.length, stateSoTNoBreak);
+      int stringLength = string.length;
+      var breaks = Breaks(string, 0, stringLength, stateSoTNoBreak);
       int startIndex = 0;
       while (count > 0) {
         int index = breaks.nextBreak();
@@ -256,11 +178,13 @@
           return _empty;
         }
       }
-      return _Characters(string.substring(startIndex));
+      if (startIndex == stringLength) return _empty;
+      return StringCharacters(string.substring(startIndex));
     }
     return this;
   }
 
+  @override
   Characters take(int count) {
     RangeError.checkNotNegative(count, "count");
     if (count == 0) return _empty;
@@ -270,26 +194,29 @@
       while (count > 0) {
         int index = breaks.nextBreak();
         if (index >= 0) {
-          count--;
           endIndex = index;
+          count--;
         } else {
           return this;
         }
       }
-      return _Characters._(string.substring(0, endIndex));
+      return StringCharacters(string.substring(0, endIndex));
     }
     return this;
   }
 
+  @override
   Characters skipWhile(bool Function(String) test) {
     if (string.isNotEmpty) {
-      var breaks = Breaks(string, 0, string.length, stateSoTNoBreak);
+      int stringLength = string.length;
+      var breaks = Breaks(string, 0, stringLength, stateSoTNoBreak);
       int index = 0;
       int startIndex = 0;
       while ((index = breaks.nextBreak()) >= 0) {
         if (!test(string.substring(startIndex, index))) {
           if (startIndex == 0) return this;
-          return _Characters._(string.substring(startIndex));
+          if (startIndex == stringLength) return _empty;
+          return StringCharacters(string.substring(startIndex));
         }
         startIndex = index;
       }
@@ -297,6 +224,7 @@
     return _empty;
   }
 
+  @override
   Characters takeWhile(bool Function(String) test) {
     if (string.isNotEmpty) {
       var breaks = Breaks(string, 0, string.length, stateSoTNoBreak);
@@ -305,7 +233,7 @@
       while ((index = breaks.nextBreak()) >= 0) {
         if (!test(string.substring(endIndex, index))) {
           if (endIndex == 0) return _empty;
-          return _Characters._(string.substring(0, endIndex));
+          return StringCharacters(string.substring(0, endIndex));
         }
         endIndex = index;
       }
@@ -313,42 +241,18 @@
     return this;
   }
 
-  Characters where(bool Function(String) test) =>
-      _Characters(super.where(test).join());
-
-  Characters operator +(Characters other) => _Characters(string + other.string);
-
-  Characters getRange(int start, int end) {
-    RangeError.checkNotNegative(start, "start");
-    if (end < start) throw RangeError.range(end, start, null, "end");
-    if (string.isEmpty) return this;
-    var breaks = Breaks(string, 0, string.length, stateSoTNoBreak);
-    int startIndex = 0;
-    int endIndex = string.length;
-    end -= start;
-    while (start > 0) {
-      int index = breaks.nextBreak();
-      if (index >= 0) {
-        startIndex = index;
-        start--;
-      } else {
-        return _empty;
-      }
-    }
-    while (end > 0) {
-      int index = breaks.nextBreak();
-      if (index >= 0) {
-        endIndex = index;
-        end--;
-      } else {
-        if (startIndex == 0) return this;
-        return _Characters(string.substring(startIndex));
-      }
-    }
-    if (startIndex == 0 && endIndex == string.length) return this;
-    return _Characters(string.substring(startIndex, endIndex));
+  @override
+  Characters where(bool Function(String) test) {
+    var string = super.where(test).join();
+    if (string.isEmpty) return _empty;
+    return StringCharacters(super.where(test).join());
   }
 
+  @override
+  Characters operator +(Characters other) =>
+      StringCharacters(string + other.string);
+
+  @override
   Characters skipLast(int count) {
     RangeError.checkNotNegative(count, "count");
     if (count == 0) return this;
@@ -364,11 +268,12 @@
           return _empty;
         }
       }
-      return _Characters(string.substring(0, endIndex));
+      if (endIndex > 0) return StringCharacters(string.substring(0, endIndex));
     }
     return _empty;
   }
 
+  @override
   Characters skipLastWhile(bool Function(String) test) {
     if (string.isNotEmpty) {
       var breaks = BackBreaks(string, string.length, 0, stateEoTNoBreak);
@@ -377,7 +282,7 @@
       while ((index = breaks.nextBreak()) >= 0) {
         if (!test(string.substring(index, end))) {
           if (end == string.length) return this;
-          return _Characters(string.substring(0, end));
+          return end == 0 ? _empty : StringCharacters(string.substring(0, end));
         }
         end = index;
       }
@@ -385,9 +290,10 @@
     return _empty;
   }
 
+  @override
   Characters takeLast(int count) {
     RangeError.checkNotNegative(count, "count");
-    if (count == 0) return this;
+    if (count == 0) return _empty;
     if (string.isNotEmpty) {
       var breaks = BackBreaks(string, string.length, 0, stateEoTNoBreak);
       int startIndex = string.length;
@@ -400,11 +306,14 @@
           return this;
         }
       }
-      return _Characters(string.substring(startIndex));
+      if (startIndex > 0) {
+        return StringCharacters(string.substring(startIndex));
+      }
     }
     return this;
   }
 
+  @override
   Characters takeLastWhile(bool Function(String) test) {
     if (string.isNotEmpty) {
       var breaks = BackBreaks(string, string.length, 0, stateEoTNoBreak);
@@ -412,7 +321,8 @@
       int start = string.length;
       while ((index = breaks.nextBreak()) >= 0) {
         if (!test(string.substring(index, start))) {
-          return _Characters(string.substring(start));
+          if (start == string.length) return _empty;
+          return StringCharacters(string.substring(start));
         }
         start = index;
       }
@@ -420,179 +330,531 @@
     return this;
   }
 
-  int indexAfter(Characters other, [int startIndex]) {
-    int length = string.length;
-    String otherString = other.string;
-    int otherLength = otherString.length;
-    if (startIndex == null) {
-      startIndex = 0;
-    } else {
-      RangeError.checkValueInInterval(startIndex, 0, length, "startIndex");
-    }
-    if (otherLength > startIndex) startIndex = otherLength;
-    int start = _indexOf(other.string, startIndex - otherLength);
-    if (start < 0) return start;
-    return start + otherLength;
-  }
+  @override
+  Characters toLowerCase() => StringCharacters(string.toLowerCase());
 
-  Characters insertAt(int index, Characters other) {
-    int length = string.length;
-    RangeError.checkValidRange(index, length, length, "index");
-    if (string.isEmpty) {
-      assert(index == 0);
-      return other;
-    }
-    return _Characters._(string.replaceRange(index, index, other.string));
-  }
+  @override
+  Characters toUpperCase() => StringCharacters(string.toUpperCase());
 
-  int lastIndexAfter(Characters other, [int startIndex]) {
-    String otherString = other.string;
-    int otherLength = otherString.length;
-    if (startIndex == null) {
-      startIndex = string.length;
-    } else {
-      RangeError.checkValueInInterval(
-          startIndex, 0, string.length, "startIndex");
-    }
-    if (otherLength > startIndex) return -1;
-    int start = _lastIndexOf(otherString, startIndex - otherLength);
-    if (start < 0) return start;
-    return start + otherLength;
-  }
-
-  int lastIndexOf(Characters other, [int startIndex]) {
-    if (startIndex == null) {
-      startIndex = string.length;
-    } else {
-      RangeError.checkValueInInterval(
-          startIndex, 0, string.length, "startIndex");
-    }
-    return _lastIndexOf(other.string, startIndex);
-  }
-
-  Characters replaceSubstring(int startIndex, int endIndex, Characters other) {
-    RangeError.checkValidRange(
-        startIndex, endIndex, string.length, "startIndex", "endIndex");
-    if (startIndex == 0 && endIndex == string.length) return other;
-    return _Characters._(
-        string.replaceRange(startIndex, endIndex, other.string));
-  }
-
-  Characters substring(int startIndex, [int endIndex]) {
-    endIndex = RangeError.checkValidRange(
-        startIndex, endIndex, string.length, "startIndex", "endIndex");
-    return _Characters(string.substring(startIndex, endIndex));
-  }
-
-  Characters toLowerCase() => _Characters(string.toLowerCase());
-
-  Characters toUpperCase() => _Characters(string.toUpperCase());
-
+  @override
   bool operator ==(Object other) =>
       other is Characters && string == other.string;
 
+  @override
   int get hashCode => string.hashCode;
 
+  @override
   String toString() => string;
+
+  @override
+  CharacterRange findFirst(Characters characters) {
+    var range = _rangeAll;
+    if (range.collapseToFirst(characters)) return range;
+    return null;
+  }
+
+  @override
+  CharacterRange findLast(Characters characters) {
+    var range = _rangeAll;
+    if (range.collapseToLast(characters)) return range;
+    return null;
+  }
 }
 
-class _Character implements Character {
-  static const int _directionForward = 0;
-  static const int _directionBackward = 0x04;
-  static const int _directionMask = 0x04;
-  static const int _cursorDeltaMask = 0x03;
-
+/// A [CharacterRange] on a single string.
+class StringCharacterRange implements CharacterRange {
+  /// The source string.
   final String _string;
+
+  /// Start index of range in string.
+  ///
+  /// The index is a code unit index in the [String].
+  /// It is always at a grapheme cluster boundary.
   int _start;
+
+  /// End index of range in string.
+  ///
+  /// The index is a code unit index in the [String].
+  /// It is always at a grapheme cluster boundary.
   int _end;
-  // Encodes current state,
-  // whether we are moving forwards or backwards ([_directionMask]),
-  // and how far ahead the cursor is from the start/end ([_cursorDeltaMask]).
-  int _state;
-  // The [current] value is created lazily and cached to avoid repeated
-  // or unnecessary string allocation.
+
+  /// The [current] value is created lazily and cached to avoid repeated
+  /// or unnecessary string allocation.
   String _currentCache;
 
-  _Character(String string) : this._(string, 0, 0, stateSoTNoBreak);
-  _Character._(this._string, this._start, this._end, this._state);
+  StringCharacterRange(String string) : this._(string, 0, 0);
+  StringCharacterRange._(this._string, this._start, this._end);
 
-  int get start => _start;
-  int get end => _end;
-
-  String get current => _currentCache ??=
-      (_start == _end ? null : _string.substring(_start, _end));
-
-  bool moveNext() {
-    int state = _state;
-    int cursor = _end;
-    if (state & _directionMask != _directionForward) {
-      state = stateSoTNoBreak;
-    } else {
-      cursor += state & _cursorDeltaMask;
-    }
-    var breaks = Breaks(_string, cursor, _string.length, state);
-    var next = breaks.nextBreak();
+  /// Changes the current range.
+  ///
+  /// Resets all cached state.
+  void _move(int start, int end) {
+    _start = start;
+    _end = end;
     _currentCache = null;
-    _start = _end;
-    if (next >= 0) {
-      _end = next;
-      _state =
-          (breaks.state & 0xF0) | _directionForward | (breaks.cursor - next);
+  }
+
+  /// Creates a [Breaks] from [_end] to `_string.length`.
+  ///
+  /// Uses information stored in [_state] for cases where the next
+  /// character has already been seen.
+  Breaks _breaksFromEnd() {
+    return Breaks(_string, _end, _string.length, stateSoTNoBreak);
+  }
+
+  /// Creates a [Breaks] from string start to [_start].
+  ///
+  /// Uses information stored in [_state] for cases where the previous
+  /// character has already been seen.
+  BackBreaks _backBreaksFromStart() {
+    return BackBreaks(_string, _start, 0, stateEoTNoBreak);
+  }
+
+  @override
+  String get current => _currentCache ??= _string.substring(_start, _end);
+
+  @override
+  bool moveNext([int count = 1]) => _advanceEnd(count, _end);
+
+  bool _advanceEnd(int count, int newStart) {
+    if (count > 0) {
+      var state = stateSoTNoBreak;
+      int index = _end;
+      while (index < _string.length) {
+        int char = _string.codeUnitAt(index);
+        int category = categoryControl;
+        int nextIndex = index + 1;
+        if (char & 0xFC00 != 0xD800) {
+          category = low(char);
+        } else if (nextIndex < _string.length) {
+          int nextChar = _string.codeUnitAt(nextIndex);
+          if (nextChar & 0xFC00 == 0xDC00) {
+            nextIndex += 1;
+            category = high(char, nextChar);
+          }
+        }
+        state = move(state, category);
+        if (state & stateNoBreak == 0 && --count == 0) {
+          _move(newStart, index);
+          return true;
+        }
+        index = nextIndex;
+      }
+      _move(newStart, _string.length);
+      return count == 1 && state != stateSoTNoBreak;
+    } else if (count == 0) {
+      _move(newStart, _end);
+      return true;
+    } else {
+      throw RangeError.range(count, 0, null, "count");
+    }
+  }
+
+  bool _moveNextPattern(String patternString, int start, int end) {
+    int offset = _indexOf(_string, patternString, start, end);
+    if (offset >= 0) {
+      _move(offset, offset + patternString.length);
       return true;
     }
-    _state = stateEoTNoBreak | _directionBackward;
     return false;
   }
 
-  bool movePrevious() {
-    int state = _state;
-    int cursor = _start;
-    if (state & _directionMask == _directionForward) {
-      state = stateEoTNoBreak;
-    } else {
-      cursor -= state & _cursorDeltaMask;
+  @override
+  bool moveBack([int count = 1]) => _retractStart(count, _start);
+
+  bool _retractStart(int count, int newEnd) {
+    RangeError.checkNotNegative(count, "count");
+    var breaks = _backBreaksFromStart();
+    int start = _start;
+    while (count > 0) {
+      int nextBreak = breaks.nextBreak();
+      if (nextBreak >= 0) {
+        start = nextBreak;
+      } else {
+        break;
+      }
+      count--;
     }
-    var breaks = BackBreaks(_string, cursor, 0, state);
-    var next = breaks.nextBreak();
-    _currentCache = null;
-    _end = _start;
-    if (next >= 0) {
-      _start = next;
-      _state =
-          (breaks.state & 0xF0) | _directionBackward | (next - breaks.cursor);
+    _move(start, newEnd);
+    return count == 0;
+  }
+
+  bool _movePreviousPattern(String patternString, int start, int end) {
+    int offset = _lastIndexOf(_string, patternString, start, end);
+    if (offset >= 0) {
+      _move(offset, offset + patternString.length);
       return true;
     }
-    _state = stateSoTNoBreak | _directionForward;
     return false;
   }
 
+  @override
   List<int> get codeUnits => _CodeUnits(_string, _start, _end);
 
+  @override
   Runes get runes => Runes(current);
 
-  void reset(int index) {
-    RangeError.checkValueInInterval(index, 0, _string.length, "index");
-    _reset(index);
+  @override
+  CharacterRange copy() {
+    return StringCharacterRange._(_string, _start, _end);
   }
 
-  void resetStart() {
-    _reset(0);
+  @override
+  void collapseToEnd() {
+    _move(_end, _end);
   }
 
-  void resetEnd() {
-    _state = stateEoTNoBreak | _directionBackward;
-    _currentCache = null;
-    _start = _end = _string.length;
+  @override
+  void collapseToStart() {
+    _move(_start, _start);
   }
 
-  void _reset(int index) {
-    _state = stateSoTNoBreak | _directionForward;
-    _currentCache = null;
-    _start = _end = index;
+  @override
+  bool dropFirst([int count = 1]) {
+    RangeError.checkNotNegative(count, "count");
+    if (_start == _end) return count == 0;
+    var breaks = Breaks(_string, _start, _end, stateSoTNoBreak);
+    while (count > 0) {
+      int nextBreak = breaks.nextBreak();
+      if (nextBreak >= 0) {
+        _start = nextBreak;
+        _currentCache = null;
+        count--;
+      } else {
+        return false;
+      }
+    }
+    return true;
   }
 
-  Character copy() {
-    return _Character._(_string, _start, _end, _state);
+  @override
+  bool dropTo(Characters target) {
+    if (_start == _end) return target.isEmpty;
+    var targetString = target.string;
+    var index = _indexOf(_string, targetString, _start, _end);
+    if (index >= 0) {
+      _move(index + targetString.length, _end);
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  bool dropUntil(Characters target) {
+    if (_start == _end) return target.isEmpty;
+    var targetString = target.string;
+    var index = _indexOf(_string, targetString, _start, _end);
+    if (index >= 0) {
+      _move(index, _end);
+      return true;
+    }
+    _move(_end, _end);
+    return false;
+  }
+
+  @override
+  void dropWhile(bool Function(String) test) {
+    if (_start == _end) return;
+    var breaks = Breaks(_string, _start, _end, stateSoTNoBreak);
+    int cursor = _start;
+    int next = 0;
+    while ((next = breaks.nextBreak()) >= 0) {
+      if (!test(_string.substring(cursor, next))) {
+        break;
+      }
+      cursor = next;
+    }
+    _move(cursor, _end);
+  }
+
+  @override
+  bool dropLast([int count = 1]) {
+    RangeError.checkNotNegative(count, "count");
+    var breaks = BackBreaks(_string, _end, _start, stateEoTNoBreak);
+    while (count > 0) {
+      int nextBreak = breaks.nextBreak();
+      if (nextBreak >= 0) {
+        _end = nextBreak;
+        _currentCache = null;
+        count--;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @override
+  bool dropBackTo(Characters target) {
+    if (_start == _end) return target.isEmpty;
+    var targetString = target.string;
+    var index = _lastIndexOf(_string, targetString, _start, _end);
+    if (index >= 0) {
+      _move(_start, index);
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  bool dropBackUntil(Characters target) {
+    if (_start == _end) return target.isEmpty;
+    var targetString = target.string;
+    var index = _lastIndexOf(_string, targetString, _start, _end);
+    if (index >= 0) {
+      _move(_start, index + targetString.length);
+      return true;
+    }
+    _move(_start, _start);
+    return false;
+  }
+
+  @override
+  void dropBackWhile(bool Function(String) test) {
+    if (_start == _end) return;
+    var breaks = BackBreaks(_string, _end, _start, stateEoTNoBreak);
+    int cursor = _end;
+    int next = 0;
+    while ((next = breaks.nextBreak()) >= 0) {
+      if (!test(_string.substring(next, cursor))) {
+        break;
+      }
+      cursor = next;
+    }
+    _move(_start, cursor);
+  }
+
+  @override
+  bool expandNext([int count = 1]) => _advanceEnd(count, _start);
+
+  @override
+  bool expandTo(Characters target) {
+    String targetString = target.string;
+    int index = _indexOf(_string, targetString, _end, _string.length);
+    if (index >= 0) {
+      _move(_start, index + targetString.length);
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  void expandWhile(bool Function(String character) test) {
+    var breaks = _breaksFromEnd();
+    int cursor = _end;
+    int next = 0;
+    while ((next = breaks.nextBreak()) >= 0) {
+      if (!test(_string.substring(cursor, next))) {
+        break;
+      }
+      cursor = next;
+    }
+    _move(_start, cursor);
+  }
+
+  @override
+  void expandAll() {
+    _move(_start, _string.length);
+  }
+
+  @override
+  bool expandBack([int count = 1]) => _retractStart(count, _end);
+
+  @override
+  bool expandBackTo(Characters target) {
+    var targetString = target.string;
+    int index = _lastIndexOf(_string, targetString, 0, _start);
+    if (index >= 0) {
+      _move(index, _end);
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  void expandBackWhile(bool Function(String character) test) {
+    var breaks = _backBreaksFromStart();
+    int cursor = _start;
+    int next = 0;
+    while ((next = breaks.nextBreak()) >= 0) {
+      if (!test(_string.substring(next, cursor))) {
+        _move(cursor, _end);
+        return;
+      }
+      cursor = next;
+    }
+    _move(0, _end);
+  }
+
+  @override
+  bool expandBackUntil(Characters target) {
+    return _retractStartUntil(target.string, _end);
+  }
+
+  @override
+  void expandBackAll() {
+    _move(0, _end);
+  }
+
+  @override
+  bool expandUntil(Characters target) {
+    return _advanceEndUntil(target.string, _start);
+  }
+
+  @override
+  bool get isEmpty => _start == _end;
+
+  @override
+  bool get isNotEmpty => _start != _end;
+
+  @override
+  bool moveBackUntil(Characters target) {
+    var targetString = target.string;
+    return _retractStartUntil(targetString, _start);
+  }
+
+  bool _retractStartUntil(String targetString, int newEnd) {
+    var index = _lastIndexOf(_string, targetString, 0, _start);
+    if (index >= 0) {
+      _move(index + targetString.length, newEnd);
+      return true;
+    }
+    _move(0, newEnd);
+    return false;
+  }
+
+  @override
+  bool collapseToFirst(Characters target) {
+    return _moveNextPattern(target.string, _start, _end);
+  }
+
+  @override
+  bool collapseToLast(Characters target) {
+    return _movePreviousPattern(target.string, _start, _end);
+  }
+
+  @override
+  bool moveUntil(Characters target) {
+    var targetString = target.string;
+    return _advanceEndUntil(targetString, _end);
+  }
+
+  bool _advanceEndUntil(String targetString, int newStart) {
+    int index = _indexOf(_string, targetString, _end, _string.length);
+    if (index >= 0) {
+      _move(newStart, index);
+      return true;
+    }
+    _move(newStart, _string.length);
+    return false;
+  }
+
+  @override
+  Characters replaceFirst(Characters pattern, Characters replacement) {
+    String patternString = pattern.string;
+    String replacementString = replacement.string;
+    if (patternString.isEmpty) {
+      return StringCharacters(
+          _string.replaceRange(_start, _start, replacementString));
+    }
+    int index = _indexOf(_string, patternString, _start, _end);
+    String result = _string;
+    if (index >= 0) {
+      result = _string.replaceRange(
+          index, index + patternString.length, replacementString);
+    }
+    return StringCharacters(result);
+  }
+
+  @override
+  Characters replaceAll(Characters pattern, Characters replacement) {
+    var patternString = pattern.string;
+    var replacementString = replacement.string;
+    if (patternString.isEmpty) {
+      var replaced = _explodeReplace(
+          _string, _start, _end, replacementString, replacementString);
+      return StringCharacters(replaced);
+    }
+    if (_start == _end) return Characters(_string);
+    int start = 0;
+    int cursor = _start;
+    StringBuffer buffer;
+    while ((cursor = _indexOf(_string, patternString, cursor, _end)) >= 0) {
+      (buffer ??= StringBuffer())
+        ..write(_string.substring(start, cursor))
+        ..write(replacementString);
+      cursor += patternString.length;
+      start = cursor;
+    }
+    if (buffer == null) return Characters(_string);
+    buffer.write(_string.substring(start));
+    return Characters(buffer.toString());
+  }
+
+  @override
+  Characters replaceRange(Characters replacement) {
+    return Characters(_string.replaceRange(_start, _end, replacement.string));
+  }
+
+  @override
+  Characters get source => Characters(_string);
+
+  @override
+  bool startsWith(Characters characters) {
+    return _startsWith(_start, _end, characters.string);
+  }
+
+  @override
+  bool endsWith(Characters characters) {
+    return _endsWith(_start, _end, characters.string);
+  }
+
+  @override
+  bool isFollowedBy(Characters characters) {
+    return _startsWith(_end, _string.length, characters.string);
+  }
+
+  @override
+  bool isPrecededBy(Characters characters) {
+    return _endsWith(0, _start, characters.string);
+  }
+
+  bool _endsWith(int start, int end, String string) {
+    int length = string.length;
+    int stringStart = end - length;
+    return stringStart >= start &&
+        _string.startsWith(string, stringStart) &&
+        isGraphemeClusterBoundary(_string, start, end, stringStart);
+  }
+
+  bool _startsWith(int start, int end, String string) {
+    int length = string.length;
+    int stringEnd = start + length;
+    return stringEnd <= end &&
+        _string.startsWith(string, start) &&
+        isGraphemeClusterBoundary(_string, start, end, stringEnd);
+  }
+
+  @override
+  bool moveBackTo(Characters target) {
+    var targetString = target.string;
+    int index = _lastIndexOf(_string, targetString, 0, _start);
+    if (index >= 0) {
+      _move(index, index + targetString.length);
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  bool moveTo(Characters target) {
+    var targetString = target.string;
+    int index = _indexOf(_string, targetString, _end, _string.length);
+    if (index >= 0) {
+      _move(index, index + targetString.length);
+      return true;
+    }
+    return false;
   }
 }
 
@@ -619,3 +881,106 @@
     throw UnsupportedError("Cannot modify an unmodifiable list");
   }
 }
+
+String _explodeReplace(String string, int start, int end,
+    String internalReplacement, String outerReplacement) {
+  if (start == end) {
+    return string.replaceRange(start, start, outerReplacement);
+  }
+  var buffer = StringBuffer(string.substring(0, start));
+  var breaks = Breaks(string, start, end, stateSoTNoBreak);
+  int index = 0;
+  String replacement = outerReplacement;
+  while ((index = breaks.nextBreak()) >= 0) {
+    buffer..write(replacement)..write(string.substring(start, index));
+    start = index;
+    replacement = internalReplacement;
+  }
+  buffer..write(outerReplacement)..write(string.substring(end));
+  return buffer.toString();
+}
+
+/// Finds [pattern] in the range from [start] to [end].
+///
+/// Both [start] and [end] are grapheme cluster boundaries in the
+/// [source] string.
+int _indexOf(String source, String pattern, int start, int end) {
+  int patternLength = pattern.length;
+  if (patternLength == 0) return start;
+  // Any start position after realEnd won't fit the pattern before end.
+  int realEnd = end - patternLength;
+  if (realEnd < start) return -1;
+  // Use indexOf if what we can overshoot is
+  // less than twice as much as what we have left to search.
+  int rest = source.length - realEnd;
+  if (rest <= (realEnd - start) * 2) {
+    int index = 0;
+    while (start < realEnd && (index = source.indexOf(pattern, start)) >= 0) {
+      if (index > realEnd) return -1;
+      if (isGraphemeClusterBoundary(source, start, end, index) &&
+          isGraphemeClusterBoundary(
+              source, start, end, index + patternLength)) {
+        return index;
+      }
+      start = index + 1;
+    }
+    return -1;
+  }
+  return _gcIndexOf(source, pattern, start, end);
+}
+
+int _gcIndexOf(String source, String pattern, int start, int end) {
+  var breaks = Breaks(source, start, end, stateSoT);
+  int index = 0;
+  while ((index = breaks.nextBreak()) >= 0) {
+    int endIndex = index + pattern.length;
+    if (endIndex > end) break;
+    if (source.startsWith(pattern, index) &&
+        isGraphemeClusterBoundary(source, start, end, endIndex)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+/// Finds pattern in the range from [start] to [end].
+/// Both [start] and [end] are grapheme cluster boundaries in the
+/// [source] string.
+int _lastIndexOf(String source, String pattern, int start, int end) {
+  int patternLength = pattern.length;
+  if (patternLength == 0) return end;
+  // Start of pattern must be in range [start .. end - patternLength].
+  int realEnd = end - patternLength;
+  if (realEnd < start) return -1;
+  // If the range from 0 to start is no more than double the range from
+  // start to end, use lastIndexOf.
+  if (realEnd * 2 > start) {
+    int index = 0;
+    while (realEnd >= start &&
+        (index = source.lastIndexOf(pattern, realEnd)) >= 0) {
+      if (index < start) return -1;
+      if (isGraphemeClusterBoundary(source, start, end, index) &&
+          isGraphemeClusterBoundary(
+              source, start, end, index + patternLength)) {
+        return index;
+      }
+      realEnd = index - 1;
+    }
+    return -1;
+  }
+  return _gcLastIndexOf(source, pattern, start, end);
+}
+
+int _gcLastIndexOf(String source, String pattern, int start, int end) {
+  var breaks = BackBreaks(source, end, start, stateEoT);
+  int index = 0;
+  while ((index = breaks.nextBreak()) >= 0) {
+    int startIndex = index - pattern.length;
+    if (startIndex < start) break;
+    if (source.startsWith(pattern, startIndex) &&
+        isGraphemeClusterBoundary(source, start, end, startIndex)) {
+      return startIndex;
+    }
+  }
+  return -1;
+}
diff --git a/lib/src/grapheme_clusters/breaks.dart b/lib/src/grapheme_clusters/breaks.dart
index 1460e05..9a41609 100644
--- a/lib/src/grapheme_clusters/breaks.dart
+++ b/lib/src/grapheme_clusters/breaks.dart
@@ -329,6 +329,8 @@
 }
 
 /// The next break no earlier than [position] in `string.substring(start, end)`.
+///
+/// The index need not be at a grapheme cluster boundary.
 int nextBreak(String text, int start, int end, int index) {
   assert(0 <= start);
   assert(start <= index);
diff --git a/pubspec.yaml b/pubspec.yaml
index db26108..5f1858c 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: characters
-version: 0.1.0
+version: 0.2.0
 environment:
   sdk: "^2.4.0"
 dev_dependencies:
diff --git a/test/characters_test.dart b/test/characters_test.dart
index 7039038..cbb6e03 100644
--- a/test/characters_test.dart
+++ b/test/characters_test.dart
@@ -22,119 +22,50 @@
       : Random().nextInt(0x3FFFFFFF);
   random = Random(seed);
   group("[Random Seed: $seed]", tests);
-  group("index", () {
-    test("simple", () {
-      var flag = "\u{1F1E9}\u{1F1F0}";
-      var string = "Hi $flag!"; // Regional Indications "DK".
+  group("characters", () {
+    test("operations", () {
+      var flag = "\u{1F1E9}\u{1F1F0}"; // Regional Indicators "DK".
+      var string = "Hi $flag!";
       expect(string.length, 8);
-      expect(gc(string).toList(), ["H", "i", " ", flag, "!"]);
+      var cs = gc(string);
+      expect(cs.length, 5);
+      expect(cs.toList(), ["H", "i", " ", flag, "!"]);
+      expect(cs.skip(2).toString(), " $flag!");
+      expect(cs.skipLast(2).toString(), "Hi ");
+      expect(cs.take(2).toString(), "Hi");
+      expect(cs.takeLast(2).toString(), "$flag!");
 
-      expect(gc(string).indexOf(gc("")), 0);
-      expect(gc(string).indexOf(gc(""), 3), 3);
-      expect(gc(string).indexOf(gc(""), 4), 7);
-      expect(gc(string).indexOf(gc(flag)), 3);
-      expect(gc(string).indexOf(gc(flag), 3), 3);
-      expect(gc(string).indexOf(gc(flag), 4), lessThan(0));
+      expect(cs.contains("\u{1F1E9}"), false);
+      expect(cs.contains(flag), true);
+      expect(cs.contains("$flag!"), false);
+      expect(cs.containsAll(gc("$flag!")), true);
 
-      expect(gc(string).indexAfter(gc("")), 0);
-      expect(gc(string).indexAfter(gc(""), 3), 3);
-      expect(gc(string).indexAfter(gc(""), 4), 7);
-      expect(gc(string).indexAfter(gc(flag)), 7);
-      expect(gc(string).indexAfter(gc(flag), 7), 7);
-      expect(gc(string).indexAfter(gc(flag), 8), lessThan(0));
+      expect(cs.takeWhile((x) => x != " ").toString(), "Hi");
+      expect(cs.takeLastWhile((x) => x != " ").toString(), "$flag!");
+      expect(cs.skipWhile((x) => x != " ").toString(), " $flag!");
+      expect(cs.skipLastWhile((x) => x != " ").toString(), "Hi ");
 
-      expect(gc(string).lastIndexOf(gc("")), string.length);
-      expect(gc(string).lastIndexOf(gc(""), 7), 7);
-      expect(gc(string).lastIndexOf(gc(""), 6), 3);
-      expect(gc(string).lastIndexOf(gc(""), 0), 0);
-      expect(gc(string).lastIndexOf(gc(flag)), 3);
-      expect(gc(string).lastIndexOf(gc(flag), 6), 3);
-      expect(gc(string).lastIndexOf(gc(flag), 2), lessThan(0));
-
-      expect(gc(string).lastIndexAfter(gc("")), string.length);
-      expect(gc(string).lastIndexAfter(gc(""), 7), 7);
-      expect(gc(string).lastIndexAfter(gc(""), 6), 3);
-      expect(gc(string).lastIndexAfter(gc(""), 0), 0);
-      expect(gc(string).lastIndexAfter(gc(flag)), 7);
-      expect(gc(string).lastIndexAfter(gc(flag), 7), 7);
-      expect(gc(string).lastIndexAfter(gc(flag), 6), lessThan(0));
-    });
-    test("multiple", () {
-      var flag = "\u{1F1E9}\u{1F1F0}"; // DK.
-      var revFlag = "\u{1F1F0}\u{1F1E9}"; // KD.
-      var string = "-${flag}-$flag$flag-";
-      expect(gc(string).indexOf(gc(flag)), 1);
-      expect(gc(string).indexOf(gc(flag), 2), 6);
-      expect(gc(string).indexOf(gc(flag), 6), 6);
-      expect(gc(string).indexOf(gc(flag), 7), 10);
-      expect(gc(string).indexOf(gc(flag), 10), 10);
-      expect(gc(string).indexOf(gc(flag), 11), lessThan(0));
-
-      expect(gc(string).indexOf(gc(revFlag)), lessThan(0));
+      expect(cs.findFirst(gc("")).moveBack(), false);
+      expect(cs.findFirst(gc(flag)).current, flag);
+      expect(cs.findLast(gc(flag)).current, flag);
+      expect(cs.iterator.moveNext(), true);
+      expect(cs.iterator.moveBack(), false);
+      expect((cs.iterator..moveNext()).current, "H");
+      expect(cs.iteratorAtEnd.moveNext(), false);
+      expect(cs.iteratorAtEnd.moveBack(), true);
+      expect((cs.iteratorAtEnd..moveBack()).current, "!");
     });
 
-    test("nonBoundary", () {
-      // Composite pictogram example, from https://en.wikipedia.org/wiki/Zero-width_joiner.
-      var flag = "\u{1f3f3}"; // U+1F3F3, Flag, waving. Category Pictogram.
-      var white = "\ufe0f"; // U+FE0F, Variant selector 16. Category Extend.
-      var zwj = "\u200d"; // U+200D, ZWJ
-      var rainbow = "\u{1f308}"; // U+1F308, Rainbow. Category Pictogram
-      var flagRainbow = "$flag$white$zwj$rainbow";
-      expect(gc(flagRainbow).length, 1);
-      for (var part in [flag, white, zwj, rainbow]) {
-        expect(gc(flagRainbow).indexOf(gc(part)), lessThan(0));
-        expect(gc(flagRainbow).indexAfter(gc(part)), lessThan(0));
-        expect(gc(flagRainbow).lastIndexOf(gc(part)), lessThan(0));
-        expect(gc(flagRainbow).lastIndexAfter(gc(part)), lessThan(0));
-      }
-      expect(gc(flagRainbow + flagRainbow).indexOf(gc(flagRainbow)), 0);
-      expect(gc(flagRainbow + flagRainbow).indexAfter(gc(flagRainbow)), 6);
-      expect(gc(flagRainbow + flagRainbow).lastIndexOf(gc(flagRainbow)), 6);
-      expect(gc(flagRainbow + flagRainbow).lastIndexAfter(gc(flagRainbow)), 12);
-      //                                      1     11   11       11           2
-      // indices           0           67    90     12   34       67           3
-      var partsAndWhole =
-          "$flagRainbow $flag $white $zwj $rainbow $flagRainbow";
-      // Flag and rainbow are independent graphemes.
-      expect(gc(partsAndWhole).toList(), [
-        flagRainbow,
-        " ",
-        flag,
-        " $white", // Other + Extend
-        " $zwj", // Other + ZWJ
-        " ",
-        rainbow,
-        " ",
-        flagRainbow
-      ]);
-      expect(gc(partsAndWhole).indexOf(gc(flag)), 7);
-      expect(gc(partsAndWhole).indexAfter(gc(flag)), 9);
-      expect(gc(partsAndWhole).lastIndexOf(gc(flag)), 7);
-      expect(gc(partsAndWhole).lastIndexAfter(gc(flag)), 9);
+    testParts(gc("a"), gc("b"), gc("c"), gc("d"), gc("e"));
 
-      expect(gc(partsAndWhole).indexOf(gc(rainbow)), 14);
-      expect(gc(partsAndWhole).indexAfter(gc(rainbow)), 16);
-      expect(gc(partsAndWhole).lastIndexOf(gc(rainbow)), 14);
-      expect(gc(partsAndWhole).lastIndexAfter(gc(rainbow)), 16);
+    // Composite pictogram example, from https://en.wikipedia.org/wiki/Zero-width_joiner.
+    var flag = "\u{1f3f3}"; // U+1F3F3, Flag, waving. Category Pictogram.
+    var white = "\ufe0f"; // U+FE0F, Variant selector 16. Category Extend.
+    var zwj = "\u200d"; // U+200D, ZWJ
+    var rainbow = "\u{1f308}"; // U+1F308, Rainbow. Category Pictogram
 
-      expect(gc(partsAndWhole).indexOf(gc(white)), lessThan(0));
-      expect(gc(partsAndWhole).indexAfter(gc(white)), lessThan(0));
-      expect(gc(partsAndWhole).lastIndexOf(gc(white)), lessThan(0));
-      expect(gc(partsAndWhole).lastIndexAfter(gc(white)), lessThan(0));
-      expect(gc(partsAndWhole).indexOf(gc(" $white")), 9);
-      expect(gc(partsAndWhole).indexAfter(gc(" $white")), 11);
-      expect(gc(partsAndWhole).lastIndexOf(gc(" $white")), 9);
-      expect(gc(partsAndWhole).lastIndexAfter(gc(" $white")), 11);
-
-      expect(gc(partsAndWhole).indexOf(gc(zwj)), lessThan(0));
-      expect(gc(partsAndWhole).indexAfter(gc(zwj)), lessThan(0));
-      expect(gc(partsAndWhole).lastIndexOf(gc(zwj)), lessThan(0));
-      expect(gc(partsAndWhole).lastIndexAfter(gc(zwj)), lessThan(0));
-      expect(gc(partsAndWhole).indexOf(gc(" $zwj")), 11);
-      expect(gc(partsAndWhole).indexAfter(gc(" $zwj")), 13);
-      expect(gc(partsAndWhole).lastIndexOf(gc(" $zwj")), 11);
-      expect(gc(partsAndWhole).lastIndexAfter(gc(" $zwj")), 13);
-    });
+    testParts(gc("$flag$white$zwj$rainbow"), gc("$flag$white"), gc("$rainbow"),
+        gc("$flag$zwj$rainbow"), gc("!"));
   });
 }
 
@@ -277,22 +208,7 @@
         expected.take(expected.length - 1).join());
     expect(actual.takeLast(1).toString(),
         expected.skip(expected.length - 1).join());
-
-    expect(actual.indexOf(gc(expected.first)), 0);
-    expect(actual.indexAfter(gc(expected.first)), expected.first.length);
-    expect(actual.lastIndexOf(gc(expected.last)),
-        text.length - expected.last.length);
-    expect(actual.lastIndexAfter(gc(expected.last)), text.length);
-    if (expected.length > 1) {
-      if (expected[0] != expected[1]) {
-        expect(actual.indexOf(gc(expected[1])), expected[0].length);
-      }
-    }
   }
-
-  expect(actual.getRange(1, 3).toString(), expected.take(3).skip(1).join());
-  expect(actual.getRange(1, 3).toString(), expected.take(3).skip(1).join());
-
   bool isEven(String s) => s.length.isEven;
 
   expect(
@@ -313,48 +229,27 @@
 
   expect((actual + actual).toString(), actual.string + actual.string);
 
-  List<int> accumulatedLengths = [0];
-  for (int i = 0; i < expected.length; i++) {
-    accumulatedLengths.add(accumulatedLengths.last + expected[i].length);
-  }
-
   // Iteration.
   var it = actual.iterator;
-  expect(it.start, 0);
-  expect(it.end, 0);
+  expect(it.isEmpty, true);
   for (var i = 0; i < expected.length; i++) {
     expect(it.moveNext(), true);
-    expect(it.start, accumulatedLengths[i]);
-    expect(it.end, accumulatedLengths[i + 1]);
     expect(it.current, expected[i]);
 
     expect(actual.elementAt(i), expected[i]);
     expect(actual.skip(i).first, expected[i]);
   }
   expect(it.moveNext(), false);
-  expect(it.start, accumulatedLengths.last);
-  expect(it.end, accumulatedLengths.last);
   for (var i = expected.length - 1; i >= 0; i--) {
-    expect(it.movePrevious(), true);
-    expect(it.start, accumulatedLengths[i]);
-    expect(it.end, accumulatedLengths[i + 1]);
+    expect(it.moveBack(), true);
     expect(it.current, expected[i]);
   }
-  expect(it.movePrevious(), false);
-  expect(it.start, 0);
-  expect(it.end, 0);
+  expect(it.moveBack(), false);
+  expect(it.isEmpty, true);
 
   // GraphemeClusters operations.
-  expect(actual.toUpperCase().toString(), text.toUpperCase());
-  expect(actual.toLowerCase().toString(), text.toLowerCase());
-
-  if (text.isNotEmpty) {
-    expect(actual.insertAt(1, gc("abc")).toString(),
-        text.replaceRange(1, 1, "abc"));
-    expect(actual.replaceSubstring(0, 1, gc("abc")).toString(),
-        text.replaceRange(0, 1, "abc"));
-    expect(actual.substring(0, 1).string, actual.string.substring(0, 1));
-  }
+  expect(actual.toUpperCase().string, text.toUpperCase());
+  expect(actual.toLowerCase().string, text.toLowerCase());
 
   expect(actual.string, text);
 
@@ -368,36 +263,9 @@
       expect(actual.endsWith(gc(expected.sublist(i).join())), true);
       for (int t = s + 1; t <= steps; t++) {
         int j = expected.length * t ~/ steps;
-        int start = accumulatedLengths[i];
-        int end = accumulatedLengths[j];
         var slice = expected.sublist(i, j).join();
         var gcs = gc(slice);
         expect(actual.containsAll(gcs), true);
-        expect(actual.startsWith(gcs, start), true);
-        expect(actual.endsWith(gcs, end), true);
-      }
-    }
-    if (accumulatedLengths.last > expected.length) {
-      int i = expected.indexWhere((s) => s.length != 1);
-      assert(accumulatedLengths[i + 1] > accumulatedLengths[i] + 1);
-      expect(
-          actual.startsWith(gc(text.substring(0, accumulatedLengths[i] + 1))),
-          false);
-      expect(actual.endsWith(gc(text.substring(accumulatedLengths[i] + 1))),
-          false);
-      if (i > 0) {
-        expect(
-            actual.startsWith(
-                gc(text.substring(1, accumulatedLengths[i] + 1)), 1),
-            false);
-      }
-      if (i < expected.length - 1) {
-        int secondToLast = accumulatedLengths[expected.length - 1];
-        expect(
-            actual.endsWith(
-                gc(text.substring(accumulatedLengths[i] + 1, secondToLast)),
-                secondToLast),
-            false);
       }
     }
   }
@@ -408,7 +276,7 @@
     int pos = -1;
     if (random.nextBool()) {
       pos = expected.length;
-      it.reset(text.length);
+      it = actual.iteratorAtEnd;
     }
     int steps = 5 + random.nextInt(expected.length * 2 + 1);
     bool lastMove = false;
@@ -416,23 +284,19 @@
       bool back = false;
       if (pos < 0) {
         expect(lastMove, false);
-        expect(it.start, 0);
-        expect(it.end, 0);
+        expect(it.isEmpty, true);
       } else if (pos >= expected.length) {
         expect(lastMove, false);
-        expect(it.start, text.length);
-        expect(it.end, text.length);
+        expect(it.isEmpty, true);
         back = true;
       } else {
         expect(lastMove, true);
         expect(it.current, expected[pos]);
-        expect(it.start, accumulatedLengths[pos]);
-        expect(it.end, accumulatedLengths[pos + 1]);
         back = random.nextBool();
       }
       if (--steps < 0) break;
       if (back) {
-        lastMove = it.movePrevious();
+        lastMove = it.moveBack();
         pos -= 1;
       } else {
         lastMove = it.moveNext();
@@ -443,3 +307,249 @@
 }
 
 Characters gc(String string) => Characters(string);
+
+void testParts(
+    Characters a, Characters b, Characters c, Characters d, Characters e) {
+  var cs = gc("$a$b$c$d$e");
+  test("$cs", () {
+    var it = cs.iterator;
+    expect(it.isEmpty, true);
+    expect(it.isNotEmpty, false);
+    expect(it.current, "");
+
+    // moveNext().
+    expect(it.moveNext(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$a");
+    expect(it.moveNext(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$b");
+    expect(it.moveNext(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$c");
+    expect(it.moveNext(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$d");
+    expect(it.moveNext(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$e");
+    expect(it.moveNext(), false);
+    expect(it.isEmpty, true);
+    expect(it.current, "");
+
+    // moveBack().
+    expect(it.moveBack(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$e");
+    expect(it.moveBack(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$d");
+    expect(it.moveBack(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$c");
+    expect(it.moveBack(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$b");
+    expect(it.moveBack(), true);
+    expect(it.isEmpty, false);
+    expect(it.current, "$a");
+    expect(it.moveBack(), false);
+    expect(it.isEmpty, true);
+    expect(it.current, "");
+
+    // moveNext(int).
+    expect(it.moveTo(c), true);
+    expect(it.current, "$c");
+    expect(it.moveTo(b), false);
+    expect(it.moveTo(c), false);
+    expect(it.current, "$c");
+    expect(it.moveTo(d), true);
+    expect(it.current, "$d");
+
+    // moveBack(c).
+    expect(it.moveBackTo(c), true);
+    expect(it.current, "$c");
+    expect(it.moveBackTo(d), false);
+    expect(it.moveBackTo(c), false);
+    expect(it.moveBackTo(a), true);
+    expect(it.current, "$a");
+
+    // moveNext(n)
+    expect(it.moveBack(), false);
+
+    expect(it.moveNext(2), true);
+    expect(it.current, "$a$b");
+    expect(it.moveNext(4), false);
+    expect(it.current, "$c$d$e");
+    expect(it.moveNext(0), true);
+    expect(it.current, "");
+    expect(it.moveNext(1), false);
+    expect(it.current, "");
+
+    // moveBack(n).
+    expect(it.moveBack(2), true);
+    expect(it.current, "$d$e");
+    expect(it.moveBack(1), true);
+    expect(it.current, "$c");
+    expect(it.moveBack(3), false);
+    expect(it.current, "$a$b");
+    expect(it.moveBack(), false);
+
+    // moveFirst.
+    it.expandAll();
+    expect(it.current, "$a$b$c$d$e");
+    expect(it.collapseToFirst(b), true);
+    expect(it.current, "$b");
+    it.expandAll();
+    expect(it.current, "$b$c$d$e");
+    expect(it.collapseToFirst(a), false);
+    expect(it.current, "$b$c$d$e");
+
+    // moveBackTo
+    it.expandBackAll();
+    expect(it.current, "$a$b$c$d$e");
+    expect(it.collapseToLast(c), true);
+    expect(it.current, "$c");
+
+    // includeNext/includePrevious
+    expect(it.expandTo(e), true);
+    expect(it.current, "$c$d$e");
+    expect(it.expandTo(e), false);
+    expect(it.expandBackTo(b), true);
+    expect(it.current, "$b$c$d$e");
+    expect(it.expandBackTo(b), false);
+    expect(it.current, "$b$c$d$e");
+    expect(it.collapseToFirst(c), true);
+    expect(it.current, "$c");
+
+    // includeUntilNext/expandBackUntil
+    expect(it.expandBackUntil(a), true);
+    expect(it.current, "$b$c");
+    expect(it.expandBackUntil(a), true);
+    expect(it.current, "$b$c");
+    expect(it.expandUntil(e), true);
+    expect(it.current, "$b$c$d");
+    expect(it.expandUntil(e), true);
+    expect(it.current, "$b$c$d");
+
+    // dropFirst/dropLast
+    expect(it.dropFirst(), true);
+    expect(it.current, "$c$d");
+    expect(it.dropLast(), true);
+    expect(it.current, "$c");
+    it.expandBackAll();
+    it.expandAll();
+    expect(it.current, "$a$b$c$d$e");
+    expect(it.dropTo(b), true);
+    expect(it.current, "$c$d$e");
+    expect(it.dropBackTo(d), true);
+    expect(it.current, "$c");
+
+    it.expandBackAll();
+    it.expandAll();
+    expect(it.current, "$a$b$c$d$e");
+
+    expect(it.dropUntil(b), true);
+    expect(it.current, "$b$c$d$e");
+    expect(it.dropBackUntil(d), true);
+    expect(it.current, "$b$c$d");
+
+    it.dropWhile((x) => x == b.string);
+    expect(it.current, "$c$d");
+    it.expandBackAll();
+    expect(it.current, "$a$b$c$d");
+    it.dropBackWhile((x) => x != b.string);
+    expect(it.current, "$a$b");
+    it.dropBackWhile((x) => false);
+    expect(it.current, "$a$b");
+
+    // include..While
+    it.expandWhile((x) => false);
+    expect(it.current, "$a$b");
+    it.expandWhile((x) => x != e.string);
+    expect(it.current, "$a$b$c$d");
+    expect(it.collapseToFirst(c), true);
+    expect(it.current, "$c");
+    it.expandBackWhile((x) => false);
+    expect(it.current, "$c");
+    it.expandBackWhile((x) => x != a.string);
+    expect(it.current, "$b$c");
+
+    var cs2 = cs.replaceAll(c, gc(""));
+    var cs3 = cs.replaceFirst(c, gc(""));
+    var cs4 = cs.findFirst(c).replaceRange(gc(""));
+    var cse = gc("$a$b$d$e");
+    expect(cs2, cse);
+    expect(cs3, cse);
+    expect(cs4, cse);
+    var cs5 = cs4.replaceAll(a, c);
+    expect(cs5, gc("$c$b$d$e"));
+    var cs6 = cs5.replaceAll(gc(""), a);
+    expect(cs6, gc("$a$c$a$b$a$d$a$e$a"));
+    var cs7 = cs6.replaceFirst(b, a);
+    expect(cs7, gc("$a$c$a$a$a$d$a$e$a"));
+    var cs8 = cs7.replaceFirst(e, a);
+    expect(cs8, gc("$a$c$a$a$a$d$a$a$a"));
+    var cs9 = cs8.replaceAll(a + a, b);
+    expect(cs9, gc("$a$c$b$a$d$b$a"));
+    it = cs9.iterator;
+    it.moveTo(b + a);
+    expect("$b$a", it.current);
+    it.expandTo(b + a);
+    expect("$b$a$d$b$a", it.current);
+    var cs10 = it.replaceAll(b + a, e + e);
+    expect(cs10, gc("$a$c$e$e$d$e$e"));
+    var cs11 = it.replaceRange(e);
+    expect(cs11, gc("$a$c$e"));
+
+    expect(cs.startsWith(gc("")), true);
+    expect(cs.startsWith(a), true);
+    expect(cs.startsWith(a + b), true);
+    expect(cs.startsWith(gc("$a$b$c")), true);
+    expect(cs.startsWith(gc("$a$b$c$d")), true);
+    expect(cs.startsWith(gc("$a$b$c$d$e")), true);
+    expect(cs.startsWith(b), false);
+    expect(cs.startsWith(c), false);
+    expect(cs.startsWith(d), false);
+    expect(cs.startsWith(e), false);
+
+    expect(cs.endsWith(gc("")), true);
+    expect(cs.endsWith(e), true);
+    expect(cs.endsWith(d + e), true);
+    expect(cs.endsWith(gc("$c$d$e")), true);
+    expect(cs.endsWith(gc("$b$c$d$e")), true);
+    expect(cs.endsWith(gc("$a$b$c$d$e")), true);
+    expect(cs.endsWith(d), false);
+    expect(cs.endsWith(c), false);
+    expect(cs.endsWith(b), false);
+    expect(cs.endsWith(a), false);
+
+    it = cs.findFirst(b + c);
+    expect(it.startsWith(gc("")), true);
+    expect(it.startsWith(b), true);
+    expect(it.startsWith(b + c), true);
+    expect(it.startsWith(a + b + c), false);
+    expect(it.startsWith(b + c + d), false);
+    expect(it.startsWith(a), false);
+
+    expect(it.endsWith(gc("")), true);
+    expect(it.endsWith(c), true);
+    expect(it.endsWith(b + c), true);
+    expect(it.endsWith(a + b + c), false);
+    expect(it.endsWith(b + c + d), false);
+    expect(it.endsWith(d), false);
+
+    it.collapseToFirst(c);
+    expect(it.isPrecededBy(gc("")), true);
+    expect(it.isPrecededBy(b), true);
+    expect(it.isPrecededBy(a + b), true);
+    expect(it.isPrecededBy(a + b + c), false);
+    expect(it.isPrecededBy(a), false);
+
+    expect(it.isFollowedBy(gc("")), true);
+    expect(it.isFollowedBy(d), true);
+    expect(it.isFollowedBy(d + e), true);
+    expect(it.isFollowedBy(c + d + e), false);
+    expect(it.isFollowedBy(e), false);
+  });
+}