anchor.diff:    static Rect lerp(Rect a, Rect b, double t) {
       assert(t != null);
       if (a == null && b == null) return null;
  -    if (a == null) {
  +    if (a == null)
         return Rect.fromLTRB(b.left * t, b.top * t, b.right * t, b.bottom * t);
  -    }
       if (b == null) {
         final double k = 1.0 - t;
         return Rect.fromLTRB(a.left * k, a.top * k, a.right * k, a.bottom * k);
  
positive.code:     if (identical(this, other)) return true;
      if (runtimeType != other.runtimeType) return false;
      final Rect typedOther = other;
      for (int i = 0; i < _kDataSize; i += 1) {
        if (_value[i] != typedOther._value[i]) return false;
      }
      return true;
    }
  
    @override
    int get hashCode => hashList(_value);
  
    @override
    String toString() =>
  
negative.code: /// ```dart
  /// Rect myRect = const Offset(1.0, 2.0) & const Size(3.0, 4.0);
  /// ```
  /// An immutable, 2D, axis-aligned, floating-point rectangle whose coordinates
  /// are relative to a given origin.
  ///
  /// A Rect can be created with one its constructors or from an [Offset] and a
  /// [Size] using the `&` operator:
  ///
  /// ```dart
  /// Rect myRect = const Offset(1.0, 2.0) & const Size(3.0, 4.0);
  /// ```
  class Rect {
    /// Construct a rectangle from its left, top, right, and bottom edges.
    @pragma('vm:entry-point')
    const Rect.fromLTRB(this.left, this.top, this.right, this.bottom)
        : assert(left != null),
          assert(top != null),
          assert(right != null),
          assert(bottom != null);
  
    /// Construct a rectangle from its left and top edges, its width, and its
    /// height.
    ///
    /// To construct a [Rect] from an [Offset] and a [Size], you can use the
    /// rectangle constructor operator `&`. See [Offset.&].
    const Rect.fromLTWH(double left, double top, double width, double height)
        : this.fromLTRB(left, top, left + width, top + height);
  
    /// Construct a rectangle that bounds the given circle.
    ///
    /// The `center` argument is assumed to be an offset from the origin.
    Rect.fromCircle({Offset center, double radius})
        : this.fromCenter(
            center: center,
            width: radius * 2,
            height: radius * 2,
          );
  
    /// Constructs a rectangle from its center point, width, and height.
    ///
    /// The `center` argument is assumed to be an offset from the origin.
    Rect.fromCenter({Offset center, double width, double height})
        : this.fromLTRB(
            center.dx - width / 2,
            center.dy - height / 2,
            center.dx + width / 2,
            center.dy + height / 2,
          );
  
    /// Construct the smallest rectangle that encloses the given offsets, treating
    /// them as vectors from the origin.
    Rect.fromPoints(Offset a, Offset b)
        : this.fromLTRB(
            math.min(a.dx, b.dx),
            math.min(a.dy, b.dy),
            math.max(a.dx, b.dx),
            math.max(a.dy, b.dy),
          );
  
    /// The offset of the left edge of this rectangle from the x axis.
    final double left;
  
    /// The offset of the top edge of this rectangle from the y axis.
    final double top;
  
    /// The offset of the right edge of this rectangle from the x axis.
    final double right;
  
    /// The offset of the bottom edge of this rectangle from the y axis.
    final double bottom;
  
    /// The distance between the left and right edges of this rectangle.
    double get width => right - left;
  