anchor.diff:    }
   
     /// Creates a [HashMap] that contains all key/value pairs of [other].
  +  /// Example:
  +  /// ```dart
  +  /// final baseMap = <int, String>{1: 'A', 2: 'B', 3: 'C'};
  +  /// final mapOf = HashMap<num, Object>.of(baseMap);
  +  /// print(mapOf); // {1: A, 2: B, 3: C}
  +  /// ```
     factory HashMap.of(Map<K, V> other) => HashMap<K, V>()..addAll(other);
   
     /// Creates a [HashMap] where the keys and values are computed from the
  
positive.code:   /// new keys. If [equals] is omitted, the key's own [Object.==] is used
    /// instead.
    ///
    /// Similar, if [hashCode] is provided, it is used to produce a hash value
    /// for keys in order to place them in the map. If [hashCode] is omitted,
    /// the key's own [Object.hashCode] is used.
    ///
    /// The used `equals` and `hashCode` method should always be consistent,
    /// so that if `equals(a, b)` then `hashCode(a) == hashCode(b)`. The hash
    /// of an object, or what it compares equal to, should not change while the
    /// object is a key in the map. If it does change, the result is
    /// unpredictable.
  
negative.code: /// must be the same for objects that are considered equal by `==`.
  ///
  /// Iterating the map's keys, values or entries (through [forEach])
  /// may happen in any order. The iteration order only changes when the map is
  /// modified. Values are iterated in the same order as their associated keys,
  /// so iterating the [keys] and [values] in parallel
  /// will give matching key and value pairs.
  ///
  /// **Notice:**
  /// Do not modify a map (add or remove keys) while an operation
  /// is being performed on that map, for example in functions
  /// called during a [forEach] or [putIfAbsent] call,
  /// or while iterating the map ([keys], [values] or [entries]).
  ///
  /// Example:
  /// ```dart
  /// final Map<int, String> planets = HashMap(); // Is a HashMap
  /// ```
  /// To add data to a map, use [operator[]=], [addAll] or [addEntries].
  /// ```
  /// planets[3] = 'Earth';
  /// planets.addAll({4: 'Mars'});
  /// final gasGiants = {6: 'Jupiter', 5: 'Saturn'};
  /// planets.addEntries(gasGiants.entries);
  /// print(planets); // fx {5: Saturn, 6: Jupiter, 3: Earth, 4: Mars}
  /// ```
  /// To check if the map is empty, use [isEmpty] or [isNotEmpty].
  /// To find the number of map entries, use [length].
  /// ```
  /// final isEmpty = planets.isEmpty; // false
  /// final length = planets.length; // 4
  /// ```
  /// The [forEach] iterates through all entries of a map.
  /// ```
  /// planets.forEach((key, value) {
  ///   print('$key \t $value');
  ///   // 5        Saturn
  ///   // 4        Mars
  ///   // 3        Earth
  ///   // 6        Jupiter
  /// });
  /// ```
  /// To check whether the map has an entry with a specific key, use [containsKey].
  /// ```
  /// final keyOneExists = planets.containsKey(4); // true
  /// final keyFiveExists = planets.containsKey(1); // false
  /// ```
  /// To check whether the map has an entry with a specific value,
  /// use [containsValue].
  /// ```
  /// final marsExists = planets.containsValue('Mars'); // true
  /// final venusExists = planets.containsValue('Venus'); // false
  /// ```
  /// To remove an entry with a specific key, use [remove].
  /// ```
  /// final removeValue = planets.remove(5);
  /// print(removeValue); // Jupiter
  /// print(planets); // fx {4: Mars, 3: Earth, 5: Saturn}
  /// ```
  /// To remove multiple entries at the same time, based on their keys and values,
  /// use [removeWhere].
  /// ```
  /// planets.removeWhere((key, value) => key == 5);
  /// print(planets); // fx {3: Earth, 4: Mars}
  /// ```
  /// To conditionally add or modify a value for a specific key, depending on
  /// whether there already is an entry with that key,
  /// use [putIfAbsent] or [update].
  /// ```
  /// planets.update(4, (v) => 'Saturn');
  /// planets.update(8, (v) => '', ifAbsent: () => 'Neptune');
  /// planets.putIfAbsent(4, () => 'Another Saturn');
  /// print(planets); // fx {4: Saturn, 8: Neptune, 3: Earth}
  /// ```
  /// To update the values of all keys, based on the existing key and value,
  /// use [updateAll].
  /// ```
  /// planets.updateAll((key, value) => 'X');
  /// print(planets); // fx {8: X, 3: X, 4: X}
  /// ```
  /// To remove all entries and empty the map, use [clear].
  /// ```
  /// planets.clear();
  /// print(planets); // {}
  /// print(planets.isEmpty); // true
  /// ```
  ///
  /// **See also:**
  /// * [Map], the general interface of key/value pair collections.
  /// * [LinkedHashMap] iterates in key insertion order.
  /// * [SplayTreeMap] iterates the keys in sorted order.
  abstract class HashMap<K, V> implements Map<K, V> {
    /// Creates an unordered hash-table based [Map].
    ///
  