anchor.diff:  ///  * [List]\: `NSArray`
   ///  * [Map]\: `NSDictionary`
   ///
  +/// When sending a `java.math.BigInteger` from Java, it is converted into a
  +/// [String] with the hexadecimal representation of the integer. (The value is
  +/// tagged as being a big integer; subclasses of this class could be made to
  +/// support it natively; see the discussion at [writeValue].) This codec does
  +/// not support sending big integers from Dart.
  +///
   /// The codec is extensible by subclasses overriding [writeValue] and
   /// [readValueOfType].
   class StandardMessageCodec implements MessageCodec<dynamic> {
     /// Creates a [MessageCodec] using the Flutter standard binary encoding.
     const StandardMessageCodec();
   
  -  // The codec serializes messages as outlined below. This format must
  -  // match the Android and iOS counterparts.
  +  // The codec serializes messages as outlined below. This format must match the
  +  // Android and iOS counterparts and cannot change (as it's possible for
  +  // someone to end up using this for persistent storage).
     //
     // * A single byte with one of the constant values below determines the
     //   type of the value.
  
positive.code:   // * Maps are encoded by first encoding their length in the expanding format,
    //   then follows the recursive encoding of each key/value pair, including the
    //   type byte for both (Maps are assumed to be heterogeneous).
    static const int _valueNull = 0;
    static const int _valueTrue = 1;
    static const int _valueFalse = 2;
  
negative.code: 
    /// Reads a value of the indicated [type] from [buffer].
    ///
    /// The codec can be extended by overriding this method, calling super for
    /// types that the extension does not handle. See the discussion at
    /// [writeValue].
    dynamic readValueOfType(int type, ReadBuffer buffer) {
      switch (type) {
        case _valueNull:
          return null;
        case _valueTrue:
          return true;
        case _valueFalse:
          return false;
        case _valueInt32:
          return buffer.getInt32();
        case _valueInt64:
          return buffer.getInt64();
        case _valueFloat64:
          return buffer.getFloat64();
        case _valueLargeInt:
        case _valueString:
          final int length = readSize(buffer);
          return utf8.decoder.convert(buffer.getUint8List(length));
        case _valueUint8List:
          final int length = readSize(buffer);
          return buffer.getUint8List(length);
        case _valueInt32List:
          final int length = readSize(buffer);
          return buffer.getInt32List(length);
        case _valueInt64List:
          final int length = readSize(buffer);
          return buffer.getInt64List(length);
        case _valueFloat64List:
          final int length = readSize(buffer);
          return buffer.getFloat64List(length);
        case _valueList:
          final int length = readSize(buffer);
          final dynamic result = List<dynamic>(length);
          for (int i = 0; i < length; i++)
            result[i] = readValue(buffer);
          return result;
        case _valueMap:
          final int length = readSize(buffer);
          final dynamic result = <dynamic, dynamic>{};
          for (int i = 0; i < length; i++)
            result[readValue(buffer)] = readValue(buffer);
          return result;
        default: throw const FormatException('Message corrupted');
      }
    }
  
    /// Writes a non-negative 32-bit integer [value] to [buffer]
  