Intervention Image Laravel

https://github.com/intervention/image-laravel
Admin
Intervention Image Laravel is a Laravel integration package that provides an easy setup with service...
Tokens:17,018
Snippets:138
Trust Score:7.9
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Example: error handling around the macro

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/service-provider.md

Example showing how to handle NotSupportedException and RuntimeException when using the response()->image() macro. It catches driver encoding issues and falls back to JPEG, or aborts with a 500 error.

```php
use Intervention\Image\Exceptions\NotSupportedException;
use Intervention\Image\Exceptions\RuntimeException;

try {
    return response()->image($image, 'webp');
} catch (NotSupportedException $e) {
    // driver cannot encode webp — re-encode as jpeg
    return response()->image($image, 'jpg', quality: 80);
} catch (RuntimeException $e) {
    abort(500, 'Image encoding failed');
}
```

--------------------------------

### Instance usage of response()

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Shows how to instantiate ImageResponseFactory and call response() to get an HTTP response.

```php
use Intervention\Image\Laravel\ImageResponseFactory;

$factory = new ImageResponseFactory($image, 'jpg', quality: 85);
return $factory->response();
```

--------------------------------

### Dependency injection example from README.md

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/service-provider.md

Shows how to inject the ImageManagerInterface into a controller constructor and use it to decode an uploaded file. The example is from the README and demonstrates the dependency injection pattern enabled by the service provider's singleton bindings.

```php
use Intervention\Image\Interfaces\ImageManagerInterface;
use Illuminate\Http\Request;

class ImageController extends Controller
{
    /**
     * Create a new controller instance by injecting an image manager.
     */
    public function __construct(
        protected ImageManagerInterface $imageManager,
    ) {}

    public function handleImageUpload(Request $request): RedirectResponse
    {
        $image = $this->imageManager->decodeSplFileInfo($request->file('image'));
        // ...
    }
}
```

--------------------------------

### Basic call example

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Decodes an image and creates a response with WebP format and quality 65. Uses the Image facade and ImageResponseFactory.

```php
use Intervention\Image\Laravel\Facades\Image;
use Intervention\Image\Laravel\ImageResponseFactory;
use Intervention\Image\Format;

$image = Image::decode(public_path('images/example.jpg'));

return ImageResponseFactory::make($image, Format::WEBP, quality: 65);
```

--------------------------------

### Error handling example

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Catches NotSupportedException, DriverException, and RuntimeException when encoding to GIF, then falls back to the original format.

```php
use Intervention\Image\Laravel\ImageResponseFactory;
use Intervention\Image\Exceptions\NotSupportedException;
use Intervention\Image\Exceptions\DriverException;
use Intervention\Image\Exceptions\RuntimeException;

try {
    return ImageResponseFactory::make($image, 'gif');
} catch (NotSupportedException|DriverException|RuntimeException $e) {
    // fall back to the original format
    return ImageResponseFactory::make($image);
}
```

--------------------------------

### Install intervention/image-laravel with Composer

Source: https://github.com/intervention/image-laravel/blob/develop/README.md

Install the package in an existing Laravel application using Composer. Requires Laravel >= 8.

```bash
composer require intervention/image-laravel
```

--------------------------------

### boot() method for ServiceProvider

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/service-provider.md

The boot() method of the ServiceProvider. It publishes the config file and registers the 'image' response macro on the Response facade, guarded by a hasMacro check. The macro delegates to ImageResponseFactory::make().

```php
public function boot()
{
    // define config files for publishing
    $this->publishes([
        __DIR__ . '/../config/intervention-image.php' => config_path('intervention-image.php'),
    ]);

    // register response macro "image"
    ResponseFacade::resolved(function ($factory): void {
        if ($factory::hasMacro('image')) {
            return;
        }

        $factory::macro('image', function (
            ImageInterface $image,
            null|string|Format|MediaType|FileExtension $format = null,
            mixed ...$options,
        ): Response {
            return ImageResponseFactory::make($image, $format, ...$options);
        });
    });
}
```

--------------------------------

### make() method signature

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Static factory method to create an HTTP response directly from an image. Throws NotSupportedException, DriverException, or RuntimeException.

```php
/**
 * Static factory method to create HTTP response directly.
 *
 * @throws NotSupportedException
 * @throws DriverException
 * @throws RuntimeException
 */
public static function make(
    ImageInterface $image,
    null|string|Format|MediaType|FileExtension $format = null,
    mixed ...$options,
): Response {
    return (new self($image, $format, ...$options))->response();
}
```

--------------------------------

### response() method implementation

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Creates an HTTP response with the encoded image content and headers. Throws NotSupportedException, DriverException, or RuntimeException from encoding.

```php
/**
 * Create HTTP response.
 *
 * @throws NotSupportedException
 * @throws DriverException
 * @throws RuntimeException
 */
public function response(): Response
{
    return new Response(
        content: $this->content(),
        headers: $this->headers(),
    );
}
```

--------------------------------

### format() private method

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Resolves the $format argument to an Intervention\Image\Format. Handles Format, MediaType, FileExtension, string, and null inputs, with JPEG as fallback for null.

```php
/**
 * Determine the target format of the image in the HTTP response.
 */
private function format(): Format
{
    if ($this->format instanceof Format) {
        return $this->format;
    }

    if ($this->format instanceof MediaType) {
        return $this->format->format();
    }

    if ($this->format instanceof FileExtension) {
        return $this->format->format();
    }

    if (is_string($this->format)) {
        return Format::create($this->format);
    }

    // target format is undefined (null) at this point:
    // try to extract the original image format or use jpeg by default.
    return Format::tryCreate($this->image->origin()->mediaType()) ?? Format::JPEG;
}
```

--------------------------------

### Constructor signature

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Shows the constructor that accepts an ImageInterface, an optional format (string, Format, MediaType, or FileExtension), and variadic options. The options are stored in $options.

```php
public function __construct(
    protected ImageInterface $image,
    protected null|string|Format|MediaType|FileExtension $format = null,
    mixed ...$options,
) {
    $this->options = $options;
}
```

--------------------------------

### content() private method

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Encodes the image to a binary string using encodeUsingMediaType with the resolved format's media type and options. This is the only place encoder exceptions originate.

```php
/**
 * Read image contents.
 *
 * @throws NotSupportedException
 * @throws DriverException
 * @throws RuntimeException
 */
private function content(): string
{
    return (string) $this->image->encodeUsingMediaType(
        $this->format()->mediaType(),
        ...$this->options,
    );
}
```

--------------------------------

### register() method in src/ServiceProvider.php

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/service-provider.md

Registers the package configuration and binds ImageManager as a singleton under three keys: Facades\Image::BINDING, ImageManager::class, and ImageManagerInterface::class. Each binding resolves to a new ImageManager instance created with the merged config. Use this in the service provider's register method to enable dependency injection of the image manager.

```php
public function register()
{
    $this->mergeConfigFrom(
        __DIR__ . '/../config/intervention-image.php',
        'intervention-image',
    );

    $this->app->singleton(Facades\Image::BINDING, function () {
        return new ImageManager(...$this->config());
    });

    $this->app->singleton(ImageManager::class, function () {
        return new ImageManager(...$this->config());
    });

    $this->app->singleton(ImageManagerInterface::class, function () {
        return new ImageManager(...$this->config());
    });
}
```

--------------------------------

### Use response()->image macro to encode and return an image

Source: https://github.com/intervention/image-laravel/blob/develop/README.md

Use the response macro to encode an image and return it as an HTTP response in one call. The image is read from storage, scaled, and encoded as WebP with quality 65; only the first parameter is required.

```php
use Illuminate\Support\Facades\Route;
use Illuminate\Support\Facades\Storage;
use Intervention\Image\Format;
use Intervention\Image\Laravel\Facades\Image;

Route::get('/', function () {
    $image = Image::decode(Storage::get('example.jpg'));
    $image = $image->scale(300, 200);

    return response()->image($image, Format::WEBP, quality: 65);
});
```

--------------------------------

### response()

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Creates an HTTP response containing the encoded image binary with the appropriate Content-Type header.

```APIDOC
## `response()` — `src/ImageResponseFactory.php:58`

### Description
Creates an HTTP response containing the encoded image binary with the appropriate `Content-Type` header.

### Method
`response()`

### Parameters
None.

### Return Type
`Illuminate\Http\Response` — constructed with the encoded binary as `content` and a single `Content-Type` header.

### Throws
- `NotSupportedException`
- `DriverException`
- `RuntimeException`

### Example
```php
use Intervention\Image\Laravel\ImageResponseFactory;

$factory = new ImageResponseFactory($image, 'jpg', quality: 85);
return $factory->response();
```
```

--------------------------------

### config() helper in src/ServiceProvider.php:81

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/service-provider.md

Returns the flattened configuration that is spread into the ImageManager constructor. The default fallback values are exactly true / true / 'ffffff' / false (third arguments of config()), and the driver default comes from the merged package config.

```php
/**
 * @return array{
 *      'driver': string,
 *      'autoOrientation': bool,
 *      'decodeAnimation': bool,
 *      'backgroundColor': mixed,
 *      'strip': bool}
 */
private function config(): array
{
    $filename = $this->hasPublishedLegacyConfig() ? 'image' : 'intervention-image';

    return [
        'driver' => config($filename . '.driver'),
        'autoOrientation' => config($filename . '.options.autoOrientation', true),
        'decodeAnimation' => config($filename . '.options.decodeAnimation', true),
        'backgroundColor' => config($filename . '.options.backgroundColor', 'ffffff'),
        'strip' => config($filename . '.options.strip', false),
    ];
}
```

--------------------------------

### Image::decode() with DirectoryNotFoundException handling

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decoding a nonexistent file path throws Intervention\Image\Exceptions\DirectoryNotFoundException. Catch it to handle missing images.

```php
use Intervention\Image\Laravel\Facades\Image;
use Intervention\Image\Exceptions\DirectoryNotFoundException;

try {
    $image = Image::decode('path/to/non_existent_image.jpg');
} catch (DirectoryNotFoundException $e) {
    abort(404, 'Image not found');
}
```

--------------------------------

### make() — static factory

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Static factory method to create an HTTP response directly from an image. It encodes the image into the specified format and returns an Illuminate\Http\Response with status code 200, the encoded image binary as the body, and the appropriate Content-Type header.

```APIDOC
## `make()` — static factory

### Description
Static factory method to create an HTTP response directly from an image. It encodes the image into the specified format and returns an `Illuminate\Http\Response` with status code 200, the encoded image binary as the body, and the appropriate `Content-Type` header.

### Method
`make` (static)

### Signature
```php
public static function make(
    ImageInterface $image,
    null|string|Format|MediaType|FileExtension $format = null,
    mixed ...$options,
): Response
```

### Parameters
- **$image** (`ImageInterface`) - Required - The image to encode into the response
- **$format** (`null|string|Format|MediaType|FileExtension`) - Optional - Target output format. Default: `null`
- **...$options** (`mixed`) - Optional - Encoder options. Default: `[]`

### Return Type
`Illuminate\Http\Response` — an HTTP response whose status code is `200`, body is the encoded image binary, and whose `Content-Type` header matches the resolved format's media type.

### Throws
- `NotSupportedException`
- `DriverException`
- `RuntimeException`

### Example — basic call
```php
use Intervention\Image\Laravel\Facades\Image;
use Intervention\Image\Laravel\ImageResponseFactory;
use Intervention\Image\Format;

$image = Image::decode(public_path('images/example.jpg'));

return ImageResponseFactory::make($image, Format::WEBP, quality: 65);
```

### Example — error handling
```php
use Intervention\Image\Laravel\ImageResponseFactory;
use Intervention\Image\Exceptions\NotSupportedException;
use Intervention\Image\Exceptions\DriverException;
use Intervention\Image\Exceptions\RuntimeException;

try {
    return ImageResponseFactory::make($image, 'gif');
} catch (NotSupportedException|DriverException|RuntimeException $e) {
    // fall back to the original format
    return ImageResponseFactory::make($image);
}
```
```

--------------------------------

### hasPublishedLegacyConfig() helper in src/ServiceProvider.php:101

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/service-provider.md

Returns true when a legacy config file with an options array is published at config('image') (the pre-4.x config/image.php layout). When true, the provider reads image.* instead of intervention-image.* for backward compatibility.

```php
private function hasPublishedLegacyConfig(): bool
{
    return is_array(config('image.options'));
}
```

--------------------------------

### headers() private method

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Returns a single Content-Type header set to the media type string value.

```php
/**
 * Return HTTP response headers to be attached in the image response.
 *
 * @return array<string, string>
 */
private function headers(): array
{
    return [
        'Content-Type' => $this->format()->mediaType()->value,
    ];
}
```

--------------------------------

### Use Image facade to decode, resize, and store an upload

Source: https://github.com/intervention/image-laravel/blob/develop/README.md

Use the Image facade to decode an uploaded image, resize it, and save it to storage with a random filename. The image is encoded using the original file extension with a quality of 70.

```php
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Intervention\Image\Laravel\Facades\Image;

Route::get('/', function (Request $request) {
    $upload = $request->file('image');
    $image = Image::decode($upload);
    $image = $image->resize(300, 200);

    Storage::put(
        Str::random() . '.' . $upload->getClientOriginalExtension(),
        $image->encodeUsingFileExtension($upload->getClientOriginalExtension(), quality: 70)
    );
});
```

--------------------------------

### Image::decodePath() from filesystem path

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from a filesystem path. Returns an ImageInterface.

```php
use Intervention\Image\Laravel\Facades\Image;

$image = Image::decodePath(public_path('images/example.jpg'));
```

--------------------------------

### Class declaration for ImageResponseFactory

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Shows the full class declaration with imports and namespace. The class implements the response factory behind the response()->image() macro.

```php
<?php

declare(strict_types=1);

namespace Intervention\Image\Laravel;

use Illuminate\Http\Response;
use Intervention\Image\Exceptions\DriverException;
use Intervention\Image\Exceptions\NotSupportedException;
use Intervention\Image\Exceptions\RuntimeException;
use Intervention\Image\FileExtension;
use Intervention\Image\Interfaces\ImageInterface;
use Intervention\Image\Format;
use Intervention\Image\MediaType;

class ImageResponseFactory
{
    // src/ImageResponseFactory.php:16
}
```

--------------------------------

### Flatten config into ImageManager constructor arguments

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/configuration.md

Used in the ServiceProvider's config() method to flatten the configuration file into constructor arguments for the ImageManager. The effective constructor receives named parameters: driver, autoOrientation, decodeAnimation, backgroundColor, and strip, with fallback defaults as shown.

```php
return [
    'driver' => config($filename . '.driver'),
    'autoOrientation' => config($filename . '.options.autoOrientation', true),
    'decodeAnimation' => config($filename . '.options.decodeAnimation', true),
    'backgroundColor' => config($filename . '.options.backgroundColor', 'ffffff'),
    'strip' => config($filename . '.options.strip', false),
];
```

--------------------------------

### Image::decode() with uploaded file and resize

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from an arbitrary source (file path, binary data, uploaded file, base64, data URI, stream), optionally restricting the decoders. Returns an ImageInterface.

```php
use Illuminate\Http\Request;
use Intervention\Image\Laravel\Facades\Image;

Route::post('/upload', function (Request $request) {
    $upload = $request->file('image');
    $image = Image::decode($upload)->resize(300, 200);

    // $image is an ImageInterface — encode, store, or return
});
```

--------------------------------

### Publish intervention-image config with artisan vendor:publish

Source: https://github.com/intervention/image-laravel/blob/develop/README.md

Publish the configuration file to config/intervention-image.php. This command copies the package's configuration to the application so you can set the driver and options centrally.

```bash
php artisan vendor:publish --provider="Intervention\Image\Laravel\ServiceProvider"
```

--------------------------------

### Default config values in config/intervention-image.php

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/configuration.md

Default configuration values for the package. The driver is set via the IMAGE_DRIVER environment variable, falling back to the GD driver. Options include autoOrientation, decodeAnimation, backgroundColor, and strip.

```php
'driver' => env('IMAGE_DRIVER', \Intervention\Image\Drivers\Gd\Driver::class),

'options' => [
    'autoOrientation' => true,
    'decodeAnimation' => true,
    'backgroundColor' => 'ffffff',
    'strip' => false,
],
```

--------------------------------

### Response macro 'image' registration

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/service-provider.md

The response macro 'image' registered on the Response facade. It accepts an ImageInterface, an optional format, and options, and delegates to ImageResponseFactory::make().

```php
$factory::macro('image', function (
    ImageInterface $image,
    null|string|Format|MediaType|FileExtension $format = null,
    mixed ...$options,
): Response {
    return ImageResponseFactory::make($image, $format, ...$options);
});
```

--------------------------------

### Generic catch guidance for image response exceptions

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/errors.md

Use this try-catch block to handle exceptions when generating an image response. It catches InvalidArgumentException for unknown format strings, NotSupportedException for unsupported formats, and DriverException or RuntimeException for driver-level or general encoding failures, with fallback responses or an abort.

```php
use Intervention\Image\Exceptions\InvalidArgumentException;
use Intervention\Image\Exceptions\NotSupportedException;
use Intervention\Image\Exceptions\DriverException;
use Intervention\Image\Exceptions\RuntimeException;

try {
    $response = response()->image($image, 'webp', quality: 65);
} catch (InvalidArgumentException $e) {
    // unknown format string — fall back to default
    $response = response()->image($image);
} catch (NotSupportedException $e) {
    // driver cannot encode this format — fall back to jpeg
    $response = response()->image($image, 'jpeg');
} catch (DriverException|RuntimeException $e) {
    // driver-level or general encoding failure
    abort(500, 'Image encoding failed');
}
```

--------------------------------

### getFacadeAccessor() returns self::BINDING

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Returns the container binding that the facade resolves and forwards static calls to. Because it returns self::BINDING, every static call on the facade is proxied to the ImageManager singleton.

```php
protected static function getFacadeAccessor()
{
    return self::BINDING;
}
```

--------------------------------

### Image facade class declaration

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

The Image facade class declaration, extending Illuminate\Support\Facades\Facade and aliased as Image. It provides static methods for creating and decoding images through the underlying ImageManager singleton.

```php
<?php

declare(strict_types=1);

namespace Intervention\Image\Laravel\Facades;

use Illuminate\Support\Facades\Facade;
use Intervention\Image\Interfaces\AnimationFactoryInterface;
use Intervention\Image\Interfaces\DataUriInterface;
use Intervention\Image\Interfaces\DecoderInterface;
use Intervention\Image\Interfaces\ImageInterface;
use SplFileInfo;
use Stringable;

/**
 * @method static ImageInterface createImage(int $width, int $height, null|callable|AnimationFactoryInterface $animation = null)
 * @method static ImageInterface decode(mixed $source, null|string|array|DecoderInterface $decoders = null)
 * @method static ImageInterface decodePath(string|Stringable $path)
 * @method static ImageInterface decodeBinary(string|Stringable $binary)
 * @method static ImageInterface decodeSplFileInfo(SplFileInfo $splFileInfo)
 * @method static ImageInterface decodeBase64(string|Stringable $base64)
 * @method static ImageInterface decodeDataUri(string|Stringable|DataUriInterface $dataUri)
 * @method static ImageInterface decodeStream(mixed $stream)
 */
class Image extends Facade
{
    // src/Facades/Image.php:25
}
```

--------------------------------

### decode(mixed $source, null|string|array|DecoderInterface $decoders = null): ImageInterface

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from an arbitrary source (file path, binary data, uploaded file, base64, data URI, stream), optionally restricting the decoders tried. Decoding a nonexistent file path throws `Intervention\Image\Exceptions\DirectoryNotFoundException`.

```APIDOC
## `decode(mixed $source, null|string|array|DecoderInterface $decoders = null): ImageInterface`

### Description
Decodes an image from an arbitrary source (file path, binary data, uploaded file, base64, data URI, stream), optionally restricting the decoders tried. Decoding a nonexistent file path throws `Intervention\Image\Exceptions\DirectoryNotFoundException`.

### Method
`decode` (static method)

### Parameters
- **$source** (mixed) - Required - The image source to decode
- **$decoders** (null|string|array|DecoderInterface) - Optional - Optional decoder or list of decoders to use

### Return Type
`ImageInterface`

### Example
```php
use Illuminate\Http\Request;
use Intervention\Image\Laravel\Facades\Image;

Route::post('/upload', function (Request $request) {
    $upload = $request->file('image');
    $image = Image::decode($upload)->resize(300, 200);

    // $image is an ImageInterface — encode, store, or return
});
```

```php
use Intervention\Image\Laravel\Facades\Image;
use Intervention\Image\Exceptions\DirectoryNotFoundException;

try {
    $image = Image::decode('path/to/non_existent_image.jpg');
} catch (DirectoryNotFoundException $e) {
    abort(404, 'Image not found');
}
```
```

--------------------------------

### Override Intervention Image driver and options via config and .env

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/configuration.md

Use this pair to override the default driver and options for the Intervention Image Laravel package. The PHP config file sets the driver from the IMAGE_DRIVER environment variable and enables auto-orientation, disables animation decoding, sets a black background, and strips EXIF data on encode. The .env line switches the driver to the Imagick driver without editing the config file.

```php
// config/intervention-image.php (published)
return [
    'driver' => env('IMAGE_DRIVER', \Intervention\Image\Drivers\Imagick\Driver::class),

    'options' => [
        'autoOrientation' => true,
        'decodeAnimation' => false,   // discard animations
        'backgroundColor' => '000000',
        'strip' => true,              // strip exif on encode
    ],
];
```

```dotenv
# .env — switch driver without touching the config file
IMAGE_DRIVER=Intervention\Image\Drivers\Imagick\Driver
```

--------------------------------

### ImageResponseFactory

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

The ImageResponseFactory class encodes an ImageInterface and wraps it in an Illuminate\Http\Response. It is the implementation behind the response()->image(...) macro and can be used directly as a factory class.

```APIDOC
## ImageResponseFactory

### Description
Encodes an `ImageInterface` and wraps it in an `Illuminate\Http\Response` in one step. It is the implementation behind the `response()->image(...)` macro registered by the `ServiceProvider`, and can also be used directly as a plain (non-Laravel-facade) factory class.

### Class Declaration
```php
<?php

declare(strict_types=1);

namespace Intervention\Image\Laravel;

use Illuminate\Http\Response;
use Intervention\Image\Exceptions\DriverException;
use Intervention\Image\Exceptions\NotSupportedException;
use Intervention\Image\Exceptions\RuntimeException;
use Intervention\Image\FileExtension;
use Intervention\Image\Interfaces\ImageInterface;
use Intervention\Image\Format;
use Intervention\Image\MediaType;

class ImageResponseFactory
{
    // src/ImageResponseFactory.php:16
}
```

### Constructor

#### `__construct()` — `src/ImageResponseFactory.php:28`

```php
public function __construct(
    protected ImageInterface $image,
    protected null|string|Format|MediaType|FileExtension $format = null,
    mixed ...$options,
) {
    $this->options = $options;
}
```

#### Parameters
- **$image** (`ImageInterface`) - Required - The image to encode into the response
- **$format** (`null|string|Format|MediaType|FileExtension`) - Optional (default: `null`) - Target output format; resolution order documented below
- **...$options** (`mixed`) - Optional (default: `[]` stored in `$options`) - Encoder options (e.g. `quality: 70`), forwarded to `encodeUsingMediaType()`

#### Return Type
None (constructor).

#### Notes
Promoted read-only-style properties; `$image` and `$format` are exposed for subclasses.

### Property

#### `$options` — `src/ImageResponseFactory.php:23`

```php
/**
 * Image encoder options.
 *
 * @var array<string, mixed>
 */
protected array $options = [];
```

Stores the variadic encoder options passed to the constructor; they are forwarded verbatim to `ImageInterface::encodeUsingMediaType()` when building the response body.
```

--------------------------------

### getFacadeAccessor()

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Returns the container binding that the facade resolves and forwards static calls to. Because it returns `self::BINDING`, every static call on the facade is proxied to the `ImageManager` singleton.

```APIDOC
## `getFacadeAccessor()`

### Description
Returns the container binding that the facade resolves and forwards static calls to. Because it returns `self::BINDING`, every static call on the facade is proxied to the `ImageManager` singleton.

### Method
`getFacadeAccessor` (static method)

### Parameters
None.

### Return Type
`string` — returns `'intervention.image'`.

### Example
```php
protected static function getFacadeAccessor()
{
    return self::BINDING;
}
```
```

--------------------------------

### Image::decodeBinary() from storage

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from raw binary string contents. Returns an ImageInterface.

```php
use Illuminate\Support\Facades\Storage;
use Intervention\Image\Laravel\Facades\Image;

$image = Image::decodeBinary(Storage::get('example.jpg'));
```

--------------------------------

### Image::createImage() with dimensions and error handling

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Creates a new image with the given dimensions. Invalid dimensions throw Intervention\Image\Exceptions\InvalidArgumentException; a callable can be passed as the third argument.

```php
use Intervention\Image\Laravel\Facades\Image;

$image = Image::createImage(800, 600)->fill('f5f5f5');

try {
    Image::createImage(-20, 10); // throws InvalidArgumentException
} catch (\Intervention\Image\Exceptions\InvalidArgumentException $e) {
    // handle invalid dimensions
}
```

--------------------------------

### Class declaration for ServiceProvider

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/service-provider.md

The full class declaration for Intervention\Image\Laravel\ServiceProvider, extending Illuminate\Support\ServiceProvider. It imports necessary classes and defines the class with a comment indicating the source file location.

```php
<?php

declare(strict_types=1);

namespace Intervention\Image\Laravel;

use Illuminate\Support\Facades\Response as ResponseFacade;
use Illuminate\Support\ServiceProvider as BaseServiceProvider;
use Intervention\Image\ImageManager;
use Intervention\Image\Interfaces\ImageInterface;
use Illuminate\Http\Response;
use Intervention\Image\FileExtension;
use Intervention\Image\Format;
use Intervention\Image\Interfaces\ImageManagerInterface;
use Intervention\Image\MediaType;

class ServiceProvider extends BaseServiceProvider
{
    // src/ServiceProvider.php:17
}
```

--------------------------------

### createImage(int $width, int $height, null|callable|AnimationFactoryInterface $animation = null): ImageInterface

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Creates a new image with the given dimensions. Invalid dimensions throw `Intervention\Image\Exceptions\InvalidArgumentException`; a callable can be passed as the third argument.

```APIDOC
## `createImage(int $width, int $height, null|callable|AnimationFactoryInterface $animation = null): ImageInterface`

### Description
Creates a new image with the given dimensions. Invalid dimensions throw `Intervention\Image\Exceptions\InvalidArgumentException`; a callable can be passed as the third argument.

### Method
`createImage` (static method)

### Parameters
- **$width** (int) - Required - Image width in pixels
- **$height** (int) - Required - Image height in pixels
- **$animation** (null|callable|AnimationFactoryInterface) - Optional - Optional animation factory/callback for animated images

### Return Type
`ImageInterface`

### Example
```php
use Intervention\Image\Laravel\Facades\Image;

$image = Image::createImage(800, 600)->fill('f5f5f5');

try {
    Image::createImage(-20, 10); // throws InvalidArgumentException
} catch (\Intervention\Image\Exceptions\InvalidArgumentException $e) {
    // handle invalid dimensions
}
```
```

--------------------------------

### Default intervention-image.php configuration

Source: https://github.com/intervention/image-laravel/blob/develop/README.md

Default configuration file for Intervention Image in Laravel. Sets the driver via the IMAGE_DRIVER environment variable (defaults to GD) and defines options for auto orientation, animation decoding, background color, and stripping metadata. The driver can be changed to Imagick or Vips by editing the 'driver' key.

```php
return [

    /*
    |--------------------------------------------------------------------------
    | Image Driver
    |--------------------------------------------------------------------------
    |
    | Intervention Image supports “GD Library” and “Imagick” to process images
    | internally. Depending on your PHP setup, you can choose one of them.
    |
    | Included options:
    |   - \Intervention\Image\Drivers\Gd\Driver::class
    |   - \Intervention\Image\Drivers\Imagick\Driver::class
    |   - \Intervention\Image\Drivers\Vips\Driver::class
    */

    'driver' => env('IMAGE_DRIVER', \Intervention\Image\Drivers\Gd\Driver::class),

    /*
    |--------------------------------------------------------------------------
    | Configuration Options
    |--------------------------------------------------------------------------
    |
    | These options control the behavior of Intervention Image.
    |
    | - "autoOrientation" controls whether an imported image should be
    |    automatically rotated according to any existing Exif data.
    |
    | - "decodeAnimation" decides whether a possibly animated image is
    |    decoded as such or whether the animation is discarded.
    |
    | - "backgroundColor" Defines the default background & blending color.
    |
    | - "strip" controls if meta data like exif tags should be removed when
    |    encoding images.
    */

    'options' => [
        'autoOrientation' => true,
        'decodeAnimation' => true,
        'backgroundColor' => 'ffffff',
        'strip' => false,
    ]
];
```

--------------------------------

### decodeBase64(string|Stringable $base64): ImageInterface

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from a base64-encoded string and returns an ImageInterface.

```APIDOC
## decodeBase64(string|Stringable $base64): ImageInterface

### Description
Decodes an image from a base64-encoded string.

### Method
N/A (PHP method)

### Endpoint
N/A (PHP method)

### Parameters
#### Path Parameters
None.

#### Query Parameters
None.

#### Request Body
- **$base64** (string|Stringable) - Required - Base64-encoded image data

### Request Example
```php
use Intervention\Image\Laravel\Facades\Image;

$image = Image::decodeBase64($request->input('image_base64'));
```

### Response
#### Success Response
Returns an `ImageInterface`.

#### Response Example
N/A
```

--------------------------------

### decodePath(string|Stringable $path): ImageInterface

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from a filesystem path.

```APIDOC
## `decodePath(string|Stringable $path): ImageInterface`

### Description
Decodes an image from a filesystem path.

### Method
`decodePath` (static method)

### Parameters
- **$path** (string|Stringable) - Required - Filesystem path to the image

### Return Type
`ImageInterface`

### Example
```php
use Intervention\Image\Laravel\Facades\Image;

$image = Image::decodePath(public_path('images/example.jpg'));
```
```

--------------------------------

### Image::decodeSplFileInfo() with uploaded file

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from an SplFileInfo (e.g. a Laravel UploadedFile, which extends SplFileInfo). Returns an ImageInterface.

```php
use Illuminate\Http\Request;
use Intervention\Image\Laravel\Facades\Image;

Route::post('/upload', function (Request $request) {
    $image = Image::decodeSplFileInfo($request->file('image'));
});
```

--------------------------------

### Options property declaration

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-response-factory.md

Declares the protected array property $options that stores encoder options passed to the constructor. These options are forwarded to encodeUsingMediaType().

```php
/**
 * Image encoder options.
 *
 * @var array<string, mixed>
 */
protected array $options = [];
```

--------------------------------

### BINDING constant for service container key

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Defines the BINDING constant that holds the service container key 'intervention.image'. This key is used to register the ImageManager singleton and can be accessed via app('intervention.image') or app(ImageFacade::BINDING).

```php
/**
 * Binding name of the service container.
 */
public const BINDING = 'intervention.image';
```

--------------------------------

### decodeBinary(string|Stringable $binary): ImageInterface

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from raw binary string contents.

```APIDOC
## `decodeBinary(string|Stringable $binary): ImageInterface`

### Description
Decodes an image from raw binary string contents.

### Method
`decodeBinary` (static method)

### Parameters
- **$binary** (string|Stringable) - Required - Raw image binary data

### Return Type
`ImageInterface`

### Example
```php
use Illuminate\Support\Facades\Storage;
use Intervention\Image\Laravel\Facades\Image;

$image = Image::decodeBinary(Storage::get('example.jpg'));
```
```

--------------------------------

### Decode base64 image with Image::decodeBase64

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from a base64-encoded string. The input is a string or Stringable containing base64 image data. Returns an ImageInterface.

```php
use Intervention\Image\Laravel\Facades\Image;

$image = Image::decodeBase64($request->input('image_base64'));
```

--------------------------------

### decodeSplFileInfo(SplFileInfo $splFileInfo): ImageInterface

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from an `SplFileInfo` (e.g. a Laravel `UploadedFile`, which extends `SplFileInfo`).

```APIDOC
## `decodeSplFileInfo(SplFileInfo $splFileInfo): ImageInterface`

### Description
Decodes an image from an `SplFileInfo` (e.g. a Laravel `UploadedFile`, which extends `SplFileInfo`).

### Method
`decodeSplFileInfo` (static method)

### Parameters
- **$splFileInfo** (SplFileInfo) - Required - File info object pointing at the image

### Return Type
`ImageInterface`

### Example
```php
use Illuminate\Http\Request;
use Intervention\Image\Laravel\Facades\Image;

Route::post('/upload', function (Request $request) {
    $image = Image::decodeSplFileInfo($request->file('image'));
});
```
```

--------------------------------

### decodeStream(mixed $stream): ImageInterface

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from a stream resource and returns an ImageInterface.

```APIDOC
## decodeStream(mixed $stream): ImageInterface

### Description
Decodes an image from a stream resource.

### Method
N/A (PHP method)

### Endpoint
N/A (PHP method)

### Parameters
#### Path Parameters
None.

#### Query Parameters
None.

#### Request Body
- **$stream** (mixed) - Required - Stream resource or stream-backed object

### Request Example
```php
use Intervention\Image\Laravel\Facades\Image;

$stream = fopen('php://memory', 'r+');
fwrite($stream, $binary);
rewind($stream);

$image = Image::decodeStream($stream);
```

### Response
#### Success Response
Returns an `ImageInterface`.

#### Response Example
N/A
```

--------------------------------

### Decode data URI image with Image::decodeDataUri

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from a data URI string or DataUriInterface value object. The input must be a valid data URI like 'data:image/png;base64,...'. Returns an ImageInterface.

```php
use Intervention\Image\Laravel\Facades\Image;

$image = Image::decodeDataUri('data:image/png;base64,iVBORw0KGgo...');
```

--------------------------------

### Inject ImageManagerInterface into a Laravel controller

Source: https://github.com/intervention/image-laravel/blob/develop/README.md

Inject the image manager into a controller constructor to use the application-wide image configuration. The manager is resolved via the ImageManagerInterface and used to decode an uploaded file.

```php
use Intervention\Image\Interfaces\ImageManagerInterface;
use Illuminate\Http\Request;

class ImageController extends Controller
{
    /**
     * Create a new controller instance by injecting an image manager.
     */
    public function __construct(
        protected ImageManagerInterface $imageManager,
    ) {}

    /**
     * Handle image upload.
     */
    public function handleImageUpload(Request $request): RedirectResponse
    {
        $image = $this->imageManager->decodeSplFileInfo($request->file('image'));
    }
}
```

--------------------------------

### decodeDataUri(string|Stringable|DataUriInterface $dataUri): ImageInterface

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from a data URI string or DataUriInterface value object and returns an ImageInterface.

```APIDOC
## decodeDataUri(string|Stringable|DataUriInterface $dataUri): ImageInterface

### Description
Decodes an image from a `data:` URI string or `DataUriInterface` value object.

### Method
N/A (PHP method)

### Endpoint
N/A (PHP method)

### Parameters
#### Path Parameters
None.

#### Query Parameters
None.

#### Request Body
- **$dataUri** (string|Stringable|DataUriInterface) - Required - Data URI (`data:image/png;base64,...`) or value object

### Request Example
```php
use Intervention\Image\Laravel\Facades\Image;

$image = Image::decodeDataUri('data:image/png;base64,iVBORw0KGgo...');
```

### Response
#### Success Response
Returns an `ImageInterface`.

#### Response Example
N/A
```

--------------------------------

### Decode stream image with Image::decodeStream

Source: https://github.com/intervention/image-laravel/blob/develop/_autodocs/api-reference/image-facade.md

Decodes an image from a stream resource. The stream must be opened and positioned correctly (e.g., after writing and rewinding). Returns an ImageInterface.

```php
use Intervention\Image\Laravel\Facades\Image;

$stream = fopen('php://memory', 'r+');
fwrite($stream, $binary);
rewind($stream);

$image = Image::decodeStream($stream);
```
Tokens:
Raw