diff --git a/classes/Admin/ServiceProvider.php b/classes/Admin/ServiceProvider.php
index 643159c11..08098d832 100644
--- a/classes/Admin/ServiceProvider.php
+++ b/classes/Admin/ServiceProvider.php
@@ -5,6 +5,7 @@
 
 use Imagify\Dependencies\League\Container\ServiceProvider\AbstractServiceProvider;
 use Imagify\Dependencies\WPMedia\PluginFamily\Controller\PluginFamily;
+use Imagify\User\User;
 
 /**
  * Service provider for Admin.
@@ -16,10 +17,10 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	protected $provides = [
-		'admin_bar',
-		'admin_subscriber',
-		'plugin_family',
-		'plugin_family_subscriber',
+		AdminBar::class,
+		AdminSubscriber::class,
+		PluginFamily::class,
+		PluginFamilySubscriber::class,
 	];
 
 	/**
@@ -28,27 +29,36 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	public $subscribers = [
-		'admin_bar',
-		'admin_subscriber',
-		'plugin_family_subscriber',
+		AdminBar::class,
+		AdminSubscriber::class,
+		PluginFamilySubscriber::class,
 	];
 
+	/**
+	 * Check if the service provider provides a specific service.
+	 *
+	 * @param string $id The id of the service.
+	 *
+	 * @return bool
+	 */
+	public function provides( string $id ): bool {
+		return in_array( $id, $this->provides, true );
+	}
+
 	/**
 	 * Registers the provided classes
 	 *
 	 * @return void
 	 */
-	public function register() {
-
-		$this->getContainer()->share( 'admin_bar', AdminBar::class )
-			->addArgument( $this->getContainer()->get( 'user' ) );
-		$this->getContainer()->share( 'admin_subscriber', AdminSubscriber::class )
-			->addArgument( $this->getContainer()->get( 'user' ) );
-
-		$this->getContainer()->add( 'plugin_family', PluginFamily::class );
+	public function register(): void {
+		$this->getContainer()->addShared( AdminBar::class )
+			->addArgument( User::class );
+		$this->getContainer()->addShared( AdminSubscriber::class )
+			->addArgument( User::class );
 
-		$this->getContainer()->add( 'plugin_family_subscriber', PluginFamilySubscriber::class )
-			->addArgument( $this->getContainer()->get( 'plugin_family' ) );
+		$this->getContainer()->add( PluginFamily::class );
+		$this->getContainer()->addShared( PluginFamilySubscriber::class )
+			->addArgument( PluginFamily::class );
 	}
 
 	/**
diff --git a/classes/Avif/ServiceProvider.php b/classes/Avif/ServiceProvider.php
index 38b33a73b..417256539 100644
--- a/classes/Avif/ServiceProvider.php
+++ b/classes/Avif/ServiceProvider.php
@@ -16,8 +16,8 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	protected $provides = [
-		'avif_display',
-		'avif_rewrite_rules',
+		Display::class,
+		RewriteRules::class,
 	];
 
 	/**
@@ -26,18 +26,29 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	public $subscribers = [
-		'avif_display',
-		'avif_rewrite_rules',
+		Display::class,
+		RewriteRules::class,
 	];
 
+	/**
+	 * Check if the service provider provides a specific service.
+	 *
+	 * @param string $id The id of the service.
+	 *
+	 * @return bool
+	 */
+	public function provides( string $id ): bool {
+		return in_array( $id, $this->provides, true );
+	}
+
 	/**
 	 * Registers the provided classes
 	 *
 	 * @return void
 	 */
-	public function register() {
-		$this->getContainer()->share( 'avif_display', Display::class );
-		$this->getContainer()->share( 'avif_rewrite_rules', RewriteRules::class );
+	public function register(): void {
+		$this->getContainer()->addShared( Display::class );
+		$this->getContainer()->addShared( RewriteRules::class );
 	}
 
 	/**
diff --git a/classes/CDN/ServiceProvider.php b/classes/CDN/ServiceProvider.php
index 094900d35..f5d0bd48f 100644
--- a/classes/CDN/ServiceProvider.php
+++ b/classes/CDN/ServiceProvider.php
@@ -15,7 +15,7 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	protected $provides = [
-		'cdn',
+		CDN::class,
 	];
 
 	/**
@@ -24,16 +24,27 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	public $subscribers = [
-		'cdn',
+		CDN::class,
 	];
 
+	/**
+	 * Check if the service provider provides a specific service.
+	 *
+	 * @param string $id The id of the service.
+	 *
+	 * @return bool
+	 */
+	public function provides( string $id ): bool {
+		return in_array( $id, $this->provides, true );
+	}
+
 	/**
 	 * Registers the provided classes
 	 *
 	 * @return void
 	 */
-	public function register() {
-		$this->getContainer()->share( 'cdn', CDN::class );
+	public function register(): void {
+		$this->getContainer()->addShared( CDN::class );
 	}
 
 	/**
diff --git a/classes/Dependencies/League/Container/Argument/RawArgumentInterface.php b/classes/Dependencies/League/Container/Argument/ArgumentInterface.php
similarity index 53%
rename from classes/Dependencies/League/Container/Argument/RawArgumentInterface.php
rename to classes/Dependencies/League/Container/Argument/ArgumentInterface.php
index 16fe992a9..2cdf82c0e 100644
--- a/classes/Dependencies/League/Container/Argument/RawArgumentInterface.php
+++ b/classes/Dependencies/League/Container/Argument/ArgumentInterface.php
@@ -1,12 +1,12 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Argument;
 
-interface RawArgumentInterface
+interface ArgumentInterface
 {
     /**
-     * Return the value of the raw argument.
-     *
      * @return mixed
      */
     public function getValue();
diff --git a/classes/Dependencies/League/Container/Argument/ArgumentResolverInterface.php b/classes/Dependencies/League/Container/Argument/ArgumentResolverInterface.php
index a56daeaad..084f97873 100644
--- a/classes/Dependencies/League/Container/Argument/ArgumentResolverInterface.php
+++ b/classes/Dependencies/League/Container/Argument/ArgumentResolverInterface.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Argument;
 
@@ -7,22 +9,6 @@
 
 interface ArgumentResolverInterface extends ContainerAwareInterface
 {
-    /**
-     * Resolve an array of arguments to their concrete implementations.
-     *
-     * @param array $arguments
-     *
-     * @return array
-     */
-    public function resolveArguments(array $arguments) : array;
-
-    /**
-     * Resolves the correct arguments to be passed to a method.
-     *
-     * @param ReflectionFunctionAbstract $method
-     * @param array                      $args
-     *
-     * @return array
-     */
-    public function reflectArguments(ReflectionFunctionAbstract $method, array $args = []) : array;
+    public function resolveArguments(array $arguments): array;
+    public function reflectArguments(ReflectionFunctionAbstract $method, array $args = []): array;
 }
diff --git a/classes/Dependencies/League/Container/Argument/ArgumentResolverTrait.php b/classes/Dependencies/League/Container/Argument/ArgumentResolverTrait.php
index 8451115bd..f637f1435 100644
--- a/classes/Dependencies/League/Container/Argument/ArgumentResolverTrait.php
+++ b/classes/Dependencies/League/Container/Argument/ArgumentResolverTrait.php
@@ -1,101 +1,100 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Argument;
 
-use Imagify\Dependencies\League\Container\Container;
+use Imagify\Dependencies\League\Container\DefinitionContainerInterface;
 use Imagify\Dependencies\League\Container\Exception\{ContainerException, NotFoundException};
 use Imagify\Dependencies\League\Container\ReflectionContainer;
 use Imagify\Dependencies\Psr\Container\ContainerInterface;
 use ReflectionFunctionAbstract;
-use ReflectionParameter;
+use ReflectionNamedType;
 
 trait ArgumentResolverTrait
 {
-    /**
-     * {@inheritdoc}
-     */
-    public function resolveArguments(array $arguments) : array
+    public function resolveArguments(array $arguments): array
     {
-        return array_map(function ($argument) {
-            $justStringValue = false;
-
-            if ($argument instanceof RawArgumentInterface) {
-                return $argument->getValue();
-            } elseif ($argument instanceof ClassNameInterface) {
-                $id = $argument->getClassName();
-            } elseif (!is_string($argument)) {
-                return $argument;
-            } else {
-                $justStringValue = true;
-                $id = $argument;
+        try {
+            $container = $this->getContainer();
+        } catch (ContainerException $e) {
+            $container = ($this instanceof ReflectionContainer) ? $this : null;
+        }
+
+        foreach ($arguments as &$arg) {
+            // if we have a literal, we don't want to do anything more with it
+            if ($arg instanceof LiteralArgumentInterface) {
+                $arg = $arg->getValue();
+                continue;
             }
 
-            $container = null;
+            if ($arg instanceof ArgumentInterface) {
+                $argValue = $arg->getValue();
+            } else {
+                $argValue = $arg;
+            }
 
-            try {
-                $container = $this->getLeagueContainer();
-            } catch (ContainerException $e) {
-                if ($this instanceof ReflectionContainer) {
-                    $container = $this;
-                }
+            if (!is_string($argValue)) {
+                 continue;
             }
 
-            if ($container !== null) {
+            // resolve the argument from the container, if it happens to be another
+            // argument wrapper, use that value
+            if ($container instanceof ContainerInterface && $container->has($argValue)) {
                 try {
-                    return $container->get($id);
-                } catch (NotFoundException $exception) {
-                    if ($argument instanceof ClassNameWithOptionalValue) {
-                        return $argument->getOptionalValue();
-                    }
+                    $arg = $container->get($argValue);
 
-                    if ($justStringValue) {
-                        return $id;
+                    if ($arg instanceof ArgumentInterface) {
+                        $arg = $arg->getValue();
                     }
 
-                    throw $exception;
+                    continue;
+                } catch (NotFoundException $e) {
                 }
             }
 
-            if ($argument instanceof ClassNameWithOptionalValue) {
-                return $argument->getOptionalValue();
+            // if we have a default value, we use that, no more resolution as
+            // we expect a default/optional argument value to be literal
+            if ($arg instanceof DefaultValueInterface) {
+                $arg = $arg->getDefaultValue();
             }
+        }
 
-            // Just a string value.
-            return $id;
-        }, $arguments);
+        return $arguments;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function reflectArguments(ReflectionFunctionAbstract $method, array $args = []) : array
+    public function reflectArguments(ReflectionFunctionAbstract $method, array $args = []): array
     {
-        $arguments = array_map(function (ReflectionParameter $param) use ($method, $args) {
+        $params    = $method->getParameters();
+        $arguments = [];
+
+        foreach ($params as $param) {
             $name = $param->getName();
-            $type = $param->getType();
 
+            // if we've been given a value for the argument, treat as literal
             if (array_key_exists($name, $args)) {
-                return new RawArgument($args[$name]);
+                $arguments[] = new LiteralArgument($args[$name]);
+                continue;
             }
 
-            if ($type) {
-                if (PHP_VERSION_ID >= 70100) {
-                    $typeName = $type->getName();
-                } else {
-                    $typeName = (string) $type;
-                }
+            $type = $param->getType();
 
-                $typeName = ltrim($typeName, '?');
+            if ($type instanceof ReflectionNamedType) {
+                // in PHP 8, nullable arguments have "?" prefix
+                $typeHint = ltrim($type->getName(), '?');
 
                 if ($param->isDefaultValueAvailable()) {
-                    return new ClassNameWithOptionalValue($typeName, $param->getDefaultValue());
+                    $arguments[] = new DefaultValueArgument($typeHint, $param->getDefaultValue());
+                    continue;
                 }
 
-                return new ClassName($typeName);
+                $arguments[] = new ResolvableArgument($typeHint);
+                continue;
             }
 
             if ($param->isDefaultValueAvailable()) {
-                return new RawArgument($param->getDefaultValue());
+                $arguments[] = new LiteralArgument($param->getDefaultValue());
+                continue;
             }
 
             throw new NotFoundException(sprintf(
@@ -103,18 +102,10 @@ public function reflectArguments(ReflectionFunctionAbstract $method, array $args
                 $name,
                 $method->getName()
             ));
-        }, $method->getParameters());
+        }
 
         return $this->resolveArguments($arguments);
     }
 
-    /**
-     * @return ContainerInterface
-     */
-    abstract public function getContainer() : ContainerInterface;
-
-    /**
-     * @return Container
-     */
-    abstract public function getLeagueContainer() : Container;
+    abstract public function getContainer(): DefinitionContainerInterface;
 }
diff --git a/classes/Dependencies/League/Container/Argument/ClassName.php b/classes/Dependencies/League/Container/Argument/ClassName.php
deleted file mode 100644
index 4d6ae395b..000000000
--- a/classes/Dependencies/League/Container/Argument/ClassName.php
+++ /dev/null
@@ -1,29 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Imagify\Dependencies\League\Container\Argument;
-
-class ClassName implements ClassNameInterface
-{
-    /**
-     * @var string
-     */
-    protected $value;
-
-    /**
-     * Construct.
-     *
-     * @param string $value
-     */
-    public function __construct(string $value)
-    {
-        $this->value = $value;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getClassName() : string
-    {
-        return $this->value;
-    }
-}
diff --git a/classes/Dependencies/League/Container/Argument/ClassNameInterface.php b/classes/Dependencies/League/Container/Argument/ClassNameInterface.php
deleted file mode 100644
index 5a923e08a..000000000
--- a/classes/Dependencies/League/Container/Argument/ClassNameInterface.php
+++ /dev/null
@@ -1,13 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Imagify\Dependencies\League\Container\Argument;
-
-interface ClassNameInterface
-{
-    /**
-     * Return the class name.
-     *
-     * @return string
-     */
-    public function getClassName() : string;
-}
diff --git a/classes/Dependencies/League/Container/Argument/ClassNameWithOptionalValue.php b/classes/Dependencies/League/Container/Argument/ClassNameWithOptionalValue.php
deleted file mode 100644
index b4593491d..000000000
--- a/classes/Dependencies/League/Container/Argument/ClassNameWithOptionalValue.php
+++ /dev/null
@@ -1,39 +0,0 @@
-<?php
-
-namespace Imagify\Dependencies\League\Container\Argument;
-
-class ClassNameWithOptionalValue implements ClassNameInterface
-{
-    /**
-     * @var string
-     */
-    private $className;
-
-    /**
-     * @var mixed
-     */
-    private $optionalValue;
-
-    /**
-     * @param string $className
-     * @param mixed $optionalValue
-     */
-    public function __construct(string $className, $optionalValue)
-    {
-        $this->className = $className;
-        $this->optionalValue = $optionalValue;
-    }
-
-    /**
-     * @inheritDoc
-     */
-    public function getClassName(): string
-    {
-        return $this->className;
-    }
-
-    public function getOptionalValue()
-    {
-        return $this->optionalValue;
-    }
-}
diff --git a/classes/Dependencies/League/Container/Argument/DefaultValueArgument.php b/classes/Dependencies/League/Container/Argument/DefaultValueArgument.php
new file mode 100644
index 000000000..0c50d7f6d
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/DefaultValueArgument.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+class DefaultValueArgument extends ResolvableArgument implements DefaultValueInterface
+{
+    protected $defaultValue;
+
+    public function __construct(string $value, $defaultValue = null)
+    {
+        $this->defaultValue = $defaultValue;
+        parent::__construct($value);
+    }
+
+    /**
+     * @return mixed|null
+     */
+    public function getDefaultValue()
+    {
+        return $this->defaultValue;
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/DefaultValueInterface.php b/classes/Dependencies/League/Container/Argument/DefaultValueInterface.php
new file mode 100644
index 000000000..d421cbb13
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/DefaultValueInterface.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+interface DefaultValueInterface extends ArgumentInterface
+{
+    /**
+     * @return mixed
+     */
+    public function getDefaultValue();
+}
diff --git a/classes/Dependencies/League/Container/Argument/Literal/ArrayArgument.php b/classes/Dependencies/League/Container/Argument/Literal/ArrayArgument.php
new file mode 100644
index 000000000..523066e3b
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/Literal/ArrayArgument.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument\Literal;
+
+use Imagify\Dependencies\League\Container\Argument\LiteralArgument;
+
+class ArrayArgument extends LiteralArgument
+{
+    public function __construct(array $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_ARRAY);
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/Literal/BooleanArgument.php b/classes/Dependencies/League/Container/Argument/Literal/BooleanArgument.php
new file mode 100644
index 000000000..b7c83a7c0
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/Literal/BooleanArgument.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument\Literal;
+
+use Imagify\Dependencies\League\Container\Argument\LiteralArgument;
+
+class BooleanArgument extends LiteralArgument
+{
+    public function __construct(bool $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_BOOL);
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/Literal/CallableArgument.php b/classes/Dependencies/League/Container/Argument/Literal/CallableArgument.php
new file mode 100644
index 000000000..748b732c9
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/Literal/CallableArgument.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument\Literal;
+
+use Imagify\Dependencies\League\Container\Argument\LiteralArgument;
+
+class CallableArgument extends LiteralArgument
+{
+    public function __construct(callable $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_CALLABLE);
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/Literal/FloatArgument.php b/classes/Dependencies/League/Container/Argument/Literal/FloatArgument.php
new file mode 100644
index 000000000..a99c3ce7a
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/Literal/FloatArgument.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument\Literal;
+
+use Imagify\Dependencies\League\Container\Argument\LiteralArgument;
+
+class FloatArgument extends LiteralArgument
+{
+    public function __construct(float $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_FLOAT);
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/Literal/IntegerArgument.php b/classes/Dependencies/League/Container/Argument/Literal/IntegerArgument.php
new file mode 100644
index 000000000..1ea6f7359
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/Literal/IntegerArgument.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument\Literal;
+
+use Imagify\Dependencies\League\Container\Argument\LiteralArgument;
+
+class IntegerArgument extends LiteralArgument
+{
+    public function __construct(int $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_INT);
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/Literal/ObjectArgument.php b/classes/Dependencies/League/Container/Argument/Literal/ObjectArgument.php
new file mode 100644
index 000000000..97d868c7f
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/Literal/ObjectArgument.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument\Literal;
+
+use Imagify\Dependencies\League\Container\Argument\LiteralArgument;
+
+class ObjectArgument extends LiteralArgument
+{
+    public function __construct(object $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_OBJECT);
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/Literal/StringArgument.php b/classes/Dependencies/League/Container/Argument/Literal/StringArgument.php
new file mode 100644
index 000000000..da8b689f5
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/Literal/StringArgument.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument\Literal;
+
+use Imagify\Dependencies\League\Container\Argument\LiteralArgument;
+
+class StringArgument extends LiteralArgument
+{
+    public function __construct(string $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_STRING);
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/LiteralArgument.php b/classes/Dependencies/League/Container/Argument/LiteralArgument.php
new file mode 100644
index 000000000..46cfe00aa
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/LiteralArgument.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+use InvalidArgumentException;
+
+class LiteralArgument implements LiteralArgumentInterface
+{
+    public const TYPE_ARRAY    = 'array';
+    public const TYPE_BOOL     = 'boolean';
+    public const TYPE_BOOLEAN  = 'boolean';
+    public const TYPE_CALLABLE = 'callable';
+    public const TYPE_DOUBLE   = 'double';
+    public const TYPE_FLOAT    = 'double';
+    public const TYPE_INT      = 'integer';
+    public const TYPE_INTEGER  = 'integer';
+    public const TYPE_OBJECT   = 'object';
+    public const TYPE_STRING   = 'string';
+
+    /**
+     * @var mixed
+     */
+    protected $value;
+
+    public function __construct($value, ?string $type = null)
+    {
+        if (
+            null === $type
+            || ($type === self::TYPE_CALLABLE && is_callable($value))
+            || ($type === self::TYPE_OBJECT && is_object($value))
+            || gettype($value) === $type
+        ) {
+            $this->value = $value;
+        } else {
+            throw new InvalidArgumentException('Incorrect type for value.');
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/LiteralArgumentInterface.php b/classes/Dependencies/League/Container/Argument/LiteralArgumentInterface.php
new file mode 100644
index 000000000..b7b2466f1
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/LiteralArgumentInterface.php
@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+interface LiteralArgumentInterface extends ArgumentInterface
+{
+}
diff --git a/classes/Dependencies/League/Container/Argument/RawArgument.php b/classes/Dependencies/League/Container/Argument/RawArgument.php
deleted file mode 100644
index e1efd4c70..000000000
--- a/classes/Dependencies/League/Container/Argument/RawArgument.php
+++ /dev/null
@@ -1,29 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Imagify\Dependencies\League\Container\Argument;
-
-class RawArgument implements RawArgumentInterface
-{
-    /**
-     * @var mixed
-     */
-    protected $value;
-
-    /**
-     * Construct.
-     *
-     * @param mixed $value
-     */
-    public function __construct($value)
-    {
-        $this->value = $value;
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getValue()
-    {
-        return $this->value;
-    }
-}
diff --git a/classes/Dependencies/League/Container/Argument/ResolvableArgument.php b/classes/Dependencies/League/Container/Argument/ResolvableArgument.php
new file mode 100644
index 000000000..970edde06
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/ResolvableArgument.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+class ResolvableArgument implements ResolvableArgumentInterface
+{
+    protected $value;
+
+    public function __construct(string $value)
+    {
+        $this->value = $value;
+    }
+
+    public function getValue(): string
+    {
+        return $this->value;
+    }
+}
diff --git a/classes/Dependencies/League/Container/Argument/ResolvableArgumentInterface.php b/classes/Dependencies/League/Container/Argument/ResolvableArgumentInterface.php
new file mode 100644
index 000000000..a4b5fb9b0
--- /dev/null
+++ b/classes/Dependencies/League/Container/Argument/ResolvableArgumentInterface.php
@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+interface ResolvableArgumentInterface extends ArgumentInterface
+{
+    public function getValue(): string;
+}
diff --git a/classes/Dependencies/League/Container/Container.php b/classes/Dependencies/League/Container/Container.php
index 370da220c..b61b60527 100644
--- a/classes/Dependencies/League/Container/Container.php
+++ b/classes/Dependencies/League/Container/Container.php
@@ -1,18 +1,18 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container;
 
 use Imagify\Dependencies\League\Container\Definition\{DefinitionAggregate, DefinitionInterface, DefinitionAggregateInterface};
 use Imagify\Dependencies\League\Container\Exception\{NotFoundException, ContainerException};
 use Imagify\Dependencies\League\Container\Inflector\{InflectorAggregate, InflectorInterface, InflectorAggregateInterface};
-use Imagify\Dependencies\League\Container\ServiceProvider\{
-    ServiceProviderAggregate,
+use Imagify\Dependencies\League\Container\ServiceProvider\{ServiceProviderAggregate,
     ServiceProviderAggregateInterface,
-    ServiceProviderInterface
-};
+    ServiceProviderInterface};
 use Imagify\Dependencies\Psr\Container\ContainerInterface;
 
-class Container implements ContainerInterface
+class Container implements DefinitionContainerInterface
 {
     /**
      * @var boolean
@@ -39,87 +39,52 @@ class Container implements ContainerInterface
      */
     protected $delegates = [];
 
-    /**
-     * Construct.
-     *
-     * @param DefinitionAggregateInterface|null      $definitions
-     * @param ServiceProviderAggregateInterface|null $providers
-     * @param InflectorAggregateInterface|null       $inflectors
-     */
     public function __construct(
-        DefinitionAggregateInterface      $definitions = null,
-        ServiceProviderAggregateInterface $providers = null,
-        InflectorAggregateInterface       $inflectors = null
+        ?DefinitionAggregateInterface $definitions = null,
+        ?ServiceProviderAggregateInterface $providers = null,
+        ?InflectorAggregateInterface $inflectors = null
     ) {
-        $this->definitions = $definitions ?? new DefinitionAggregate;
-        $this->providers   = $providers   ?? new ServiceProviderAggregate;
-        $this->inflectors  = $inflectors  ?? new InflectorAggregate;
+        $this->definitions = $definitions ?? new DefinitionAggregate();
+        $this->providers   = $providers   ?? new ServiceProviderAggregate();
+        $this->inflectors  = $inflectors  ?? new InflectorAggregate();
 
         if ($this->definitions instanceof ContainerAwareInterface) {
-            $this->definitions->setLeagueContainer($this);
+            $this->definitions->setContainer($this);
         }
 
         if ($this->providers instanceof ContainerAwareInterface) {
-            $this->providers->setLeagueContainer($this);
+            $this->providers->setContainer($this);
         }
 
         if ($this->inflectors instanceof ContainerAwareInterface) {
-            $this->inflectors->setLeagueContainer($this);
+            $this->inflectors->setContainer($this);
         }
     }
 
-    /**
-     * Add an item to the container.
-     *
-     * @param string  $id
-     * @param mixed   $concrete
-     * @param boolean $shared
-     *
-     * @return DefinitionInterface
-     */
-    public function add(string $id, $concrete = null, bool $shared = null) : DefinitionInterface
+    public function add(string $id, $concrete = null): DefinitionInterface
     {
         $concrete = $concrete ?? $id;
-        $shared = $shared ?? $this->defaultToShared;
 
-        return $this->definitions->add($id, $concrete, $shared);
+        if (true === $this->defaultToShared) {
+            return $this->addShared($id, $concrete);
+        }
+
+        return $this->definitions->add($id, $concrete);
     }
 
-    /**
-     * Proxy to add with shared as true.
-     *
-     * @param string $id
-     * @param mixed  $concrete
-     *
-     * @return DefinitionInterface
-     */
-    public function share(string $id, $concrete = null) : DefinitionInterface
+    public function addShared(string $id, $concrete = null): DefinitionInterface
     {
-        return $this->add($id, $concrete, true);
+        $concrete = $concrete ?? $id;
+        return $this->definitions->addShared($id, $concrete);
     }
 
-    /**
-     * Whether the container should default to defining shared definitions.
-     *
-     * @param boolean $shared
-     *
-     * @return self
-     */
-    public function defaultToShared(bool $shared = true) : ContainerInterface
+    public function defaultToShared(bool $shared = true): ContainerInterface
     {
         $this->defaultToShared = $shared;
-
         return $this;
     }
 
-    /**
-     * Get a definition to extend.
-     *
-     * @param string $id [description]
-     *
-     * @return DefinitionInterface
-     */
-    public function extend(string $id) : DefinitionInterface
+    public function extend(string $id): DefinitionInterface
     {
         if ($this->providers->provides($id)) {
             $this->providers->register($id);
@@ -129,69 +94,43 @@ public function extend(string $id) : DefinitionInterface
             return $this->definitions->getDefinition($id);
         }
 
-        throw new NotFoundException(
-            sprintf('Unable to extend alias (%s) as it is not being managed as a definition', $id)
-        );
+        throw new NotFoundException(sprintf(
+            'Unable to extend alias (%s) as it is not being managed as a definition',
+            $id
+        ));
     }
 
-    /**
-     * Add a service provider.
-     *
-     * @param ServiceProviderInterface|string $provider
-     *
-     * @return self
-     */
-    public function addServiceProvider($provider) : self
+    public function addServiceProvider(ServiceProviderInterface $provider): DefinitionContainerInterface
     {
         $this->providers->add($provider);
-
         return $this;
     }
 
     /**
-     * {@inheritdoc}
+     * @template RequestedType
+     *
+     * @param class-string<RequestedType>|string $id
+     *
+     * @return RequestedType|mixed
      */
-    public function get($id, bool $new = false)
+    public function get($id)
     {
-        if ($this->definitions->has($id)) {
-            $resolved = $this->definitions->resolve($id, $new);
-            return $this->inflectors->inflect($resolved);
-        }
-
-        if ($this->definitions->hasTag($id)) {
-            $arrayOf = $this->definitions->resolveTagged($id, $new);
-
-            array_walk($arrayOf, function (&$resolved) {
-                $resolved = $this->inflectors->inflect($resolved);
-            });
-
-            return $arrayOf;
-        }
-
-        if ($this->providers->provides($id)) {
-            $this->providers->register($id);
-
-            if (!$this->definitions->has($id) && !$this->definitions->hasTag($id)) {
-                throw new ContainerException(sprintf('Service provider lied about providing (%s) service', $id));
-            }
-
-            return $this->get($id, $new);
-        }
-
-        foreach ($this->delegates as $delegate) {
-            if ($delegate->has($id)) {
-                $resolved = $delegate->get($id);
-                return $this->inflectors->inflect($resolved);
-            }
-        }
-
-        throw new NotFoundException(sprintf('Alias (%s) is not being managed by the container or delegates', $id));
+        return $this->resolve($id);
     }
 
     /**
-     * {@inheritdoc}
+     * @template RequestedType
+     *
+     * @param class-string<RequestedType>|string $id
+     *
+     * @return RequestedType|mixed
      */
-    public function has($id)
+    public function getNew($id)
+    {
+        return $this->resolve($id, true);
+    }
+
+    public function has($id): bool
     {
         if ($this->definitions->has($id)) {
             return true;
@@ -214,35 +153,58 @@ public function has($id)
         return false;
     }
 
-    /**
-     * Allows for manipulation of specific types on resolution.
-     *
-     * @param string        $type
-     * @param callable|null $callback
-     *
-     * @return InflectorInterface
-     */
-    public function inflector(string $type, callable $callback = null) : InflectorInterface
+    public function inflector(string $type, ?callable $callback = null): InflectorInterface
     {
         return $this->inflectors->add($type, $callback);
     }
 
-    /**
-     * Delegate a backup container to be checked for services if it
-     * cannot be resolved via this container.
-     *
-     * @param ContainerInterface $container
-     *
-     * @return self
-     */
-    public function delegate(ContainerInterface $container) : self
+    public function delegate(ContainerInterface $container): self
     {
         $this->delegates[] = $container;
 
         if ($container instanceof ContainerAwareInterface) {
-            $container->setLeagueContainer($this);
+            $container->setContainer($this);
         }
 
         return $this;
     }
+
+    protected function resolve($id, bool $new = false)
+    {
+        if ($this->definitions->has($id)) {
+            $resolved = (true === $new) ? $this->definitions->resolveNew($id) : $this->definitions->resolve($id);
+            return $this->inflectors->inflect($resolved);
+        }
+
+        if ($this->definitions->hasTag($id)) {
+            $arrayOf = (true === $new)
+                ? $this->definitions->resolveTaggedNew($id)
+                : $this->definitions->resolveTagged($id);
+
+            array_walk($arrayOf, function (&$resolved) {
+                $resolved = $this->inflectors->inflect($resolved);
+            });
+
+            return $arrayOf;
+        }
+
+        if ($this->providers->provides($id)) {
+            $this->providers->register($id);
+
+            if (!$this->definitions->has($id) && !$this->definitions->hasTag($id)) {
+                throw new ContainerException(sprintf('Service provider lied about providing (%s) service', $id));
+            }
+
+            return $this->resolve($id, $new);
+        }
+
+        foreach ($this->delegates as $delegate) {
+            if ($delegate->has($id)) {
+                $resolved = $delegate->get($id);
+                return $this->inflectors->inflect($resolved);
+            }
+        }
+
+        throw new NotFoundException(sprintf('Alias (%s) is not being managed by the container or delegates', $id));
+    }
 }
diff --git a/classes/Dependencies/League/Container/ContainerAwareInterface.php b/classes/Dependencies/League/Container/ContainerAwareInterface.php
index f79443177..4f2d46882 100644
--- a/classes/Dependencies/League/Container/ContainerAwareInterface.php
+++ b/classes/Dependencies/League/Container/ContainerAwareInterface.php
@@ -1,40 +1,11 @@
-<?php declare(strict_types=1);
+<?php
 
-namespace Imagify\Dependencies\League\Container;
+declare(strict_types=1);
 
-use Imagify\Dependencies\Psr\Container\ContainerInterface;
+namespace Imagify\Dependencies\League\Container;
 
 interface ContainerAwareInterface
 {
-    /**
-     * Set a container
-     *
-     * @param ContainerInterface $container
-     *
-     * @return self
-     */
-    public function setContainer(ContainerInterface $container) : ContainerAwareInterface;
-
-    /**
-     * Get the container
-     *
-     * @return ContainerInterface
-     */
-    public function getContainer() : ContainerInterface;
-
-    /**
-     * Set a container. This will be removed in favour of setContainer receiving Container in next major release.
-     *
-     * @param Container $container
-     *
-     * @return self
-     */
-    public function setLeagueContainer(Container $container) : self;
-
-    /**
-     * Get the container. This will be removed in favour of getContainer returning Container in next major release.
-     *
-     * @return Container
-     */
-    public function getLeagueContainer() : Container;
+    public function getContainer(): DefinitionContainerInterface;
+    public function setContainer(DefinitionContainerInterface $container): ContainerAwareInterface;
 }
diff --git a/classes/Dependencies/League/Container/ContainerAwareTrait.php b/classes/Dependencies/League/Container/ContainerAwareTrait.php
index bdfc4101f..7481d6efd 100644
--- a/classes/Dependencies/League/Container/ContainerAwareTrait.php
+++ b/classes/Dependencies/League/Container/ContainerAwareTrait.php
@@ -1,74 +1,38 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container;
 
+use BadMethodCallException;
 use Imagify\Dependencies\League\Container\Exception\ContainerException;
-use Imagify\Dependencies\Psr\Container\ContainerInterface;
 
 trait ContainerAwareTrait
 {
     /**
-     * @var ContainerInterface
+     * @var ?DefinitionContainerInterface
      */
     protected $container;
 
-    /**
-     * @var Container
-     */
-    protected $leagueContainer;
-
-    /**
-     * Set a container.
-     *
-     * @param ContainerInterface $container
-     *
-     * @return ContainerAwareInterface
-     */
-    public function setContainer(ContainerInterface $container) : ContainerAwareInterface
+    public function setContainer(DefinitionContainerInterface $container): ContainerAwareInterface
     {
         $this->container = $container;
 
-        return $this;
-    }
-
-    /**
-     * Get the container.
-     *
-     * @return ContainerInterface
-     */
-    public function getContainer() : ContainerInterface
-    {
-        if ($this->container instanceof ContainerInterface) {
-            return $this->container;
+        if ($this instanceof ContainerAwareInterface) {
+            return $this;
         }
 
-        throw new ContainerException('No container implementation has been set.');
+        throw new BadMethodCallException(sprintf(
+            'Attempt to use (%s) while not implementing (%s)',
+            ContainerAwareTrait::class,
+            ContainerAwareInterface::class
+        ));
     }
 
-    /**
-     * Set a container.
-     *
-     * @param Container $container
-     *
-     * @return self
-     */
-    public function setLeagueContainer(Container $container) : ContainerAwareInterface
+    public function getContainer(): DefinitionContainerInterface
     {
-        $this->container = $container;
-        $this->leagueContainer = $container;
-
-        return $this;
-    }
-
-    /**
-     * Get the container.
-     *
-     * @return Container
-     */
-    public function getLeagueContainer() : Container
-    {
-        if ($this->leagueContainer instanceof Container) {
-            return $this->leagueContainer;
+        if ($this->container instanceof DefinitionContainerInterface) {
+            return $this->container;
         }
 
         throw new ContainerException('No container implementation has been set.');
diff --git a/classes/Dependencies/League/Container/Definition/Definition.php b/classes/Dependencies/League/Container/Definition/Definition.php
index 8128d7781..0918959e8 100644
--- a/classes/Dependencies/League/Container/Definition/Definition.php
+++ b/classes/Dependencies/League/Container/Definition/Definition.php
@@ -1,13 +1,20 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Definition;
 
 use Imagify\Dependencies\League\Container\Argument\{
-    ArgumentResolverInterface, ArgumentResolverTrait, ClassNameInterface, RawArgumentInterface
+    ArgumentResolverInterface,
+    ArgumentResolverTrait,
+    ArgumentInterface,
+    LiteralArgumentInterface
 };
 use Imagify\Dependencies\League\Container\ContainerAwareTrait;
+use Imagify\Dependencies\League\Container\Exception\ContainerException;
+use Imagify\Dependencies\League\Container\Exception\NotFoundException;
+use Imagify\Dependencies\Psr\Container\ContainerInterface;
 use ReflectionClass;
-use ReflectionException;
 
 class Definition implements ArgumentResolverInterface, DefinitionInterface
 {
@@ -50,106 +57,77 @@ class Definition implements ArgumentResolverInterface, DefinitionInterface
     protected $resolved;
 
     /**
-     * Constructor.
-     *
-     * @param string $id
-     * @param mixed  $concrete
+     * @var array
+     */
+    protected $recursiveCheck = [];
+
+    /**
+     * @param string     $id
+     * @param mixed|null $concrete
      */
     public function __construct(string $id, $concrete = null)
     {
-        $concrete = $concrete ?? $id;
+        $id = static::normaliseAlias($id);
 
+        $concrete = $concrete ?? $id;
         $this->alias    = $id;
         $this->concrete = $concrete;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function addTag(string $tag) : DefinitionInterface
+    public function addTag(string $tag): DefinitionInterface
     {
         $this->tags[$tag] = true;
-
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function hasTag(string $tag) : bool
+    public function hasTag(string $tag): bool
     {
         return isset($this->tags[$tag]);
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function setAlias(string $id) : DefinitionInterface
+    public function setAlias(string $id): DefinitionInterface
     {
-        $this->alias = $id;
+        $id = static::normaliseAlias($id);
 
+        $this->alias = $id;
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getAlias() : string
+    public function getAlias(): string
     {
         return $this->alias;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function setShared(bool $shared = true) : DefinitionInterface
+    public function setShared(bool $shared = true): DefinitionInterface
     {
         $this->shared = $shared;
-
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function isShared() : bool
+    public function isShared(): bool
     {
         return $this->shared;
     }
 
-    /**
-     * {@inheritdoc}
-     */
     public function getConcrete()
     {
         return $this->concrete;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function setConcrete($concrete) : DefinitionInterface
+    public function setConcrete($concrete): DefinitionInterface
     {
         $this->concrete = $concrete;
         $this->resolved = null;
-
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function addArgument($arg) : DefinitionInterface
+    public function addArgument($arg): DefinitionInterface
     {
         $this->arguments[] = $arg;
-
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function addArguments(array $args) : DefinitionInterface
+    public function addArguments(array $args): DefinitionInterface
     {
         foreach ($args as $arg) {
             $this->addArgument($arg);
@@ -158,10 +136,7 @@ public function addArguments(array $args) : DefinitionInterface
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function addMethodCall(string $method, array $args = []) : DefinitionInterface
+    public function addMethodCall(string $method, array $args = []): DefinitionInterface
     {
         $this->methods[] = [
             'method'    => $method,
@@ -171,10 +146,7 @@ public function addMethodCall(string $method, array $args = []) : DefinitionInte
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function addMethodCalls(array $methods = []) : DefinitionInterface
+    public function addMethodCalls(array $methods = []): DefinitionInterface
     {
         foreach ($methods as $method => $args) {
             $this->addMethodCall($method, $args);
@@ -183,29 +155,30 @@ public function addMethodCalls(array $methods = []) : DefinitionInterface
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function resolve(bool $new = false)
+    public function resolve()
     {
-        $concrete = $this->concrete;
-
-        if ($this->isShared() && $this->resolved !== null && $new === false) {
+        if (null !== $this->resolved && $this->isShared()) {
             return $this->resolved;
         }
 
+        return $this->resolveNew();
+    }
+
+    public function resolveNew()
+    {
+        $concrete = $this->concrete;
+
         if (is_callable($concrete)) {
             $concrete = $this->resolveCallable($concrete);
         }
 
-        if ($concrete instanceof RawArgumentInterface) {
+        if ($concrete instanceof LiteralArgumentInterface) {
             $this->resolved = $concrete->getValue();
-
             return $concrete->getValue();
         }
 
-        if ($concrete instanceof ClassNameInterface) {
-            $concrete = $concrete->getClassName();
+        if ($concrete instanceof ArgumentInterface) {
+            $concrete = $concrete->getValue();
         }
 
         if (is_string($concrete) && class_exists($concrete)) {
@@ -216,63 +189,63 @@ public function resolve(bool $new = false)
             $concrete = $this->invokeMethods($concrete);
         }
 
-        if (is_string($concrete) && $this->getContainer()->has($concrete)) {
-            $concrete = $this->getContainer()->get($concrete);
+        try {
+            $container = $this->getContainer();
+        } catch (ContainerException $e) {
+            $container = null;
         }
 
-        $this->resolved = $concrete;
+        // stop recursive resolving
+        if (is_string($concrete) && in_array($concrete, $this->recursiveCheck)) {
+            $this->resolved = $concrete;
+            return $concrete;
+        }
+
+        // if we still have a string, try to pull it from the container
+        // this allows for `alias -> alias -> ... -> concrete
+        if (is_string($concrete) && $container instanceof ContainerInterface && $container->has($concrete)) {
+            $this->recursiveCheck[] = $concrete;
+            $concrete = $container->get($concrete);
+        }
 
+        $this->resolved = $concrete;
         return $concrete;
     }
 
     /**
-     * Resolve a callable.
-     *
      * @param callable $concrete
-     *
      * @return mixed
      */
     protected function resolveCallable(callable $concrete)
     {
         $resolved = $this->resolveArguments($this->arguments);
-
         return call_user_func_array($concrete, $resolved);
     }
 
-    /**
-     * Resolve a class.
-     *
-     * @param string $concrete
-     *
-     * @return object
-     *
-     * @throws ReflectionException
-     */
-    protected function resolveClass(string $concrete)
+    protected function resolveClass(string $concrete): object
     {
         $resolved   = $this->resolveArguments($this->arguments);
         $reflection = new ReflectionClass($concrete);
-
         return $reflection->newInstanceArgs($resolved);
     }
 
-    /**
-     * Invoke methods on resolved instance.
-     *
-     * @param object $instance
-     *
-     * @return object
-     */
-    protected function invokeMethods($instance)
+    protected function invokeMethods(object $instance): object
     {
         foreach ($this->methods as $method) {
             $args = $this->resolveArguments($method['arguments']);
-
-            /** @var callable $callable */
             $callable = [$instance, $method['method']];
             call_user_func_array($callable, $args);
         }
 
         return $instance;
     }
+
+    public static function normaliseAlias(string $alias): string
+    {
+        if (strpos($alias, '\\') === 0) {
+            return substr($alias, 1);
+        }
+
+        return $alias;
+    }
 }
diff --git a/classes/Dependencies/League/Container/Definition/DefinitionAggregate.php b/classes/Dependencies/League/Container/Definition/DefinitionAggregate.php
index 651c8c180..81709ea8d 100644
--- a/classes/Dependencies/League/Container/Definition/DefinitionAggregate.php
+++ b/classes/Dependencies/League/Container/Definition/DefinitionAggregate.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Definition;
 
@@ -15,40 +17,34 @@ class DefinitionAggregate implements DefinitionAggregateInterface
      */
     protected $definitions = [];
 
-    /**
-     * Construct.
-     *
-     * @param DefinitionInterface[] $definitions
-     */
     public function __construct(array $definitions = [])
     {
-        $this->definitions = array_filter($definitions, function ($definition) {
+        $this->definitions = array_filter($definitions, static function ($definition) {
             return ($definition instanceof DefinitionInterface);
         });
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function add(string $id, $definition, bool $shared = false) : DefinitionInterface
+    public function add(string $id, $definition): DefinitionInterface
     {
-        if (!$definition instanceof DefinitionInterface) {
+        if (false === ($definition instanceof DefinitionInterface)) {
             $definition = new Definition($id, $definition);
         }
 
-        $this->definitions[] = $definition
-            ->setAlias($id)
-            ->setShared($shared)
-        ;
+        $this->definitions[] = $definition->setAlias($id);
 
         return $definition;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function has(string $id) : bool
+    public function addShared(string $id, $definition): DefinitionInterface
     {
+        $definition = $this->add($id, $definition);
+        return $definition->setShared(true);
+    }
+
+    public function has(string $id): bool
+    {
+        $id = Definition::normaliseAlias($id);
+
         foreach ($this->getIterator() as $definition) {
             if ($id === $definition->getAlias()) {
                 return true;
@@ -58,10 +54,7 @@ public function has(string $id) : bool
         return false;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function hasTag(string $tag) : bool
+    public function hasTag(string $tag): bool
     {
         foreach ($this->getIterator() as $definition) {
             if ($definition->hasTag($tag)) {
@@ -72,53 +65,57 @@ public function hasTag(string $tag) : bool
         return false;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getDefinition(string $id) : DefinitionInterface
+    public function getDefinition(string $id): DefinitionInterface
     {
+        $id = Definition::normaliseAlias($id);
+
         foreach ($this->getIterator() as $definition) {
             if ($id === $definition->getAlias()) {
-                return $definition->setLeagueContainer($this->getLeagueContainer());
+                return $definition->setContainer($this->getContainer());
             }
         }
 
         throw new NotFoundException(sprintf('Alias (%s) is not being handled as a definition.', $id));
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function resolve(string $id, bool $new = false)
+    public function resolve(string $id)
     {
-        return $this->getDefinition($id)->resolve($new);
+        return $this->getDefinition($id)->resolve();
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function resolveTagged(string $tag, bool $new = false) : array
+    public function resolveNew(string $id)
+    {
+        return $this->getDefinition($id)->resolveNew();
+    }
+
+    public function resolveTagged(string $tag): array
     {
         $arrayOf = [];
 
         foreach ($this->getIterator() as $definition) {
             if ($definition->hasTag($tag)) {
-                $arrayOf[] = $definition->setLeagueContainer($this->getLeagueContainer())->resolve($new);
+                $arrayOf[] = $definition->setContainer($this->getContainer())->resolve();
             }
         }
 
         return $arrayOf;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getIterator() : Generator
+    public function resolveTaggedNew(string $tag): array
     {
-        $count = count($this->definitions);
+        $arrayOf = [];
 
-        for ($i = 0; $i < $count; $i++) {
-            yield $this->definitions[$i];
+        foreach ($this->getIterator() as $definition) {
+            if ($definition->hasTag($tag)) {
+                $arrayOf[] = $definition->setContainer($this->getContainer())->resolveNew();
+            }
         }
+
+        return $arrayOf;
+    }
+
+    public function getIterator(): Generator
+    {
+        yield from $this->definitions;
     }
 }
diff --git a/classes/Dependencies/League/Container/Definition/DefinitionAggregateInterface.php b/classes/Dependencies/League/Container/Definition/DefinitionAggregateInterface.php
index e0c83a923..c72fbd5e7 100644
--- a/classes/Dependencies/League/Container/Definition/DefinitionAggregateInterface.php
+++ b/classes/Dependencies/League/Container/Definition/DefinitionAggregateInterface.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Definition;
 
@@ -7,61 +9,13 @@
 
 interface DefinitionAggregateInterface extends ContainerAwareInterface, IteratorAggregate
 {
-    /**
-     * Add a definition to the aggregate.
-     *
-     * @param string  $id
-     * @param mixed   $definition
-     * @param boolean $shared
-     *
-     * @return DefinitionInterface
-     */
-    public function add(string $id, $definition, bool $shared = false) : DefinitionInterface;
-
-    /**
-     * Checks whether alias exists as definition.
-     *
-     * @param string $id
-     *
-     * @return boolean
-     */
-    public function has(string $id) : bool;
-
-    /**
-     * Checks whether tag exists as definition.
-     *
-     * @param string $tag
-     *
-     * @return boolean
-     */
-    public function hasTag(string $tag) : bool;
-
-    /**
-     * Get the definition to be extended.
-     *
-     * @param string $id
-     *
-     * @return DefinitionInterface
-     */
-    public function getDefinition(string $id) : DefinitionInterface;
-
-    /**
-     * Resolve and build a concrete value from an id/alias.
-     *
-     * @param string  $id
-     * @param boolean $new
-     *
-     * @return mixed
-     */
-    public function resolve(string $id, bool $new = false);
-
-    /**
-     * Resolve and build an array of concrete values from a tag.
-     *
-     * @param string  $tag
-     * @param boolean $new
-     *
-     * @return mixed
-     */
-    public function resolveTagged(string $tag, bool $new = false);
+    public function add(string $id, $definition): DefinitionInterface;
+    public function addShared(string $id, $definition): DefinitionInterface;
+    public function getDefinition(string $id): DefinitionInterface;
+    public function has(string $id): bool;
+    public function hasTag(string $tag): bool;
+    public function resolve(string $id);
+    public function resolveNew(string $id);
+    public function resolveTagged(string $tag): array;
+    public function resolveTaggedNew(string $tag): array;
 }
diff --git a/classes/Dependencies/League/Container/Definition/DefinitionInterface.php b/classes/Dependencies/League/Container/Definition/DefinitionInterface.php
index 8184c2266..7f286d3fd 100644
--- a/classes/Dependencies/League/Container/Definition/DefinitionInterface.php
+++ b/classes/Dependencies/League/Container/Definition/DefinitionInterface.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Definition;
 
@@ -6,115 +8,18 @@
 
 interface DefinitionInterface extends ContainerAwareInterface
 {
-    /**
-     * Add a tag to the definition.
-     *
-     * @param string $tag
-     *
-     * @return self
-     */
-    public function addTag(string $tag) : DefinitionInterface;
-
-    /**
-     * Does the definition have a tag?
-     *
-     * @param string $tag
-     *
-     * @return boolean
-     */
-    public function hasTag(string $tag) : bool;
-
-    /**
-     * Set the alias of the definition.
-     *
-     * @param string $id
-     *
-     * @return DefinitionInterface
-     */
-    public function setAlias(string $id) : DefinitionInterface;
-
-    /**
-     * Get the alias of the definition.
-     *
-     * @return string
-     */
-    public function getAlias() : string;
-
-    /**
-     * Set whether this is a shared definition.
-     *
-     * @param boolean $shared
-     *
-     * @return self
-     */
-    public function setShared(bool $shared) : DefinitionInterface;
-
-    /**
-     * Is this a shared definition?
-     *
-     * @return boolean
-     */
-    public function isShared() : bool;
-
-    /**
-     * Get the concrete of the definition.
-     *
-     * @return mixed
-     */
+    public function addArgument($arg): DefinitionInterface;
+    public function addArguments(array $args): DefinitionInterface;
+    public function addMethodCall(string $method, array $args = []): DefinitionInterface;
+    public function addMethodCalls(array $methods = []): DefinitionInterface;
+    public function addTag(string $tag): DefinitionInterface;
+    public function getAlias(): string;
     public function getConcrete();
-
-    /**
-     * Set the concrete of the definition.
-     *
-     * @param mixed $concrete
-     *
-     * @return DefinitionInterface
-     */
-    public function setConcrete($concrete) : DefinitionInterface;
-
-    /**
-     * Add an argument to be injected.
-     *
-     * @param mixed $arg
-     *
-     * @return self
-     */
-    public function addArgument($arg) : DefinitionInterface;
-
-    /**
-     * Add multiple arguments to be injected.
-     *
-     * @param array $args
-     *
-     * @return self
-     */
-    public function addArguments(array $args) : DefinitionInterface;
-
-    /**
-     * Add a method to be invoked
-     *
-     * @param string $method
-     * @param array  $args
-     *
-     * @return self
-     */
-    public function addMethodCall(string $method, array $args = []) : DefinitionInterface;
-
-    /**
-     * Add multiple methods to be invoked
-     *
-     * @param array $methods
-     *
-     * @return self
-     */
-    public function addMethodCalls(array $methods = []) : DefinitionInterface;
-
-    /**
-     * Handle instantiation and manipulation of value and return.
-     *
-     * @param boolean $new
-     *
-     * @return mixed
-     */
-    public function resolve(bool $new = false);
+    public function hasTag(string $tag): bool;
+    public function isShared(): bool;
+    public function resolve();
+    public function resolveNew();
+    public function setAlias(string $id): DefinitionInterface;
+    public function setConcrete($concrete): DefinitionInterface;
+    public function setShared(bool $shared): DefinitionInterface;
 }
diff --git a/classes/Dependencies/League/Container/DefinitionContainerInterface.php b/classes/Dependencies/League/Container/DefinitionContainerInterface.php
new file mode 100644
index 000000000..1d8a80cb7
--- /dev/null
+++ b/classes/Dependencies/League/Container/DefinitionContainerInterface.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container;
+
+use Imagify\Dependencies\League\Container\Definition\DefinitionInterface;
+use Imagify\Dependencies\League\Container\Inflector\InflectorInterface;
+use Imagify\Dependencies\League\Container\ServiceProvider\ServiceProviderInterface;
+use Imagify\Dependencies\Psr\Container\ContainerInterface;
+
+interface DefinitionContainerInterface extends ContainerInterface
+{
+    public function add(string $id, $concrete = null): DefinitionInterface;
+    public function addServiceProvider(ServiceProviderInterface $provider): self;
+    public function addShared(string $id, $concrete = null): DefinitionInterface;
+    public function extend(string $id): DefinitionInterface;
+    public function getNew($id);
+    public function inflector(string $type, ?callable $callback = null): InflectorInterface;
+}
diff --git a/classes/Dependencies/League/Container/Exception/ContainerException.php b/classes/Dependencies/League/Container/Exception/ContainerException.php
index a7473ea85..318d56e96 100644
--- a/classes/Dependencies/League/Container/Exception/ContainerException.php
+++ b/classes/Dependencies/League/Container/Exception/ContainerException.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 namespace Imagify\Dependencies\League\Container\Exception;
 
 use Imagify\Dependencies\Psr\Container\ContainerExceptionInterface;
diff --git a/classes/Dependencies/League/Container/Exception/NotFoundException.php b/classes/Dependencies/League/Container/Exception/NotFoundException.php
index 5e8026105..0563089ce 100644
--- a/classes/Dependencies/League/Container/Exception/NotFoundException.php
+++ b/classes/Dependencies/League/Container/Exception/NotFoundException.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 namespace Imagify\Dependencies\League\Container\Exception;
 
 use Imagify\Dependencies\Psr\Container\NotFoundExceptionInterface;
diff --git a/classes/Dependencies/League/Container/Inflector/Inflector.php b/classes/Dependencies/League/Container/Inflector/Inflector.php
index f6c556bd9..d6e6c17ba 100644
--- a/classes/Dependencies/League/Container/Inflector/Inflector.php
+++ b/classes/Dependencies/League/Container/Inflector/Inflector.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Inflector;
 
@@ -31,40 +33,24 @@ class Inflector implements ArgumentResolverInterface, InflectorInterface
      */
     protected $properties = [];
 
-    /**
-     * Construct.
-     *
-     * @param string        $type
-     * @param callable|null $callback
-     */
-    public function __construct(string $type, callable $callback = null)
+    public function __construct(string $type, ?callable $callback = null)
     {
-        $this->type     = $type;
+        $this->type = $type;
         $this->callback = $callback;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getType() : string
+    public function getType(): string
     {
         return $this->type;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function invokeMethod(string $name, array $args) : InflectorInterface
+    public function invokeMethod(string $name, array $args): InflectorInterface
     {
         $this->methods[$name] = $args;
-
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function invokeMethods(array $methods) : InflectorInterface
+    public function invokeMethods(array $methods): InflectorInterface
     {
         foreach ($methods as $name => $args) {
             $this->invokeMethod($name, $args);
@@ -73,20 +59,13 @@ public function invokeMethods(array $methods) : InflectorInterface
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function setProperty(string $property, $value) : InflectorInterface
+    public function setProperty(string $property, $value): InflectorInterface
     {
         $this->properties[$property] = $this->resolveArguments([$value])[0];
-
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function setProperties(array $properties) : InflectorInterface
+    public function setProperties(array $properties): InflectorInterface
     {
         foreach ($properties as $property => $value) {
             $this->setProperty($property, $value);
@@ -95,10 +74,7 @@ public function setProperties(array $properties) : InflectorInterface
         return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function inflect($object)
+    public function inflect(object $object): void
     {
         $properties = $this->resolveArguments(array_values($this->properties));
         $properties = array_combine(array_keys($this->properties), $properties);
@@ -110,8 +86,6 @@ public function inflect($object)
 
         foreach ($this->methods as $method => $args) {
             $args = $this->resolveArguments($args);
-
-            /** @var callable $callable */
             $callable = [$object, $method];
             call_user_func_array($callable, $args);
         }
diff --git a/classes/Dependencies/League/Container/Inflector/InflectorAggregate.php b/classes/Dependencies/League/Container/Inflector/InflectorAggregate.php
index f82c6696c..023aa6e07 100644
--- a/classes/Dependencies/League/Container/Inflector/InflectorAggregate.php
+++ b/classes/Dependencies/League/Container/Inflector/InflectorAggregate.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Inflector;
 
@@ -14,45 +16,29 @@ class InflectorAggregate implements InflectorAggregateInterface
      */
     protected $inflectors = [];
 
-    /**
-     * {@inheritdoc}
-     */
-    public function add(string $type, callable $callback = null) : Inflector
+    public function add(string $type, ?callable $callback = null): Inflector
     {
-        $inflector          = new Inflector($type, $callback);
+        $inflector = new Inflector($type, $callback);
         $this->inflectors[] = $inflector;
-
         return $inflector;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getIterator() : Generator
-    {
-        $count = count($this->inflectors);
-
-        for ($i = 0; $i < $count; $i++) {
-            yield $this->inflectors[$i];
-        }
-    }
-
-    /**
-     * {@inheritdoc}
-     */
     public function inflect($object)
     {
         foreach ($this->getIterator() as $inflector) {
             $type = $inflector->getType();
 
-            if (! $object instanceof $type) {
-                continue;
+            if ($object instanceof $type) {
+                $inflector->setContainer($this->getContainer());
+                $inflector->inflect($object);
             }
-
-            $inflector->setLeagueContainer($this->getLeagueContainer());
-            $inflector->inflect($object);
         }
 
         return $object;
     }
+
+    public function getIterator(): Generator
+    {
+        yield from $this->inflectors;
+    }
 }
diff --git a/classes/Dependencies/League/Container/Inflector/InflectorAggregateInterface.php b/classes/Dependencies/League/Container/Inflector/InflectorAggregateInterface.php
index 0c2a57d15..2b5a9644e 100644
--- a/classes/Dependencies/League/Container/Inflector/InflectorAggregateInterface.php
+++ b/classes/Dependencies/League/Container/Inflector/InflectorAggregateInterface.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Inflector;
 
@@ -7,21 +9,6 @@
 
 interface InflectorAggregateInterface extends ContainerAwareInterface, IteratorAggregate
 {
-    /**
-     * Add an inflector to the aggregate.
-     *
-     * @param string   $type
-     * @param callable $callback
-     *
-     * @return Inflector
-     */
-    public function add(string $type, callable $callback = null) : Inflector;
-
-    /**
-     * Applies all inflectors to an object.
-     *
-     * @param  object $object
-     * @return object
-     */
-    public function inflect($object);
+    public function add(string $type, ?callable $callback = null): Inflector;
+    public function inflect(object $object);
 }
diff --git a/classes/Dependencies/League/Container/Inflector/InflectorInterface.php b/classes/Dependencies/League/Container/Inflector/InflectorInterface.php
index eaff0e7ae..cdacf4151 100644
--- a/classes/Dependencies/League/Container/Inflector/InflectorInterface.php
+++ b/classes/Dependencies/League/Container/Inflector/InflectorInterface.php
@@ -1,60 +1,15 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\Inflector;
 
 interface InflectorInterface
 {
-    /**
-     * Get the type.
-     *
-     * @return string
-     */
-    public function getType() : string;
-
-    /**
-     * Defines a method to be invoked on the subject object.
-     *
-     * @param string $name
-     * @param array  $args
-     *
-     * @return self
-     */
-    public function invokeMethod(string $name, array $args) : InflectorInterface;
-
-    /**
-     * Defines multiple methods to be invoked on the subject object.
-     *
-     * @param array $methods
-     *
-     * @return self
-     */
-    public function invokeMethods(array $methods) : InflectorInterface;
-
-    /**
-     * Defines a property to be set on the subject object.
-     *
-     * @param string $property
-     * @param mixed  $value
-     *
-     * @return self
-     */
-    public function setProperty(string $property, $value) : InflectorInterface;
-
-    /**
-     * Defines multiple properties to be set on the subject object.
-     *
-     * @param array $properties
-     *
-     * @return self
-     */
-    public function setProperties(array $properties) : InflectorInterface;
-
-    /**
-     * Apply inflections to an object.
-     *
-     * @param object $object
-     *
-     * @return void
-     */
-    public function inflect($object);
+    public function getType(): string;
+    public function inflect(object $object): void;
+    public function invokeMethod(string $name, array $args): InflectorInterface;
+    public function invokeMethods(array $methods): InflectorInterface;
+    public function setProperties(array $properties): InflectorInterface;
+    public function setProperty(string $property, $value): InflectorInterface;
 }
diff --git a/classes/Dependencies/League/Container/ReflectionContainer.php b/classes/Dependencies/League/Container/ReflectionContainer.php
index 5676dddff..c62a0fa93 100644
--- a/classes/Dependencies/League/Container/ReflectionContainer.php
+++ b/classes/Dependencies/League/Container/ReflectionContainer.php
@@ -1,12 +1,14 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container;
 
 use Imagify\Dependencies\League\Container\Argument\{ArgumentResolverInterface, ArgumentResolverTrait};
+use Imagify\Dependencies\League\Container\Exception\ContainerException;
 use Imagify\Dependencies\League\Container\Exception\NotFoundException;
 use Imagify\Dependencies\Psr\Container\ContainerInterface;
 use ReflectionClass;
-use ReflectionException;
 use ReflectionFunction;
 use ReflectionMethod;
 
@@ -18,27 +20,25 @@ class ReflectionContainer implements ArgumentResolverInterface, ContainerInterfa
     /**
      * @var boolean
      */
-    protected $cacheResolutions = false;
+    protected $cacheResolutions;
 
     /**
-     * Cache of resolutions.
-     *
      * @var array
      */
     protected $cache = [];
 
-    /**
-     * {@inheritdoc}
-     *
-     * @throws ReflectionException
-     */
+    public function __construct(bool $cacheResolutions = false)
+    {
+        $this->cacheResolutions = $cacheResolutions;
+    }
+
     public function get($id, array $args = [])
     {
         if ($this->cacheResolutions === true && array_key_exists($id, $this->cache)) {
             return $this->cache[$id];
         }
 
-        if (! $this->has($id)) {
+        if (!$this->has($id)) {
             throw new NotFoundException(
                 sprintf('Alias (%s) is not an existing class and therefore cannot be resolved', $id)
             );
@@ -54,8 +54,8 @@ public function get($id, array $args = [])
         }
 
         $resolution = $construct === null
-            ? new $id
-            : $resolution = $reflector->newInstanceArgs($this->reflectArguments($construct, $args))
+            ? new $id()
+            : $reflector->newInstanceArgs($this->reflectArguments($construct, $args))
         ;
 
         if ($this->cacheResolutions === true) {
@@ -65,24 +65,11 @@ public function get($id, array $args = [])
         return $resolution;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function has($id)
+    public function has($id): bool
     {
         return class_exists($id);
     }
 
-    /**
-     * Invoke a callable via the container.
-     *
-     * @param callable $callable
-     * @param array    $args
-     *
-     * @return mixed
-     *
-     * @throws ReflectionException
-     */
     public function call(callable $callable, array $args = [])
     {
         if (is_string($callable) && strpos($callable, '::') !== false) {
@@ -91,7 +78,12 @@ public function call(callable $callable, array $args = [])
 
         if (is_array($callable)) {
             if (is_string($callable[0])) {
-                $callable[0] = $this->getContainer()->get($callable[0]);
+                // if we have a definition container, try that first, otherwise, reflect
+                try {
+                    $callable[0] = $this->getContainer()->get($callable[0]);
+                } catch (ContainerException $e) {
+                    $callable[0] = $this->get($callable[0]);
+                }
             }
 
             $reflection = new ReflectionMethod($callable[0], $callable[1]);
@@ -105,7 +97,6 @@ public function call(callable $callable, array $args = [])
 
         if (is_object($callable)) {
             $reflection = new ReflectionMethod($callable, '__invoke');
-
             return $reflection->invokeArgs($callable, $this->reflectArguments($reflection, $args));
         }
 
@@ -113,19 +104,4 @@ public function call(callable $callable, array $args = [])
 
         return $reflection->invokeArgs($this->reflectArguments($reflection, $args));
     }
-
-    /**
-     * Whether the container should default to caching resolutions and returning
-     * the cache on following calls.
-     *
-     * @param boolean $option
-     *
-     * @return self
-     */
-    public function cacheResolutions(bool $option = true) : ContainerInterface
-    {
-        $this->cacheResolutions = $option;
-
-        return $this;
-    }
 }
diff --git a/classes/Dependencies/League/Container/ServiceProvider/AbstractServiceProvider.php b/classes/Dependencies/League/Container/ServiceProvider/AbstractServiceProvider.php
index 64efcb27e..f436b1471 100644
--- a/classes/Dependencies/League/Container/ServiceProvider/AbstractServiceProvider.php
+++ b/classes/Dependencies/League/Container/ServiceProvider/AbstractServiceProvider.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\ServiceProvider;
 
@@ -8,39 +10,19 @@ abstract class AbstractServiceProvider implements ServiceProviderInterface
 {
     use ContainerAwareTrait;
 
-    /**
-     * @var array
-     */
-    protected $provides = [];
-
     /**
      * @var string
      */
     protected $identifier;
 
-    /**
-     * {@inheritdoc}
-     */
-    public function provides(string $alias) : bool
+    public function getIdentifier(): string
     {
-        return in_array($alias, $this->provides, true);
+        return $this->identifier ?? get_class($this);
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function setIdentifier(string $id) : ServiceProviderInterface
+    public function setIdentifier(string $id): ServiceProviderInterface
     {
         $this->identifier = $id;
-
         return $this;
     }
-
-    /**
-     * {@inheritdoc}
-     */
-    public function getIdentifier() : string
-    {
-        return $this->identifier ?? get_class($this);
-    }
 }
diff --git a/classes/Dependencies/League/Container/ServiceProvider/BootableServiceProviderInterface.php b/classes/Dependencies/League/Container/ServiceProvider/BootableServiceProviderInterface.php
index 29d147fcd..32bdd7add 100644
--- a/classes/Dependencies/League/Container/ServiceProvider/BootableServiceProviderInterface.php
+++ b/classes/Dependencies/League/Container/ServiceProvider/BootableServiceProviderInterface.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\ServiceProvider;
 
@@ -10,5 +12,5 @@ interface BootableServiceProviderInterface extends ServiceProviderInterface
      *
      * @return void
      */
-    public function boot();
+    public function boot(): void;
 }
diff --git a/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderAggregate.php b/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderAggregate.php
index 263ce5158..060d71499 100644
--- a/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderAggregate.php
+++ b/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderAggregate.php
@@ -1,10 +1,12 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\ServiceProvider;
 
 use Generator;
-use Imagify\Dependencies\League\Container\{ContainerAwareInterface, ContainerAwareTrait};
 use Imagify\Dependencies\League\Container\Exception\ContainerException;
+use Imagify\Dependencies\League\Container\{ContainerAwareInterface, ContainerAwareTrait};
 
 class ServiceProviderAggregate implements ServiceProviderAggregateInterface
 {
@@ -20,45 +22,23 @@ class ServiceProviderAggregate implements ServiceProviderAggregateInterface
      */
     protected $registered = [];
 
-    /**
-     * {@inheritdoc}
-     */
-    public function add($provider) : ServiceProviderAggregateInterface
+    public function add(ServiceProviderInterface $provider): ServiceProviderAggregateInterface
     {
-        if (is_string($provider) && $this->getContainer()->has($provider)) {
-            $provider = $this->getContainer()->get($provider);
-        } elseif (is_string($provider) && class_exists($provider)) {
-            $provider = new $provider;
-        }
-
         if (in_array($provider, $this->providers, true)) {
             return $this;
         }
 
-        if ($provider instanceof ContainerAwareInterface) {
-            $provider->setLeagueContainer($this->getLeagueContainer());
-        }
+        $provider->setContainer($this->getContainer());
 
         if ($provider instanceof BootableServiceProviderInterface) {
             $provider->boot();
         }
 
-        if ($provider instanceof ServiceProviderInterface) {
-            $this->providers[] = $provider;
-
-            return $this;
-        }
-
-        throw new ContainerException(
-            'A service provider must be a fully qualified class name or instance ' .
-            'of (\Imagify\Dependencies\League\Container\ServiceProvider\ServiceProviderInterface)'
-        );
+        $this->providers[] = $provider;
+        return $this;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function provides(string $service) : bool
+    public function provides(string $service): bool
     {
         foreach ($this->getIterator() as $provider) {
             if ($provider->provides($service)) {
@@ -69,22 +49,12 @@ public function provides(string $service) : bool
         return false;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getIterator() : Generator
+    public function getIterator(): Generator
     {
-        $count = count($this->providers);
-
-        for ($i = 0; $i < $count; $i++) {
-            yield $this->providers[$i];
-        }
+        yield from $this->providers;
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function register(string $service)
+    public function register(string $service): void
     {
         if (false === $this->provides($service)) {
             throw new ContainerException(
@@ -98,8 +68,8 @@ public function register(string $service)
             }
 
             if ($provider->provides($service)) {
-                $this->registered[] = $provider->getIdentifier();
                 $provider->register();
+                $this->registered[] = $provider->getIdentifier();
             }
         }
     }
diff --git a/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderAggregateInterface.php b/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderAggregateInterface.php
index a9e264887..85236dec7 100644
--- a/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderAggregateInterface.php
+++ b/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderAggregateInterface.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\ServiceProvider;
 
@@ -7,30 +9,7 @@
 
 interface ServiceProviderAggregateInterface extends ContainerAwareInterface, IteratorAggregate
 {
-    /**
-     * Add a service provider to the aggregate.
-     *
-     * @param string|ServiceProviderInterface $provider
-     *
-     * @return self
-     */
-    public function add($provider) : ServiceProviderAggregateInterface;
-
-    /**
-     * Determines whether a service is provided by the aggregate.
-     *
-     * @param string $service
-     *
-     * @return boolean
-     */
-    public function provides(string $service) : bool;
-
-    /**
-     * Invokes the register method of a provider that provides a specific service.
-     *
-     * @param string $service
-     *
-     * @return void
-     */
-    public function register(string $service);
+    public function add(ServiceProviderInterface $provider): ServiceProviderAggregateInterface;
+    public function provides(string $id): bool;
+    public function register(string $service): void;
 }
diff --git a/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderInterface.php b/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderInterface.php
index d9ef777de..ec8e75be9 100644
--- a/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderInterface.php
+++ b/classes/Dependencies/League/Container/ServiceProvider/ServiceProviderInterface.php
@@ -1,4 +1,6 @@
-<?php declare(strict_types=1);
+<?php
+
+declare(strict_types=1);
 
 namespace Imagify\Dependencies\League\Container\ServiceProvider;
 
@@ -6,41 +8,8 @@
 
 interface ServiceProviderInterface extends ContainerAwareInterface
 {
-    /**
-     * Returns a boolean if checking whether this provider provides a specific
-     * service or returns an array of provided services if no argument passed.
-     *
-     * @param string $service
-     *
-     * @return boolean
-     */
-    public function provides(string $service) : bool;
-
-    /**
-     * Use the register method to register items with the container via the
-     * protected $this->leagueContainer property or the `getLeagueContainer` method
-     * from the ContainerAwareTrait.
-     *
-     * @return void
-     */
-    public function register();
-
-    /**
-     * Set a custom id for the service provider. This enables
-     * registering the same service provider multiple times.
-     *
-     * @param string $id
-     *
-     * @return self
-     */
-    public function setIdentifier(string $id) : ServiceProviderInterface;
-
-    /**
-     * The id of the service provider uniquely identifies it, so
-     * that we can quickly determine if it has already been registered.
-     * Defaults to get_class($provider).
-     *
-     * @return string
-     */
-    public function getIdentifier() : string;
+    public function getIdentifier(): string;
+    public function provides(string $id): bool;
+    public function register(): void;
+    public function setIdentifier(string $id): ServiceProviderInterface;
 }
diff --git a/classes/Dependencies/Psr/Container/ContainerInterface.php b/classes/Dependencies/Psr/Container/ContainerInterface.php
index b90363894..f503efe0f 100644
--- a/classes/Dependencies/Psr/Container/ContainerInterface.php
+++ b/classes/Dependencies/Psr/Container/ContainerInterface.php
@@ -32,5 +32,5 @@ public function get(string $id);
      *
      * @return bool
      */
-    public function has(string $id);
+    public function has(string $id): bool;
 }
diff --git a/classes/Picture/ServiceProvider.php b/classes/Picture/ServiceProvider.php
index 1e1f6efca..033d551c6 100644
--- a/classes/Picture/ServiceProvider.php
+++ b/classes/Picture/ServiceProvider.php
@@ -15,7 +15,7 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	protected $provides = [
-		'picture_display',
+		Display::class,
 	];
 
 	/**
@@ -24,17 +24,28 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	public $subscribers = [
-		'picture_display',
+		Display::class,
 	];
 
+	/**
+	 * Check if the service provider provides a specific service.
+	 *
+	 * @param string $id The id of the service.
+	 *
+	 * @return bool
+	 */
+	public function provides( string $id ): bool {
+		return in_array( $id, $this->provides, true );
+	}
+
 	/**
 	 * Registers the provided classes
 	 *
 	 * @return void
 	 */
-	public function register() {
-		$this->getContainer()->share( 'picture_display', Display::class )
-			->addArgument( $this->getContainer()->get( 'filesystem' ) );
+	public function register(): void {
+		$this->getContainer()->addShared( Display::class )
+			->addArgument( 'filesystem' );
 	}
 
 	/**
diff --git a/classes/Plugin.php b/classes/Plugin.php
index 877fc0b9f..bf4e7f887 100644
--- a/classes/Plugin.php
+++ b/classes/Plugin.php
@@ -86,14 +86,14 @@ public function init( $providers ) {
 			return;
 		}
 
-		$this->container->share(
+		$this->container->addShared(
 			'event_manager',
 			function () {
 				return new EventManager();
 			}
 		);
 
-		$this->container->share(
+		$this->container->addShared(
 			'filesystem',
 			function() {
 				return new Imagify_Filesystem();
diff --git a/classes/Stats/ServiceProvider.php b/classes/Stats/ServiceProvider.php
index afb855147..8ccae2364 100644
--- a/classes/Stats/ServiceProvider.php
+++ b/classes/Stats/ServiceProvider.php
@@ -15,7 +15,7 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	protected $provides = [
-		'optimized_media_without_next_gen',
+		OptimizedMediaWithoutNextGen::class,
 	];
 
 	/**
@@ -24,16 +24,27 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	public $subscribers = [
-		'optimized_media_without_next_gen',
+		OptimizedMediaWithoutNextGen::class,
 	];
 
+	/**
+	 * Check if the service provider provides a specific service.
+	 *
+	 * @param string $id The id of the service.
+	 *
+	 * @return bool
+	 */
+	public function provides( string $id ): bool {
+		return in_array( $id, $this->provides, true );
+	}
+
 	/**
 	 * Registers the provided classes
 	 *
 	 * @return void
 	 */
-	public function register() {
-		$this->getContainer()->share( 'optimized_media_without_next_gen', OptimizedMediaWithoutNextGen::class );
+	public function register(): void {
+		$this->getContainer()->addShared( OptimizedMediaWithoutNextGen::class );
 	}
 
 	/**
diff --git a/classes/User/ServiceProvider.php b/classes/User/ServiceProvider.php
index c2b89bd8e..fe10e869c 100644
--- a/classes/User/ServiceProvider.php
+++ b/classes/User/ServiceProvider.php
@@ -15,16 +15,27 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	protected $provides = [
-		'user',
+		User::class,
 	];
 
+	/**
+	 * Check if the service provider provides a specific service.
+	 *
+	 * @param string $id The id of the service.
+	 *
+	 * @return bool
+	 */
+	public function provides( string $id ): bool {
+		return in_array( $id, $this->provides, true );
+	}
+
 	/**
 	 * Registers the provided classes
 	 *
 	 * @return void
 	 */
-	public function register() {
-		$this->getContainer()->add( 'user', User::class );
+	public function register(): void {
+		$this->getContainer()->add( User::class );
 	}
 
 	/**
diff --git a/classes/Webp/ServiceProvider.php b/classes/Webp/ServiceProvider.php
index 12d45ddfa..4ab171bf1 100644
--- a/classes/Webp/ServiceProvider.php
+++ b/classes/Webp/ServiceProvider.php
@@ -16,8 +16,8 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	protected $provides = [
-		'webp_display',
-		'webp_rewrite_rules',
+		Display::class,
+		RewriteRules::class,
 	];
 
 	/**
@@ -26,18 +26,29 @@ class ServiceProvider extends AbstractServiceProvider {
 	 * @var array
 	 */
 	public $subscribers = [
-		'webp_display',
-		'webp_rewrite_rules',
+		Display::class,
+		RewriteRules::class,
 	];
 
+	/**
+	 * Check if the service provider provides a specific service.
+	 *
+	 * @param string $id The id of the service.
+	 *
+	 * @return bool
+	 */
+	public function provides( string $id ): bool {
+		return in_array( $id, $this->provides, true );
+	}
+
 	/**
 	 * Registers the provided classes
 	 *
 	 * @return void
 	 */
-	public function register() {
-		$this->getContainer()->share( 'webp_display', Display::class );
-		$this->getContainer()->share( 'webp_rewrite_rules', RewriteRules::class );
+	public function register(): void {
+		$this->getContainer()->addShared( Display::class );
+		$this->getContainer()->addShared( RewriteRules::class );
 	}
 
 	/**
diff --git a/composer.json b/composer.json
index c3df36cd4..781821789 100644
--- a/composer.json
+++ b/composer.json
@@ -43,14 +43,13 @@
 		"coenjacobs/mozart": "^0.7",
 		"dealerdirect/phpcodesniffer-composer-installer": "^0.7.0",
 		"deliciousbrains/wp-background-processing": "~1.0",
-		"league/container": "^3.0",
+		"league/container": "^4.2",
 		"mnsami/composer-custom-directory-installer": "^2.0",
 		"phpcompatibility/phpcompatibility-wp": "^2.0",
 		"phpunit/phpunit": "^7.5 || ^8 || ^9",
 		"roave/security-advisories": "dev-master",
 		"woocommerce/action-scheduler": "^3.4",
 		"wp-coding-standards/wpcs": "^2",
-		"wp-media/event-manager": "^3.1",
 		"wp-media/phpunit": "3.0"
 	},
 	"autoload": {
@@ -88,7 +87,6 @@
 			"packages": [
 				"deliciousbrains/wp-background-processing",
 				"league/container",
-				"wp-media/event-manager",
 				"wp-media/plugin-family"
 			]
 		}
diff --git a/phpcs.xml b/phpcs.xml
index 8655baccd..371cb4714 100644
--- a/phpcs.xml
+++ b/phpcs.xml
@@ -29,8 +29,8 @@
 	<arg name="parallel" value="50"/><!-- Enables parallel processing when available for faster results. -->
 	<arg name="extensions" value="php"/><!-- Limit to PHP files -->
 
-	<!-- Check for cross-version support for PHP 5.4 and higher + WP 4.0 and higher. -->
-	<config name="testVersion" value="7.0-"/>
+	<!-- Check for cross-version support for PHP 7.3 and higher + WP 5.3 and higher. -->
+	<config name="testVersion" value="7.3-"/>
 	<config name="minimum_supported_wp_version" value="5.3"/>
 
 	<!-- Run against the PHPCompatibility ruleset dedicated to WP. -->