anchor.diff:      return result;
     }
   
  -  /// Creates trie from an iterable (and possible transformation functions).
  +  /// Creates a [Trie] from an iterable (and possible transformation functions).
  +  /// The [parts] define how the keys are computed and optionally provides a
  +  /// custom [root] node.
     factory Trie.fromIterable(
       Iterable iterable, {
       required GetParts<K, P> parts,
  
positive.code:             !current.hasKeyAndValue &&
              !current.hasNodes) {
            current = nodes.removeLast();
            current.removeNode(parts.removeLast());
          }
          // Return the value of the remove node.
          return value;
  
negative.code: /// Function to extract the parts of type [P] from a key of type [K].
  typedef GetParts<K, P> = Iterable<P> Function(K key);
  
  /// A generalized [Trie] (or prefix tree) which keys of type [K] split into
  /// parts of type [P], and values of type [V].
  class Trie<K, P extends Comparable<P>, V> extends MapBase<K, V> {
    /// Creates an empty [Trie] that splits the keys of type [K] into [parts] of
    /// type [P] with the provided function. Optionally a custom [root] node can
    /// be provided.
    factory Trie({required GetParts<K, P> parts, TrieNode<K, P, V>? root}) =>
        Trie._(root ?? TrieNodeImpl<K, P, V>(), parts);
  
    /// Creates a [Trie] from another instance. Optionally redefines how the
    /// [parts] of the keys are computed and provides a custom [root] node.
    factory Trie.fromTrie(Trie<K, P, V> other,
            {GetParts<K, P>? parts, TrieNode<K, P, V>? root}) =>
        Trie<K, P, V>.fromMap(other, parts: parts ?? other._getParts, root: root);
  
    /// Creates a [Trie] from a [Map]. The [parts] define how the keys are
    /// computed and optionally provides a custom [root] node.
    factory Trie.fromMap(Map<K, V> other,
        {required GetParts<K, P> parts, TrieNode<K, P, V>? root}) {
      final result = Trie<K, P, V>(parts: parts, root: root);
  