diff --git a/docker-compose.yml b/docker-compose.yml
index f3850e17..3a4527e8 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -18,7 +18,7 @@ services:
   analysis:
     build: ./
     working_dir: /project
-    command: bash -c "composer install && ./vendor/bin/phpstan analyze --memory-limit=512M --level=4 ./src"
+    command: bash -c "composer install && ./vendor/bin/phpstan analyze --memory-limit=512M ./src"
     volumes:
       - ./:/project
   standards:
diff --git a/phpstan.dist.neon b/phpstan.dist.neon
index 0b689b56..a2a6f826 100644
--- a/phpstan.dist.neon
+++ b/phpstan.dist.neon
@@ -1,5 +1,5 @@
 parameters:
-    level: 4
+    level: 5
     paths:
         - src
     exceptions:
diff --git a/src/Colors/Cmyk/Colorspace.php b/src/Colors/Cmyk/Colorspace.php
index 2b64030f..e7ab6aec 100644
--- a/src/Colors/Cmyk/Colorspace.php
+++ b/src/Colors/Cmyk/Colorspace.php
@@ -9,6 +9,7 @@
 use Intervention\Image\Colors\Hsv\Color as HsvColor;
 use Intervention\Image\Colors\Hsl\Color as HslColor;
 use Intervention\Image\Colors\Rgb\Colorspace as RgbColorspace;
+use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Interfaces\ColorInterface;
 use Intervention\Image\Interfaces\ColorspaceInterface;
 
@@ -36,9 +37,9 @@ public function colorFromNormalized(array $normalized): ColorInterface
     }
 
     /**
-     * {@inheritdoc}
-     *
-     * @see ColorspaceInterface::importColor()
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
      */
     public function importColor(ColorInterface $color): ColorInterface
     {
@@ -50,8 +51,17 @@ public function importColor(ColorInterface $color): ColorInterface
         };
     }
 
-    protected function importRgbColor(RgbColor $color): CmykColor
+    /**
+     * @param ColorInterface $color
+     * @return Color
+     * @throws ColorException
+     */
+    protected function importRgbColor(ColorInterface $color): CmykColor
     {
+        if (!($color instanceof RgbColor)) {
+            throw new ColorException('Unabled to import color of type ' . $color::class . '.');
+        }
+
         $c = (255 - $color->red()->value()) / 255.0 * 100;
         $m = (255 - $color->green()->value()) / 255.0 * 100;
         $y = (255 - $color->blue()->value()) / 255.0 * 100;
diff --git a/src/Colors/Hsl/Colorspace.php b/src/Colors/Hsl/Colorspace.php
index c8baf320..e2b7d35d 100644
--- a/src/Colors/Hsl/Colorspace.php
+++ b/src/Colors/Hsl/Colorspace.php
@@ -8,6 +8,7 @@
 use Intervention\Image\Colors\Rgb\Color as RgbColor;
 use Intervention\Image\Colors\Hsv\Color as HsvColor;
 use Intervention\Image\Colors\Rgb\Colorspace as RgbColorspace;
+use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Interfaces\ColorInterface;
 use Intervention\Image\Interfaces\ColorspaceInterface;
 
@@ -33,6 +34,11 @@ public function colorFromNormalized(array $normalized): ColorInterface
         return new Color(...$values);
     }
 
+    /**
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
+     */
     public function importColor(ColorInterface $color): ColorInterface
     {
         return match ($color::class) {
@@ -43,8 +49,17 @@ public function importColor(ColorInterface $color): ColorInterface
         };
     }
 
-    protected function importRgbColor(RgbColor $color): ColorInterface
+    /**
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
+     */
+    protected function importRgbColor(ColorInterface $color): ColorInterface
     {
+        if (!($color instanceof RgbColor)) {
+            throw new ColorException('Unabled to import color of type ' . $color::class . '.');
+        }
+
         // normalized values of rgb channels
         $values = array_map(function ($channel) {
             return $channel->normalize();
@@ -84,8 +99,17 @@ protected function importRgbColor(RgbColor $color): ColorInterface
         );
     }
 
-    protected function importHsvColor(HsvColor $color): ColorInterface
+    /**
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
+     */
+    protected function importHsvColor(ColorInterface $color): ColorInterface
     {
+        if (!($color instanceof HsvColor)) {
+            throw new ColorException('Unabled to import color of type ' . $color::class . '.');
+        }
+
         // normalized values of hsv channels
         list($h, $s, $v) = array_map(function ($channel) {
             return $channel->normalize();
diff --git a/src/Colors/Hsv/Colorspace.php b/src/Colors/Hsv/Colorspace.php
index c6f2f545..ad390275 100644
--- a/src/Colors/Hsv/Colorspace.php
+++ b/src/Colors/Hsv/Colorspace.php
@@ -8,6 +8,7 @@
 use Intervention\Image\Colors\Rgb\Color as RgbColor;
 use Intervention\Image\Colors\Hsl\Color as HslColor;
 use Intervention\Image\Colors\Rgb\Colorspace as RgbColorspace;
+use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Interfaces\ColorInterface;
 use Intervention\Image\Interfaces\ColorspaceInterface;
 
@@ -34,9 +35,9 @@ public function colorFromNormalized(array $normalized): ColorInterface
     }
 
     /**
-     * {@inheritdoc}
-     *
-     * @see ColorspaceInterface::importColor()
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
      */
     public function importColor(ColorInterface $color): ColorInterface
     {
@@ -48,8 +49,17 @@ public function importColor(ColorInterface $color): ColorInterface
         };
     }
 
-    protected function importRgbColor(RgbColor $color): ColorInterface
+    /**
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
+     */
+    protected function importRgbColor(ColorInterface $color): ColorInterface
     {
+        if (!($color instanceof RgbColor)) {
+            throw new ColorException('Unabled to import color of type ' . $color::class . '.');
+        }
+
         // normalized values of rgb channels
         $values = array_map(function ($channel) {
             return $channel->normalize();
@@ -89,8 +99,17 @@ protected function importRgbColor(RgbColor $color): ColorInterface
         );
     }
 
-    protected function importHslColor(HslColor $color): ColorInterface
+    /**
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
+     */
+    protected function importHslColor(ColorInterface $color): ColorInterface
     {
+        if (!($color instanceof HslColor)) {
+            throw new ColorException('Unabled to import color of type ' . $color::class . '.');
+        }
+
         // normalized values of hsl channels
         list($h, $s, $l) = array_map(function ($channel) {
             return $channel->normalize();
diff --git a/src/Colors/Rgb/Colorspace.php b/src/Colors/Rgb/Colorspace.php
index 0335eabd..3c9b4787 100644
--- a/src/Colors/Rgb/Colorspace.php
+++ b/src/Colors/Rgb/Colorspace.php
@@ -7,6 +7,7 @@
 use Intervention\Image\Colors\Hsv\Color as HsvColor;
 use Intervention\Image\Colors\Hsl\Color as HslColor;
 use Intervention\Image\Colors\Cmyk\Color as CmykColor;
+use Intervention\Image\Exceptions\ColorException;
 use Intervention\Image\Interfaces\ColorInterface;
 use Intervention\Image\Interfaces\ColorspaceInterface;
 
@@ -34,9 +35,9 @@ public function colorFromNormalized(array $normalized): ColorInterface
     }
 
     /**
-     * {@inheritdoc}
-     *
-     * @see ColorspaceInterface::importColor()
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
      */
     public function importColor(ColorInterface $color): ColorInterface
     {
@@ -48,8 +49,17 @@ public function importColor(ColorInterface $color): ColorInterface
         };
     }
 
-    protected function importCmykColor(CmykColor $color): ColorInterface
+    /**
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
+     */
+    protected function importCmykColor(ColorInterface $color): ColorInterface
     {
+        if (!($color instanceof CmykColor)) {
+            throw new ColorException('Unabled to import color of type ' . $color::class . '.');
+        }
+
         return new Color(
             (int) (255 * (1 - $color->cyan()->normalize()) * (1 - $color->key()->normalize())),
             (int) (255 * (1 - $color->magenta()->normalize()) * (1 - $color->key()->normalize())),
@@ -57,8 +67,17 @@ protected function importCmykColor(CmykColor $color): ColorInterface
         );
     }
 
-    protected function importHsvColor(HsvColor $color): ColorInterface
+    /**
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
+     */
+    protected function importHsvColor(ColorInterface $color): ColorInterface
     {
+        if (!($color instanceof HsvColor)) {
+            throw new ColorException('Unabled to import color of type ' . $color::class . '.');
+        }
+
         $chroma = $color->value()->normalize() * $color->saturation()->normalize();
         $hue = $color->hue()->normalize() * 6;
         $x = $chroma * (1 - abs(fmod($hue, 2) - 1));
@@ -83,8 +102,17 @@ protected function importHsvColor(HsvColor $color): ColorInterface
         return $this->colorFromNormalized($values);
     }
 
-    protected function importHslColor(HslColor $color): ColorInterface
+    /**
+     * @param ColorInterface $color
+     * @return ColorInterface
+     * @throws ColorException
+     */
+    protected function importHslColor(ColorInterface $color): ColorInterface
     {
+        if (!($color instanceof HslColor)) {
+            throw new ColorException('Unabled to import color of type ' . $color::class . '.');
+        }
+
         // normalized values of hsl channels
         list($h, $s, $l) = array_map(function ($channel) {
             return $channel->normalize();
diff --git a/src/Format.php b/src/Format.php
index 3b81b1cd..da48a116 100644
--- a/src/Format.php
+++ b/src/Format.php
@@ -16,6 +16,7 @@
 use Intervention\Image\Encoders\WebpEncoder;
 use Intervention\Image\Exceptions\NotSupportedException;
 use Intervention\Image\Interfaces\EncoderInterface;
+use ReflectionClass;
 
 enum Format
 {
@@ -88,23 +89,43 @@ public function fileExtensions(): array
     }
 
     /**
-     * Create an encoder instance that matches the format
+     * Create an encoder instance with given options that matches the format
      *
-     * @param array $options
+     * @param mixed $options
      * @return EncoderInterface
      */
     public function encoder(mixed ...$options): EncoderInterface
     {
-        return match ($this) {
-            self::AVIF => new AvifEncoder(...$options),
-            self::BMP => new BmpEncoder(...$options),
-            self::GIF => new GifEncoder(...$options),
-            self::HEIC => new HeicEncoder(...$options),
-            self::JP2 => new Jpeg2000Encoder(...$options),
-            self::JPEG => new JpegEncoder(...$options),
-            self::PNG => new PngEncoder(...$options),
-            self::TIFF => new TiffEncoder(...$options),
-            self::WEBP => new WebpEncoder(...$options),
+        // get classname of target encoder from current format
+        $classname = match ($this) {
+            self::AVIF => AvifEncoder::class,
+            self::BMP => BmpEncoder::class,
+            self::GIF => GifEncoder::class,
+            self::HEIC => HeicEncoder::class,
+            self::JP2 => Jpeg2000Encoder::class,
+            self::JPEG => JpegEncoder::class,
+            self::PNG => PngEncoder::class,
+            self::TIFF => TiffEncoder::class,
+            self::WEBP => WebpEncoder::class,
         };
+
+        // get parameters of target encoder
+        $parameters = [];
+        $reflectionClass = new ReflectionClass($classname);
+        if ($constructor = $reflectionClass->getConstructor()) {
+            $parameters = array_map(
+                fn ($parameter) => $parameter->getName(),
+                $constructor->getParameters(),
+            );
+        }
+
+        // filter out unavailable options of target encoder
+        $options = array_filter(
+            $options,
+            fn ($key) => in_array($key, $parameters),
+            ARRAY_FILTER_USE_KEY,
+        );
+
+        return new $classname(...$options);
     }
 }
diff --git a/src/Geometry/Point.php b/src/Geometry/Point.php
index 29cb2d2e..7f524838 100644
--- a/src/Geometry/Point.php
+++ b/src/Geometry/Point.php
@@ -113,17 +113,17 @@ public function setPosition(int $x, int $y): self
      * Rotate point ccw around pivot
      *
      * @param float $angle
-     * @param Point $pivot
+     * @param PointInterface $pivot
      * @return Point
      */
-    public function rotate(float $angle, self $pivot): self
+    public function rotate(float $angle, PointInterface $pivot): self
     {
         $sin = round(sin(deg2rad($angle)), 6);
         $cos = round(cos(deg2rad($angle)), 6);
 
         return $this->setPosition(
-            intval($cos * ($this->x - $pivot->x) - $sin * ($this->y - $pivot->y) + $pivot->x),
-            intval($sin * ($this->x - $pivot->x) + $cos * ($this->y - $pivot->y) + $pivot->y)
+            intval($cos * ($this->x() - $pivot->x()) - $sin * ($this->y() - $pivot->y()) + $pivot->x()),
+            intval($sin * ($this->x() - $pivot->x()) + $cos * ($this->y() - $pivot->y()) + $pivot->y())
         );
     }
 }
diff --git a/src/Modifiers/CropModifier.php b/src/Modifiers/CropModifier.php
index d14958d6..ffc6b499 100644
--- a/src/Modifiers/CropModifier.php
+++ b/src/Modifiers/CropModifier.php
@@ -17,7 +17,7 @@ public function __construct(
         public int $height,
         public int $offset_x = 0,
         public int $offset_y = 0,
-        public mixed $background = 'f00',
+        public mixed $background = 'ffffff',
         public string $position = 'top-left'
     ) {
     }
diff --git a/tests/Unit/Encoders/FileExtensionEncoderTest.php b/tests/Unit/Encoders/FileExtensionEncoderTest.php
index 8d111b98..4e28d9fc 100644
--- a/tests/Unit/Encoders/FileExtensionEncoderTest.php
+++ b/tests/Unit/Encoders/FileExtensionEncoderTest.php
@@ -18,13 +18,19 @@
 use Intervention\Image\FileExtension;
 use Intervention\Image\Interfaces\EncoderInterface;
 use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
 
 final class FileExtensionEncoderTest extends BaseTestCase
 {
-    private function testEncoder(string|FileExtension $extension): EncoderInterface
+    private function testEncoder(string|FileExtension $extension, array $options = []): EncoderInterface
     {
-        $encoder = new class () extends FileExtensionEncoder
+        $encoder = new class ($extension, ...$options) extends FileExtensionEncoder
         {
+            public function __construct($mediaType, ...$options)
+            {
+                parent::__construct($mediaType, ...$options);
+            }
+
             public function test($extension)
             {
                 return $this->encoderByFileExtension($extension);
@@ -34,100 +40,56 @@ public function test($extension)
         return $encoder->test($extension);
     }
 
-    public function testEncoderByFileExtensionString(): void
-    {
-        $this->assertInstanceOf(
-            WebpEncoder::class,
-            $this->testEncoder('webp')
-        );
-
+    #[DataProvider('targetEncoderProvider')]
+    public function testEncoderByFileExtensionString(
+        string|FileExtension $fileExtension,
+        string $targetEncoderClassname,
+    ): void {
         $this->assertInstanceOf(
-            AvifEncoder::class,
-            $this->testEncoder('avif')
-        );
-
-        $this->assertInstanceOf(
-            JpegEncoder::class,
-            $this->testEncoder('jpeg')
-        );
-
-        $this->assertInstanceOf(
-            BmpEncoder::class,
-            $this->testEncoder('bmp')
-        );
-
-        $this->assertInstanceOf(
-            GifEncoder::class,
-            $this->testEncoder('gif')
-        );
-
-        $this->assertInstanceOf(
-            PngEncoder::class,
-            $this->testEncoder('png')
-        );
-
-        $this->assertInstanceOf(
-            TiffEncoder::class,
-            $this->testEncoder('tiff')
-        );
-
-        $this->assertInstanceOf(
-            Jpeg2000Encoder::class,
-            $this->testEncoder('jp2')
-        );
-
-        $this->assertInstanceOf(
-            HeicEncoder::class,
-            $this->testEncoder('heic')
+            $targetEncoderClassname,
+            $this->testEncoder($fileExtension),
         );
     }
 
-    public function testEncoderByFileExtensionEnumMember(): void
+    public static function targetEncoderProvider(): array
     {
-        $this->assertInstanceOf(
-            WebpEncoder::class,
-            $this->testEncoder(FileExtension::WEBP)
-        );
-
-        $this->assertInstanceOf(
-            AvifEncoder::class,
-            $this->testEncoder(FileExtension::AVIF)
-        );
-
-        $this->assertInstanceOf(
-            JpegEncoder::class,
-            $this->testEncoder(FileExtension::JPG)
-        );
-
-        $this->assertInstanceOf(
-            BmpEncoder::class,
-            $this->testEncoder(FileExtension::BMP)
-        );
-
-        $this->assertInstanceOf(
-            GifEncoder::class,
-            $this->testEncoder(FileExtension::GIF)
-        );
-
-        $this->assertInstanceOf(
-            PngEncoder::class,
-            $this->testEncoder(FileExtension::PNG)
-        );
-
-        $this->assertInstanceOf(
-            TiffEncoder::class,
-            $this->testEncoder(FileExtension::TIF)
-        );
+        return [
+            ['webp', WebpEncoder::class],
+            ['avif', AvifEncoder::class],
+            ['jpeg', JpegEncoder::class],
+            ['jpg', JpegEncoder::class],
+            ['bmp', BmpEncoder::class],
+            ['gif', GifEncoder::class],
+            ['png', PngEncoder::class],
+            ['tiff', TiffEncoder::class],
+            ['tif', TiffEncoder::class],
+            ['jp2', Jpeg2000Encoder::class],
+            ['heic', HeicEncoder::class],
+            [FileExtension::WEBP, WebpEncoder::class],
+            [FileExtension::AVIF, AvifEncoder::class],
+            [FileExtension::JPG, JpegEncoder::class],
+            [FileExtension::BMP, BmpEncoder::class],
+            [FileExtension::GIF, GifEncoder::class],
+            [FileExtension::PNG, PngEncoder::class],
+            [FileExtension::TIF, TiffEncoder::class],
+            [FileExtension::TIFF, TiffEncoder::class],
+            [FileExtension::JP2, Jpeg2000Encoder::class],
+            [FileExtension::HEIC, HeicEncoder::class],
+        ];
+    }
 
-        $this->assertInstanceOf(
-            Jpeg2000Encoder::class,
-            $this->testEncoder(FileExtension::JPG2)
+    public function testArgumentsNotSupportedByTargetEncoder(): void
+    {
+        $encoder = $this->testEncoder(
+            'png',
+            [
+                'interlaced' => true, // is not ignored
+                'quality' => 10, // is ignored because png encoder has no quality argument
+            ],
         );
 
-        $this->assertInstanceOf(
-            HeicEncoder::class,
-            $this->testEncoder(FileExtension::HEIC)
-        );
+        $this->assertInstanceOf(PngEncoder::class, $encoder);
+        $this->assertTrue($encoder->interlaced);
     }
 
     public function testEncoderByFileExtensionUnknown(): void
diff --git a/tests/Unit/Encoders/MediaTypeEncoderTest.php b/tests/Unit/Encoders/MediaTypeEncoderTest.php
new file mode 100644
index 00000000..713611ac
--- /dev/null
+++ b/tests/Unit/Encoders/MediaTypeEncoderTest.php
@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Intervention\Image\Tests\Unit\Encoders;
+
+use Intervention\Image\Encoders\AvifEncoder;
+use Intervention\Image\Encoders\BmpEncoder;
+use Intervention\Image\Encoders\GifEncoder;
+use Intervention\Image\Encoders\HeicEncoder;
+use Intervention\Image\Encoders\Jpeg2000Encoder;
+use Intervention\Image\Encoders\JpegEncoder;
+use Intervention\Image\Encoders\MediaTypeEncoder;
+use Intervention\Image\Encoders\PngEncoder;
+use Intervention\Image\Encoders\TiffEncoder;
+use Intervention\Image\Encoders\WebpEncoder;
+use Intervention\Image\Exceptions\EncoderException;
+use Intervention\Image\Interfaces\EncoderInterface;
+use Intervention\Image\MediaType;
+use Intervention\Image\Tests\BaseTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+final class MediaTypeEncoderTest extends BaseTestCase
+{
+    private function testEncoder(string|MediaType $mediaType, array $options = []): EncoderInterface
+    {
+        $encoder = new class ($mediaType, ...$options) extends MediaTypeEncoder
+        {
+            public function __construct($mediaType, ...$options)
+            {
+                parent::__construct($mediaType, ...$options);
+            }
+
+            public function test($mediaType)
+            {
+                return $this->encoderByMediaType($mediaType);
+            }
+        };
+
+        return $encoder->test($mediaType);
+    }
+
+    #[DataProvider('targetEncoderProvider')]
+    public function testEncoderByMediaType(
+        string|MediaType $mediaType,
+        string $targetEncoderClassname,
+    ): void {
+        $this->assertInstanceOf(
+            $targetEncoderClassname,
+            $this->testEncoder($mediaType)
+        );
+    }
+
+    public static function targetEncoderProvider(): array
+    {
+        return [
+            ['image/webp', WebpEncoder::class],
+            ['image/avif', AvifEncoder::class],
+            ['image/jpeg', JpegEncoder::class],
+            ['image/bmp', BmpEncoder::class],
+            ['image/gif', GifEncoder::class],
+            ['image/png', PngEncoder::class],
+            ['image/png', PngEncoder::class],
+            ['image/tiff', TiffEncoder::class],
+            ['image/jp2', Jpeg2000Encoder::class],
+            ['image/heic', HeicEncoder::class],
+            [MediaType::IMAGE_WEBP, WebpEncoder::class],
+            [MediaType::IMAGE_AVIF, AvifEncoder::class],
+            [MediaType::IMAGE_JPEG, JpegEncoder::class],
+            [MediaType::IMAGE_BMP, BmpEncoder::class],
+            [MediaType::IMAGE_GIF, GifEncoder::class],
+            [MediaType::IMAGE_PNG, PngEncoder::class],
+            [MediaType::IMAGE_TIFF, TiffEncoder::class],
+            [MediaType::IMAGE_JP2, Jpeg2000Encoder::class],
+            [MediaType::IMAGE_HEIC, HeicEncoder::class],
+            [MediaType::IMAGE_HEIF, HeicEncoder::class],
+        ];
+    }
+
+    public function testArgumentsNotSupportedByTargetEncoder(): void
+    {
+        $encoder = $this->testEncoder(
+            'image/png',
+            [
+                'interlaced' => true, // is not ignored
+                'quality' => 10, // is ignored because png encoder has no quality argument
+            ],
+        );
+
+        $this->assertInstanceOf(PngEncoder::class, $encoder);
+        $this->assertTrue($encoder->interlaced);
+    }
+
+    public function testEncoderByFileExtensionUnknown(): void
+    {
+        $this->expectException(EncoderException::class);
+        $this->testEncoder('test');
+    }
+}