anchor.diff:    /// Height of the image.
     final int height;
   
  +  /// The channels used by this image, indicating whether the alpha channel
  +  /// is used or not. All images have an implicit alpha channel due to the
  +  /// image data being stored in a Uint32, but some images, such as those
  +  /// decoded from a Jpeg, don't use the alpha channel. This allows
  +  /// image encoders that support both rgb and rgba formats, to know which
  +  /// one it should use.
     Channels channels;
   
  -  /// x position at which to render the frame.
  +  /// x position at which to render the frame. This is used for frames
  +  /// in an animation, such as from an animated GIF.
     int xOffset = 0;
   
  -  /// y position at which to render the frame.
  +  /// y position at which to render the frame. This is used for frames
  +  /// in an animation, such as from an animated GIF.
     int yOffset = 0;
   
     /// How long this frame should be displayed, in milliseconds.
  
positive.code:   /// as quickly as it can.
    int duration = 0;
  
    /// Defines what should be done to the canvas when drawing this frame.
    DisposeMode disposeMethod = DisposeMode.clear;
  
    /// Defines the blending method (alpha compositing) to use when drawing this
    /// frame.
    BlendMode blendMethod = BlendMode.over;
  
    /// Pixels are encoded into 4-byte integers, where each byte is an RGBA
    /// channel.
    final Uint32List data;
    ExifData exif;
    ICCProfileData iccProfile;
  
    /// Create an image with the given dimensions and format.
  
negative.code:   /// Is the given pixel coordinates within the resolution of the image.
    bool boundsSafe(int x, int y) => x >= 0 && x < width && y >= 0 && y < height;
  
    /// Get the pixel from the given [x], [y] coordinate. Color is encoded in a
    /// Uint32 as 0xAARRGGBB.
    int getPixel(int x, int y) => data[y * width + x];
  
    /// Get the pixel from the given [x], [y] coordinate. Color is encoded in a
    /// Uint32 as 0xAARRGGBB. If the pixel coordinates are out of bounds, 0 is
    /// returned.
    int getPixelSafe(int x, int y) => boundsSafe(x, y) ? data[y * width + x] : 0;
  
    /// Get the pixel using the given [interpolation] type for non-integer pixel
  