update

modules/paynow/vendor/php-http/discovery/src/ClassDiscovery.php

@@ -6,6 +6,7 @@ use Http\Discovery\Exception\ClassInstantiationFailedException;
 use Http\Discovery\Exception\DiscoveryFailedException;
 use Http\Discovery\Exception\NoCandidateFoundException;
 use Http\Discovery\Exception\StrategyUnavailableException;
+use Http\Discovery\Strategy\DiscoveryStrategy;
 
 /**
  * Registry that based find results on class existence.
@@ -19,9 +20,10 @@ abstract class ClassDiscovery
     /**
      * A list of strategies to find classes.
      *
-     * @var array
+     * @var DiscoveryStrategy[]
      */
     private static $strategies = [
+        Strategy\GeneratedDiscoveryStrategy::class,
         Strategy\CommonClassesStrategy::class,
         Strategy\CommonPsr17ClassesStrategy::class,
         Strategy\PuliBetaStrategy::class,
@@ -54,10 +56,17 @@ abstract class ClassDiscovery
             return $class;
         }
 
+        static $skipStrategy;
+        $skipStrategy ?? $skipStrategy = self::safeClassExists(Strategy\GeneratedDiscoveryStrategy::class) ? false : Strategy\GeneratedDiscoveryStrategy::class;
+
         $exceptions = [];
         foreach (self::$strategies as $strategy) {
+            if ($skipStrategy === $strategy) {
+                continue;
+            }
+
             try {
-                $candidates = call_user_func($strategy.'::getCandidates', $type);
+                $candidates = $strategy::getCandidates($type);
             } catch (StrategyUnavailableException $e) {
                 if (!isset(self::$deprecatedStrategies[$strategy])) {
                     $exceptions[] = $e;
@@ -122,7 +131,7 @@ abstract class ClassDiscovery
     /**
      * Set new strategies and clear the cache.
      *
-     * @param array $strategies string array of fully qualified class name to a DiscoveryStrategy
+     * @param string[] $strategies list of fully qualified class names that implement DiscoveryStrategy
      */
     public static function setStrategies(array $strategies)
     {
@@ -143,7 +152,7 @@ abstract class ClassDiscovery
     /**
      * Append a strategy at the end of the strategy queue.
      *
-     * @param string $strategy Fully qualified class name to a DiscoveryStrategy
+     * @param string $strategy Fully qualified class name of a DiscoveryStrategy
      */
     public static function appendStrategy($strategy)
     {
@@ -162,9 +171,6 @@ abstract class ClassDiscovery
         self::clearCache();
     }
 
-    /**
-     * Clear the cache.
-     */
     public static function clearCache()
     {
         self::$cache = [];
@@ -173,8 +179,6 @@ abstract class ClassDiscovery
     /**
      * Evaluates conditions to boolean.
      *
-     * @param mixed $condition
-     *
      * @return bool
      */
     protected static function evaluateCondition($condition)
@@ -230,14 +234,13 @@ abstract class ClassDiscovery
     }
 
     /**
-     * We want to do a "safe" version of PHP's "class_exists" because Magento has a bug
+     * We need a "safe" version of PHP's "class_exists" because Magento has a bug
      * (or they call it a "feature"). Magento is throwing an exception if you do class_exists()
      * on a class that ends with "Factory" and if that file does not exits.
      *
-     * This function will catch all potential exceptions and make sure it returns a boolean.
+     * This function catches all potential exceptions and makes sure to always return a boolean.
      *
      * @param string $class
-     * @param bool   $autoload
      *
      * @return bool
      */

modules/paynow/vendor/php-http/discovery/src/Composer/Plugin.php

@@ -0,0 +1,465 @@
+<?php
+
+namespace Http\Discovery\Composer;
+
+use Composer\Composer;
+use Composer\DependencyResolver\Pool;
+use Composer\EventDispatcher\EventSubscriberInterface;
+use Composer\Factory;
+use Composer\Installer;
+use Composer\IO\IOInterface;
+use Composer\Json\JsonFile;
+use Composer\Json\JsonManipulator;
+use Composer\Package\Locker;
+use Composer\Package\Version\VersionParser;
+use Composer\Package\Version\VersionSelector;
+use Composer\Plugin\PluginInterface;
+use Composer\Repository\InstalledRepositoryInterface;
+use Composer\Repository\RepositorySet;
+use Composer\Script\Event;
+use Composer\Script\ScriptEvents;
+use Composer\Util\Filesystem;
+use Http\Discovery\ClassDiscovery;
+
+/**
+ * Auto-installs missing implementations.
+ *
+ * When a dependency requires both this package and one of the supported `*-implementation`
+ * virtual packages, this plugin will auto-install a well-known implementation if none is
+ * found. The plugin will first look at already installed packages and figure out the
+ * preferred implementation to install based on the below stickyness rules (or on the first
+ * listed implementation if no rules match.)
+ *
+ * Don't miss updating src/Strategy/Common*Strategy.php when adding a new supported package.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class Plugin implements PluginInterface, EventSubscriberInterface
+{
+    /**
+     * Describes, for every supported virtual implementation, which packages
+     * provide said implementation and which extra dependencies each package
+     * requires to provide the implementation.
+     */
+    private const PROVIDE_RULES = [
+        'php-http/async-client-implementation' => [
+            'symfony/http-client:>=6.3' => ['guzzlehttp/promises', 'psr/http-factory-implementation', 'php-http/httplug'],
+            'symfony/http-client' => ['guzzlehttp/promises', 'php-http/message-factory', 'psr/http-factory-implementation', 'php-http/httplug'],
+            'php-http/guzzle7-adapter' => [],
+            'php-http/guzzle6-adapter' => [],
+            'php-http/curl-client' => [],
+            'php-http/react-adapter' => [],
+        ],
+        'php-http/client-implementation' => [
+            'symfony/http-client:>=6.3' => ['psr/http-factory-implementation', 'php-http/httplug'],
+            'symfony/http-client' => ['php-http/message-factory', 'psr/http-factory-implementation', 'php-http/httplug'],
+            'php-http/guzzle7-adapter' => [],
+            'php-http/guzzle6-adapter' => [],
+            'php-http/cakephp-adapter' => [],
+            'php-http/curl-client' => [],
+            'php-http/react-adapter' => [],
+            'php-http/buzz-adapter' => [],
+            'php-http/artax-adapter' => [],
+            'kriswallsmith/buzz:^1' => [],
+        ],
+        'psr/http-client-implementation' => [
+            'symfony/http-client' => ['psr/http-factory-implementation', 'psr/http-client'],
+            'guzzlehttp/guzzle' => [],
+            'kriswallsmith/buzz:^1' => [],
+        ],
+        'psr/http-message-implementation' => [
+            'php-http/discovery' => ['psr/http-factory-implementation'],
+        ],
+        'psr/http-factory-implementation' => [
+            'nyholm/psr7' => [],
+            'guzzlehttp/psr7:>=2' => [],
+            'slim/psr7' => [],
+            'laminas/laminas-diactoros' => [],
+            'phalcon/cphalcon:^4' => [],
+            'http-interop/http-factory-guzzle' => [],
+            'http-interop/http-factory-diactoros' => [],
+            'http-interop/http-factory-slim' => [],
+            'httpsoft/http-message' => [],
+        ],
+    ];
+
+    /**
+     * Describes which package should be preferred on the left side
+     * depending on which one is already installed on the right side.
+     */
+    private const STICKYNESS_RULES = [
+        'symfony/http-client' => 'symfony/framework-bundle',
+        'php-http/guzzle7-adapter' => 'guzzlehttp/guzzle:^7',
+        'php-http/guzzle6-adapter' => 'guzzlehttp/guzzle:^6',
+        'php-http/guzzle5-adapter' => 'guzzlehttp/guzzle:^5',
+        'php-http/cakephp-adapter' => 'cakephp/cakephp',
+        'php-http/react-adapter' => 'react/event-loop',
+        'php-http/buzz-adapter' => 'kriswallsmith/buzz:^0.15.1',
+        'php-http/artax-adapter' => 'amphp/artax:^3',
+        'http-interop/http-factory-guzzle' => 'guzzlehttp/psr7:^1',
+        'http-interop/http-factory-slim' => 'slim/slim:^3',
+    ];
+
+    private const INTERFACE_MAP = [
+        'php-http/async-client-implementation' => [
+            'Http\Client\HttpAsyncClient',
+        ],
+        'php-http/client-implementation' => [
+            'Http\Client\HttpClient',
+        ],
+        'psr/http-client-implementation' => [
+            'Psr\Http\Client\ClientInterface',
+        ],
+        'psr/http-factory-implementation' => [
+            'Psr\Http\Message\RequestFactoryInterface',
+            'Psr\Http\Message\ResponseFactoryInterface',
+            'Psr\Http\Message\ServerRequestFactoryInterface',
+            'Psr\Http\Message\StreamFactoryInterface',
+            'Psr\Http\Message\UploadedFileFactoryInterface',
+            'Psr\Http\Message\UriFactoryInterface',
+        ],
+    ];
+
+    public static function getSubscribedEvents(): array
+    {
+        return [
+            ScriptEvents::PRE_AUTOLOAD_DUMP => 'preAutoloadDump',
+            ScriptEvents::POST_UPDATE_CMD => 'postUpdate',
+        ];
+    }
+
+    public function activate(Composer $composer, IOInterface $io): void
+    {
+    }
+
+    public function deactivate(Composer $composer, IOInterface $io)
+    {
+    }
+
+    public function uninstall(Composer $composer, IOInterface $io)
+    {
+    }
+
+    public function postUpdate(Event $event)
+    {
+        $composer = $event->getComposer();
+        $repo = $composer->getRepositoryManager()->getLocalRepository();
+        $requires = [
+            $composer->getPackage()->getRequires(),
+            $composer->getPackage()->getDevRequires(),
+        ];
+        $pinnedAbstractions = [];
+        $pinned = $composer->getPackage()->getExtra()['discovery'] ?? [];
+        foreach (self::INTERFACE_MAP as $abstraction => $interfaces) {
+            foreach (isset($pinned[$abstraction]) ? [] : $interfaces as $interface) {
+                if (!isset($pinned[$interface])) {
+                    continue 2;
+                }
+            }
+            $pinnedAbstractions[$abstraction] = true;
+        }
+
+        $missingRequires = $this->getMissingRequires($repo, $requires, 'project' === $composer->getPackage()->getType(), $pinnedAbstractions);
+        $missingRequires = [
+            'require' => array_fill_keys(array_merge([], ...array_values($missingRequires[0])), '*'),
+            'require-dev' => array_fill_keys(array_merge([], ...array_values($missingRequires[1])), '*'),
+            'remove' => array_fill_keys(array_merge([], ...array_values($missingRequires[2])), '*'),
+        ];
+
+        if (!$missingRequires = array_filter($missingRequires)) {
+            return;
+        }
+
+        $composerJsonContents = file_get_contents(Factory::getComposerFile());
+        $this->updateComposerJson($missingRequires, $composer->getConfig()->get('sort-packages'));
+
+        $installer = null;
+        // Find the composer installer, hack borrowed from symfony/flex
+        foreach (debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT) as $trace) {
+            if (isset($trace['object']) && $trace['object'] instanceof Installer) {
+                $installer = $trace['object'];
+                break;
+            }
+        }
+
+        if (!$installer) {
+            return;
+        }
+
+        $event->stopPropagation();
+
+        $dispatcher = $composer->getEventDispatcher();
+        $disableScripts = !method_exists($dispatcher, 'setRunScripts') || !((array) $dispatcher)["\0*\0runScripts"];
+        $composer = Factory::create($event->getIO(), null, false, $disableScripts);
+
+        /** @var Installer $installer */
+        $installer = clone $installer;
+        if (method_exists($installer, 'setAudit')) {
+            $trace['object']->setAudit(false);
+        }
+        // we need a clone of the installer to preserve its configuration state but with our own service objects
+        $installer->__construct(
+            $event->getIO(),
+            $composer->getConfig(),
+            $composer->getPackage(),
+            $composer->getDownloadManager(),
+            $composer->getRepositoryManager(),
+            $composer->getLocker(),
+            $composer->getInstallationManager(),
+            $composer->getEventDispatcher(),
+            $composer->getAutoloadGenerator()
+        );
+        if (method_exists($installer, 'setPlatformRequirementFilter')) {
+            $installer->setPlatformRequirementFilter(((array) $trace['object'])["\0*\0platformRequirementFilter"]);
+        }
+
+        if (0 !== $installer->run()) {
+            file_put_contents(Factory::getComposerFile(), $composerJsonContents);
+
+            return;
+        }
+
+        $versionSelector = new VersionSelector(ClassDiscovery::safeClassExists(RepositorySet::class) ? new RepositorySet() : new Pool());
+        $updateComposerJson = false;
+
+        foreach ($composer->getRepositoryManager()->getLocalRepository()->getPackages() as $package) {
+            foreach (['require', 'require-dev'] as $key) {
+                if (!isset($missingRequires[$key][$package->getName()])) {
+                    continue;
+                }
+                $updateComposerJson = true;
+                $missingRequires[$key][$package->getName()] = $versionSelector->findRecommendedRequireVersion($package);
+            }
+        }
+
+        if ($updateComposerJson) {
+            $this->updateComposerJson($missingRequires, $composer->getConfig()->get('sort-packages'));
+            $this->updateComposerLock($composer, $event->getIO());
+        }
+    }
+
+    public function getMissingRequires(InstalledRepositoryInterface $repo, array $requires, bool $isProject, array $pinnedAbstractions): array
+    {
+        $allPackages = [];
+        $devPackages = method_exists($repo, 'getDevPackageNames') ? array_fill_keys($repo->getDevPackageNames(), true) : [];
+
+        // One must require "php-http/discovery"
+        // to opt-in for auto-installation of virtual package implementations
+        if (!isset($requires[0]['php-http/discovery'])) {
+            $requires = [[], []];
+        }
+
+        foreach ($repo->getPackages() as $package) {
+            $allPackages[$package->getName()] = true;
+
+            if (1 < \count($names = $package->getNames(false))) {
+                $allPackages += array_fill_keys($names, false);
+
+                if (isset($devPackages[$package->getName()])) {
+                    $devPackages += $names;
+                }
+            }
+
+            if (isset($package->getRequires()['php-http/discovery'])) {
+                $requires[(int) isset($devPackages[$package->getName()])] += $package->getRequires();
+            }
+        }
+
+        $missingRequires = [[], [], []];
+        $versionParser = new VersionParser();
+
+        if (ClassDiscovery::safeClassExists(\Phalcon\Http\Message\RequestFactory::class, false)) {
+            $missingRequires[0]['psr/http-factory-implementation'] = [];
+            $missingRequires[1]['psr/http-factory-implementation'] = [];
+        }
+
+        foreach ($requires as $dev => $rules) {
+            $abstractions = [];
+            $rules = array_intersect_key(self::PROVIDE_RULES, $rules);
+
+            while ($rules) {
+                $abstraction = key($rules);
+
+                if (isset($pinnedAbstractions[$abstraction])) {
+                    unset($rules[$abstraction]);
+                    continue;
+                }
+
+                $abstractions[] = $abstraction;
+
+                foreach (array_shift($rules) as $candidate => $deps) {
+                    [$candidate, $version] = explode(':', $candidate, 2) + [1 => null];
+
+                    if (!isset($allPackages[$candidate])) {
+                        continue;
+                    }
+                    if (null !== $version && !$repo->findPackage($candidate, $versionParser->parseConstraints($version))) {
+                        continue;
+                    }
+                    if ($isProject && !$dev && isset($devPackages[$candidate])) {
+                        $missingRequires[0][$abstraction] = [$candidate];
+                        $missingRequires[2][$abstraction] = [$candidate];
+                    } else {
+                        $missingRequires[$dev][$abstraction] = [];
+                    }
+
+                    foreach ($deps as $dep) {
+                        if (isset(self::PROVIDE_RULES[$dep])) {
+                            $rules[$dep] = self::PROVIDE_RULES[$dep];
+                        } elseif (!isset($allPackages[$dep])) {
+                            $missingRequires[$dev][$abstraction][] = $dep;
+                        } elseif ($isProject && !$dev && isset($devPackages[$dep])) {
+                            $missingRequires[0][$abstraction][] = $dep;
+                            $missingRequires[2][$abstraction][] = $dep;
+                        }
+                    }
+                    break;
+                }
+            }
+
+            while ($abstractions) {
+                $abstraction = array_shift($abstractions);
+
+                if (isset($missingRequires[$dev][$abstraction])) {
+                    continue;
+                }
+                $candidates = self::PROVIDE_RULES[$abstraction];
+
+                foreach ($candidates as $candidate => $deps) {
+                    [$candidate, $version] = explode(':', $candidate, 2) + [1 => null];
+
+                    if (null !== $version && !$repo->findPackage($candidate, $versionParser->parseConstraints($version))) {
+                        continue;
+                    }
+                    if (isset($allPackages[$candidate]) && (!$isProject || $dev || !isset($devPackages[$candidate]))) {
+                        continue 2;
+                    }
+                }
+
+                foreach (array_intersect_key(self::STICKYNESS_RULES, $candidates) as $candidate => $stickyRule) {
+                    [$stickyName, $stickyVersion] = explode(':', $stickyRule, 2) + [1 => null];
+                    if (!isset($allPackages[$stickyName]) || ($isProject && !$dev && isset($devPackages[$stickyName]))) {
+                        continue;
+                    }
+                    if (null !== $stickyVersion && !$repo->findPackage($stickyName, $versionParser->parseConstraints($stickyVersion))) {
+                        continue;
+                    }
+
+                    $candidates = [$candidate => $candidates[$candidate]];
+                    break;
+                }
+
+                $dep = key($candidates);
+                [$dep] = explode(':', $dep, 2);
+                $missingRequires[$dev][$abstraction] = [$dep];
+
+                if ($isProject && !$dev && isset($devPackages[$dep])) {
+                    $missingRequires[2][$abstraction][] = $dep;
+                }
+            }
+        }
+
+        $missingRequires[1] = array_diff_key($missingRequires[1], $missingRequires[0]);
+
+        return $missingRequires;
+    }
+
+    public function preAutoloadDump(Event $event)
+    {
+        $filesystem = new Filesystem();
+        // Double realpath() on purpose, see https://bugs.php.net/72738
+        $vendorDir = $filesystem->normalizePath(realpath(realpath($event->getComposer()->getConfig()->get('vendor-dir'))));
+        $filesystem->ensureDirectoryExists($vendorDir.'/composer');
+        $pinned = $event->getComposer()->getPackage()->getExtra()['discovery'] ?? [];
+        $candidates = [];
+
+        $allInterfaces = array_merge(...array_values(self::INTERFACE_MAP));
+        foreach ($pinned as $abstraction => $class) {
+            if (isset(self::INTERFACE_MAP[$abstraction])) {
+                $interfaces = self::INTERFACE_MAP[$abstraction];
+            } elseif (false !== $k = array_search($abstraction, $allInterfaces, true)) {
+                $interfaces = [$allInterfaces[$k]];
+            } else {
+                throw new \UnexpectedValueException(sprintf('Invalid "extra.discovery" pinned in composer.json: "%s" is not one of ["%s"].', $abstraction, implode('", "', array_keys(self::INTERFACE_MAP))));
+            }
+
+            foreach ($interfaces as $interface) {
+                $candidates[] = sprintf("case %s: return [['class' => %s]];\n", var_export($interface, true), var_export($class, true));
+            }
+        }
+
+        $file = $vendorDir.'/composer/GeneratedDiscoveryStrategy.php';
+
+        if (!$candidates) {
+            if (file_exists($file)) {
+                unlink($file);
+            }
+
+            return;
+        }
+
+        $candidates = implode('            ', $candidates);
+        $code = <<<EOPHP
+<?php
+
+namespace Http\Discovery\Strategy;
+
+class GeneratedDiscoveryStrategy implements DiscoveryStrategy
+{
+    public static function getCandidates(\$type)
+    {
+        switch (\$type) {
+            $candidates
+            default: return [];
+        }
+    }
+}
+
+EOPHP
+        ;
+
+        if (!file_exists($file) || $code !== file_get_contents($file)) {
+            file_put_contents($file, $code);
+        }
+
+        $rootPackage = $event->getComposer()->getPackage();
+        $autoload = $rootPackage->getAutoload();
+        $autoload['classmap'][] = $vendorDir.'/composer/GeneratedDiscoveryStrategy.php';
+        $rootPackage->setAutoload($autoload);
+    }
+
+    private function updateComposerJson(array $missingRequires, bool $sortPackages)
+    {
+        $file = Factory::getComposerFile();
+        $contents = file_get_contents($file);
+
+        $manipulator = new JsonManipulator($contents);
+
+        foreach ($missingRequires as $key => $packages) {
+            foreach ($packages as $package => $constraint) {
+                if ('remove' === $key) {
+                    $manipulator->removeSubNode('require-dev', $package);
+                } else {
+                    $manipulator->addLink($key, $package, $constraint, $sortPackages);
+                }
+            }
+        }
+
+        file_put_contents($file, $manipulator->getContents());
+    }
+
+    private function updateComposerLock(Composer $composer, IOInterface $io)
+    {
+        $lock = substr(Factory::getComposerFile(), 0, -4).'lock';
+        $composerJson = file_get_contents(Factory::getComposerFile());
+        $lockFile = new JsonFile($lock, null, $io);
+        $locker = ClassDiscovery::safeClassExists(RepositorySet::class)
+            ? new Locker($io, $lockFile, $composer->getInstallationManager(), $composerJson)
+            : new Locker($io, $lockFile, $composer->getRepositoryManager(), $composer->getInstallationManager(), $composerJson);
+        $lockData = $locker->getLockData();
+        $lockData['content-hash'] = Locker::getContentHash($composerJson);
+        $lockFile->write($lockData);
+    }
+}

modules/paynow/vendor/php-http/discovery/src/Composer/index.php

@@ -0,0 +1,11 @@
+<?php
+
+header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');
+header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
+
+header('Cache-Control: no-store, no-cache, must-revalidate');
+header('Cache-Control: post-check=0, pre-check=0', false);
+header('Pragma: no-cache');
+
+header('Location: ../');
+exit;

modules/paynow/vendor/php-http/discovery/src/Exception.php

@@ -7,6 +7,6 @@ namespace Http\Discovery;
  *
  * @author Tobias Nyholm <tobias.nyholm@gmail.com>
  */
-interface Exception
+interface Exception extends \Throwable
 {
 }

modules/paynow/vendor/php-http/discovery/src/HttpClientDiscovery.php

@@ -9,6 +9,8 @@ use Http\Discovery\Exception\DiscoveryFailedException;
  * Finds an HTTP Client.
  *
  * @author Márk Sági-Kazár <mark.sagikazar@gmail.com>
+ *
+ * @deprecated This will be removed in 2.0. Consider using Psr18ClientDiscovery.
  */
 final class HttpClientDiscovery extends ClassDiscovery
 {

modules/paynow/vendor/php-http/discovery/src/MessageFactoryDiscovery.php

@@ -26,7 +26,7 @@ final class MessageFactoryDiscovery extends ClassDiscovery
         try {
             $messageFactory = static::findOneByType(MessageFactory::class);
         } catch (DiscoveryFailedException $e) {
-            throw new NotFoundException('No message factories found. To use Guzzle, Diactoros or Slim Framework factories install php-http/message and the chosen message implementation.', 0, $e);
+            throw new NotFoundException('No php-http message factories found. Note that the php-http message factories are deprecated in favor of the PSR-17 message factories. To use the legacy Guzzle, Diactoros or Slim Framework factories of php-http, install php-http/message and php-http/message-factory and the chosen message implementation.', 0, $e);
         }
 
         return static::instantiateClass($messageFactory);

modules/paynow/vendor/php-http/discovery/src/Psr17Factory.php

@@ -0,0 +1,303 @@
+<?php
+
+namespace Http\Discovery;
+
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Http\Message\UploadedFileInterface;
+use Psr\Http\Message\UriFactoryInterface;
+use Psr\Http\Message\UriInterface;
+
+/**
+ * A generic PSR-17 implementation.
+ *
+ * You can create this class with concrete factory instances or let
+ * it use discovery to find suitable implementations as needed.
+ *
+ * This class also provides two additional methods that are not in PSR17,
+ * to help with creating PSR-7 objects from PHP superglobals:
+ *  - createServerRequestFromGlobals()
+ *  - createUriFromGlobals()
+ *
+ * The code in this class is inspired by the "nyholm/psr7", "guzzlehttp/psr7"
+ * and "symfony/http-foundation" packages, all licenced under MIT.
+ *
+ * Copyright (c) 2004-2023 Fabien Potencier <fabien@symfony.com>
+ * Copyright (c) 2015 Michael Dowling <mtdowling@gmail.com>
+ * Copyright (c) 2015 Márk Sági-Kazár <mark.sagikazar@gmail.com>
+ * Copyright (c) 2015 Graham Campbell <hello@gjcampbell.co.uk>
+ * Copyright (c) 2016 Tobias Schultze <webmaster@tubo-world.de>
+ * Copyright (c) 2016 George Mponos <gmponos@gmail.com>
+ * Copyright (c) 2016-2018 Tobias Nyholm <tobias.nyholm@gmail.com>
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class Psr17Factory implements RequestFactoryInterface, ResponseFactoryInterface, ServerRequestFactoryInterface, StreamFactoryInterface, UploadedFileFactoryInterface, UriFactoryInterface
+{
+    private $requestFactory;
+    private $responseFactory;
+    private $serverRequestFactory;
+    private $streamFactory;
+    private $uploadedFileFactory;
+    private $uriFactory;
+
+    public function __construct(
+        RequestFactoryInterface $requestFactory = null,
+        ResponseFactoryInterface $responseFactory = null,
+        ServerRequestFactoryInterface $serverRequestFactory = null,
+        StreamFactoryInterface $streamFactory = null,
+        UploadedFileFactoryInterface $uploadedFileFactory = null,
+        UriFactoryInterface $uriFactory = null
+    ) {
+        $this->requestFactory = $requestFactory;
+        $this->responseFactory = $responseFactory;
+        $this->serverRequestFactory = $serverRequestFactory;
+        $this->streamFactory = $streamFactory;
+        $this->uploadedFileFactory = $uploadedFileFactory;
+        $this->uriFactory = $uriFactory;
+
+        $this->setFactory($requestFactory);
+        $this->setFactory($responseFactory);
+        $this->setFactory($serverRequestFactory);
+        $this->setFactory($streamFactory);
+        $this->setFactory($uploadedFileFactory);
+        $this->setFactory($uriFactory);
+    }
+
+    /**
+     * @param UriInterface|string $uri
+     */
+    public function createRequest(string $method, $uri): RequestInterface
+    {
+        $factory = $this->requestFactory ?? $this->setFactory(Psr17FactoryDiscovery::findRequestFactory());
+
+        return $factory->createRequest(...\func_get_args());
+    }
+
+    public function createResponse(int $code = 200, string $reasonPhrase = ''): ResponseInterface
+    {
+        $factory = $this->responseFactory ?? $this->setFactory(Psr17FactoryDiscovery::findResponseFactory());
+
+        return $factory->createResponse(...\func_get_args());
+    }
+
+    /**
+     * @param UriInterface|string $uri
+     */
+    public function createServerRequest(string $method, $uri, array $serverParams = []): ServerRequestInterface
+    {
+        $factory = $this->serverRequestFactory ?? $this->setFactory(Psr17FactoryDiscovery::findServerRequestFactory());
+
+        return $factory->createServerRequest(...\func_get_args());
+    }
+
+    public function createServerRequestFromGlobals(array $server = null, array $get = null, array $post = null, array $cookie = null, array $files = null, StreamInterface $body = null): ServerRequestInterface
+    {
+        $server = $server ?? $_SERVER;
+        $request = $this->createServerRequest($server['REQUEST_METHOD'] ?? 'GET', $this->createUriFromGlobals($server), $server);
+
+        return $this->buildServerRequestFromGlobals($request, $server, $files ?? $_FILES)
+            ->withQueryParams($get ?? $_GET)
+            ->withParsedBody($post ?? $_POST)
+            ->withCookieParams($cookie ?? $_COOKIE)
+            ->withBody($body ?? $this->createStreamFromFile('php://input', 'r+'));
+    }
+
+    public function createStream(string $content = ''): StreamInterface
+    {
+        $factory = $this->streamFactory ?? $this->setFactory(Psr17FactoryDiscovery::findStreamFactory());
+
+        return $factory->createStream($content);
+    }
+
+    public function createStreamFromFile(string $filename, string $mode = 'r'): StreamInterface
+    {
+        $factory = $this->streamFactory ?? $this->setFactory(Psr17FactoryDiscovery::findStreamFactory());
+
+        return $factory->createStreamFromFile($filename, $mode);
+    }
+
+    /**
+     * @param resource $resource
+     */
+    public function createStreamFromResource($resource): StreamInterface
+    {
+        $factory = $this->streamFactory ?? $this->setFactory(Psr17FactoryDiscovery::findStreamFactory());
+
+        return $factory->createStreamFromResource($resource);
+    }
+
+    public function createUploadedFile(StreamInterface $stream, int $size = null, int $error = \UPLOAD_ERR_OK, string $clientFilename = null, string $clientMediaType = null): UploadedFileInterface
+    {
+        $factory = $this->uploadedFileFactory ?? $this->setFactory(Psr17FactoryDiscovery::findUploadedFileFactory());
+
+        return $factory->createUploadedFile(...\func_get_args());
+    }
+
+    public function createUri(string $uri = ''): UriInterface
+    {
+        $factory = $this->uriFactory ?? $this->setFactory(Psr17FactoryDiscovery::findUriFactory());
+
+        return $factory->createUri(...\func_get_args());
+    }
+
+    public function createUriFromGlobals(array $server = null): UriInterface
+    {
+        return $this->buildUriFromGlobals($this->createUri(''), $server ?? $_SERVER);
+    }
+
+    private function setFactory($factory)
+    {
+        if (!$this->requestFactory && $factory instanceof RequestFactoryInterface) {
+            $this->requestFactory = $factory;
+        }
+        if (!$this->responseFactory && $factory instanceof ResponseFactoryInterface) {
+            $this->responseFactory = $factory;
+        }
+        if (!$this->serverRequestFactory && $factory instanceof ServerRequestFactoryInterface) {
+            $this->serverRequestFactory = $factory;
+        }
+        if (!$this->streamFactory && $factory instanceof StreamFactoryInterface) {
+            $this->streamFactory = $factory;
+        }
+        if (!$this->uploadedFileFactory && $factory instanceof UploadedFileFactoryInterface) {
+            $this->uploadedFileFactory = $factory;
+        }
+        if (!$this->uriFactory && $factory instanceof UriFactoryInterface) {
+            $this->uriFactory = $factory;
+        }
+
+        return $factory;
+    }
+
+    private function buildServerRequestFromGlobals(ServerRequestInterface $request, array $server, array $files): ServerRequestInterface
+    {
+        $request = $request
+            ->withProtocolVersion(isset($server['SERVER_PROTOCOL']) ? str_replace('HTTP/', '', $server['SERVER_PROTOCOL']) : '1.1')
+            ->withUploadedFiles($this->normalizeFiles($files));
+
+        $headers = [];
+        foreach ($server as $k => $v) {
+            if (0 === strpos($k, 'HTTP_')) {
+                $k = substr($k, 5);
+            } elseif (!\in_array($k, ['CONTENT_TYPE', 'CONTENT_LENGTH', 'CONTENT_MD5'], true)) {
+                continue;
+            }
+            $k = str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', $k))));
+
+            $headers[$k] = $v;
+        }
+
+        if (!isset($headers['Authorization'])) {
+            if (isset($_SERVER['REDIRECT_HTTP_AUTHORIZATION'])) {
+                $headers['Authorization'] = $_SERVER['REDIRECT_HTTP_AUTHORIZATION'];
+            } elseif (isset($_SERVER['PHP_AUTH_USER'])) {
+                $headers['Authorization'] = 'Basic '.base64_encode($_SERVER['PHP_AUTH_USER'].':'.($_SERVER['PHP_AUTH_PW'] ?? ''));
+            } elseif (isset($_SERVER['PHP_AUTH_DIGEST'])) {
+                $headers['Authorization'] = $_SERVER['PHP_AUTH_DIGEST'];
+            }
+        }
+
+        foreach ($headers as $k => $v) {
+            try {
+                $request = $request->withHeader($k, $v);
+            } catch (\InvalidArgumentException $e) {
+                // ignore invalid headers
+            }
+        }
+
+        return $request;
+    }
+
+    private function buildUriFromGlobals(UriInterface $uri, array $server): UriInterface
+    {
+        $uri = $uri->withScheme(!empty($server['HTTPS']) && 'off' !== strtolower($server['HTTPS']) ? 'https' : 'http');
+
+        $hasPort = false;
+        if (isset($server['HTTP_HOST'])) {
+            $parts = parse_url('http://'.$server['HTTP_HOST']);
+
+            $uri = $uri->withHost($parts['host'] ?? 'localhost');
+
+            if ($parts['port'] ?? false) {
+                $hasPort = true;
+                $uri = $uri->withPort($parts['port']);
+            }
+        } else {
+            $uri = $uri->withHost($server['SERVER_NAME'] ?? $server['SERVER_ADDR'] ?? 'localhost');
+        }
+
+        if (!$hasPort && isset($server['SERVER_PORT'])) {
+            $uri = $uri->withPort($server['SERVER_PORT']);
+        }
+
+        $hasQuery = false;
+        if (isset($server['REQUEST_URI'])) {
+            $requestUriParts = explode('?', $server['REQUEST_URI'], 2);
+            $uri = $uri->withPath($requestUriParts[0]);
+            if (isset($requestUriParts[1])) {
+                $hasQuery = true;
+                $uri = $uri->withQuery($requestUriParts[1]);
+            }
+        }
+
+        if (!$hasQuery && isset($server['QUERY_STRING'])) {
+            $uri = $uri->withQuery($server['QUERY_STRING']);
+        }
+
+        return $uri;
+    }
+
+    private function normalizeFiles(array $files): array
+    {
+        foreach ($files as $k => $v) {
+            if ($v instanceof UploadedFileInterface) {
+                continue;
+            }
+            if (!\is_array($v)) {
+                unset($files[$k]);
+            } elseif (!isset($v['tmp_name'])) {
+                $files[$k] = $this->normalizeFiles($v);
+            } else {
+                $files[$k] = $this->createUploadedFileFromSpec($v);
+            }
+        }
+
+        return $files;
+    }
+
+    /**
+     * Create and return an UploadedFile instance from a $_FILES specification.
+     *
+     * @param array $value $_FILES struct
+     *
+     * @return UploadedFileInterface|UploadedFileInterface[]
+     */
+    private function createUploadedFileFromSpec(array $value)
+    {
+        if (!is_array($tmpName = $value['tmp_name'])) {
+            $file = is_file($tmpName) ? $this->createStreamFromFile($tmpName, 'r') : $this->createStream();
+
+            return $this->createUploadedFile($file, $value['size'], $value['error'], $value['name'], $value['type']);
+        }
+
+        foreach ($tmpName as $k => $v) {
+            $tmpName[$k] = $this->createUploadedFileFromSpec([
+                'tmp_name' => $v,
+                'size' => $value['size'][$k] ?? null,
+                'error' => $value['error'][$k] ?? null,
+                'name' => $value['name'][$k] ?? null,
+                'type' => $value['type'][$k] ?? null,
+            ]);
+        }
+
+        return $tmpName;
+    }
+}

modules/paynow/vendor/php-http/discovery/src/Psr18Client.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Http\Discovery;
+
+use Psr\Http\Client\ClientInterface;
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Http\Message\UriFactoryInterface;
+
+/**
+ * A generic PSR-18 and PSR-17 implementation.
+ *
+ * You can create this class with concrete client and factory instances
+ * or let it use discovery to find suitable implementations as needed.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class Psr18Client extends Psr17Factory implements ClientInterface
+{
+    private $client;
+
+    public function __construct(
+        ClientInterface $client = null,
+        RequestFactoryInterface $requestFactory = null,
+        ResponseFactoryInterface $responseFactory = null,
+        ServerRequestFactoryInterface $serverRequestFactory = null,
+        StreamFactoryInterface $streamFactory = null,
+        UploadedFileFactoryInterface $uploadedFileFactory = null,
+        UriFactoryInterface $uriFactory = null
+    ) {
+        parent::__construct($requestFactory, $responseFactory, $serverRequestFactory, $streamFactory, $uploadedFileFactory, $uriFactory);
+
+        $this->client = $client ?? Psr18ClientDiscovery::find();
+    }
+
+    public function sendRequest(RequestInterface $request): ResponseInterface
+    {
+        return $this->client->sendRequest($request);
+    }
+}

modules/paynow/vendor/php-http/discovery/src/Strategy/CommonClassesStrategy.php

@@ -12,20 +12,17 @@ use Http\Adapter\Guzzle5\Client as Guzzle5;
 use Http\Adapter\Guzzle6\Client as Guzzle6;
 use Http\Adapter\Guzzle7\Client as Guzzle7;
 use Http\Adapter\React\Client as React;
-use Http\Adapter\Zend\Client as Zend;
 use Http\Client\Curl\Client as Curl;
 use Http\Client\HttpAsyncClient;
 use Http\Client\HttpClient;
 use Http\Client\Socket\Client as Socket;
 use Http\Discovery\ClassDiscovery;
 use Http\Discovery\Exception\NotFoundException;
-use Http\Discovery\MessageFactoryDiscovery;
 use Http\Discovery\Psr17FactoryDiscovery;
 use Http\Message\MessageFactory;
 use Http\Message\MessageFactory\DiactorosMessageFactory;
 use Http\Message\MessageFactory\GuzzleMessageFactory;
 use Http\Message\MessageFactory\SlimMessageFactory;
-use Http\Message\RequestFactory;
 use Http\Message\StreamFactory;
 use Http\Message\StreamFactory\DiactorosStreamFactory;
 use Http\Message\StreamFactory\GuzzleStreamFactory;
@@ -41,12 +38,13 @@ use Psr\Http\Message\RequestFactoryInterface as Psr17RequestFactory;
 use Slim\Http\Request as SlimRequest;
 use Symfony\Component\HttpClient\HttplugClient as SymfonyHttplug;
 use Symfony\Component\HttpClient\Psr18Client as SymfonyPsr18;
-use Zend\Diactoros\Request as ZendDiactorosRequest;
 
 /**
  * @internal
  *
  * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ *
+ * Don't miss updating src/Composer/Plugin.php when adding a new supported class.
  */
 final class CommonClassesStrategy implements DiscoveryStrategy
 {
@@ -57,33 +55,30 @@ final class CommonClassesStrategy implements DiscoveryStrategy
         MessageFactory::class => [
             ['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]],
             ['class' => GuzzleMessageFactory::class, 'condition' => [GuzzleRequest::class, GuzzleMessageFactory::class]],
-            ['class' => DiactorosMessageFactory::class, 'condition' => [ZendDiactorosRequest::class, DiactorosMessageFactory::class]],
             ['class' => DiactorosMessageFactory::class, 'condition' => [DiactorosRequest::class, DiactorosMessageFactory::class]],
             ['class' => SlimMessageFactory::class, 'condition' => [SlimRequest::class, SlimMessageFactory::class]],
         ],
         StreamFactory::class => [
             ['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]],
             ['class' => GuzzleStreamFactory::class, 'condition' => [GuzzleRequest::class, GuzzleStreamFactory::class]],
-            ['class' => DiactorosStreamFactory::class, 'condition' => [ZendDiactorosRequest::class, DiactorosStreamFactory::class]],
             ['class' => DiactorosStreamFactory::class, 'condition' => [DiactorosRequest::class, DiactorosStreamFactory::class]],
             ['class' => SlimStreamFactory::class, 'condition' => [SlimRequest::class, SlimStreamFactory::class]],
         ],
         UriFactory::class => [
             ['class' => NyholmHttplugFactory::class, 'condition' => [NyholmHttplugFactory::class]],
             ['class' => GuzzleUriFactory::class, 'condition' => [GuzzleRequest::class, GuzzleUriFactory::class]],
-            ['class' => DiactorosUriFactory::class, 'condition' => [ZendDiactorosRequest::class, DiactorosUriFactory::class]],
             ['class' => DiactorosUriFactory::class, 'condition' => [DiactorosRequest::class, DiactorosUriFactory::class]],
             ['class' => SlimUriFactory::class, 'condition' => [SlimRequest::class, SlimUriFactory::class]],
         ],
         HttpAsyncClient::class => [
-            ['class' => SymfonyHttplug::class, 'condition' => [SymfonyHttplug::class, Promise::class, RequestFactory::class, [self::class, 'isPsr17FactoryInstalled']]],
+            ['class' => SymfonyHttplug::class, 'condition' => [SymfonyHttplug::class, Promise::class, [self::class, 'isPsr17FactoryInstalled']]],
             ['class' => Guzzle7::class, 'condition' => Guzzle7::class],
             ['class' => Guzzle6::class, 'condition' => Guzzle6::class],
             ['class' => Curl::class, 'condition' => Curl::class],
             ['class' => React::class, 'condition' => React::class],
         ],
         HttpClient::class => [
-            ['class' => SymfonyHttplug::class, 'condition' => [SymfonyHttplug::class, RequestFactory::class, [self::class, 'isPsr17FactoryInstalled']]],
+            ['class' => SymfonyHttplug::class, 'condition' => [SymfonyHttplug::class, [self::class, 'isPsr17FactoryInstalled']]],
             ['class' => Guzzle7::class, 'condition' => Guzzle7::class],
             ['class' => Guzzle6::class, 'condition' => Guzzle6::class],
             ['class' => Guzzle5::class, 'condition' => Guzzle5::class],
@@ -92,7 +87,6 @@ final class CommonClassesStrategy implements DiscoveryStrategy
             ['class' => Buzz::class, 'condition' => Buzz::class],
             ['class' => React::class, 'condition' => React::class],
             ['class' => Cake::class, 'condition' => Cake::class],
-            ['class' => Zend::class, 'condition' => Zend::class],
             ['class' => Artax::class, 'condition' => Artax::class],
             [
                 'class' => [self::class, 'buzzInstantiate'],
@@ -115,9 +109,6 @@ final class CommonClassesStrategy implements DiscoveryStrategy
         ],
     ];
 
-    /**
-     * {@inheritdoc}
-     */
     public static function getCandidates($type)
     {
         if (Psr18Client::class === $type) {
@@ -154,7 +145,7 @@ final class CommonClassesStrategy implements DiscoveryStrategy
 
     public static function buzzInstantiate()
     {
-        return new \Buzz\Client\FileGetContents(MessageFactoryDiscovery::find());
+        return new \Buzz\Client\FileGetContents(Psr17FactoryDiscovery::findResponseFactory());
     }
 
     public static function symfonyPsr18Instantiate()

modules/paynow/vendor/php-http/discovery/src/Strategy/CommonPsr17ClassesStrategy.php

@@ -13,6 +13,8 @@ use Psr\Http\Message\UriFactoryInterface;
  * @internal
  *
  * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ *
+ * Don't miss updating src/Composer/Plugin.php when adding a new supported class.
  */
 final class CommonPsr17ClassesStrategy implements DiscoveryStrategy
 {
@@ -23,74 +25,71 @@ final class CommonPsr17ClassesStrategy implements DiscoveryStrategy
         RequestFactoryInterface::class => [
             'Phalcon\Http\Message\RequestFactory',
             'Nyholm\Psr7\Factory\Psr17Factory',
-            'Zend\Diactoros\RequestFactory',
             'GuzzleHttp\Psr7\HttpFactory',
             'Http\Factory\Diactoros\RequestFactory',
             'Http\Factory\Guzzle\RequestFactory',
             'Http\Factory\Slim\RequestFactory',
             'Laminas\Diactoros\RequestFactory',
             'Slim\Psr7\Factory\RequestFactory',
+            'HttpSoft\Message\RequestFactory',
         ],
         ResponseFactoryInterface::class => [
             'Phalcon\Http\Message\ResponseFactory',
             'Nyholm\Psr7\Factory\Psr17Factory',
-            'Zend\Diactoros\ResponseFactory',
             'GuzzleHttp\Psr7\HttpFactory',
             'Http\Factory\Diactoros\ResponseFactory',
             'Http\Factory\Guzzle\ResponseFactory',
             'Http\Factory\Slim\ResponseFactory',
             'Laminas\Diactoros\ResponseFactory',
             'Slim\Psr7\Factory\ResponseFactory',
+            'HttpSoft\Message\ResponseFactory',
         ],
         ServerRequestFactoryInterface::class => [
             'Phalcon\Http\Message\ServerRequestFactory',
             'Nyholm\Psr7\Factory\Psr17Factory',
-            'Zend\Diactoros\ServerRequestFactory',
             'GuzzleHttp\Psr7\HttpFactory',
             'Http\Factory\Diactoros\ServerRequestFactory',
             'Http\Factory\Guzzle\ServerRequestFactory',
             'Http\Factory\Slim\ServerRequestFactory',
             'Laminas\Diactoros\ServerRequestFactory',
             'Slim\Psr7\Factory\ServerRequestFactory',
+            'HttpSoft\Message\ServerRequestFactory',
         ],
         StreamFactoryInterface::class => [
             'Phalcon\Http\Message\StreamFactory',
             'Nyholm\Psr7\Factory\Psr17Factory',
-            'Zend\Diactoros\StreamFactory',
             'GuzzleHttp\Psr7\HttpFactory',
             'Http\Factory\Diactoros\StreamFactory',
             'Http\Factory\Guzzle\StreamFactory',
             'Http\Factory\Slim\StreamFactory',
             'Laminas\Diactoros\StreamFactory',
             'Slim\Psr7\Factory\StreamFactory',
+            'HttpSoft\Message\StreamFactory',
         ],
         UploadedFileFactoryInterface::class => [
             'Phalcon\Http\Message\UploadedFileFactory',
             'Nyholm\Psr7\Factory\Psr17Factory',
-            'Zend\Diactoros\UploadedFileFactory',
             'GuzzleHttp\Psr7\HttpFactory',
             'Http\Factory\Diactoros\UploadedFileFactory',
             'Http\Factory\Guzzle\UploadedFileFactory',
             'Http\Factory\Slim\UploadedFileFactory',
             'Laminas\Diactoros\UploadedFileFactory',
             'Slim\Psr7\Factory\UploadedFileFactory',
+            'HttpSoft\Message\UploadedFileFactory',
         ],
         UriFactoryInterface::class => [
             'Phalcon\Http\Message\UriFactory',
             'Nyholm\Psr7\Factory\Psr17Factory',
-            'Zend\Diactoros\UriFactory',
             'GuzzleHttp\Psr7\HttpFactory',
             'Http\Factory\Diactoros\UriFactory',
             'Http\Factory\Guzzle\UriFactory',
             'Http\Factory\Slim\UriFactory',
             'Laminas\Diactoros\UriFactory',
             'Slim\Psr7\Factory\UriFactory',
+            'HttpSoft\Message\UriFactory',
         ],
     ];
 
-    /**
-     * {@inheritdoc}
-     */
     public static function getCandidates($type)
     {
         $candidates = [];

modules/paynow/vendor/php-http/discovery/src/Strategy/MockClientStrategy.php

@@ -13,9 +13,6 @@ use Http\Mock\Client as Mock;
  */
 final class MockClientStrategy implements DiscoveryStrategy
 {
-    /**
-     * {@inheritdoc}
-     */
     public static function getCandidates($type)
     {
         if (is_a(HttpClient::class, $type, true) || is_a(HttpAsyncClient::class, $type, true)) {

modules/paynow/vendor/php-http/discovery/src/Strategy/PuliBetaStrategy.php

@@ -11,6 +11,7 @@ use Puli\GeneratedPuliFactory;
  * Find candidates using Puli.
  *
  * @internal
+ *
  * @final
  *
  * @author David de Boer <david@ddeboer.nl>
@@ -71,9 +72,6 @@ class PuliBetaStrategy implements DiscoveryStrategy
         return self::$puliDiscovery;
     }
 
-    /**
-     * {@inheritdoc}
-     */
     public static function getCandidates($type)
     {
         $returnData = [];