anchor.diff:    }
   
     AffineTransform translate(num dx, num dy) {
  -    _m02 += dx * _m00 + dy * _m01;
  -    _m12 += dx * _m10 + dy * _m11;
  +    _tX += dx * _scX + dy * _shX;
  +    _tY += dx * _shY + dy * _scY;
       return this;
     }
   
  
positive.code:   AffineTransform createInverse() {
      num det = determinant;
      return new AffineTransform(
          _m11 / det,
          -_m10 / det,
          -_m01 / det,
          _m00 / det,
          (_m01 * _m12 - _m11 * _m02) / det,
          (_m10 * _m02 - _m00 * _m12) / det);
    }
  
    AffineTransform lerpTx(AffineTransform other, num x) {
  
negative.code:     return new AffineTransform(1, 0, 0, 1, x, y);
    }
  
    num get scaleX => _scX;
  
    num get scaleY => _scY;
  
    num get translateX => _tX;
  
    num get translateY => _tY;
  
    Vector get translateVector => new Vector(translateX, translateY);
  
    num get shearX => _shX;
  
    num get shearY => _shY;
  
    num get determinant => _scX * _scY - _shX * _shY;
  
    bool get isIdentity {
      return _scX == 1 && _shY == 0 &&
          _shX == 0 && _scY == 1 &&
          _tX == 0 && _tY == 0;
    }
  
    AffineTransform scale(num sx, num sy) {
      _scX *= sx;
      _shY *= sx;
      _shX *= sy;
      _scY *= sy;
      return this;
    }
  
    AffineTransform concatenate(tx) {
      var m0 = this._scX;
      var m1 = this._shX;
      this._scX = tx._scX * m0 + tx._shY * m1;
      this._shX = tx._shX * m0 + tx._scY * m1;
      this._tX += tx._tX * m0 + tx._tY * m1;
  
      m0 = this._shY;
      m1 = this._scY;
      this._shY = tx._scX * m0 + tx._shY * m1;
      this._scY = tx._shX * m0 + tx._scY * m1;
      this._tY += tx._tX * m0 + tx._tY * m1;
      return this;
    }
  
  