anchor.diff:    // * 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).
  +  //
  +  // The type labels below must not change, since it's possible for this interface
  +  // to be used for persistent storage.
     static const int _valueNull = 0;
     static const int _valueTrue = 1;
     static const int _valueFalse = 2;
  
positive.code:   //   * values 2^16+1..2^32 inclusive using five bytes, the first of which is
    //     255, the next four the usual unsigned representation of the value.
    // * null, true, and false have empty serialization; they are encoded directly
    //   in the type byte (using _kNull, _kTrue, _kFalse)
    // * Integers representable in 32 bits are encoded using 4 bytes two's
    //   complement representation.
    // * Larger integers are encoded using 8 bytes two's complement
  
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);
  