扩展包

.gitignore

@@ -2,7 +2,7 @@
 /public/hot
 /public/storage
 /storage/*.key
-/vendor
+#/vendor
 .env
 .env.backup
 .phpunit.result.cache

.idea/workspace.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="b7921fed-e263-406a-ad46-a37b33cde5f1" name="变更" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="ComposerSettings" synchronizationState="SYNCHRONIZE">
+    <pharConfigPath>$PROJECT_DIR$/composer.json</pharConfigPath>
+    <execution />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="PhpWorkspaceProjectConfiguration">
+    <include_path>
+      <path value="$PROJECT_DIR$/vendor/psr/http-factory" />
+      <path value="$PROJECT_DIR$/vendor/psr/simple-cache" />
+      <path value="$PROJECT_DIR$/vendor/psr/http-client" />
+      <path value="$PROJECT_DIR$/vendor/psr/container" />
+      <path value="$PROJECT_DIR$/vendor/psr/event-dispatcher" />
+      <path value="$PROJECT_DIR$/vendor/psr/http-message" />
+      <path value="$PROJECT_DIR$/vendor/psy/psysh" />
+      <path value="$PROJECT_DIR$/vendor/psr/log" />
+      <path value="$PROJECT_DIR$/vendor/opis/closure" />
+      <path value="$PROJECT_DIR$/vendor/filp/whoops" />
+      <path value="$PROJECT_DIR$/vendor/asm89/stack-cors" />
+      <path value="$PROJECT_DIR$/vendor/voku/portable-ascii" />
+      <path value="$PROJECT_DIR$/vendor/nikic/php-parser" />
+      <path value="$PROJECT_DIR$/vendor/brick/math" />
+      <path value="$PROJECT_DIR$/vendor/facade/flare-client-php" />
+      <path value="$PROJECT_DIR$/vendor/facade/ignition-contracts" />
+      <path value="$PROJECT_DIR$/vendor/league/commonmark" />
+      <path value="$PROJECT_DIR$/vendor/facade/ignition" />
+      <path value="$PROJECT_DIR$/vendor/league/flysystem" />
+      <path value="$PROJECT_DIR$/vendor/league/mime-type-detection" />
+      <path value="$PROJECT_DIR$/vendor/ramsey/collection" />
+      <path value="$PROJECT_DIR$/vendor/nesbot/carbon" />
+      <path value="$PROJECT_DIR$/vendor/scrivo/highlight.php" />
+      <path value="$PROJECT_DIR$/vendor/ramsey/uuid" />
+      <path value="$PROJECT_DIR$/vendor/egulias/email-validator" />
+      <path value="$PROJECT_DIR$/vendor/vlucas/phpdotenv" />
+      <path value="$PROJECT_DIR$/vendor/laravel/framework" />
+      <path value="$PROJECT_DIR$/vendor/laravel/tinker" />
+      <path value="$PROJECT_DIR$/vendor/monolog/monolog" />
+      <path value="$PROJECT_DIR$/vendor/mockery/mockery" />
+      <path value="$PROJECT_DIR$/vendor/phar-io/version" />
+      <path value="$PROJECT_DIR$/vendor/myclabs/deep-copy" />
+      <path value="$PROJECT_DIR$/vendor/phpunit/php-code-coverage" />
+      <path value="$PROJECT_DIR$/vendor/phar-io/manifest" />
+      <path value="$PROJECT_DIR$/vendor/phpunit/php-text-template" />
+      <path value="$PROJECT_DIR$/vendor/phpunit/phpunit" />
+      <path value="$PROJECT_DIR$/vendor/phpunit/php-token-stream" />
+      <path value="$PROJECT_DIR$/vendor/phpunit/php-file-iterator" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-mbstring" />
+      <path value="$PROJECT_DIR$/vendor/phpunit/php-timer" />
+      <path value="$PROJECT_DIR$/vendor/symfony/deprecation-contracts" />
+      <path value="$PROJECT_DIR$/vendor/symfony/finder" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-intl-grapheme" />
+      <path value="$PROJECT_DIR$/vendor/symfony/routing" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-intl-normalizer" />
+      <path value="$PROJECT_DIR$/vendor/symfony/css-selector" />
+      <path value="$PROJECT_DIR$/vendor/symfony/mime" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-php80" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-php72" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-ctype" />
+      <path value="$PROJECT_DIR$/vendor/symfony/event-dispatcher-contracts" />
+      <path value="$PROJECT_DIR$/vendor/symfony/error-handler" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-intl-idn" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-php73" />
+      <path value="$PROJECT_DIR$/vendor/symfony/polyfill-iconv" />
+      <path value="$PROJECT_DIR$/vendor/symfony/console" />
+      <path value="$PROJECT_DIR$/vendor/symfony/var-dumper" />
+      <path value="$PROJECT_DIR$/vendor/symfony/event-dispatcher" />
+      <path value="$PROJECT_DIR$/vendor/symfony/http-kernel" />
+      <path value="$PROJECT_DIR$/vendor/symfony/http-foundation" />
+      <path value="$PROJECT_DIR$/vendor/symfony/service-contracts" />
+      <path value="$PROJECT_DIR$/vendor/symfony/translation-contracts" />
+      <path value="$PROJECT_DIR$/vendor/symfony/translation" />
+      <path value="$PROJECT_DIR$/vendor/symfony/string" />
+      <path value="$PROJECT_DIR$/vendor/theseer/tokenizer" />
+      <path value="$PROJECT_DIR$/vendor/symfony/process" />
+      <path value="$PROJECT_DIR$/vendor/doctrine/instantiator" />
+      <path value="$PROJECT_DIR$/vendor/doctrine/lexer" />
+      <path value="$PROJECT_DIR$/vendor/fakerphp/faker" />
+      <path value="$PROJECT_DIR$/vendor/doctrine/inflector" />
+      <path value="$PROJECT_DIR$/vendor/fideloper/proxy" />
+      <path value="$PROJECT_DIR$/vendor/hamcrest/hamcrest-php" />
+      <path value="$PROJECT_DIR$/vendor/phpoption/phpoption" />
+      <path value="$PROJECT_DIR$/vendor/fruitcake/laravel-cors" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/type" />
+      <path value="$PROJECT_DIR$/vendor/ralouphie/getallheaders" />
+      <path value="$PROJECT_DIR$/vendor/composer" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/diff" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/recursion-context" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/object-enumerator" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/resource-operations" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/environment" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/global-state" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/code-unit-reverse-lookup" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/comparator" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/exporter" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/version" />
+      <path value="$PROJECT_DIR$/vendor/guzzlehttp/promises" />
+      <path value="$PROJECT_DIR$/vendor/sebastian/object-reflector" />
+      <path value="$PROJECT_DIR$/vendor/guzzlehttp/guzzle" />
+      <path value="$PROJECT_DIR$/vendor/guzzlehttp/psr7" />
+      <path value="$PROJECT_DIR$/vendor/swiftmailer/swiftmailer" />
+      <path value="$PROJECT_DIR$/vendor/nunomaduro/collision" />
+      <path value="$PROJECT_DIR$/vendor/dragonmantank/cron-expression" />
+      <path value="$PROJECT_DIR$/vendor/tijsverkoyen/css-to-inline-styles" />
+    </include_path>
+  </component>
+  <component name="ProjectId" id="2GLZBD2hLEjeJafKoEd4IE4F544" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">
+    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
+    <property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
+    <property name="WebServerToolWindowFactoryState" value="false" />
+    <property name="last_opened_file_path" value="//wsl$/Ubuntu-20.04/data/www/semour_web" />
+    <property name="nodejs_interpreter_path.stuck_in_default_project" value="undefined stuck path" />
+    <property name="nodejs_package_manager_path" value="npm" />
+    <property name="vue.rearranger.settings.migration" value="true" />
+  </component>
+  <component name="RunManager">
+    <configuration default="true" type="ComposerRunConfigurationType" factoryName="Composer Script">
+      <option name="pathToComposerJson" value="$PROJECT_DIR$/composer.json" />
+      <method v="2" />
+    </configuration>
+    <configuration name="phpunit.xml" type="PHPUnitRunConfigurationType" factoryName="PHPUnit">
+      <TestRunner scope="XML" />
+      <method v="2" />
+    </configuration>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="应用程序级" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="默认任务">
+      <changelist id="b7921fed-e263-406a-ad46-a37b33cde5f1" name="变更" comment="" />
+      <created>1666169689455</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1666169689455</updated>
+      <workItem from="1666169690936" duration="563000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+</project>
\ No newline at end of file

vendor/asm89/stack-cors/LICENSE

+Copyright (c) 2013-2017 Alexander <iam.asm89@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/asm89/stack-cors/README.md

+# Stack/Cors
+
+Library and middleware enabling cross-origin resource sharing for your
+http-{foundation,kernel} using application. It attempts to implement the
+[W3C Recommendation] for cross-origin resource sharing.
+
+[W3C Recommendation]: http://www.w3.org/TR/cors/
+
+Build status: ![.github/workflows/run-tests.yml](https://github.com/asm89/stack-cors/workflows/.github/workflows/run-tests.yml/badge.svg)
+
+## Installation
+
+Require `asm89/stack-cors` using composer.
+
+## Usage
+
+This package can be used as a library or as [stack middleware].
+
+[stack middleware]: http://stackphp.com/
+
+### Options
+
+| Option                 | Description                                                | Default value |
+|------------------------|------------------------------------------------------------|---------------|
+| allowedMethods         | Matches the request method.                                | `[]`          |
+| allowedOrigins         | Matches the request origin.                                | `[]`          |
+| allowedOriginsPatterns | Matches the request origin with `preg_match`.              | `[]`          |
+| allowedHeaders         | Sets the Access-Control-Allow-Headers response header.     | `[]`          |
+| exposedHeaders         | Sets the Access-Control-Expose-Headers response header.    | `false`       |
+| maxAge                 | Sets the Access-Control-Max-Age response header.           | `false`       |
+| supportsCredentials    | Sets the Access-Control-Allow-Credentials header.          | `false`       |
+
+The _allowedMethods_ and _allowedHeaders_ options are case-insensitive.
+
+You don't need to provide both _allowedOrigins_ and _allowedOriginsPatterns_. If one of the strings passed matches, it is considered a valid origin.
+
+If `['*']` is provided to _allowedMethods_, _allowedOrigins_ or _allowedHeaders_ all methods / origins / headers are allowed.
+
+### Example: using the library
+
+```php
+<?php
+
+use Asm89\Stack\CorsService;
+
+$cors = new CorsService([
+    'allowedHeaders'         => ['x-allowed-header', 'x-other-allowed-header'],
+    'allowedMethods'         => ['DELETE', 'GET', 'POST', 'PUT'],
+    'allowedOrigins'         => ['http://localhost'],
+    'allowedOriginsPatterns' => ['/localhost:\d/'],
+    'exposedHeaders'         => false,
+    'maxAge'                 => false,
+    'supportsCredentials'    => false,
+]);
+
+$cors->addActualRequestHeaders(Response $response, $origin);
+$cors->handlePreflightRequest(Request $request);
+$cors->isActualRequestAllowed(Request $request);
+$cors->isCorsRequest(Request $request);
+$cors->isPreflightRequest(Request $request);
+```
+
+## Example: using the stack middleware
+
+```php
+<?php
+
+use Asm89\Stack\Cors;
+
+$app = new Cors($app, [
+    // you can use ['*'] to allow any headers
+    'allowedHeaders'      => ['x-allowed-header', 'x-other-allowed-header'],
+    // you can use ['*'] to allow any methods
+    'allowedMethods'      => ['DELETE', 'GET', 'POST', 'PUT'],
+    // you can use ['*'] to allow requests from any origin
+    'allowedOrigins'      => ['localhost'],
+    // you can enter regexes that are matched to the origin request header
+    'allowedOriginsPatterns' => ['/localhost:\d/'],
+    'exposedHeaders'      => false,
+    'maxAge'              => false,
+    'supportsCredentials' => false,
+]);
+```

vendor/asm89/stack-cors/composer.json

+{
+    "name": "asm89/stack-cors",
+    "description": "Cross-origin resource sharing library and stack middleware",
+    "keywords": ["stack", "cors"],
+    "homepage": "https://github.com/asm89/stack-cors",
+    "type": "library",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Alexander",
+            "email": "iam.asm89@gmail.com"
+        }
+    ],
+    "require": {
+        "php": "^7.2|^8.0",
+        "symfony/http-foundation": "^4|^5|^6",
+        "symfony/http-kernel": "^4|^5|^6"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^7|^9",
+        "squizlabs/php_codesniffer": "^3.5"
+    },
+    "autoload": {
+        "psr-4": {
+            "Asm89\\Stack\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Asm89\\Stack\\Tests\\": "tests/"
+        }
+    },
+    "scripts": {
+        "test": "phpunit",
+        "check-style": "phpcs -p --standard=PSR12 --exclude=Generic.Files.LineLength --runtime-set ignore_errors_on_exit 1 --runtime-set ignore_warnings_on_exit 1 src",
+        "fix-style": "phpcbf -p --standard=PSR12 --exclude=Generic.Files.LineLength --runtime-set ignore_errors_on_exit 1 --runtime-set ignore_warnings_on_exit 1 src"
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.1-dev"
+        }
+    }
+}

vendor/asm89/stack-cors/src/Cors.php

+<?php
+
+/*
+ * This file is part of asm89/stack-cors.
+ *
+ * (c) Alexander <iam.asm89@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Asm89\Stack;
+
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+use Symfony\Component\HttpFoundation\Request;
+
+class Cors implements HttpKernelInterface
+{
+    /**
+     * @var \Symfony\Component\HttpKernel\HttpKernelInterface
+     */
+    private $app;
+
+    /**
+     * @var \Asm89\Stack\CorsService
+     */
+    private $cors;
+
+    private $defaultOptions = [
+        'allowedHeaders'         => [],
+        'allowedMethods'         => [],
+        'allowedOrigins'         => [],
+        'allowedOriginsPatterns' => [],
+        'exposedHeaders'         => [],
+        'maxAge'                 => 0,
+        'supportsCredentials'    => false,
+    ];
+
+    public function __construct(HttpKernelInterface $app, array $options = [])
+    {
+        $this->app  = $app;
+        $this->cors = new CorsService(array_merge($this->defaultOptions, $options));
+    }
+
+    public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true): Response
+    {
+        if ($this->cors->isPreflightRequest($request)) {
+            $response = $this->cors->handlePreflightRequest($request);
+            return $this->cors->varyHeader($response, 'Access-Control-Request-Method');
+        }
+
+        $response = $this->app->handle($request, $type, $catch);
+
+        if ($request->getMethod() === 'OPTIONS') {
+            $this->cors->varyHeader($response, 'Access-Control-Request-Method');
+        }
+
+        return $this->cors->addActualRequestHeaders($response, $request);
+    }
+}

vendor/asm89/stack-cors/src/CorsService.php

+<?php
+
+/*
+ * This file is part of asm89/stack-cors.
+ *
+ * (c) Alexander <iam.asm89@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Asm89\Stack;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+class CorsService
+{
+    private $options;
+
+    public function __construct(array $options = [])
+    {
+        $this->options = $this->normalizeOptions($options);
+    }
+
+    private function normalizeOptions(array $options = []): array
+    {
+        $options += [
+            'allowedOrigins' => [],
+            'allowedOriginsPatterns' => [],
+            'supportsCredentials' => false,
+            'allowedHeaders' => [],
+            'exposedHeaders' => [],
+            'allowedMethods' => [],
+            'maxAge' => 0,
+        ];
+
+        // normalize array('*') to true
+        if (in_array('*', $options['allowedOrigins'])) {
+            $options['allowedOrigins'] = true;
+        }
+        if (in_array('*', $options['allowedHeaders'])) {
+            $options['allowedHeaders'] = true;
+        } else {
+            $options['allowedHeaders'] = array_map('strtolower', $options['allowedHeaders']);
+        }
+
+        if (in_array('*', $options['allowedMethods'])) {
+            $options['allowedMethods'] = true;
+        } else {
+            $options['allowedMethods'] = array_map('strtoupper', $options['allowedMethods']);
+        }
+
+        return $options;
+    }
+
+    /**
+     * @deprecated use isOriginAllowed
+     */
+    public function isActualRequestAllowed(Request $request): bool
+    {
+        return $this->isOriginAllowed($request);
+    }
+
+    public function isCorsRequest(Request $request): bool
+    {
+        return $request->headers->has('Origin');
+    }
+
+    public function isPreflightRequest(Request $request): bool
+    {
+        return $request->getMethod() === 'OPTIONS' && $request->headers->has('Access-Control-Request-Method');
+    }
+
+    public function handlePreflightRequest(Request $request): Response
+    {
+        $response = new Response();
+
+        $response->setStatusCode(204);
+
+        return $this->addPreflightRequestHeaders($response, $request);
+    }
+
+    public function addPreflightRequestHeaders(Response $response, Request $request): Response
+    {
+        $this->configureAllowedOrigin($response, $request);
+
+        if ($response->headers->has('Access-Control-Allow-Origin')) {
+            $this->configureAllowCredentials($response, $request);
+
+            $this->configureAllowedMethods($response, $request);
+
+            $this->configureAllowedHeaders($response, $request);
+
+            $this->configureMaxAge($response, $request);
+        }
+
+        return $response;
+    }
+
+    public function isOriginAllowed(Request $request): bool
+    {
+        if ($this->options['allowedOrigins'] === true) {
+            return true;
+        }
+
+        if (!$request->headers->has('Origin')) {
+            return false;
+        }
+
+        $origin = $request->headers->get('Origin');
+
+        if (in_array($origin, $this->options['allowedOrigins'])) {
+            return true;
+        }
+
+        foreach ($this->options['allowedOriginsPatterns'] as $pattern) {
+            if (preg_match($pattern, $origin)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function addActualRequestHeaders(Response $response, Request $request): Response
+    {
+        $this->configureAllowedOrigin($response, $request);
+
+        if ($response->headers->has('Access-Control-Allow-Origin')) {
+            $this->configureAllowCredentials($response, $request);
+
+            $this->configureExposedHeaders($response, $request);
+        }
+
+        return $response;
+    }
+
+    private function configureAllowedOrigin(Response $response, Request $request)
+    {
+        if ($this->options['allowedOrigins'] === true && !$this->options['supportsCredentials']) {
+            // Safe+cacheable, allow everything
+            $response->headers->set('Access-Control-Allow-Origin', '*');
+        } elseif ($this->isSingleOriginAllowed()) {
+            // Single origins can be safely set
+            $response->headers->set('Access-Control-Allow-Origin', array_values($this->options['allowedOrigins'])[0]);
+        } else {
+            // For dynamic headers, set the requested Origin header when set and allowed
+            if ($this->isCorsRequest($request) && $this->isOriginAllowed($request)) {
+                $response->headers->set('Access-Control-Allow-Origin', $request->headers->get('Origin'));
+            }
+
+            $this->varyHeader($response, 'Origin');
+        }
+    }
+
+    private function isSingleOriginAllowed(): bool
+    {
+        if ($this->options['allowedOrigins'] === true || !empty($this->options['allowedOriginsPatterns'])) {
+            return false;
+        }
+
+        return count($this->options['allowedOrigins']) === 1;
+    }
+
+    private function configureAllowedMethods(Response $response, Request $request)
+    {
+        if ($this->options['allowedMethods'] === true) {
+            $allowMethods = strtoupper($request->headers->get('Access-Control-Request-Method'));
+            $this->varyHeader($response, 'Access-Control-Request-Method');
+        } else {
+            $allowMethods = implode(', ', $this->options['allowedMethods']);
+        }
+
+        $response->headers->set('Access-Control-Allow-Methods', $allowMethods);
+    }
+
+    private function configureAllowedHeaders(Response $response, Request $request)
+    {
+        if ($this->options['allowedHeaders'] === true) {
+            $allowHeaders = $request->headers->get('Access-Control-Request-Headers');
+            $this->varyHeader($response, 'Access-Control-Request-Headers');
+        } else {
+            $allowHeaders = implode(', ', $this->options['allowedHeaders']);
+        }
+        $response->headers->set('Access-Control-Allow-Headers', $allowHeaders);
+    }
+
+    private function configureAllowCredentials(Response $response, Request $request)
+    {
+        if ($this->options['supportsCredentials']) {
+            $response->headers->set('Access-Control-Allow-Credentials', 'true');
+        }
+    }
+
+    private function configureExposedHeaders(Response $response, Request $request)
+    {
+        if ($this->options['exposedHeaders']) {
+            $response->headers->set('Access-Control-Expose-Headers', implode(', ', $this->options['exposedHeaders']));
+        }
+    }
+
+    private function configureMaxAge(Response $response, Request $request)
+    {
+        if ($this->options['maxAge'] !== null) {
+            $response->headers->set('Access-Control-Max-Age', (int) $this->options['maxAge']);
+        }
+    }
+
+    public function varyHeader(Response $response, $header): Response
+    {
+        if (!$response->headers->has('Vary')) {
+            $response->headers->set('Vary', $header);
+        } elseif (!in_array($header, explode(', ', $response->headers->get('Vary')))) {
+            $response->headers->set('Vary', $response->headers->get('Vary') . ', ' . $header);
+        }
+
+        return $response;
+    }
+
+    private function isSameHost(Request $request): bool
+    {
+        return $request->headers->get('Origin') === $request->getSchemeAndHttpHost();
+    }
+}

vendor/autoload.php

+<?php
+
+// autoload.php @generated by Composer
+
+require_once __DIR__ . '/composer/autoload_real.php';
+
+return ComposerAutoloaderInit98d517a41e74f308f2c33f0bb882c41a::getLoader();

vendor/bin/carbon

+#!/usr/bin/env php
+<?php
+
+/**
+ * Proxy PHP file generated by Composer
+ *
+ * This file includes the referenced bin path (../nesbot/carbon/bin/carbon) using eval to remove the shebang if present
+ *
+ * @generated
+ */
+
+$binPath = realpath(__DIR__ . "/" . '../nesbot/carbon/bin/carbon');
+$contents = file_get_contents($binPath);
+$contents = preg_replace('{^#!/.+\r?\n<\?(php)?}', '', $contents, 1, $replaced);
+if ($replaced) {
+    $contents = strtr($contents, array(
+        '__FILE__' => var_export($binPath, true),
+        '__DIR__' => var_export(dirname($binPath), true),
+    ));
+
+    eval($contents);
+    exit(0);
+}
+include $binPath;

vendor/bin/carbon.bat

+@ECHO OFF
+setlocal DISABLEDELAYEDEXPANSION
+SET BIN_TARGET=%~dp0/../nesbot/carbon/bin/carbon
+php "%BIN_TARGET%" %*

vendor/bin/commonmark

+#!/usr/bin/env php
+<?php
+
+/**
+ * Proxy PHP file generated by Composer
+ *
+ * This file includes the referenced bin path (../league/commonmark/bin/commonmark) using eval to remove the shebang if present
+ *
+ * @generated
+ */
+
+$binPath = realpath(__DIR__ . "/" . '../league/commonmark/bin/commonmark');
+$contents = file_get_contents($binPath);
+$contents = preg_replace('{^#!/.+\r?\n<\?(php)?}', '', $contents, 1, $replaced);
+if ($replaced) {
+    $contents = strtr($contents, array(
+        '__FILE__' => var_export($binPath, true),
+        '__DIR__' => var_export(dirname($binPath), true),
+    ));
+
+    eval($contents);
+    exit(0);
+}
+include $binPath;

vendor/bin/commonmark.bat

+@ECHO OFF
+setlocal DISABLEDELAYEDEXPANSION
+SET BIN_TARGET=%~dp0/../league/commonmark/bin/commonmark
+php "%BIN_TARGET%" %*

vendor/bin/patch-type-declarations

+#!/usr/bin/env php
+<?php
+
+/**
+ * Proxy PHP file generated by Composer
+ *
+ * This file includes the referenced bin path (../symfony/error-handler/Resources/bin/patch-type-declarations) using eval to remove the shebang if present
+ *
+ * @generated
+ */
+
+$binPath = realpath(__DIR__ . "/" . '../symfony/error-handler/Resources/bin/patch-type-declarations');
+$contents = file_get_contents($binPath);
+$contents = preg_replace('{^#!/.+\r?\n<\?(php)?}', '', $contents, 1, $replaced);
+if ($replaced) {
+    $contents = strtr($contents, array(
+        '__FILE__' => var_export($binPath, true),
+        '__DIR__' => var_export(dirname($binPath), true),
+    ));
+
+    eval($contents);
+    exit(0);
+}
+include $binPath;

vendor/bin/patch-type-declarations.bat

+@ECHO OFF
+setlocal DISABLEDELAYEDEXPANSION
+SET BIN_TARGET=%~dp0/../symfony/error-handler/Resources/bin/patch-type-declarations
+php "%BIN_TARGET%" %*

vendor/bin/php-parse

+#!/usr/bin/env php
+<?php
+
+/**
+ * Proxy PHP file generated by Composer
+ *
+ * This file includes the referenced bin path (../nikic/php-parser/bin/php-parse) using eval to remove the shebang if present
+ *
+ * @generated
+ */
+
+$binPath = realpath(__DIR__ . "/" . '../nikic/php-parser/bin/php-parse');
+$contents = file_get_contents($binPath);
+$contents = preg_replace('{^#!/.+\r?\n<\?(php)?}', '', $contents, 1, $replaced);
+if ($replaced) {
+    $contents = strtr($contents, array(
+        '__FILE__' => var_export($binPath, true),
+        '__DIR__' => var_export(dirname($binPath), true),
+    ));
+
+    eval($contents);
+    exit(0);
+}
+include $binPath;

vendor/bin/php-parse.bat

+@ECHO OFF
+setlocal DISABLEDELAYEDEXPANSION
+SET BIN_TARGET=%~dp0/../nikic/php-parser/bin/php-parse
+php "%BIN_TARGET%" %*

vendor/bin/phpunit

+#!/usr/bin/env php
+<?php
+
+/**
+ * Proxy PHP file generated by Composer
+ *
+ * This file includes the referenced bin path (../phpunit/phpunit/phpunit) using eval to remove the shebang if present
+ *
+ * @generated
+ */
+
+$binPath = realpath(__DIR__ . "/" . '../phpunit/phpunit/phpunit');
+$contents = file_get_contents($binPath);
+$contents = preg_replace('{^#!/.+\r?\n<\?(php)?}', '', $contents, 1, $replaced);
+if ($replaced) {
+    $contents = strtr($contents, array(
+        '__FILE__' => var_export($binPath, true),
+        '__DIR__' => var_export(dirname($binPath), true),
+    ));
+
+    eval($contents);
+    exit(0);
+}
+include $binPath;

vendor/bin/phpunit.bat

+@ECHO OFF
+setlocal DISABLEDELAYEDEXPANSION
+SET BIN_TARGET=%~dp0/../phpunit/phpunit/phpunit
+php "%BIN_TARGET%" %*

vendor/bin/psysh

+#!/usr/bin/env php
+<?php
+
+/**
+ * Proxy PHP file generated by Composer
+ *
+ * This file includes the referenced bin path (../psy/psysh/bin/psysh) using eval to remove the shebang if present
+ *
+ * @generated
+ */
+
+$binPath = realpath(__DIR__ . "/" . '../psy/psysh/bin/psysh');
+$contents = file_get_contents($binPath);
+$contents = preg_replace('{^#!/.+\r?\n<\?(php)?}', '', $contents, 1, $replaced);
+if ($replaced) {
+    $contents = strtr($contents, array(
+        '__FILE__' => var_export($binPath, true),
+        '__DIR__' => var_export(dirname($binPath), true),
+    ));
+
+    eval($contents);
+    exit(0);
+}
+include $binPath;

vendor/bin/psysh.bat

+@ECHO OFF
+setlocal DISABLEDELAYEDEXPANSION
+SET BIN_TARGET=%~dp0/../psy/psysh/bin/psysh
+php "%BIN_TARGET%" %*

vendor/bin/var-dump-server

+#!/usr/bin/env php
+<?php
+
+/**
+ * Proxy PHP file generated by Composer
+ *
+ * This file includes the referenced bin path (../symfony/var-dumper/Resources/bin/var-dump-server) using eval to remove the shebang if present
+ *
+ * @generated
+ */
+
+$binPath = realpath(__DIR__ . "/" . '../symfony/var-dumper/Resources/bin/var-dump-server');
+$contents = file_get_contents($binPath);
+$contents = preg_replace('{^#!/.+\r?\n<\?(php)?}', '', $contents, 1, $replaced);
+if ($replaced) {
+    $contents = strtr($contents, array(
+        '__FILE__' => var_export($binPath, true),
+        '__DIR__' => var_export(dirname($binPath), true),
+    ));
+
+    eval($contents);
+    exit(0);
+}
+include $binPath;

vendor/bin/var-dump-server.bat

+@ECHO OFF
+setlocal DISABLEDELAYEDEXPANSION
+SET BIN_TARGET=%~dp0/../symfony/var-dumper/Resources/bin/var-dump-server
+php "%BIN_TARGET%" %*

vendor/brick/math/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2013-present Benjamin Morel
+
+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/brick/math/SECURITY.md

+# Security Policy
+
+## Supported Versions
+
+Only the last two release streams are supported.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 0.9.x   | :white_check_mark: |
+| 0.8.x   | :white_check_mark: |
+| < 0.8   | :x:                |
+
+## Reporting a Vulnerability
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.

vendor/brick/math/composer.json

+{
+    "name": "brick/math",
+    "description": "Arbitrary-precision arithmetic library",
+    "type": "library",
+    "keywords": [
+        "Brick",
+        "Math",
+        "Arbitrary-precision",
+        "Arithmetic",
+        "BigInteger",
+        "BigDecimal",
+        "BigRational",
+        "Bignum"
+    ],
+    "license": "MIT",
+    "require": {
+        "php": "^7.1 || ^8.0",
+        "ext-json": "*"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^7.5.15 || ^8.5 || ^9.0",
+        "php-coveralls/php-coveralls": "^2.2",
+        "vimeo/psalm": "4.9.2"
+    },
+    "autoload": {
+        "psr-4": {
+            "Brick\\Math\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Brick\\Math\\Tests\\": "tests/"
+        }
+    }
+}

vendor/brick/math/src/Exception/DivisionByZeroException.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Exception thrown when a division by zero occurs.
+ */
+class DivisionByZeroException extends MathException
+{
+    /**
+     * @return DivisionByZeroException
+     *
+     * @psalm-pure
+     */
+    public static function divisionByZero() : DivisionByZeroException
+    {
+        return new self('Division by zero.');
+    }
+
+    /**
+     * @return DivisionByZeroException
+     *
+     * @psalm-pure
+     */
+    public static function modulusMustNotBeZero() : DivisionByZeroException
+    {
+        return new self('The modulus must not be zero.');
+    }
+
+    /**
+     * @return DivisionByZeroException
+     *
+     * @psalm-pure
+     */
+    public static function denominatorMustNotBeZero() : DivisionByZeroException
+    {
+        return new self('The denominator of a rational number cannot be zero.');
+    }
+}

vendor/brick/math/src/Exception/IntegerOverflowException.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+use Brick\Math\BigInteger;
+
+/**
+ * Exception thrown when an integer overflow occurs.
+ */
+class IntegerOverflowException extends MathException
+{
+    /**
+     * @param BigInteger $value
+     *
+     * @return IntegerOverflowException
+     *
+     * @psalm-pure
+     */
+    public static function toIntOverflow(BigInteger $value) : IntegerOverflowException
+    {
+        $message = '%s is out of range %d to %d and cannot be represented as an integer.';
+
+        return new self(\sprintf($message, (string) $value, PHP_INT_MIN, PHP_INT_MAX));
+    }
+}

vendor/brick/math/src/Exception/MathException.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Base class for all math exceptions.
+ *
+ * This class is abstract to ensure that only fine-grained exceptions are thrown throughout the code.
+ */
+class MathException extends \RuntimeException
+{
+}

vendor/brick/math/src/Exception/NegativeNumberException.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Exception thrown when attempting to perform an unsupported operation, such as a square root, on a negative number.
+ */
+class NegativeNumberException extends MathException
+{
+}

vendor/brick/math/src/Exception/NumberFormatException.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Exception thrown when attempting to create a number from a string with an invalid format.
+ */
+class NumberFormatException extends MathException
+{
+    /**
+     * @param string $char The failing character.
+     *
+     * @return NumberFormatException
+     *
+     * @psalm-pure
+     */
+    public static function charNotInAlphabet(string $char) : self
+    {
+        $ord = \ord($char);
+
+        if ($ord < 32 || $ord > 126) {
+            $char = \strtoupper(\dechex($ord));
+
+            if ($ord < 10) {
+                $char = '0' . $char;
+            }
+        } else {
+            $char = '"' . $char . '"';
+        }
+
+        return new self(sprintf('Char %s is not a valid character in the given alphabet.', $char));
+    }
+}

vendor/brick/math/src/Exception/RoundingNecessaryException.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Exception;
+
+/**
+ * Exception thrown when a number cannot be represented at the requested scale without rounding.
+ */
+class RoundingNecessaryException extends MathException
+{
+    /**
+     * @return RoundingNecessaryException
+     *
+     * @psalm-pure
+     */
+    public static function roundingNecessary() : RoundingNecessaryException
+    {
+        return new self('Rounding is necessary to represent the result of the operation at this scale.');
+    }
+}

vendor/brick/math/src/Internal/Calculator/BcMathCalculator.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Internal\Calculator;
+
+use Brick\Math\Internal\Calculator;
+
+/**
+ * Calculator implementation built around the bcmath library.
+ *
+ * @internal
+ *
+ * @psalm-immutable
+ */
+class BcMathCalculator extends Calculator
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function add(string $a, string $b) : string
+    {
+        return \bcadd($a, $b, 0);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function sub(string $a, string $b) : string
+    {
+        return \bcsub($a, $b, 0);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function mul(string $a, string $b) : string
+    {
+        return \bcmul($a, $b, 0);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @psalm-suppress InvalidNullableReturnType
+     * @psalm-suppress NullableReturnStatement
+     */
+    public function divQ(string $a, string $b) : string
+    {
+        return \bcdiv($a, $b, 0);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @psalm-suppress InvalidNullableReturnType
+     * @psalm-suppress NullableReturnStatement
+     */
+    public function divR(string $a, string $b) : string
+    {
+        if (version_compare(PHP_VERSION, '7.2') >= 0) {
+            return \bcmod($a, $b, 0);
+        }
+
+        return \bcmod($a, $b);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function divQR(string $a, string $b) : array
+    {
+        $q = \bcdiv($a, $b, 0);
+
+        if (version_compare(PHP_VERSION, '7.2') >= 0) {
+            $r = \bcmod($a, $b, 0);
+        } else {
+            $r = \bcmod($a, $b);
+        }
+
+        assert($q !== null);
+        assert($r !== null);
+
+        return [$q, $r];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function pow(string $a, int $e) : string
+    {
+        return \bcpow($a, (string) $e, 0);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @psalm-suppress InvalidNullableReturnType
+     * @psalm-suppress NullableReturnStatement
+     */
+    public function modPow(string $base, string $exp, string $mod) : string
+    {
+        return \bcpowmod($base, $exp, $mod, 0);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @psalm-suppress NullableReturnStatement
+     * @psalm-suppress InvalidNullableReturnType
+     */
+    public function sqrt(string $n) : string
+    {
+        return \bcsqrt($n, 0);
+    }
+}

vendor/brick/math/src/Internal/Calculator/GmpCalculator.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math\Internal\Calculator;
+
+use Brick\Math\Internal\Calculator;
+
+/**
+ * Calculator implementation built around the GMP library.
+ *
+ * @internal
+ *
+ * @psalm-immutable
+ */
+class GmpCalculator extends Calculator
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function add(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_add($a, $b));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function sub(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_sub($a, $b));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function mul(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_mul($a, $b));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function divQ(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_div_q($a, $b));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function divR(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_div_r($a, $b));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function divQR(string $a, string $b) : array
+    {
+        [$q, $r] = \gmp_div_qr($a, $b);
+
+        return [
+            \gmp_strval($q),
+            \gmp_strval($r)
+        ];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function pow(string $a, int $e) : string
+    {
+        return \gmp_strval(\gmp_pow($a, $e));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function modInverse(string $x, string $m) : ?string
+    {
+        $result = \gmp_invert($x, $m);
+
+        if ($result === false) {
+            return null;
+        }
+
+        return \gmp_strval($result);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function modPow(string $base, string $exp, string $mod) : string
+    {
+        return \gmp_strval(\gmp_powm($base, $exp, $mod));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function gcd(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_gcd($a, $b));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fromBase(string $number, int $base) : string
+    {
+        return \gmp_strval(\gmp_init($number, $base));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function toBase(string $number, int $base) : string
+    {
+        return \gmp_strval($number, $base);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function and(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_and($a, $b));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function or(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_or($a, $b));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function xor(string $a, string $b) : string
+    {
+        return \gmp_strval(\gmp_xor($a, $b));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function sqrt(string $n) : string
+    {
+        return \gmp_strval(\gmp_sqrt($n));
+    }
+}

vendor/brick/math/src/RoundingMode.php

+<?php
+
+declare(strict_types=1);
+
+namespace Brick\Math;
+
+/**
+ * Specifies a rounding behavior for numerical operations capable of discarding precision.
+ *
+ * Each rounding mode indicates how the least significant returned digit of a rounded result
+ * is to be calculated. If fewer digits are returned than the digits needed to represent the
+ * exact numerical result, the discarded digits will be referred to as the discarded fraction
+ * regardless the digits' contribution to the value of the number. In other words, considered
+ * as a numerical value, the discarded fraction could have an absolute value greater than one.
+ */
+final class RoundingMode
+{
+    /**
+     * Private constructor. This class is not instantiable.
+     *
+     * @codeCoverageIgnore
+     */
+    private function __construct()
+    {
+    }
+
+    /**
+     * Asserts that the requested operation has an exact result, hence no rounding is necessary.
+     *
+     * If this rounding mode is specified on an operation that yields a result that
+     * cannot be represented at the requested scale, a RoundingNecessaryException is thrown.
+     */
+    public const UNNECESSARY = 0;
+
+    /**
+     * Rounds away from zero.
+     *
+     * Always increments the digit prior to a nonzero discarded fraction.
+     * Note that this rounding mode never decreases the magnitude of the calculated value.
+     */
+    public const UP = 1;
+
+    /**
+     * Rounds towards zero.
+     *
+     * Never increments the digit prior to a discarded fraction (i.e., truncates).
+     * Note that this rounding mode never increases the magnitude of the calculated value.
+     */
+    public const DOWN = 2;
+
+    /**
+     * Rounds towards positive infinity.
+     *
+     * If the result is positive, behaves as for UP; if negative, behaves as for DOWN.
+     * Note that this rounding mode never decreases the calculated value.
+     */
+    public const CEILING = 3;
+
+    /**
+     * Rounds towards negative infinity.
+     *
+     * If the result is positive, behave as for DOWN; if negative, behave as for UP.
+     * Note that this rounding mode never increases the calculated value.
+     */
+    public const FLOOR = 4;
+
+    /**
+     * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round up.
+     *
+     * Behaves as for UP if the discarded fraction is >= 0.5; otherwise, behaves as for DOWN.
+     * Note that this is the rounding mode commonly taught at school.
+     */
+    public const HALF_UP = 5;
+
+    /**
+     * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round down.
+     *
+     * Behaves as for UP if the discarded fraction is > 0.5; otherwise, behaves as for DOWN.
+     */
+    public const HALF_DOWN = 6;
+
+    /**
+     * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round towards positive infinity.
+     *
+     * If the result is positive, behaves as for HALF_UP; if negative, behaves as for HALF_DOWN.
+     */
+    public const HALF_CEILING = 7;
+
+    /**
+     * Rounds towards "nearest neighbor" unless both neighbors are equidistant, in which case round towards negative infinity.
+     *
+     * If the result is positive, behaves as for HALF_DOWN; if negative, behaves as for HALF_UP.
+     */
+    public const HALF_FLOOR = 8;
+
+    /**
+     * Rounds towards the "nearest neighbor" unless both neighbors are equidistant, in which case rounds towards the even neighbor.
+     *
+     * Behaves as for HALF_UP if the digit to the left of the discarded fraction is odd;
+     * behaves as for HALF_DOWN if it's even.
+     *
+     * Note that this is the rounding mode that statistically minimizes
+     * cumulative error when applied repeatedly over a sequence of calculations.
+     * It is sometimes known as "Banker's rounding", and is chiefly used in the USA.
+     */
+    public const HALF_EVEN = 9;
+}

vendor/composer/LICENSE

+
+Copyright (c) Nils Adermann, Jordi Boggiano
+
+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/composer/autoload_files.php

+<?php
+
+// autoload_files.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'a4a119a56e50fbb293281d9a48007e0e' => $vendorDir . '/symfony/polyfill-php80/bootstrap.php',
+    '6e3fae29631ef280660b3cdad06f25a8' => $vendorDir . '/symfony/deprecation-contracts/function.php',
+    '0e6d7bf4a5811bfa5cf40c5ccd6fae6a' => $vendorDir . '/symfony/polyfill-mbstring/bootstrap.php',
+    'e69f7f6ee287b969198c3c9d6777bd38' => $vendorDir . '/symfony/polyfill-intl-normalizer/bootstrap.php',
+    '25072dd6e2470089de65ae7bf11d3109' => $vendorDir . '/symfony/polyfill-php72/bootstrap.php',
+    'f598d06aa772fa33d905e87be6398fb1' => $vendorDir . '/symfony/polyfill-intl-idn/bootstrap.php',
+    '320cde22f66dd4f5d3fd621d3e88b98f' => $vendorDir . '/symfony/polyfill-ctype/bootstrap.php',
+    '0d59ee240a4cd96ddbb4ff164fccea4d' => $vendorDir . '/symfony/polyfill-php73/bootstrap.php',
+    '8825ede83f2f289127722d4e842cf7e8' => $vendorDir . '/symfony/polyfill-intl-grapheme/bootstrap.php',
+    'b6b991a57620e2fb6b2f66f03fe9ddc2' => $vendorDir . '/symfony/string/Resources/functions.php',
+    '667aeda72477189d0494fecd327c3641' => $vendorDir . '/symfony/var-dumper/Resources/functions/dump.php',
+    '7b11c4dc42b3b3023073cb14e519683c' => $vendorDir . '/ralouphie/getallheaders/src/getallheaders.php',
+    'def43f6c87e4f8dfd0c9e1b1bab14fe8' => $vendorDir . '/symfony/polyfill-iconv/bootstrap.php',
+    'c964ee0ededf28c96ebd9db5099ef910' => $vendorDir . '/guzzlehttp/promises/src/functions_include.php',
+    '2c102faa651ef8ea5874edb585946bce' => $vendorDir . '/swiftmailer/swiftmailer/lib/swift_required.php',
+    '37a3dc5111fe8f707ab4c132ef1dbc62' => $vendorDir . '/guzzlehttp/guzzle/src/functions_include.php',
+    '801c31d8ed748cfa537fa45402288c95' => $vendorDir . '/psy/psysh/src/functions.php',
+    'a1105708a18b76903365ca1c4aa61b02' => $vendorDir . '/symfony/translation/Resources/functions.php',
+    '538ca81a9a966a6716601ecf48f4eaef' => $vendorDir . '/opis/closure/functions.php',
+    'e39a8b23c42d4e1452234d762b03835a' => $vendorDir . '/ramsey/uuid/src/functions.php',
+    'f0906e6318348a765ffb6eb24e0d0938' => $vendorDir . '/laravel/framework/src/Illuminate/Foundation/helpers.php',
+    '58571171fd5812e6e447dce228f52f4d' => $vendorDir . '/laravel/framework/src/Illuminate/Support/helpers.php',
+    'b6ec61354e97f32c0ae683041c78392a' => $vendorDir . '/scrivo/highlight.php/HighlightUtilities/functions.php',
+    '9cdd7b9056abc3081735233ba9dd9c7f' => $vendorDir . '/facade/flare-client-php/src/helpers.php',
+    'ed962a97bd972bc82007176b647d4e36' => $vendorDir . '/facade/ignition/src/helpers.php',
+    '6124b4c8570aa390c21fafd04a26c69f' => $vendorDir . '/myclabs/deep-copy/src/DeepCopy/deep_copy.php',
+);

vendor/composer/autoload_namespaces.php

+<?php
+
+// autoload_namespaces.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'Mockery' => array($vendorDir . '/mockery/mockery/library'),
+    'Highlight\\' => array($vendorDir . '/scrivo/highlight.php'),
+    'HighlightUtilities\\' => array($vendorDir . '/scrivo/highlight.php'),
+);

vendor/composer/autoload_psr4.php

+<?php
+
+// autoload_psr4.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'voku\\' => array($vendorDir . '/voku/portable-ascii/src/voku'),
+    'Whoops\\' => array($vendorDir . '/filp/whoops/src/Whoops'),
+    'TijsVerkoyen\\CssToInlineStyles\\' => array($vendorDir . '/tijsverkoyen/css-to-inline-styles/src'),
+    'Tests\\' => array($baseDir . '/tests'),
+    'Symfony\\Polyfill\\Php80\\' => array($vendorDir . '/symfony/polyfill-php80'),
+    'Symfony\\Polyfill\\Php73\\' => array($vendorDir . '/symfony/polyfill-php73'),
+    'Symfony\\Polyfill\\Php72\\' => array($vendorDir . '/symfony/polyfill-php72'),
+    'Symfony\\Polyfill\\Mbstring\\' => array($vendorDir . '/symfony/polyfill-mbstring'),
+    'Symfony\\Polyfill\\Intl\\Normalizer\\' => array($vendorDir . '/symfony/polyfill-intl-normalizer'),
+    'Symfony\\Polyfill\\Intl\\Idn\\' => array($vendorDir . '/symfony/polyfill-intl-idn'),
+    'Symfony\\Polyfill\\Intl\\Grapheme\\' => array($vendorDir . '/symfony/polyfill-intl-grapheme'),
+    'Symfony\\Polyfill\\Iconv\\' => array($vendorDir . '/symfony/polyfill-iconv'),
+    'Symfony\\Polyfill\\Ctype\\' => array($vendorDir . '/symfony/polyfill-ctype'),
+    'Symfony\\Contracts\\Translation\\' => array($vendorDir . '/symfony/translation-contracts'),
+    'Symfony\\Contracts\\Service\\' => array($vendorDir . '/symfony/service-contracts'),
+    'Symfony\\Contracts\\EventDispatcher\\' => array($vendorDir . '/symfony/event-dispatcher-contracts'),
+    'Symfony\\Component\\VarDumper\\' => array($vendorDir . '/symfony/var-dumper'),
+    'Symfony\\Component\\Translation\\' => array($vendorDir . '/symfony/translation'),
+    'Symfony\\Component\\String\\' => array($vendorDir . '/symfony/string'),
+    'Symfony\\Component\\Routing\\' => array($vendorDir . '/symfony/routing'),
+    'Symfony\\Component\\Process\\' => array($vendorDir . '/symfony/process'),
+    'Symfony\\Component\\Mime\\' => array($vendorDir . '/symfony/mime'),
+    'Symfony\\Component\\HttpKernel\\' => array($vendorDir . '/symfony/http-kernel'),
+    'Symfony\\Component\\HttpFoundation\\' => array($vendorDir . '/symfony/http-foundation'),
+    'Symfony\\Component\\Finder\\' => array($vendorDir . '/symfony/finder'),
+    'Symfony\\Component\\EventDispatcher\\' => array($vendorDir . '/symfony/event-dispatcher'),
+    'Symfony\\Component\\ErrorHandler\\' => array($vendorDir . '/symfony/error-handler'),
+    'Symfony\\Component\\CssSelector\\' => array($vendorDir . '/symfony/css-selector'),
+    'Symfony\\Component\\Console\\' => array($vendorDir . '/symfony/console'),
+    'Ramsey\\Uuid\\' => array($vendorDir . '/ramsey/uuid/src'),
+    'Ramsey\\Collection\\' => array($vendorDir . '/ramsey/collection/src'),
+    'Psy\\' => array($vendorDir . '/psy/psysh/src'),
+    'Psr\\SimpleCache\\' => array($vendorDir . '/psr/simple-cache/src'),
+    'Psr\\Log\\' => array($vendorDir . '/psr/log/Psr/Log'),
+    'Psr\\Http\\Message\\' => array($vendorDir . '/psr/http-message/src', $vendorDir . '/psr/http-factory/src'),
+    'Psr\\Http\\Client\\' => array($vendorDir . '/psr/http-client/src'),
+    'Psr\\EventDispatcher\\' => array($vendorDir . '/psr/event-dispatcher/src'),
+    'Psr\\Container\\' => array($vendorDir . '/psr/container/src'),
+    'PhpParser\\' => array($vendorDir . '/nikic/php-parser/lib/PhpParser'),
+    'PhpOption\\' => array($vendorDir . '/phpoption/phpoption/src/PhpOption'),
+    'Opis\\Closure\\' => array($vendorDir . '/opis/closure/src'),
+    'NunoMaduro\\Collision\\' => array($vendorDir . '/nunomaduro/collision/src'),
+    'Monolog\\' => array($vendorDir . '/monolog/monolog/src/Monolog'),
+    'League\\MimeTypeDetection\\' => array($vendorDir . '/league/mime-type-detection/src'),
+    'League\\Flysystem\\' => array($vendorDir . '/league/flysystem/src'),
+    'League\\CommonMark\\' => array($vendorDir . '/league/commonmark/src'),
+    'Laravel\\Tinker\\' => array($vendorDir . '/laravel/tinker/src'),
+    'Illuminate\\' => array($vendorDir . '/laravel/framework/src/Illuminate'),
+    'GuzzleHttp\\Psr7\\' => array($vendorDir . '/guzzlehttp/psr7/src'),
+    'GuzzleHttp\\Promise\\' => array($vendorDir . '/guzzlehttp/promises/src'),
+    'GuzzleHttp\\' => array($vendorDir . '/guzzlehttp/guzzle/src'),
+    'Fruitcake\\Cors\\' => array($vendorDir . '/fruitcake/laravel-cors/src'),
+    'Fideloper\\Proxy\\' => array($vendorDir . '/fideloper/proxy/src'),
+    'Faker\\' => array($vendorDir . '/fakerphp/faker/src/Faker'),
+    'Facade\\Ignition\\' => array($vendorDir . '/facade/ignition/src'),
+    'Facade\\IgnitionContracts\\' => array($vendorDir . '/facade/ignition-contracts/src'),
+    'Facade\\FlareClient\\' => array($vendorDir . '/facade/flare-client-php/src'),
+    'Egulias\\EmailValidator\\' => array($vendorDir . '/egulias/email-validator/src'),
+    'Dotenv\\' => array($vendorDir . '/vlucas/phpdotenv/src'),
+    'Doctrine\\Instantiator\\' => array($vendorDir . '/doctrine/instantiator/src/Doctrine/Instantiator'),
+    'Doctrine\\Inflector\\' => array($vendorDir . '/doctrine/inflector/lib/Doctrine/Inflector'),
+    'Doctrine\\Common\\Lexer\\' => array($vendorDir . '/doctrine/lexer/lib/Doctrine/Common/Lexer'),
+    'DeepCopy\\' => array($vendorDir . '/myclabs/deep-copy/src/DeepCopy'),
+    'Cron\\' => array($vendorDir . '/dragonmantank/cron-expression/src/Cron'),
+    'Carbon\\' => array($vendorDir . '/nesbot/carbon/src/Carbon'),
+    'Brick\\Math\\' => array($vendorDir . '/brick/math/src'),
+    'Asm89\\Stack\\' => array($vendorDir . '/asm89/stack-cors/src'),
+    'App\\' => array($baseDir . '/app'),
+);

vendor/composer/autoload_real.php

+<?php
+
+// autoload_real.php @generated by Composer
+
+class ComposerAutoloaderInit98d517a41e74f308f2c33f0bb882c41a
+{
+    private static $loader;
+
+    public static function loadClassLoader($class)
+    {
+        if ('Composer\Autoload\ClassLoader' === $class) {
+            require __DIR__ . '/ClassLoader.php';
+        }
+    }
+
+    /**
+     * @return \Composer\Autoload\ClassLoader
+     */
+    public static function getLoader()
+    {
+        if (null !== self::$loader) {
+            return self::$loader;
+        }
+
+        require __DIR__ . '/platform_check.php';
+
+        spl_autoload_register(array('ComposerAutoloaderInit98d517a41e74f308f2c33f0bb882c41a', 'loadClassLoader'), true, true);
+        self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(\dirname(__FILE__)));
+        spl_autoload_unregister(array('ComposerAutoloaderInit98d517a41e74f308f2c33f0bb882c41a', 'loadClassLoader'));
+
+        $useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
+        if ($useStaticLoader) {
+            require __DIR__ . '/autoload_static.php';
+
+            call_user_func(\Composer\Autoload\ComposerStaticInit98d517a41e74f308f2c33f0bb882c41a::getInitializer($loader));
+        } else {
+            $map = require __DIR__ . '/autoload_namespaces.php';
+            foreach ($map as $namespace => $path) {
+                $loader->set($namespace, $path);
+            }
+
+            $map = require __DIR__ . '/autoload_psr4.php';
+            foreach ($map as $namespace => $path) {
+                $loader->setPsr4($namespace, $path);
+            }
+
+            $classMap = require __DIR__ . '/autoload_classmap.php';
+            if ($classMap) {
+                $loader->addClassMap($classMap);
+            }
+        }
+
+        $loader->register(true);
+
+        if ($useStaticLoader) {
+            $includeFiles = Composer\Autoload\ComposerStaticInit98d517a41e74f308f2c33f0bb882c41a::$files;
+        } else {
+            $includeFiles = require __DIR__ . '/autoload_files.php';
+        }
+        foreach ($includeFiles as $fileIdentifier => $file) {
+            composerRequire98d517a41e74f308f2c33f0bb882c41a($fileIdentifier, $file);
+        }
+
+        return $loader;
+    }
+}
+
+function composerRequire98d517a41e74f308f2c33f0bb882c41a($fileIdentifier, $file)
+{
+    if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
+        require $file;
+
+        $GLOBALS['__composer_autoload_files'][$fileIdentifier] = true;
+    }
+}

vendor/composer/platform_check.php

+<?php
+
+// platform_check.php @generated by Composer
+
+$issues = array();
+
+if (!(PHP_VERSION_ID >= 70205)) {
+    $issues[] = 'Your Composer dependencies require a PHP version ">= 7.2.5". You are running ' . PHP_VERSION . '.';
+}
+
+if ($issues) {
+    if (!headers_sent()) {
+        header('HTTP/1.1 500 Internal Server Error');
+    }
+    if (!ini_get('display_errors')) {
+        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
+            fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL);
+        } elseif (!headers_sent()) {
+            echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL;
+        }
+    }
+    trigger_error(
+        'Composer detected issues in your platform: ' . implode(' ', $issues),
+        E_USER_ERROR
+    );
+}

vendor/doctrine/inflector/LICENSE

+Copyright (c) 2006-2015 Doctrine Project
+
+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/doctrine/inflector/README.md

+# Doctrine Inflector
+
+Doctrine Inflector is a small library that can perform string manipulations
+with regard to uppercase/lowercase and singular/plural forms of words.
+
+[![Build Status](https://github.com/doctrine/inflector/workflows/Continuous%20Integration/badge.svg)](https://github.com/doctrine/inflector/actions?query=workflow%3A%22Continuous+Integration%22+branch%3A4.0.x)
+[![Code Coverage](https://codecov.io/gh/doctrine/inflector/branch/2.0.x/graph/badge.svg)](https://codecov.io/gh/doctrine/inflector/branch/2.0.x)

vendor/doctrine/inflector/composer.json

+{
+    "name": "doctrine/inflector",
+    "type": "library",
+    "description": "PHP Doctrine Inflector is a small library that can perform string manipulations with regard to upper/lowercase and singular/plural forms of words.",
+    "keywords": ["php", "strings", "words", "manipulation", "inflector", "inflection", "uppercase", "lowercase", "singular", "plural"],
+    "homepage": "https://www.doctrine-project.org/projects/inflector.html",
+    "license": "MIT",
+    "authors": [
+        {"name": "Guilherme Blanco", "email": "guilhermeblanco@gmail.com"},
+        {"name": "Roman Borschel", "email": "roman@code-factory.org"},
+        {"name": "Benjamin Eberlei", "email": "kontakt@beberlei.de"},
+        {"name": "Jonathan Wage", "email": "jonwage@gmail.com"},
+        {"name": "Johannes Schmitt", "email": "schmittjoh@gmail.com"}
+    ],
+    "require": {
+        "php": "^7.2 || ^8.0"
+    },
+    "require-dev": {
+        "doctrine/coding-standard": "^8.2",
+        "phpstan/phpstan": "^0.12",
+        "phpstan/phpstan-phpunit": "^0.12",
+        "phpstan/phpstan-strict-rules": "^0.12",
+        "phpunit/phpunit": "^7.0 || ^8.0 || ^9.0",
+        "vimeo/psalm": "^4.10"
+    },
+    "autoload": {
+        "psr-4": {
+            "Doctrine\\Inflector\\": "lib/Doctrine/Inflector"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Doctrine\\Tests\\Inflector\\": "tests/Doctrine/Tests/Inflector"
+        }
+    }
+}

vendor/doctrine/inflector/docs/en/index.rst

+Introduction
+============
+
+The Doctrine Inflector has methods for inflecting text. The features include pluralization,
+singularization, converting between camelCase and under_score and capitalizing
+words.
+
+Installation
+============
+
+You can install the Inflector with composer:
+
+.. code-block:: console
+
+    $ composer require doctrine/inflector
+
+Usage
+=====
+
+Using the inflector is easy, you can create a new ``Doctrine\Inflector\Inflector`` instance by using
+the ``Doctrine\Inflector\InflectorFactory`` class:
+
+.. code-block:: php
+
+    use Doctrine\Inflector\InflectorFactory;
+
+    $inflector = InflectorFactory::create()->build();
+
+By default it will create an English inflector. If you want to use another language, just pass the language
+you want to create an inflector for to the ``createForLanguage()`` method:
+
+.. code-block:: php
+
+    use Doctrine\Inflector\InflectorFactory;
+    use Doctrine\Inflector\Language;
+
+    $inflector = InflectorFactory::createForLanguage(Language::SPANISH)->build();
+
+The supported languages are as follows:
+
+- ``Language::ENGLISH``
+- ``Language::FRENCH``
+- ``Language::NORWEGIAN_BOKMAL``
+- ``Language::PORTUGUESE``
+- ``Language::SPANISH``
+- ``Language::TURKISH``
+
+If you want to manually construct the inflector instead of using a factory, you can do so like this:
+
+.. code-block:: php
+
+    use Doctrine\Inflector\CachedWordInflector;
+    use Doctrine\Inflector\RulesetInflector;
+    use Doctrine\Inflector\Rules\English;
+
+    $inflector = new Inflector(
+        new CachedWordInflector(new RulesetInflector(
+            English\Rules::getSingularRuleset()
+        )),
+        new CachedWordInflector(new RulesetInflector(
+            English\Rules::getPluralRuleset()
+        ))
+    );
+
+Adding Languages
+----------------
+
+If you are interested in adding support for your language, take a look at the other languages defined in the
+``Doctrine\Inflector\Rules`` namespace and the tests located in ``Doctrine\Tests\Inflector\Rules``. You can copy
+one of the languages and update the rules for your language.
+
+Once you have done this, send a pull request to the ``doctrine/inflector`` repository with the additions.
+
+Custom Setup
+============
+
+If you want to setup custom singular and plural rules, you can configure these in the factory:
+
+.. code-block:: php
+
+    use Doctrine\Inflector\InflectorFactory;
+    use Doctrine\Inflector\Rules\Pattern;
+    use Doctrine\Inflector\Rules\Patterns;
+    use Doctrine\Inflector\Rules\Ruleset;
+    use Doctrine\Inflector\Rules\Substitution;
+    use Doctrine\Inflector\Rules\Substitutions;
+    use Doctrine\Inflector\Rules\Transformation;
+    use Doctrine\Inflector\Rules\Transformations;
+    use Doctrine\Inflector\Rules\Word;
+
+    $inflector = InflectorFactory::create()
+        ->withSingularRules(
+            new Ruleset(
+                new Transformations(
+                    new Transformation(new Pattern('/^(bil)er$/i'), '\1'),
+                    new Transformation(new Pattern('/^(inflec|contribu)tors$/i'), '\1ta')
+                ),
+                new Patterns(new Pattern('singulars')),
+                new Substitutions(new Substitution(new Word('spins'), new Word('spinor')))
+            )
+        )
+        ->withPluralRules(
+            new Ruleset(
+                new Transformations(
+                    new Transformation(new Pattern('^(bil)er$'), '\1'),
+                    new Transformation(new Pattern('^(inflec|contribu)tors$'), '\1ta')
+                ),
+                new Patterns(new Pattern('noflect'), new Pattern('abtuse')),
+                new Substitutions(
+                    new Substitution(new Word('amaze'), new Word('amazable')),
+                    new Substitution(new Word('phone'), new Word('phonezes'))
+                )
+            )
+        )
+        ->build();
+
+No operation inflector
+----------------------
+
+The ``Doctrine\Inflector\NoopWordInflector`` may be used to configure an inflector that doesn't perform any operation for
+pluralization and/or singularization. If will simply return the input as output.
+
+This is an implementation of the `Null Object design pattern <https://sourcemaking.com/design_patterns/null_object>`_.
+
+.. code-block:: php
+
+    use Doctrine\Inflector\Inflector;
+    use Doctrine\Inflector\NoopWordInflector;
+
+    $inflector = new Inflector(new NoopWordInflector(), new NoopWordInflector());
+
+Tableize
+========
+
+Converts ``ModelName`` to ``model_name``:
+
+.. code-block:: php
+
+    echo $inflector->tableize('ModelName'); // model_name
+
+Classify
+========
+
+Converts ``model_name`` to ``ModelName``:
+
+.. code-block:: php
+
+    echo $inflector->classify('model_name'); // ModelName
+
+Camelize
+========
+
+This method uses `Classify`_ and then converts the first character to lowercase:
+
+.. code-block:: php
+
+    echo $inflector->camelize('model_name'); // modelName
+
+Capitalize
+==========
+
+Takes a string and capitalizes all of the words, like PHP's built-in
+``ucwords`` function. This extends that behavior, however, by allowing the
+word delimiters to be configured, rather than only separating on
+whitespace.
+
+Here is an example:
+
+.. code-block:: php
+
+    $string = 'top-o-the-morning to all_of_you!';
+
+    echo $inflector->capitalize($string); // Top-O-The-Morning To All_of_you!
+
+    echo $inflector->capitalize($string, '-_ '); // Top-O-The-Morning To All_Of_You!
+
+Pluralize
+=========
+
+Returns a word in plural form.
+
+.. code-block:: php
+
+    echo $inflector->pluralize('browser'); // browsers
+
+Singularize
+===========
+
+Returns a word in singular form.
+
+.. code-block:: php
+
+    echo $inflector->singularize('browsers'); // browser
+
+Urlize
+======
+
+Generate a URL friendly string from a string of text:
+
+.. code-block:: php
+
+    echo $inflector->urlize('My first blog post'); // my-first-blog-post
+
+Unaccent
+========
+
+You can unaccent a string of text using the ``unaccent()`` method:
+
+.. code-block:: php
+
+    echo $inflector->unaccent('año'); // ano
+
+Legacy API
+==========
+
+The API present in Inflector 1.x is still available, but will be deprecated in a future release and dropped for 3.0.
+Support for languages other than English is available in the 2.0 API only.
+
+Acknowledgements
+================
+
+The language rules in this library have been adapted from several different sources, including but not limited to:
+
+- `Ruby On Rails Inflector <http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html>`_
+- `ICanBoogie Inflector <https://github.com/ICanBoogie/Inflector>`_
+- `CakePHP Inflector <https://book.cakephp.org/3.0/en/core-libraries/inflector.html>`_

vendor/doctrine/inflector/lib/Doctrine/Inflector/CachedWordInflector.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector;
+
+class CachedWordInflector implements WordInflector
+{
+    /** @var WordInflector */
+    private $wordInflector;
+
+    /** @var string[] */
+    private $cache = [];
+
+    public function __construct(WordInflector $wordInflector)
+    {
+        $this->wordInflector = $wordInflector;
+    }
+
+    public function inflect(string $word): string
+    {
+        return $this->cache[$word] ?? $this->cache[$word] = $this->wordInflector->inflect($word);
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/GenericLanguageInflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector;
+
+use Doctrine\Inflector\Rules\Ruleset;
+
+use function array_unshift;
+
+abstract class GenericLanguageInflectorFactory implements LanguageInflectorFactory
+{
+    /** @var Ruleset[] */
+    private $singularRulesets = [];
+
+    /** @var Ruleset[] */
+    private $pluralRulesets = [];
+
+    final public function __construct()
+    {
+        $this->singularRulesets[] = $this->getSingularRuleset();
+        $this->pluralRulesets[]   = $this->getPluralRuleset();
+    }
+
+    final public function build(): Inflector
+    {
+        return new Inflector(
+            new CachedWordInflector(new RulesetInflector(
+                ...$this->singularRulesets
+            )),
+            new CachedWordInflector(new RulesetInflector(
+                ...$this->pluralRulesets
+            ))
+        );
+    }
+
+    final public function withSingularRules(?Ruleset $singularRules, bool $reset = false): LanguageInflectorFactory
+    {
+        if ($reset) {
+            $this->singularRulesets = [];
+        }
+
+        if ($singularRules instanceof Ruleset) {
+            array_unshift($this->singularRulesets, $singularRules);
+        }
+
+        return $this;
+    }
+
+    final public function withPluralRules(?Ruleset $pluralRules, bool $reset = false): LanguageInflectorFactory
+    {
+        if ($reset) {
+            $this->pluralRulesets = [];
+        }
+
+        if ($pluralRules instanceof Ruleset) {
+            array_unshift($this->pluralRulesets, $pluralRules);
+        }
+
+        return $this;
+    }
+
+    abstract protected function getSingularRuleset(): Ruleset;
+
+    abstract protected function getPluralRuleset(): Ruleset;
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/InflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector;
+
+use Doctrine\Inflector\Rules\English;
+use Doctrine\Inflector\Rules\French;
+use Doctrine\Inflector\Rules\NorwegianBokmal;
+use Doctrine\Inflector\Rules\Portuguese;
+use Doctrine\Inflector\Rules\Spanish;
+use Doctrine\Inflector\Rules\Turkish;
+use InvalidArgumentException;
+
+use function sprintf;
+
+final class InflectorFactory
+{
+    public static function create(): LanguageInflectorFactory
+    {
+        return self::createForLanguage(Language::ENGLISH);
+    }
+
+    public static function createForLanguage(string $language): LanguageInflectorFactory
+    {
+        switch ($language) {
+            case Language::ENGLISH:
+                return new English\InflectorFactory();
+
+            case Language::FRENCH:
+                return new French\InflectorFactory();
+
+            case Language::NORWEGIAN_BOKMAL:
+                return new NorwegianBokmal\InflectorFactory();
+
+            case Language::PORTUGUESE:
+                return new Portuguese\InflectorFactory();
+
+            case Language::SPANISH:
+                return new Spanish\InflectorFactory();
+
+            case Language::TURKISH:
+                return new Turkish\InflectorFactory();
+
+            default:
+                throw new InvalidArgumentException(sprintf(
+                    'Language "%s" is not supported.',
+                    $language
+                ));
+        }
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Language.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector;
+
+final class Language
+{
+    public const ENGLISH          = 'english';
+    public const FRENCH           = 'french';
+    public const NORWEGIAN_BOKMAL = 'norwegian-bokmal';
+    public const PORTUGUESE       = 'portuguese';
+    public const SPANISH          = 'spanish';
+    public const TURKISH          = 'turkish';
+
+    private function __construct()
+    {
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/LanguageInflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector;
+
+use Doctrine\Inflector\Rules\Ruleset;
+
+interface LanguageInflectorFactory
+{
+    /**
+     * Applies custom rules for singularisation
+     *
+     * @param bool $reset If true, will unset default inflections for all new rules
+     *
+     * @return $this
+     */
+    public function withSingularRules(?Ruleset $singularRules, bool $reset = false): self;
+
+    /**
+     * Applies custom rules for pluralisation
+     *
+     * @param bool $reset If true, will unset default inflections for all new rules
+     *
+     * @return $this
+     */
+    public function withPluralRules(?Ruleset $pluralRules, bool $reset = false): self;
+
+    /**
+     * Builds the inflector instance with all applicable rules
+     */
+    public function build(): Inflector;
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/NoopWordInflector.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector;
+
+class NoopWordInflector implements WordInflector
+{
+    public function inflect(string $word): string
+    {
+        return $word;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/English/InflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\English;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/English/Rules.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\English;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/English/Uninflected.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\English;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /**
+     * @return Pattern[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+
+        yield new Pattern('.*ss');
+        yield new Pattern('clothes');
+        yield new Pattern('data');
+        yield new Pattern('fascia');
+        yield new Pattern('fuchsia');
+        yield new Pattern('galleria');
+        yield new Pattern('mafia');
+        yield new Pattern('militia');
+        yield new Pattern('pants');
+        yield new Pattern('petunia');
+        yield new Pattern('sepia');
+        yield new Pattern('trivia');
+        yield new Pattern('utopia');
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+
+        yield new Pattern('people');
+        yield new Pattern('trivia');
+        yield new Pattern('\w+ware$');
+        yield new Pattern('media');
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('\w+media');
+        yield new Pattern('advice');
+        yield new Pattern('aircraft');
+        yield new Pattern('amoyese');
+        yield new Pattern('art');
+        yield new Pattern('audio');
+        yield new Pattern('baggage');
+        yield new Pattern('bison');
+        yield new Pattern('borghese');
+        yield new Pattern('bream');
+        yield new Pattern('breeches');
+        yield new Pattern('britches');
+        yield new Pattern('buffalo');
+        yield new Pattern('butter');
+        yield new Pattern('cantus');
+        yield new Pattern('carp');
+        yield new Pattern('chassis');
+        yield new Pattern('clippers');
+        yield new Pattern('clothing');
+        yield new Pattern('coal');
+        yield new Pattern('cod');
+        yield new Pattern('coitus');
+        yield new Pattern('compensation');
+        yield new Pattern('congoese');
+        yield new Pattern('contretemps');
+        yield new Pattern('coreopsis');
+        yield new Pattern('corps');
+        yield new Pattern('cotton');
+        yield new Pattern('data');
+        yield new Pattern('debris');
+        yield new Pattern('deer');
+        yield new Pattern('diabetes');
+        yield new Pattern('djinn');
+        yield new Pattern('education');
+        yield new Pattern('eland');
+        yield new Pattern('elk');
+        yield new Pattern('emoji');
+        yield new Pattern('equipment');
+        yield new Pattern('evidence');
+        yield new Pattern('faroese');
+        yield new Pattern('feedback');
+        yield new Pattern('fish');
+        yield new Pattern('flounder');
+        yield new Pattern('flour');
+        yield new Pattern('foochowese');
+        yield new Pattern('food');
+        yield new Pattern('furniture');
+        yield new Pattern('gallows');
+        yield new Pattern('genevese');
+        yield new Pattern('genoese');
+        yield new Pattern('gilbertese');
+        yield new Pattern('gold');
+        yield new Pattern('headquarters');
+        yield new Pattern('herpes');
+        yield new Pattern('hijinks');
+        yield new Pattern('homework');
+        yield new Pattern('hottentotese');
+        yield new Pattern('impatience');
+        yield new Pattern('information');
+        yield new Pattern('innings');
+        yield new Pattern('jackanapes');
+        yield new Pattern('jeans');
+        yield new Pattern('jedi');
+        yield new Pattern('kiplingese');
+        yield new Pattern('knowledge');
+        yield new Pattern('kongoese');
+        yield new Pattern('leather');
+        yield new Pattern('love');
+        yield new Pattern('lucchese');
+        yield new Pattern('luggage');
+        yield new Pattern('mackerel');
+        yield new Pattern('Maltese');
+        yield new Pattern('management');
+        yield new Pattern('metadata');
+        yield new Pattern('mews');
+        yield new Pattern('money');
+        yield new Pattern('moose');
+        yield new Pattern('mumps');
+        yield new Pattern('music');
+        yield new Pattern('nankingese');
+        yield new Pattern('news');
+        yield new Pattern('nexus');
+        yield new Pattern('niasese');
+        yield new Pattern('nutrition');
+        yield new Pattern('offspring');
+        yield new Pattern('oil');
+        yield new Pattern('patience');
+        yield new Pattern('pekingese');
+        yield new Pattern('piedmontese');
+        yield new Pattern('pincers');
+        yield new Pattern('pistoiese');
+        yield new Pattern('plankton');
+        yield new Pattern('pliers');
+        yield new Pattern('pokemon');
+        yield new Pattern('police');
+        yield new Pattern('polish');
+        yield new Pattern('portuguese');
+        yield new Pattern('proceedings');
+        yield new Pattern('progress');
+        yield new Pattern('rabies');
+        yield new Pattern('rain');
+        yield new Pattern('research');
+        yield new Pattern('rhinoceros');
+        yield new Pattern('rice');
+        yield new Pattern('salmon');
+        yield new Pattern('sand');
+        yield new Pattern('sarawakese');
+        yield new Pattern('scissors');
+        yield new Pattern('sea[- ]bass');
+        yield new Pattern('series');
+        yield new Pattern('shavese');
+        yield new Pattern('shears');
+        yield new Pattern('sheep');
+        yield new Pattern('siemens');
+        yield new Pattern('silk');
+        yield new Pattern('sms');
+        yield new Pattern('soap');
+        yield new Pattern('social media');
+        yield new Pattern('spam');
+        yield new Pattern('species');
+        yield new Pattern('staff');
+        yield new Pattern('sugar');
+        yield new Pattern('swine');
+        yield new Pattern('talent');
+        yield new Pattern('toothpaste');
+        yield new Pattern('traffic');
+        yield new Pattern('travel');
+        yield new Pattern('trousers');
+        yield new Pattern('trout');
+        yield new Pattern('tuna');
+        yield new Pattern('us');
+        yield new Pattern('vermontese');
+        yield new Pattern('vinegar');
+        yield new Pattern('weather');
+        yield new Pattern('wenchowese');
+        yield new Pattern('wheat');
+        yield new Pattern('whiting');
+        yield new Pattern('wildebeest');
+        yield new Pattern('wood');
+        yield new Pattern('wool');
+        yield new Pattern('yengeese');
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/French/Inflectible.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\French;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /**
+     * @return Transformation[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/(b|cor|ém|gemm|soupir|trav|vant|vitr)aux$/'), '\1ail');
+        yield new Transformation(new Pattern('/ails$/'), 'ail');
+        yield new Transformation(new Pattern('/(journ|chev)aux$/'), '\1al');
+        yield new Transformation(new Pattern('/(bijou|caillou|chou|genou|hibou|joujou|pou|au|eu|eau)x$/'), '\1');
+        yield new Transformation(new Pattern('/s$/'), '');
+    }
+
+    /**
+     * @return Transformation[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/(s|x|z)$/'), '\1');
+        yield new Transformation(new Pattern('/(b|cor|ém|gemm|soupir|trav|vant|vitr)ail$/'), '\1aux');
+        yield new Transformation(new Pattern('/ail$/'), 'ails');
+        yield new Transformation(new Pattern('/(chacal|carnaval|festival|récital)$/'), '\1s');
+        yield new Transformation(new Pattern('/al$/'), 'aux');
+        yield new Transformation(new Pattern('/(bleu|émeu|landau|pneu|sarrau)$/'), '\1s');
+        yield new Transformation(new Pattern('/(bijou|caillou|chou|genou|hibou|joujou|lieu|pou|au|eu|eau)$/'), '\1x');
+        yield new Transformation(new Pattern('/$/'), 's');
+    }
+
+    /**
+     * @return Substitution[]
+     */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('monsieur'), new Word('messieurs'));
+        yield new Substitution(new Word('madame'), new Word('mesdames'));
+        yield new Substitution(new Word('mademoiselle'), new Word('mesdemoiselles'));
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/French/InflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\French;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/French/Rules.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\French;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/French/Uninflected.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\French;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /**
+     * @return Pattern[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('');
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Inflectible.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\NorwegianBokmal;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /**
+     * @return Transformation[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/re$/i'), 'r');
+        yield new Transformation(new Pattern('/er$/i'), '');
+    }
+
+    /**
+     * @return Transformation[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/e$/i'), 'er');
+        yield new Transformation(new Pattern('/r$/i'), 're');
+        yield new Transformation(new Pattern('/$/'), 'er');
+    }
+
+    /**
+     * @return Substitution[]
+     */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('konto'), new Word('konti'));
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/NorwegianBokmal/InflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\NorwegianBokmal;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Rules.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\NorwegianBokmal;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/NorwegianBokmal/Uninflected.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\NorwegianBokmal;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /**
+     * @return Pattern[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('barn');
+        yield new Pattern('fjell');
+        yield new Pattern('hus');
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Pattern.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use function preg_match;
+
+final class Pattern
+{
+    /** @var string */
+    private $pattern;
+
+    /** @var string */
+    private $regex;
+
+    public function __construct(string $pattern)
+    {
+        $this->pattern = $pattern;
+
+        if (isset($this->pattern[0]) && $this->pattern[0] === '/') {
+            $this->regex = $this->pattern;
+        } else {
+            $this->regex = '/' . $this->pattern . '/i';
+        }
+    }
+
+    public function getPattern(): string
+    {
+        return $this->pattern;
+    }
+
+    public function getRegex(): string
+    {
+        return $this->regex;
+    }
+
+    public function matches(string $word): bool
+    {
+        return preg_match($this->getRegex(), $word) === 1;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Patterns.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use function array_map;
+use function implode;
+use function preg_match;
+
+class Patterns
+{
+    /** @var Pattern[] */
+    private $patterns;
+
+    /** @var string */
+    private $regex;
+
+    public function __construct(Pattern ...$patterns)
+    {
+        $this->patterns = $patterns;
+
+        $patterns = array_map(static function (Pattern $pattern): string {
+            return $pattern->getPattern();
+        }, $this->patterns);
+
+        $this->regex = '/^(?:' . implode('|', $patterns) . ')$/i';
+    }
+
+    public function matches(string $word): bool
+    {
+        return preg_match($this->regex, $word, $regs) === 1;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Portuguese/Inflectible.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Portuguese;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /**
+     * @return Transformation[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/^(g|)ases$/i'), '\1ás');
+        yield new Transformation(new Pattern('/(japon|escoc|ingl|dinamarqu|fregu|portugu)eses$/i'), '\1ês');
+        yield new Transformation(new Pattern('/(ae|ao|oe)s$/'), 'ao');
+        yield new Transformation(new Pattern('/(ãe|ão|õe)s$/'), 'ão');
+        yield new Transformation(new Pattern('/^(.*[^s]s)es$/i'), '\1');
+        yield new Transformation(new Pattern('/sses$/i'), 'sse');
+        yield new Transformation(new Pattern('/ns$/i'), 'm');
+        yield new Transformation(new Pattern('/(r|t|f|v)is$/i'), '\1il');
+        yield new Transformation(new Pattern('/uis$/i'), 'ul');
+        yield new Transformation(new Pattern('/ois$/i'), 'ol');
+        yield new Transformation(new Pattern('/eis$/i'), 'ei');
+        yield new Transformation(new Pattern('/éis$/i'), 'el');
+        yield new Transformation(new Pattern('/([^p])ais$/i'), '\1al');
+        yield new Transformation(new Pattern('/(r|z)es$/i'), '\1');
+        yield new Transformation(new Pattern('/^(á|gá)s$/i'), '\1s');
+        yield new Transformation(new Pattern('/([^ê])s$/i'), '\1');
+    }
+
+    /**
+     * @return Transformation[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/^(alem|c|p)ao$/i'), '\1aes');
+        yield new Transformation(new Pattern('/^(irm|m)ao$/i'), '\1aos');
+        yield new Transformation(new Pattern('/ao$/i'), 'oes');
+        yield new Transformation(new Pattern('/^(alem|c|p)ão$/i'), '\1ães');
+        yield new Transformation(new Pattern('/^(irm|m)ão$/i'), '\1ãos');
+        yield new Transformation(new Pattern('/ão$/i'), 'ões');
+        yield new Transformation(new Pattern('/^(|g)ás$/i'), '\1ases');
+        yield new Transformation(new Pattern('/^(japon|escoc|ingl|dinamarqu|fregu|portugu)ês$/i'), '\1eses');
+        yield new Transformation(new Pattern('/m$/i'), 'ns');
+        yield new Transformation(new Pattern('/([^aeou])il$/i'), '\1is');
+        yield new Transformation(new Pattern('/ul$/i'), 'uis');
+        yield new Transformation(new Pattern('/ol$/i'), 'ois');
+        yield new Transformation(new Pattern('/el$/i'), 'eis');
+        yield new Transformation(new Pattern('/al$/i'), 'ais');
+        yield new Transformation(new Pattern('/(z|r)$/i'), '\1es');
+        yield new Transformation(new Pattern('/(s)$/i'), '\1');
+        yield new Transformation(new Pattern('/$/'), 's');
+    }
+
+    /**
+     * @return Substitution[]
+     */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('abdomen'), new Word('abdomens'));
+        yield new Substitution(new Word('alemão'), new Word('alemães'));
+        yield new Substitution(new Word('artesã'), new Word('artesãos'));
+        yield new Substitution(new Word('álcool'), new Word('álcoois'));
+        yield new Substitution(new Word('árvore'), new Word('árvores'));
+        yield new Substitution(new Word('bencão'), new Word('bencãos'));
+        yield new Substitution(new Word('cão'), new Word('cães'));
+        yield new Substitution(new Word('campus'), new Word('campi'));
+        yield new Substitution(new Word('cadáver'), new Word('cadáveres'));
+        yield new Substitution(new Word('capelão'), new Word('capelães'));
+        yield new Substitution(new Word('capitão'), new Word('capitães'));
+        yield new Substitution(new Word('chão'), new Word('chãos'));
+        yield new Substitution(new Word('charlatão'), new Word('charlatães'));
+        yield new Substitution(new Word('cidadão'), new Word('cidadãos'));
+        yield new Substitution(new Word('consul'), new Word('consules'));
+        yield new Substitution(new Word('cristão'), new Word('cristãos'));
+        yield new Substitution(new Word('difícil'), new Word('difíceis'));
+        yield new Substitution(new Word('email'), new Word('emails'));
+        yield new Substitution(new Word('escrivão'), new Word('escrivães'));
+        yield new Substitution(new Word('fóssil'), new Word('fósseis'));
+        yield new Substitution(new Word('gás'), new Word('gases'));
+        yield new Substitution(new Word('germens'), new Word('germen'));
+        yield new Substitution(new Word('grão'), new Word('grãos'));
+        yield new Substitution(new Word('hífen'), new Word('hífens'));
+        yield new Substitution(new Word('irmão'), new Word('irmãos'));
+        yield new Substitution(new Word('liquens'), new Word('liquen'));
+        yield new Substitution(new Word('mal'), new Word('males'));
+        yield new Substitution(new Word('mão'), new Word('mãos'));
+        yield new Substitution(new Word('orfão'), new Word('orfãos'));
+        yield new Substitution(new Word('país'), new Word('países'));
+        yield new Substitution(new Word('pai'), new Word('pais'));
+        yield new Substitution(new Word('pão'), new Word('pães'));
+        yield new Substitution(new Word('projétil'), new Word('projéteis'));
+        yield new Substitution(new Word('réptil'), new Word('répteis'));
+        yield new Substitution(new Word('sacristão'), new Word('sacristães'));
+        yield new Substitution(new Word('sotão'), new Word('sotãos'));
+        yield new Substitution(new Word('tabelião'), new Word('tabeliães'));
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Portuguese/InflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Portuguese;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Portuguese/Rules.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Portuguese;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Portuguese/Uninflected.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Portuguese;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /**
+     * @return Pattern[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('tórax');
+        yield new Pattern('tênis');
+        yield new Pattern('ônibus');
+        yield new Pattern('lápis');
+        yield new Pattern('fênix');
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Ruleset.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+class Ruleset
+{
+    /** @var Transformations */
+    private $regular;
+
+    /** @var Patterns */
+    private $uninflected;
+
+    /** @var Substitutions */
+    private $irregular;
+
+    public function __construct(Transformations $regular, Patterns $uninflected, Substitutions $irregular)
+    {
+        $this->regular     = $regular;
+        $this->uninflected = $uninflected;
+        $this->irregular   = $irregular;
+    }
+
+    public function getRegular(): Transformations
+    {
+        return $this->regular;
+    }
+
+    public function getUninflected(): Patterns
+    {
+        return $this->uninflected;
+    }
+
+    public function getIrregular(): Substitutions
+    {
+        return $this->irregular;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Spanish/Inflectible.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Spanish;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /**
+     * @return Transformation[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/ereses$/'), 'erés');
+        yield new Transformation(new Pattern('/iones$/'), 'ión');
+        yield new Transformation(new Pattern('/ces$/'), 'z');
+        yield new Transformation(new Pattern('/es$/'), '');
+        yield new Transformation(new Pattern('/s$/'), '');
+    }
+
+    /**
+     * @return Transformation[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/ú([sn])$/i'), 'u\1es');
+        yield new Transformation(new Pattern('/ó([sn])$/i'), 'o\1es');
+        yield new Transformation(new Pattern('/í([sn])$/i'), 'i\1es');
+        yield new Transformation(new Pattern('/é([sn])$/i'), 'e\1es');
+        yield new Transformation(new Pattern('/á([sn])$/i'), 'a\1es');
+        yield new Transformation(new Pattern('/z$/i'), 'ces');
+        yield new Transformation(new Pattern('/([aeiou]s)$/i'), '\1');
+        yield new Transformation(new Pattern('/([^aeéiou])$/i'), '\1es');
+        yield new Transformation(new Pattern('/$/'), 's');
+    }
+
+    /**
+     * @return Substitution[]
+     */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('el'), new Word('los'));
+        yield new Substitution(new Word('papá'), new Word('papás'));
+        yield new Substitution(new Word('mamá'), new Word('mamás'));
+        yield new Substitution(new Word('sofá'), new Word('sofás'));
+        yield new Substitution(new Word('mes'), new Word('meses'));
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Spanish/InflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Spanish;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Spanish/Rules.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Spanish;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Spanish/Uninflected.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Spanish;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /**
+     * @return Pattern[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('lunes');
+        yield new Pattern('rompecabezas');
+        yield new Pattern('crisis');
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Substitution.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+final class Substitution
+{
+    /** @var Word */
+    private $from;
+
+    /** @var Word */
+    private $to;
+
+    public function __construct(Word $from, Word $to)
+    {
+        $this->from = $from;
+        $this->to   = $to;
+    }
+
+    public function getFrom(): Word
+    {
+        return $this->from;
+    }
+
+    public function getTo(): Word
+    {
+        return $this->to;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Substitutions.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use Doctrine\Inflector\WordInflector;
+
+use function strtolower;
+use function strtoupper;
+use function substr;
+
+class Substitutions implements WordInflector
+{
+    /** @var Substitution[] */
+    private $substitutions;
+
+    public function __construct(Substitution ...$substitutions)
+    {
+        foreach ($substitutions as $substitution) {
+            $this->substitutions[$substitution->getFrom()->getWord()] = $substitution;
+        }
+    }
+
+    public function getFlippedSubstitutions(): Substitutions
+    {
+        $substitutions = [];
+
+        foreach ($this->substitutions as $substitution) {
+            $substitutions[] = new Substitution(
+                $substitution->getTo(),
+                $substitution->getFrom()
+            );
+        }
+
+        return new Substitutions(...$substitutions);
+    }
+
+    public function inflect(string $word): string
+    {
+        $lowerWord = strtolower($word);
+
+        if (isset($this->substitutions[$lowerWord])) {
+            $firstLetterUppercase = $lowerWord[0] !== $word[0];
+
+            $toWord = $this->substitutions[$lowerWord]->getTo()->getWord();
+
+            if ($firstLetterUppercase) {
+                return strtoupper($toWord[0]) . substr($toWord, 1);
+            }
+
+            return $toWord;
+        }
+
+        return $word;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Transformation.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use Doctrine\Inflector\WordInflector;
+
+use function preg_replace;
+
+final class Transformation implements WordInflector
+{
+    /** @var Pattern */
+    private $pattern;
+
+    /** @var string */
+    private $replacement;
+
+    public function __construct(Pattern $pattern, string $replacement)
+    {
+        $this->pattern     = $pattern;
+        $this->replacement = $replacement;
+    }
+
+    public function getPattern(): Pattern
+    {
+        return $this->pattern;
+    }
+
+    public function getReplacement(): string
+    {
+        return $this->replacement;
+    }
+
+    public function inflect(string $word): string
+    {
+        return (string) preg_replace($this->pattern->getRegex(), $this->replacement, $word);
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Transformations.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use Doctrine\Inflector\WordInflector;
+
+class Transformations implements WordInflector
+{
+    /** @var Transformation[] */
+    private $transformations;
+
+    public function __construct(Transformation ...$transformations)
+    {
+        $this->transformations = $transformations;
+    }
+
+    public function inflect(string $word): string
+    {
+        foreach ($this->transformations as $transformation) {
+            if ($transformation->getPattern()->matches($word)) {
+                return $transformation->inflect($word);
+            }
+        }
+
+        return $word;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Turkish/Inflectible.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Turkish;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /**
+     * @return Transformation[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/l[ae]r$/i'), '');
+    }
+
+    /**
+     * @return Transformation[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/([eöiü][^aoıueöiü]{0,6})$/u'), '\1ler');
+        yield new Transformation(new Pattern('/([aoıu][^aoıueöiü]{0,6})$/u'), '\1lar');
+    }
+
+    /**
+     * @return Substitution[]
+     */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('ben'), new Word('biz'));
+        yield new Substitution(new Word('sen'), new Word('siz'));
+        yield new Substitution(new Word('o'), new Word('onlar'));
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Turkish/InflectorFactory.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Turkish;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Turkish/Rules.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Turkish;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Turkish/Uninflected.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Turkish;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /**
+     * @return Pattern[]
+     */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /**
+     * @return Pattern[]
+     */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('lunes');
+        yield new Pattern('rompecabezas');
+        yield new Pattern('crisis');
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/Rules/Word.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+class Word
+{
+    /** @var string */
+    private $word;
+
+    public function __construct(string $word)
+    {
+        $this->word = $word;
+    }
+
+    public function getWord(): string
+    {
+        return $this->word;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/RulesetInflector.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector;
+
+use Doctrine\Inflector\Rules\Ruleset;
+
+use function array_merge;
+
+/**
+ * Inflects based on multiple rulesets.
+ *
+ * Rules:
+ * - If the word matches any uninflected word pattern, it is not inflected
+ * - The first ruleset that returns a different value for an irregular word wins
+ * - The first ruleset that returns a different value for a regular word wins
+ * - If none of the above match, the word is left as-is
+ */
+class RulesetInflector implements WordInflector
+{
+    /** @var Ruleset[] */
+    private $rulesets;
+
+    public function __construct(Ruleset $ruleset, Ruleset ...$rulesets)
+    {
+        $this->rulesets = array_merge([$ruleset], $rulesets);
+    }
+
+    public function inflect(string $word): string
+    {
+        if ($word === '') {
+            return '';
+        }
+
+        foreach ($this->rulesets as $ruleset) {
+            if ($ruleset->getUninflected()->matches($word)) {
+                return $word;
+            }
+
+            $inflected = $ruleset->getIrregular()->inflect($word);
+
+            if ($inflected !== $word) {
+                return $inflected;
+            }
+
+            $inflected = $ruleset->getRegular()->inflect($word);
+
+            if ($inflected !== $word) {
+                return $inflected;
+            }
+        }
+
+        return $word;
+    }
+}

vendor/doctrine/inflector/lib/Doctrine/Inflector/WordInflector.php

+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector;
+
+interface WordInflector
+{
+    public function inflect(string $word): string;
+}

vendor/doctrine/inflector/phpstan.neon.dist

+includes:
+    - vendor/phpstan/phpstan-phpunit/extension.neon
+    - vendor/phpstan/phpstan-phpunit/rules.neon
+    - vendor/phpstan/phpstan-strict-rules/rules.neon
+
+parameters:
+    level: 7
+    paths:
+      - lib
+      - tests
+
+    excludes_analyse:
+        - %rootDir%/../../../tests/Doctrine/Tests/Common/*

vendor/doctrine/inflector/psalm.xml

+<?xml version="1.0"?>
+<psalm
+    errorLevel="7"
+    resolveFromConfigFile="true"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="https://getpsalm.org/schema/config"
+    xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+>
+    <projectFiles>
+        <directory name="lib/Doctrine/Inflector" />
+        <ignoreFiles>
+            <directory name="vendor" />
+        </ignoreFiles>
+    </projectFiles>
+</psalm>