anchor.diff:  
     /// 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.
  +  /// 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) {
  -    dynamic result;
       switch (type) {
         case _valueNull:
  -        result = null;
  -        break;
  +        return null;
         case _valueTrue:
  -        result = true;
  -        break;
  +        return true;
         case _valueFalse:
  -        result = false;
  -        break;
  +        return false;
         case _valueInt32:
  -        result = buffer.getInt32();
  -        break;
  +        return buffer.getInt32();
         case _valueInt64:
  -        result = buffer.getInt64();
  -        break;
  +        return buffer.getInt64();
  +      case _valueFloat64:
  +        return buffer.getFloat64();
         case _valueLargeInt:
  -        // Flutter Engine APIs to use large ints have been deprecated on
  -        // 2018-01-09 and will be made unavailable.
  -        // TODO(mravn): remove this case once the APIs are unavailable.
  -        final int length = readSize(buffer);
  -        final String hex = utf8.decoder.convert(buffer.getUint8List(length));
  -        result = int.parse(hex, radix: 16);
  -        break;
  -      case _valueFloat64:
  -        result = buffer.getFloat64();
  -        break;
         case _valueString:
           final int length = readSize(buffer);
  -        result = utf8.decoder.convert(buffer.getUint8List(length));
  -        break;
  +        return utf8.decoder.convert(buffer.getUint8List(length));
         case _valueUint8List:
           final int length = readSize(buffer);
  -        result = buffer.getUint8List(length);
  -        break;
  +        return buffer.getUint8List(length);
         case _valueInt32List:
           final int length = readSize(buffer);
  -        result = buffer.getInt32List(length);
  -        break;
  +        return buffer.getInt32List(length);
         case _valueInt64List:
           final int length = readSize(buffer);
  -        result = buffer.getInt64List(length);
  -        break;
  +        return buffer.getInt64List(length);
         case _valueFloat64List:
           final int length = readSize(buffer);
  -        result = buffer.getFloat64List(length);
  -        break;
  +        return buffer.getFloat64List(length);
         case _valueList:
           final int length = readSize(buffer);
  -        result = List<dynamic>(length);
  -        for (int i = 0; i < length; i++) {
  +        final dynamic result = List<dynamic>(length);
  +        for (int i = 0; i < length; i++)
             result[i] = readValue(buffer);
  -        }
  -        break;
  +        return result;
         case _valueMap:
           final int length = readSize(buffer);
  -        result = <dynamic, dynamic>{};
  -        for (int i = 0; i < length; i++) {
  +        final dynamic result = <dynamic, dynamic>{};
  +        for (int i = 0; i < length; i++)
             result[readValue(buffer)] = readValue(buffer);
  -        }
  -        break;
  +        return result;
         default: throw const FormatException('Message corrupted');
       }
  -    return result;
     }
   
     /// Writes a non-negative 32-bit integer [value] to [buffer]
  
positive.code: ///  * [List]\: `NSArray`
  ///  * [Map]\: `NSDictionary`
  ///
  /// 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.
    //
    // * A single byte with one of the constant values below determines the
    //   type of the value.
  
negative.code:   /// This method may be called recursively to serialize container values.
    ///
    /// Type discriminators 0 through 127 inclusive are reserved for use by the
    /// base class, as follows:
    ///
    ///  * null = 0
    ///  * true = 1
    ///  * false = 2
    ///  * 32 bit integer = 3
    ///  * 64 bit integer = 4
    ///  * larger integers = 5 (see below)
    ///  * 64 bit floating-point number = 6
    ///  * String = 7
    ///  * Uint8List = 8
    ///  * Int32List = 9
    ///  * Int64List = 10
    ///  * Float64List = 11
    ///  * List = 12
    ///  * Map = 13
    ///  * Reserved for future expansion: 14..127
    ///
    /// The codec can be extended by overriding this method, calling super
    /// for values that the extension does not handle. Type discriminators
    /// used by extensions must be greater than or equal to 128 in order to avoid
    /// clashes with any later extensions to the base class.
    ///
    /// The "larger integers" type, 5, is never used by [writeValue]. A subclass
    /// could represent big integers from another package using that type. The
    /// format is first the type byte (0x05), then the actual number as an ASCII
    /// string giving the hexadecimal representation of the integer, with the
    /// string's length as encoded by [writeSize] followed by the string bytes. On
    /// Android, that would get converted to a `java.math.BigInteger` object. On
    /// iOS, the string representation is returned.
    void writeValue(WriteBuffer buffer, dynamic value) {
      if (value == null) {
        buffer.putUint8(_valueNull);
  