first commit

vendor/league/container/CHANGELOG.md

@@ -0,0 +1,268 @@
+# Changelog
+
+All Notable changes to `League\Container` will be documented in this file
+
+## 4.2.1
+
+### Fixed
+- Remove an unnecessary conditional in ServiceProviderAggregate. (@SubhanSh)
+- Fixed an infinite loop in resolving definitions. (@arai-ta)
+
+## 4.2.0
+
+### Added
+- Support for psr/container 1.1.0.
+
+## 4.1.2
+
+### Fixed
+- Fix bug that was causing an error on inflection due to introduced type hint.
+
+## 4.1.1
+
+### Changed
+- Move files autoload directive to dev (@ADmad)
+
+## 4.1.0
+
+### Added
+- Way to handle non-public controllers safely (@beryllium)
+
+## 4.0.0
+
+### Added
+- New definition interface that extends psr/container
+- Literal and resolvable argument wrappers for better explicitness in definitions
+
+### Changed
+- PHP requirement now `>=7.2`
+- Updated `psr/container` to ^2.0.0
+- `Container::shared` convenience method is now explicit `Container::addShared` method
+- Removed third argument `$shared` from `Container::add`, use `Container::addShared`
+- `ServiceProviderInterface` now defines return types
+- Service providers now require implementation of a `provides` method rather than relying on a class property.
+
+## 3.4.1
+
+### Added
+- Way to handle non-public controllers safely (@beryllium)
+- PHPUnit ^7.0 for PHP versions that support it (@beryllium)
+
+## 3.4.0
+
+### Removed
+- Support for `psr/container` ^2.0.0 as the interface cannot be reconciled between versions
+
+## 3.3.5
+
+### Added
+- Support for `psr/container` ^2.0.0
+
+## 3.3.4
+
+### Fixed
+- Fixed an issue that caused a recursive `register` call. @pcoutinho
+- Fixed a return type declaration. @orbex
+
+## 3.3.3
+
+### Fixed
+- Fixed bug relating to `ReflectionContainer::call` on arrow functions.
+
+## 3.3.2
+
+### Added
+- Experimental support for PHP 8.
+
+### Fixed
+- Fix issue when preventing reflection from using default value for arguments.
+
+## 3.3.1
+
+### Fixed
+- Respect `$new` argument when getting tagged definitions.
+
+## 3.3.0
+
+### Added
+- Support for PHP 7.3
+- `{set,get}LeagueContainer` methods added to ContainerAwareTrait as a temporary measure until next major release when this can be properly addressed, less hinting of `Psr\Container\ContainerInterface`
+
+### Changed
+- Various internal code improvements
+
+### Fixed
+- Fix for `setConcrete` not re-resolving class on when overriding (@jleeothon)
+- Fix stack overflow error incase a service provider lies about providing a specific service (@azjezz)
+- Fix issue where providers may be aggregated multiple times (@bwg)
+- Various documentation fixes
+
+## 3.2.2
+
+### Fixed
+- Fixed issue that prevented service providers from registering if a previous one in the aggregate was already registered.
+
+## 3.2.1
+
+### Fixed
+- Fixed issue where all service providers were registered regardless of whether they need to be.
+
+## 3.2.0
+
+### Added
+- Added ability to add definition as not shared when container is set to default to shared.
+- Added `{set|get}Concrete` to definitions to allow for better use of `extend`.
+
+## 3.1.0
+
+### Added
+- Re-added the `share` proxy method that was mistakenly removed in previous major release.
+- Added ability to set Conatiner to "share" by default using `defaultToShared` method.
+- Added ability for `ReflectionContainer` to cache resolutions and pull from cache for following calls.
+
+## 3.0.1
+
+### Added
+- Allow definition aggregates to be built outside of container.
+
+## 3.0.0
+
+### Added
+- Service providers can now be pulled from the container if they are registered.
+- Definition logic now handled by aggregate for better separation.
+- Now able to add tags to a definition to return an array of items containing that tag.
+
+### Changed
+- Updated minimum PHP requirements to 7.0.
+- Now depend directly on PSR-11 interfaces, including providing PSR-11 exceptions.
+- Refactored inflector logic to accept type on construction and use generator to iterate.
+- Refactored service provider logic with better separation and performance.
+- Merged service provider signature logic in to one interface and abstract.
+- Heavily simplified definition logic providing more control to user.
+
+## 2.4.1
+
+### Fixed
+- Ensures `ReflectionContainer` converts class name in array callable to object.
+
+## 2.4.0
+
+### Changed
+- Can now wrap shared objects as `RawArgument`.
+- Ability to override shared items.
+
+### Fixed
+- Booleans now recognised as accepted values.
+- Various docblock fixes.
+- Unused imports removed.
+- Unreachable arguments no longer passed.
+
+## 2.3.0
+
+### Added
+- Now implementation of the PSR-11.
+
+## 2.2.0
+
+### Changed
+- Service providers can now be added multiple times by giving them a signature.
+
+## 2.1.0
+
+### Added
+- Allow resolving of `RawArgument` objects as first class dependencies.
+
+### Changed
+- Unnecessary recursion removed from `Container::get`.
+
+## 2.0.3
+
+### Fixed
+- Bug where delegating container was not passed to delegate when needed.
+- Bug where `Container::extend` would not return a shared definition to extend.
+
+## 2.0.2
+
+### Fixed
+- Bug introduced in 2.0.1 where shared definitions registered via a service provider would never be returned as shared.
+
+## 2.0.1
+
+### Fixed
+- Bug where shared definitions were not stored as shared.
+
+## 2.0.0
+
+### Added
+- Now implementation of the container-interop project.
+- `BootableServiceProviderInterface` for eagerly loaded service providers.
+- Delegate container functionality.
+- `RawArgument` to ensure scalars are not resolved from the container but seen as an argument.
+
+### Altered
+- Refactor of definition functionality.
+- `Container::share` replaces `singleton` functionality to improve understanding.
+- Auto wiring is now disabled by default.
+- Auto wiring abstracted to be a delegate container `ReflectionContainer` handling all reflection based functionality.
+- Inflection functionality abstracted to an aggregate.
+- Service provider functionality abstracted to an aggregate.
+- Much bloat removed.
+- `Container::call` now proxies to `ReflectionContainer::call` and handles argument resolution in a much more efficient way.
+
+### Removed
+- Ability to register invokables, this functionality added a layer of complexity too large for the problem it solved.
+- Container no longer accepts a configuration array, this functionality will now be provided by an external service provider package.
+
+## 1.4.0
+
+### Added
+- Added `isRegisteredCallable` method to public API.
+- Invoking `call` now accepts named arguments at runtime.
+
+### Fixed
+- Container now stores instantiated Service Providers after first instantiation.
+- Extending a definition now looks in Service Providers as well as just Definitions.
+
+## 1.3.1 - 2015-02-21
+
+### Fixed
+- Fixed bug where arbitrary values were attempted to be resolved as classes.
+
+## 1.3.0 - 2015-02-09
+
+### Added
+- Added `ServiceProvider` functionality to allow cleaner resolving of complex dependencies.
+- Added `Inflector` functionality to allow for manipulation of resolved objects of a specific type.
+- Improvements to DRY throughout the package.
+
+### Fixed
+- Setter in `ContainerAwareTrait` now returns self (`$this`).
+
+## 1.2.1 - 2015-01-29
+
+### Fixed
+- Allow arbitrary values to be registered via container config.
+
+## 1.2.0 - 2015-01-13
+
+### Added
+- Improvements to `Container::call` functionality.
+
+### Fixed
+- General code tidy.
+- Improvements to test suite.
+
+## 1.1.1 - 2015-01-13
+
+### Fixed
+- Allow singleton to be passed as method argument.
+
+## 1.1.0 - 2015-01-12
+
+### Added
+- Addition of `ContainerAwareTrait` to provide functionality from `ContainerAwareInterface`.
+
+## 1.0.0 - 2015-01-12
+
+### Added
+- Migrated from [Orno\Di](https://github.com/orno/di).

vendor/league/container/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Contributing
+
+Contributions are **welcome** and will be fully **credited**.
+
+We accept contributions via Pull Requests on [Github](https://github.com/thephpleague/container).
+
+## Pull Requests
+
+- **[PSR-2 Coding Standard](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md)** - The easiest way to apply the conventions is to install [PHP Code Sniffer](http://pear.php.net/package/PHP_CodeSniffer).
+
+- **Add tests!** - Your patch won't be accepted if it doesn't have tests.
+
+- **Document any change in behaviour** - Make sure the `README.md` and any other relevant documentation are kept up-to-date.
+
+- **Consider our release cycle** - We try to follow [SemVer v2.0.0](http://semver.org/). Randomly breaking public APIs is not an option.
+
+- **Create feature branches** - Don't ask us to pull from your master branch.
+
+- **One pull request per feature** - If you want to do more than one thing, send multiple pull requests.
+
+- **Send coherent history** - Make sure each individual commit in your pull request is meaningful. If you had to make multiple intermediate commits while developing, please squash them before submitting.
+
+## Running Tests
+
+``` bash
+$ composer test
+```
+
+**Happy coding**!

vendor/league/container/LICENSE.md

@@ -0,0 +1,21 @@
+# The MIT License (MIT)
+
+Copyright (c) 2021 Phil Bennett <philipobenito@gmail.com>
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.

vendor/league/container/README.md

@@ -0,0 +1,64 @@
+# Container (Dependency Injection)
+
+[![Author](http://img.shields.io/badge/author-@philipobenito-blue.svg?style=flat-square)](https://twitter.com/philipobenito)
+[![Latest Version](https://img.shields.io/github/release/thephpleague/container.svg?style=flat-square)](https://github.com/thephpleague/container/releases)
+[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)
+[![Build Status](https://img.shields.io/travis/thephpleague/container/master.svg?style=flat-square)](https://travis-ci.org/thephpleague/container)
+[![Coverage Status](https://img.shields.io/scrutinizer/coverage/g/thephpleague/container.svg?style=flat-square)](https://scrutinizer-ci.com/g/thephpleague/container/code-structure)
+[![Quality Score](https://img.shields.io/scrutinizer/g/thephpleague/container.svg?style=flat-square)](https://scrutinizer-ci.com/g/thephpleague/container)
+[![Total Downloads](https://img.shields.io/packagist/dt/league/container.svg?style=flat-square)](https://packagist.org/packages/league/container)
+
+This package is compliant with [PSR-1], [PSR-2], [PSR-12], [PSR-4] and [PSR-11]. If you notice compliance oversights, please send a patch via pull request.
+
+[PSR-1]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md
+[PSR-2]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md
+[PSR-12]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-12-extended-coding-style-guide.md
+[PSR-4]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md
+[PSR-11]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-11-container.md
+
+## Install
+
+Via Composer
+
+``` bash
+$ composer require league/container
+```
+
+## Requirements
+
+The following versions of PHP are supported by this version.
+
+* PHP 7.2
+* PHP 7.3
+* PHP 7.4
+
+## Documentation
+
+Container has [full documentation](http://container.thephpleague.com), powered by [Jekyll](http://jekyllrb.com/).
+
+Contribute to this documentation in the [docs/](https://github.com/thephpleague/container/tree/master/docs) sub-directory.
+
+## Testing
+
+Testing includes PHPUnit and PHPStan (Level 7).
+``` bash
+$ composer test
+```
+
+## Contributing
+
+Please see [CONTRIBUTING](https://github.com/thephpleague/container/blob/master/CONTRIBUTING.md) for details.
+
+## Security
+
+If you discover any security related issues, please email philipobenito@gmail.com instead of using the issue tracker.
+
+## Credits
+
+- [Phil Bennett](https://github.com/philipobenito)
+- [All Contributors](https://github.com/thephpleague/container/contributors)
+- `Orno\Di` contributors
+
+## License
+
+The MIT License (MIT). Please see [License File](https://github.com/thephpleague/container/blob/master/LICENSE.md) for more information.

vendor/league/container/composer.json

@@ -0,0 +1,69 @@
+{
+    "name": "league/container",
+    "description": "A fast and intuitive dependency injection container.",
+    "keywords": [
+        "league",
+        "container",
+        "dependency",
+        "injection",
+        "di",
+        "service",
+        "provider"
+    ],
+    "homepage": "https://github.com/thephpleague/container",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Phil Bennett",
+            "email": "mail@philbennett.co.uk",
+            "role": "Developer"
+        }
+    ],
+    "require": {
+        "php": "^7.2 || ^8.0",
+        "psr/container": "^1.1 || ^2.0"
+    },
+    "require-dev": {
+        "nette/php-generator": "^3.4",
+        "nikic/php-parser": "^4.10",
+        "phpstan/phpstan": "^0.12.47",
+        "phpunit/phpunit": "^8.5.17",
+        "roave/security-advisories": "dev-latest",
+        "scrutinizer/ocular": "^1.8",
+        "squizlabs/php_codesniffer": "^3.6"
+    },
+    "provide": {
+        "psr/container-implementation": "^1.0"
+    },
+    "replace": {
+        "orno/di": "~2.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "League\\Container\\": "src"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "League\\Container\\Test\\": "tests"
+        },
+        "files": [
+            "tests/Asset/function.php"
+        ]        
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "4.x-dev",
+            "dev-4.x": "4.x-dev",
+            "dev-3.x": "3.x-dev",
+            "dev-2.x": "2.x-dev",
+            "dev-1.x": "1.x-dev"
+        }
+    },
+    "scripts": {
+        "test": [
+            "phpunit",
+            "phpstan analyse"
+        ]
+    }
+}

vendor/league/container/src/Argument/ArgumentInterface.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument;
+
+interface ArgumentInterface
+{
+    /**
+     * @return mixed
+     */
+    public function getValue();
+}

vendor/league/container/src/Argument/ArgumentResolverInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument;
+
+use League\Container\ContainerAwareInterface;
+use ReflectionFunctionAbstract;
+
+interface ArgumentResolverInterface extends ContainerAwareInterface
+{
+    public function resolveArguments(array $arguments): array;
+    public function reflectArguments(ReflectionFunctionAbstract $method, array $args = []): array;
+}

vendor/league/container/src/Argument/ArgumentResolverTrait.php

@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument;
+
+use League\Container\DefinitionContainerInterface;
+use League\Container\Exception\{ContainerException, NotFoundException};
+use League\Container\ReflectionContainer;
+use Psr\Container\ContainerInterface;
+use ReflectionFunctionAbstract;
+use ReflectionNamedType;
+
+trait ArgumentResolverTrait
+{
+    public function resolveArguments(array $arguments): array
+    {
+        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;
+            }
+
+            if ($arg instanceof ArgumentInterface) {
+                $argValue = $arg->getValue();
+            } else {
+                $argValue = $arg;
+            }
+
+            if (!is_string($argValue)) {
+                 continue;
+            }
+
+            // 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 {
+                    $arg = $container->get($argValue);
+
+                    if ($arg instanceof ArgumentInterface) {
+                        $arg = $arg->getValue();
+                    }
+
+                    continue;
+                } catch (NotFoundException $e) {
+                }
+            }
+
+            // 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();
+            }
+        }
+
+        return $arguments;
+    }
+
+    public function reflectArguments(ReflectionFunctionAbstract $method, array $args = []): array
+    {
+        $params    = $method->getParameters();
+        $arguments = [];
+
+        foreach ($params as $param) {
+            $name = $param->getName();
+
+            // if we've been given a value for the argument, treat as literal
+            if (array_key_exists($name, $args)) {
+                $arguments[] = new LiteralArgument($args[$name]);
+                continue;
+            }
+
+            $type = $param->getType();
+
+            if ($type instanceof ReflectionNamedType) {
+                // in PHP 8, nullable arguments have "?" prefix
+                $typeHint = ltrim($type->getName(), '?');
+
+                if ($param->isDefaultValueAvailable()) {
+                    $arguments[] = new DefaultValueArgument($typeHint, $param->getDefaultValue());
+                    continue;
+                }
+
+                $arguments[] = new ResolvableArgument($typeHint);
+                continue;
+            }
+
+            if ($param->isDefaultValueAvailable()) {
+                $arguments[] = new LiteralArgument($param->getDefaultValue());
+                continue;
+            }
+
+            throw new NotFoundException(sprintf(
+                'Unable to resolve a value for parameter (%s) in the function/method (%s)',
+                $name,
+                $method->getName()
+            ));
+        }
+
+        return $this->resolveArguments($arguments);
+    }
+
+    abstract public function getContainer(): DefinitionContainerInterface;
+}

vendor/league/container/src/Argument/DefaultValueArgument.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace 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;
+    }
+}

vendor/league/container/src/Argument/DefaultValueInterface.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument;
+
+interface DefaultValueInterface extends ArgumentInterface
+{
+    /**
+     * @return mixed
+     */
+    public function getDefaultValue();
+}

vendor/league/container/src/Argument/Literal/ArrayArgument.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument\Literal;
+
+use League\Container\Argument\LiteralArgument;
+
+class ArrayArgument extends LiteralArgument
+{
+    public function __construct(array $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_ARRAY);
+    }
+}

vendor/league/container/src/Argument/Literal/BooleanArgument.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument\Literal;
+
+use League\Container\Argument\LiteralArgument;
+
+class BooleanArgument extends LiteralArgument
+{
+    public function __construct(bool $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_BOOL);
+    }
+}

vendor/league/container/src/Argument/Literal/CallableArgument.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument\Literal;
+
+use League\Container\Argument\LiteralArgument;
+
+class CallableArgument extends LiteralArgument
+{
+    public function __construct(callable $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_CALLABLE);
+    }
+}

vendor/league/container/src/Argument/Literal/FloatArgument.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument\Literal;
+
+use League\Container\Argument\LiteralArgument;
+
+class FloatArgument extends LiteralArgument
+{
+    public function __construct(float $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_FLOAT);
+    }
+}

vendor/league/container/src/Argument/Literal/IntegerArgument.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument\Literal;
+
+use League\Container\Argument\LiteralArgument;
+
+class IntegerArgument extends LiteralArgument
+{
+    public function __construct(int $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_INT);
+    }
+}

vendor/league/container/src/Argument/Literal/ObjectArgument.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument\Literal;
+
+use League\Container\Argument\LiteralArgument;
+
+class ObjectArgument extends LiteralArgument
+{
+    public function __construct(object $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_OBJECT);
+    }
+}

vendor/league/container/src/Argument/Literal/StringArgument.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument\Literal;
+
+use League\Container\Argument\LiteralArgument;
+
+class StringArgument extends LiteralArgument
+{
+    public function __construct(string $value)
+    {
+        parent::__construct($value, LiteralArgument::TYPE_STRING);
+    }
+}

vendor/league/container/src/Argument/LiteralArgument.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace 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;
+    }
+}

vendor/league/container/src/Argument/LiteralArgumentInterface.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument;
+
+interface LiteralArgumentInterface extends ArgumentInterface
+{
+}

vendor/league/container/src/Argument/ResolvableArgument.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument;
+
+class ResolvableArgument implements ResolvableArgumentInterface
+{
+    protected $value;
+
+    public function __construct(string $value)
+    {
+        $this->value = $value;
+    }
+
+    public function getValue(): string
+    {
+        return $this->value;
+    }
+}

vendor/league/container/src/Argument/ResolvableArgumentInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Argument;
+
+interface ResolvableArgumentInterface extends ArgumentInterface
+{
+    public function getValue(): string;
+}

vendor/league/container/src/Container.php

@@ -0,0 +1,210 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container;
+
+use League\Container\Definition\{DefinitionAggregate, DefinitionInterface, DefinitionAggregateInterface};
+use League\Container\Exception\{NotFoundException, ContainerException};
+use League\Container\Inflector\{InflectorAggregate, InflectorInterface, InflectorAggregateInterface};
+use League\Container\ServiceProvider\{ServiceProviderAggregate,
+    ServiceProviderAggregateInterface,
+    ServiceProviderInterface};
+use Psr\Container\ContainerInterface;
+
+class Container implements DefinitionContainerInterface
+{
+    /**
+     * @var boolean
+     */
+    protected $defaultToShared = false;
+
+    /**
+     * @var DefinitionAggregateInterface
+     */
+    protected $definitions;
+
+    /**
+     * @var ServiceProviderAggregateInterface
+     */
+    protected $providers;
+
+    /**
+     * @var InflectorAggregateInterface
+     */
+    protected $inflectors;
+
+    /**
+     * @var ContainerInterface[]
+     */
+    protected $delegates = [];
+
+    public function __construct(
+        DefinitionAggregateInterface $definitions = null,
+        ServiceProviderAggregateInterface $providers = null,
+        InflectorAggregateInterface $inflectors = null
+    ) {
+        $this->definitions = $definitions ?? new DefinitionAggregate();
+        $this->providers   = $providers   ?? new ServiceProviderAggregate();
+        $this->inflectors  = $inflectors  ?? new InflectorAggregate();
+
+        if ($this->definitions instanceof ContainerAwareInterface) {
+            $this->definitions->setContainer($this);
+        }
+
+        if ($this->providers instanceof ContainerAwareInterface) {
+            $this->providers->setContainer($this);
+        }
+
+        if ($this->inflectors instanceof ContainerAwareInterface) {
+            $this->inflectors->setContainer($this);
+        }
+    }
+
+    public function add(string $id, $concrete = null): DefinitionInterface
+    {
+        $concrete = $concrete ?? $id;
+
+        if (true === $this->defaultToShared) {
+            return $this->addShared($id, $concrete);
+        }
+
+        return $this->definitions->add($id, $concrete);
+    }
+
+    public function addShared(string $id, $concrete = null): DefinitionInterface
+    {
+        $concrete = $concrete ?? $id;
+        return $this->definitions->addShared($id, $concrete);
+    }
+
+    public function defaultToShared(bool $shared = true): ContainerInterface
+    {
+        $this->defaultToShared = $shared;
+        return $this;
+    }
+
+    public function extend(string $id): DefinitionInterface
+    {
+        if ($this->providers->provides($id)) {
+            $this->providers->register($id);
+        }
+
+        if ($this->definitions->has($id)) {
+            return $this->definitions->getDefinition($id);
+        }
+
+        throw new NotFoundException(sprintf(
+            'Unable to extend alias (%s) as it is not being managed as a definition',
+            $id
+        ));
+    }
+
+    public function addServiceProvider(ServiceProviderInterface $provider): DefinitionContainerInterface
+    {
+        $this->providers->add($provider);
+        return $this;
+    }
+
+    /**
+     * @template RequestedType
+     *
+     * @param class-string<RequestedType>|string $id
+     *
+     * @return RequestedType|mixed
+     */
+    public function get($id)
+    {
+        return $this->resolve($id);
+    }
+
+    /**
+     * @template RequestedType
+     *
+     * @param class-string<RequestedType>|string $id
+     *
+     * @return RequestedType|mixed
+     */
+    public function getNew($id)
+    {
+        return $this->resolve($id, true);
+    }
+
+    public function has($id): bool
+    {
+        if ($this->definitions->has($id)) {
+            return true;
+        }
+
+        if ($this->definitions->hasTag($id)) {
+            return true;
+        }
+
+        if ($this->providers->provides($id)) {
+            return true;
+        }
+
+        foreach ($this->delegates as $delegate) {
+            if ($delegate->has($id)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function inflector(string $type, callable $callback = null): InflectorInterface
+    {
+        return $this->inflectors->add($type, $callback);
+    }
+
+    public function delegate(ContainerInterface $container): self
+    {
+        $this->delegates[] = $container;
+
+        if ($container instanceof ContainerAwareInterface) {
+            $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));
+    }
+}

vendor/league/container/src/ContainerAwareInterface.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container;
+
+interface ContainerAwareInterface
+{
+    public function getContainer(): DefinitionContainerInterface;
+    public function setContainer(DefinitionContainerInterface $container): ContainerAwareInterface;
+}

vendor/league/container/src/ContainerAwareTrait.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container;
+
+use BadMethodCallException;
+use League\Container\Exception\ContainerException;
+
+trait ContainerAwareTrait
+{
+    /**
+     * @var ?DefinitionContainerInterface
+     */
+    protected $container;
+
+    public function setContainer(DefinitionContainerInterface $container): ContainerAwareInterface
+    {
+        $this->container = $container;
+
+        if ($this instanceof ContainerAwareInterface) {
+            return $this;
+        }
+
+        throw new BadMethodCallException(sprintf(
+            'Attempt to use (%s) while not implementing (%s)',
+            ContainerAwareTrait::class,
+            ContainerAwareInterface::class
+        ));
+    }
+
+    public function getContainer(): DefinitionContainerInterface
+    {
+        if ($this->container instanceof DefinitionContainerInterface) {
+            return $this->container;
+        }
+
+        throw new ContainerException('No container implementation has been set.');
+    }
+}

vendor/league/container/src/Definition/Definition.php

@@ -0,0 +1,238 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Definition;
+
+use League\Container\Argument\{
+    ArgumentResolverInterface,
+    ArgumentResolverTrait,
+    ArgumentInterface,
+    LiteralArgumentInterface
+};
+use League\Container\ContainerAwareTrait;
+use League\Container\Exception\ContainerException;
+use League\Container\Exception\NotFoundException;
+use Psr\Container\ContainerInterface;
+use ReflectionClass;
+
+class Definition implements ArgumentResolverInterface, DefinitionInterface
+{
+    use ArgumentResolverTrait;
+    use ContainerAwareTrait;
+
+    /**
+     * @var string
+     */
+    protected $alias;
+
+    /**
+     * @var mixed
+     */
+    protected $concrete;
+
+    /**
+     * @var boolean
+     */
+    protected $shared = false;
+
+    /**
+     * @var array
+     */
+    protected $tags = [];
+
+    /**
+     * @var array
+     */
+    protected $arguments = [];
+
+    /**
+     * @var array
+     */
+    protected $methods = [];
+
+    /**
+     * @var mixed
+     */
+    protected $resolved;
+
+    /**
+     * @var array
+     */
+    protected $recursiveCheck = [];
+
+    /**
+     * @param string     $id
+     * @param mixed|null $concrete
+     */
+    public function __construct(string $id, $concrete = null)
+    {
+        $concrete = $concrete ?? $id;
+        $this->alias    = $id;
+        $this->concrete = $concrete;
+    }
+
+    public function addTag(string $tag): DefinitionInterface
+    {
+        $this->tags[$tag] = true;
+        return $this;
+    }
+
+    public function hasTag(string $tag): bool
+    {
+        return isset($this->tags[$tag]);
+    }
+
+    public function setAlias(string $id): DefinitionInterface
+    {
+        $this->alias = $id;
+        return $this;
+    }
+
+    public function getAlias(): string
+    {
+        return $this->alias;
+    }
+
+    public function setShared(bool $shared = true): DefinitionInterface
+    {
+        $this->shared = $shared;
+        return $this;
+    }
+
+    public function isShared(): bool
+    {
+        return $this->shared;
+    }
+
+    public function getConcrete()
+    {
+        return $this->concrete;
+    }
+
+    public function setConcrete($concrete): DefinitionInterface
+    {
+        $this->concrete = $concrete;
+        $this->resolved = null;
+        return $this;
+    }
+
+    public function addArgument($arg): DefinitionInterface
+    {
+        $this->arguments[] = $arg;
+        return $this;
+    }
+
+    public function addArguments(array $args): DefinitionInterface
+    {
+        foreach ($args as $arg) {
+            $this->addArgument($arg);
+        }
+
+        return $this;
+    }
+
+    public function addMethodCall(string $method, array $args = []): DefinitionInterface
+    {
+        $this->methods[] = [
+            'method'    => $method,
+            'arguments' => $args
+        ];
+
+        return $this;
+    }
+
+    public function addMethodCalls(array $methods = []): DefinitionInterface
+    {
+        foreach ($methods as $method => $args) {
+            $this->addMethodCall($method, $args);
+        }
+
+        return $this;
+    }
+
+    public function resolve()
+    {
+        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 LiteralArgumentInterface) {
+            $this->resolved = $concrete->getValue();
+            return $concrete->getValue();
+        }
+
+        if ($concrete instanceof ArgumentInterface) {
+            $concrete = $concrete->getValue();
+        }
+
+        if (is_string($concrete) && class_exists($concrete)) {
+            $concrete = $this->resolveClass($concrete);
+        }
+
+        if (is_object($concrete)) {
+            $concrete = $this->invokeMethods($concrete);
+        }
+
+        try {
+            $container = $this->getContainer();
+        } catch (ContainerException $e) {
+            $container = null;
+        }
+
+        // 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;
+    }
+
+    /**
+     * @param callable $concrete
+     * @return mixed
+     */
+    protected function resolveCallable(callable $concrete)
+    {
+        $resolved = $this->resolveArguments($this->arguments);
+        return call_user_func_array($concrete, $resolved);
+    }
+
+    protected function resolveClass(string $concrete): object
+    {
+        $resolved   = $this->resolveArguments($this->arguments);
+        $reflection = new ReflectionClass($concrete);
+        return $reflection->newInstanceArgs($resolved);
+    }
+
+    protected function invokeMethods(object $instance): object
+    {
+        foreach ($this->methods as $method) {
+            $args = $this->resolveArguments($method['arguments']);
+            $callable = [$instance, $method['method']];
+            call_user_func_array($callable, $args);
+        }
+
+        return $instance;
+    }
+}

vendor/league/container/src/Definition/DefinitionAggregate.php

@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Definition;
+
+use Generator;
+use League\Container\ContainerAwareTrait;
+use League\Container\Exception\NotFoundException;
+
+class DefinitionAggregate implements DefinitionAggregateInterface
+{
+    use ContainerAwareTrait;
+
+    /**
+     * @var DefinitionInterface[]
+     */
+    protected $definitions = [];
+
+    public function __construct(array $definitions = [])
+    {
+        $this->definitions = array_filter($definitions, static function ($definition) {
+            return ($definition instanceof DefinitionInterface);
+        });
+    }
+
+    public function add(string $id, $definition): DefinitionInterface
+    {
+        if (false === ($definition instanceof DefinitionInterface)) {
+            $definition = new Definition($id, $definition);
+        }
+
+        $this->definitions[] = $definition->setAlias($id);
+
+        return $definition;
+    }
+
+    public function addShared(string $id, $definition): DefinitionInterface
+    {
+        $definition = $this->add($id, $definition);
+        return $definition->setShared(true);
+    }
+
+    public function has(string $id): bool
+    {
+        foreach ($this->getIterator() as $definition) {
+            if ($id === $definition->getAlias()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function hasTag(string $tag): bool
+    {
+        foreach ($this->getIterator() as $definition) {
+            if ($definition->hasTag($tag)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function getDefinition(string $id): DefinitionInterface
+    {
+        foreach ($this->getIterator() as $definition) {
+            if ($id === $definition->getAlias()) {
+                return $definition->setContainer($this->getContainer());
+            }
+        }
+
+        throw new NotFoundException(sprintf('Alias (%s) is not being handled as a definition.', $id));
+    }
+
+    public function resolve(string $id)
+    {
+        return $this->getDefinition($id)->resolve();
+    }
+
+    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->setContainer($this->getContainer())->resolve();
+            }
+        }
+
+        return $arrayOf;
+    }
+
+    public function resolveTaggedNew(string $tag): array
+    {
+        $arrayOf = [];
+
+        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;
+    }
+}

vendor/league/container/src/Definition/DefinitionAggregateInterface.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Definition;
+
+use IteratorAggregate;
+use League\Container\ContainerAwareInterface;
+
+interface DefinitionAggregateInterface extends ContainerAwareInterface, IteratorAggregate
+{
+    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;
+}

vendor/league/container/src/Definition/DefinitionInterface.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Definition;
+
+use League\Container\ContainerAwareInterface;
+
+interface DefinitionInterface extends ContainerAwareInterface
+{
+    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();
+    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;
+}

vendor/league/container/src/DefinitionContainerInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container;
+
+use League\Container\Definition\DefinitionInterface;
+use League\Container\Inflector\InflectorInterface;
+use League\Container\ServiceProvider\ServiceProviderInterface;
+use 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;
+}

vendor/league/container/src/Exception/ContainerException.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Exception;
+
+use Psr\Container\ContainerExceptionInterface;
+use RuntimeException;
+
+class ContainerException extends RuntimeException implements ContainerExceptionInterface
+{
+}

vendor/league/container/src/Exception/NotFoundException.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Exception;
+
+use Psr\Container\NotFoundExceptionInterface;
+use InvalidArgumentException;
+
+class NotFoundException extends InvalidArgumentException implements NotFoundExceptionInterface
+{
+}

vendor/league/container/src/Inflector/Inflector.php

@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Inflector;
+
+use League\Container\Argument\ArgumentResolverInterface;
+use League\Container\Argument\ArgumentResolverTrait;
+use League\Container\ContainerAwareTrait;
+
+class Inflector implements ArgumentResolverInterface, InflectorInterface
+{
+    use ArgumentResolverTrait;
+    use ContainerAwareTrait;
+
+    /**
+     * @var string
+     */
+    protected $type;
+
+    /**
+     * @var callable|null
+     */
+    protected $callback;
+
+    /**
+     * @var array
+     */
+    protected $methods = [];
+
+    /**
+     * @var array
+     */
+    protected $properties = [];
+
+    public function __construct(string $type, callable $callback = null)
+    {
+        $this->type = $type;
+        $this->callback = $callback;
+    }
+
+    public function getType(): string
+    {
+        return $this->type;
+    }
+
+    public function invokeMethod(string $name, array $args): InflectorInterface
+    {
+        $this->methods[$name] = $args;
+        return $this;
+    }
+
+    public function invokeMethods(array $methods): InflectorInterface
+    {
+        foreach ($methods as $name => $args) {
+            $this->invokeMethod($name, $args);
+        }
+
+        return $this;
+    }
+
+    public function setProperty(string $property, $value): InflectorInterface
+    {
+        $this->properties[$property] = $this->resolveArguments([$value])[0];
+        return $this;
+    }
+
+    public function setProperties(array $properties): InflectorInterface
+    {
+        foreach ($properties as $property => $value) {
+            $this->setProperty($property, $value);
+        }
+
+        return $this;
+    }
+
+    public function inflect(object $object): void
+    {
+        $properties = $this->resolveArguments(array_values($this->properties));
+        $properties = array_combine(array_keys($this->properties), $properties);
+
+        // array_combine() can technically return false
+        foreach ($properties ?: [] as $property => $value) {
+            $object->{$property} = $value;
+        }
+
+        foreach ($this->methods as $method => $args) {
+            $args = $this->resolveArguments($args);
+            $callable = [$object, $method];
+            call_user_func_array($callable, $args);
+        }
+
+        if ($this->callback !== null) {
+            call_user_func($this->callback, $object);
+        }
+    }
+}

vendor/league/container/src/Inflector/InflectorAggregate.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Inflector;
+
+use Generator;
+use League\Container\ContainerAwareTrait;
+
+class InflectorAggregate implements InflectorAggregateInterface
+{
+    use ContainerAwareTrait;
+
+    /**
+     * @var Inflector[]
+     */
+    protected $inflectors = [];
+
+    public function add(string $type, callable $callback = null): Inflector
+    {
+        $inflector = new Inflector($type, $callback);
+        $this->inflectors[] = $inflector;
+        return $inflector;
+    }
+
+    public function inflect($object)
+    {
+        foreach ($this->getIterator() as $inflector) {
+            $type = $inflector->getType();
+
+            if ($object instanceof $type) {
+                $inflector->setContainer($this->getContainer());
+                $inflector->inflect($object);
+            }
+        }
+
+        return $object;
+    }
+
+    public function getIterator(): Generator
+    {
+        yield from $this->inflectors;
+    }
+}

vendor/league/container/src/Inflector/InflectorAggregateInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Inflector;
+
+use IteratorAggregate;
+use League\Container\ContainerAwareInterface;
+
+interface InflectorAggregateInterface extends ContainerAwareInterface, IteratorAggregate
+{
+    public function add(string $type, callable $callback = null): Inflector;
+    public function inflect(object $object);
+}

vendor/league/container/src/Inflector/InflectorInterface.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\Inflector;
+
+interface InflectorInterface
+{
+    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;
+}

vendor/league/container/src/ReflectionContainer.php

@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container;
+
+use League\Container\Argument\{ArgumentResolverInterface, ArgumentResolverTrait};
+use League\Container\Exception\ContainerException;
+use League\Container\Exception\NotFoundException;
+use Psr\Container\ContainerInterface;
+use ReflectionClass;
+use ReflectionFunction;
+use ReflectionMethod;
+
+class ReflectionContainer implements ArgumentResolverInterface, ContainerInterface
+{
+    use ArgumentResolverTrait;
+    use ContainerAwareTrait;
+
+    /**
+     * @var boolean
+     */
+    protected $cacheResolutions;
+
+    /**
+     * @var array
+     */
+    protected $cache = [];
+
+    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)) {
+            throw new NotFoundException(
+                sprintf('Alias (%s) is not an existing class and therefore cannot be resolved', $id)
+            );
+        }
+
+        $reflector = new ReflectionClass($id);
+        $construct = $reflector->getConstructor();
+
+        if ($construct && !$construct->isPublic()) {
+            throw new NotFoundException(
+                sprintf('Alias (%s) has a non-public constructor and therefore cannot be instantiated', $id)
+            );
+        }
+
+        $resolution = $construct === null
+            ? new $id()
+            : $reflector->newInstanceArgs($this->reflectArguments($construct, $args))
+        ;
+
+        if ($this->cacheResolutions === true) {
+            $this->cache[$id] = $resolution;
+        }
+
+        return $resolution;
+    }
+
+    public function has($id): bool
+    {
+        return class_exists($id);
+    }
+
+    public function call(callable $callable, array $args = [])
+    {
+        if (is_string($callable) && strpos($callable, '::') !== false) {
+            $callable = explode('::', $callable);
+        }
+
+        if (is_array($callable)) {
+            if (is_string($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]);
+
+            if ($reflection->isStatic()) {
+                $callable[0] = null;
+            }
+
+            return $reflection->invokeArgs($callable[0], $this->reflectArguments($reflection, $args));
+        }
+
+        if (is_object($callable)) {
+            $reflection = new ReflectionMethod($callable, '__invoke');
+            return $reflection->invokeArgs($callable, $this->reflectArguments($reflection, $args));
+        }
+
+        $reflection = new ReflectionFunction(\Closure::fromCallable($callable));
+
+        return $reflection->invokeArgs($this->reflectArguments($reflection, $args));
+    }
+}

vendor/league/container/src/ServiceProvider/AbstractServiceProvider.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\ServiceProvider;
+
+use League\Container\ContainerAwareTrait;
+
+abstract class AbstractServiceProvider implements ServiceProviderInterface
+{
+    use ContainerAwareTrait;
+
+    /**
+     * @var string
+     */
+    protected $identifier;
+
+    public function getIdentifier(): string
+    {
+        return $this->identifier ?? get_class($this);
+    }
+
+    public function setIdentifier(string $id): ServiceProviderInterface
+    {
+        $this->identifier = $id;
+        return $this;
+    }
+}

vendor/league/container/src/ServiceProvider/BootableServiceProviderInterface.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\ServiceProvider;
+
+interface BootableServiceProviderInterface extends ServiceProviderInterface
+{
+    /**
+     * Method will be invoked on registration of a service provider implementing
+     * this interface. Provides ability for eager loading of Service Providers.
+     *
+     * @return void
+     */
+    public function boot(): void;
+}

vendor/league/container/src/ServiceProvider/ServiceProviderAggregate.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\ServiceProvider;
+
+use Generator;
+use League\Container\Exception\ContainerException;
+use League\Container\{ContainerAwareInterface, ContainerAwareTrait};
+
+class ServiceProviderAggregate implements ServiceProviderAggregateInterface
+{
+    use ContainerAwareTrait;
+
+    /**
+     * @var ServiceProviderInterface[]
+     */
+    protected $providers = [];
+
+    /**
+     * @var array
+     */
+    protected $registered = [];
+
+    public function add(ServiceProviderInterface $provider): ServiceProviderAggregateInterface
+    {
+        if (in_array($provider, $this->providers, true)) {
+            return $this;
+        }
+
+        $provider->setContainer($this->getContainer());
+
+        if ($provider instanceof BootableServiceProviderInterface) {
+            $provider->boot();
+        }
+
+        $this->providers[] = $provider;
+        return $this;
+    }
+
+    public function provides(string $service): bool
+    {
+        foreach ($this->getIterator() as $provider) {
+            if ($provider->provides($service)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function getIterator(): Generator
+    {
+        yield from $this->providers;
+    }
+
+    public function register(string $service): void
+    {
+        if (false === $this->provides($service)) {
+            throw new ContainerException(
+                sprintf('(%s) is not provided by a service provider', $service)
+            );
+        }
+
+        foreach ($this->getIterator() as $provider) {
+            if (in_array($provider->getIdentifier(), $this->registered, true)) {
+                continue;
+            }
+
+            if ($provider->provides($service)) {
+                $provider->register();
+                $this->registered[] = $provider->getIdentifier();
+            }
+        }
+    }
+}

vendor/league/container/src/ServiceProvider/ServiceProviderAggregateInterface.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\ServiceProvider;
+
+use IteratorAggregate;
+use League\Container\ContainerAwareInterface;
+
+interface ServiceProviderAggregateInterface extends ContainerAwareInterface, IteratorAggregate
+{
+    public function add(ServiceProviderInterface $provider): ServiceProviderAggregateInterface;
+    public function provides(string $id): bool;
+    public function register(string $service): void;
+}

vendor/league/container/src/ServiceProvider/ServiceProviderInterface.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Container\ServiceProvider;
+
+use League\Container\ContainerAwareInterface;
+
+interface ServiceProviderInterface extends ContainerAwareInterface
+{
+    public function getIdentifier(): string;
+    public function provides(string $id): bool;
+    public function register(): void;
+    public function setIdentifier(string $id): ServiceProviderInterface;
+}