Download project

vendor/symfony/http-client/CachingHttpClient.php

@@ -0,0 +1,144 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Symfony\Component\HttpClient\Response\MockResponse;
+use Symfony\Component\HttpClient\Response\ResponseStream;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\HttpCache\HttpCache;
+use Symfony\Component\HttpKernel\HttpCache\StoreInterface;
+use Symfony\Component\HttpKernel\HttpClientKernel;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+
+/**
+ * Adds caching on top of an HTTP client.
+ *
+ * The implementation buffers responses in memory and doesn't stream directly from the network.
+ * You can disable/enable this layer by setting option "no_cache" under "extra" to true/false.
+ * By default, caching is enabled unless the "buffer" option is set to false.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class CachingHttpClient implements HttpClientInterface
+{
+    use HttpClientTrait;
+
+    private $client;
+    private $cache;
+    private $defaultOptions = self::OPTIONS_DEFAULTS;
+
+    public function __construct(HttpClientInterface $client, StoreInterface $store, array $defaultOptions = [])
+    {
+        if (!class_exists(HttpClientKernel::class)) {
+            throw new \LogicException(sprintf('Using "%s" requires that the HttpKernel component version 4.3 or higher is installed, try running "composer require symfony/http-kernel:^4.3".', __CLASS__));
+        }
+
+        $this->client = $client;
+        $kernel = new HttpClientKernel($client);
+        $this->cache = new HttpCache($kernel, $store, null, $defaultOptions);
+
+        unset($defaultOptions['debug']);
+        unset($defaultOptions['default_ttl']);
+        unset($defaultOptions['private_headers']);
+        unset($defaultOptions['allow_reload']);
+        unset($defaultOptions['allow_revalidate']);
+        unset($defaultOptions['stale_while_revalidate']);
+        unset($defaultOptions['stale_if_error']);
+        unset($defaultOptions['trace_level']);
+        unset($defaultOptions['trace_header']);
+
+        if ($defaultOptions) {
+            [, $this->defaultOptions] = self::prepareRequest(null, null, $defaultOptions, $this->defaultOptions);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function request(string $method, string $url, array $options = []): ResponseInterface
+    {
+        [$url, $options] = $this->prepareRequest($method, $url, $options, $this->defaultOptions, true);
+        $url = implode('', $url);
+
+        if (!empty($options['body']) || !empty($options['extra']['no_cache']) || !\in_array($method, ['GET', 'HEAD', 'OPTIONS'])) {
+            return $this->client->request($method, $url, $options);
+        }
+
+        $request = Request::create($url, $method);
+        $request->attributes->set('http_client_options', $options);
+
+        foreach ($options['normalized_headers'] as $name => $values) {
+            if ('cookie' !== $name) {
+                foreach ($values as $value) {
+                    $request->headers->set($name, substr($value, 2 + \strlen($name)), false);
+                }
+
+                continue;
+            }
+
+            foreach ($values as $cookies) {
+                foreach (explode('; ', substr($cookies, \strlen('Cookie: '))) as $cookie) {
+                    if ('' !== $cookie) {
+                        $cookie = explode('=', $cookie, 2);
+                        $request->cookies->set($cookie[0], $cookie[1] ?? '');
+                    }
+                }
+            }
+        }
+
+        $response = $this->cache->handle($request);
+        $response = new MockResponse($response->getContent(), [
+            'http_code' => $response->getStatusCode(),
+            'response_headers' => $response->headers->allPreserveCase(),
+        ]);
+
+        return MockResponse::fromRequest($method, $url, $options, $response);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function stream($responses, float $timeout = null): ResponseStreamInterface
+    {
+        if ($responses instanceof ResponseInterface) {
+            $responses = [$responses];
+        } elseif (!is_iterable($responses)) {
+            throw new \TypeError(sprintf('"%s()" expects parameter 1 to be an iterable of ResponseInterface objects, "%s" given.', __METHOD__, \is_object($responses) ? \get_class($responses) : \gettype($responses)));
+        }
+
+        $mockResponses = [];
+        $clientResponses = [];
+
+        foreach ($responses as $response) {
+            if ($response instanceof MockResponse) {
+                $mockResponses[] = $response;
+            } else {
+                $clientResponses[] = $response;
+            }
+        }
+
+        if (!$mockResponses) {
+            return $this->client->stream($clientResponses, $timeout);
+        }
+
+        if (!$clientResponses) {
+            return new ResponseStream(MockResponse::stream($mockResponses, $timeout));
+        }
+
+        return new ResponseStream((function () use ($mockResponses, $clientResponses, $timeout) {
+            yield from MockResponse::stream($mockResponses, $timeout);
+            yield $this->client->stream($clientResponses, $timeout);
+        })());
+    }
+}

vendor/symfony/http-client/Chunk/DataChunk.php

@@ -0,0 +1,87 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Chunk;
+
+use Symfony\Contracts\HttpClient\ChunkInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class DataChunk implements ChunkInterface
+{
+    private $offset = 0;
+    private $content = '';
+
+    public function __construct(int $offset = 0, string $content = '')
+    {
+        $this->offset = $offset;
+        $this->content = $content;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isTimeout(): bool
+    {
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isFirst(): bool
+    {
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isLast(): bool
+    {
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getInformationalStatus(): ?array
+    {
+        return null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getContent(): string
+    {
+        return $this->content;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOffset(): int
+    {
+        return $this->offset;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getError(): ?string
+    {
+        return null;
+    }
+}

vendor/symfony/http-client/Chunk/ErrorChunk.php

@@ -0,0 +1,135 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Chunk;
+
+use Symfony\Component\HttpClient\Exception\TransportException;
+use Symfony\Contracts\HttpClient\ChunkInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class ErrorChunk implements ChunkInterface
+{
+    private $didThrow = false;
+    private $offset;
+    private $errorMessage;
+    private $error;
+
+    /**
+     * @param \Throwable|string $error
+     */
+    public function __construct(int $offset, $error)
+    {
+        $this->offset = $offset;
+
+        if (\is_string($error)) {
+            $this->errorMessage = $error;
+        } else {
+            $this->error = $error;
+            $this->errorMessage = $error->getMessage();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isTimeout(): bool
+    {
+        $this->didThrow = true;
+
+        if (null !== $this->error) {
+            throw new TransportException($this->errorMessage, 0, $this->error);
+        }
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isFirst(): bool
+    {
+        $this->didThrow = true;
+        throw new TransportException($this->errorMessage, 0, $this->error);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isLast(): bool
+    {
+        $this->didThrow = true;
+        throw new TransportException($this->errorMessage, 0, $this->error);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getInformationalStatus(): ?array
+    {
+        $this->didThrow = true;
+        throw new TransportException($this->errorMessage, 0, $this->error);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getContent(): string
+    {
+        $this->didThrow = true;
+        throw new TransportException($this->errorMessage, 0, $this->error);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOffset(): int
+    {
+        return $this->offset;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getError(): ?string
+    {
+        return $this->errorMessage;
+    }
+
+    /**
+     * @return bool Whether the wrapped error has been thrown or not
+     */
+    public function didThrow(): bool
+    {
+        return $this->didThrow;
+    }
+
+    public function __sleep()
+    {
+        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+    }
+
+    public function __wakeup()
+    {
+        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+    }
+
+    public function __destruct()
+    {
+        if (!$this->didThrow) {
+            $this->didThrow = true;
+            throw new TransportException($this->errorMessage, 0, $this->error);
+        }
+    }
+}

vendor/symfony/http-client/Chunk/FirstChunk.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Chunk;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class FirstChunk extends DataChunk
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function isFirst(): bool
+    {
+        return true;
+    }
+}

vendor/symfony/http-client/Chunk/InformationalChunk.php

@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Chunk;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class InformationalChunk extends DataChunk
+{
+    private $status;
+
+    public function __construct(int $statusCode, array $headers)
+    {
+        $this->status = [$statusCode, $headers];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getInformationalStatus(): ?array
+    {
+        return $this->status;
+    }
+}

vendor/symfony/http-client/Chunk/LastChunk.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Chunk;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class LastChunk extends DataChunk
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function isLast(): bool
+    {
+        return true;
+    }
+}

vendor/symfony/http-client/CurlHttpClient.php

@@ -0,0 +1,509 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Psr\Log\LoggerAwareInterface;
+use Psr\Log\LoggerAwareTrait;
+use Symfony\Component\HttpClient\Exception\InvalidArgumentException;
+use Symfony\Component\HttpClient\Exception\TransportException;
+use Symfony\Component\HttpClient\Internal\CurlClientState;
+use Symfony\Component\HttpClient\Internal\PushedResponse;
+use Symfony\Component\HttpClient\Response\CurlResponse;
+use Symfony\Component\HttpClient\Response\ResponseStream;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+use Symfony\Contracts\Service\ResetInterface;
+
+/**
+ * A performant implementation of the HttpClientInterface contracts based on the curl extension.
+ *
+ * This provides fully concurrent HTTP requests, with transparent
+ * HTTP/2 push when a curl version that supports it is installed.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class CurlHttpClient implements HttpClientInterface, LoggerAwareInterface, ResetInterface
+{
+    use HttpClientTrait;
+    use LoggerAwareTrait;
+
+    private $defaultOptions = self::OPTIONS_DEFAULTS + [
+        'auth_ntlm' => null, // array|string - an array containing the username as first value, and optionally the
+                             //   password as the second one; or string like username:password - enabling NTLM auth
+    ];
+
+    /**
+     * An internal object to share state between the client and its responses.
+     *
+     * @var CurlClientState
+     */
+    private $multi;
+
+    private static $curlVersion;
+
+    /**
+     * @param array $defaultOptions     Default request's options
+     * @param int   $maxHostConnections The maximum number of connections to a single host
+     * @param int   $maxPendingPushes   The maximum number of pushed responses to accept in the queue
+     *
+     * @see HttpClientInterface::OPTIONS_DEFAULTS for available options
+     */
+    public function __construct(array $defaultOptions = [], int $maxHostConnections = 6, int $maxPendingPushes = 50)
+    {
+        if (!\extension_loaded('curl')) {
+            throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\CurlHttpClient" as the "curl" extension is not installed.');
+        }
+
+        $this->defaultOptions['buffer'] = $this->defaultOptions['buffer'] ?? \Closure::fromCallable([__CLASS__, 'shouldBuffer']);
+
+        if ($defaultOptions) {
+            [, $this->defaultOptions] = self::prepareRequest(null, null, $defaultOptions, $this->defaultOptions);
+        }
+
+        $this->multi = new CurlClientState();
+        self::$curlVersion = self::$curlVersion ?? curl_version();
+
+        // Don't enable HTTP/1.1 pipelining: it forces responses to be sent in order
+        if (\defined('CURLPIPE_MULTIPLEX')) {
+            curl_multi_setopt($this->multi->handle, \CURLMOPT_PIPELINING, \CURLPIPE_MULTIPLEX);
+        }
+        if (\defined('CURLMOPT_MAX_HOST_CONNECTIONS')) {
+            $maxHostConnections = curl_multi_setopt($this->multi->handle, \CURLMOPT_MAX_HOST_CONNECTIONS, 0 < $maxHostConnections ? $maxHostConnections : \PHP_INT_MAX) ? 0 : $maxHostConnections;
+        }
+        if (\defined('CURLMOPT_MAXCONNECTS') && 0 < $maxHostConnections) {
+            curl_multi_setopt($this->multi->handle, \CURLMOPT_MAXCONNECTS, $maxHostConnections);
+        }
+
+        // Skip configuring HTTP/2 push when it's unsupported or buggy, see https://bugs.php.net/77535
+        if (0 >= $maxPendingPushes || \PHP_VERSION_ID < 70217 || (\PHP_VERSION_ID >= 70300 && \PHP_VERSION_ID < 70304)) {
+            return;
+        }
+
+        // HTTP/2 push crashes before curl 7.61
+        if (!\defined('CURLMOPT_PUSHFUNCTION') || 0x073d00 > self::$curlVersion['version_number'] || !(\CURL_VERSION_HTTP2 & self::$curlVersion['features'])) {
+            return;
+        }
+
+        curl_multi_setopt($this->multi->handle, \CURLMOPT_PUSHFUNCTION, function ($parent, $pushed, array $requestHeaders) use ($maxPendingPushes) {
+            return $this->handlePush($parent, $pushed, $requestHeaders, $maxPendingPushes);
+        });
+    }
+
+    /**
+     * @see HttpClientInterface::OPTIONS_DEFAULTS for available options
+     *
+     * {@inheritdoc}
+     */
+    public function request(string $method, string $url, array $options = []): ResponseInterface
+    {
+        [$url, $options] = self::prepareRequest($method, $url, $options, $this->defaultOptions);
+        $scheme = $url['scheme'];
+        $authority = $url['authority'];
+        $host = parse_url($authority, \PHP_URL_HOST);
+        $url = implode('', $url);
+
+        if (!isset($options['normalized_headers']['user-agent'])) {
+            $options['headers'][] = 'User-Agent: Symfony HttpClient/Curl';
+        }
+
+        $curlopts = [
+            \CURLOPT_URL => $url,
+            \CURLOPT_TCP_NODELAY => true,
+            \CURLOPT_PROTOCOLS => \CURLPROTO_HTTP | \CURLPROTO_HTTPS,
+            \CURLOPT_REDIR_PROTOCOLS => \CURLPROTO_HTTP | \CURLPROTO_HTTPS,
+            \CURLOPT_FOLLOWLOCATION => true,
+            \CURLOPT_MAXREDIRS => 0 < $options['max_redirects'] ? $options['max_redirects'] : 0,
+            \CURLOPT_COOKIEFILE => '', // Keep track of cookies during redirects
+            \CURLOPT_TIMEOUT => 0,
+            \CURLOPT_PROXY => $options['proxy'],
+            \CURLOPT_NOPROXY => $options['no_proxy'] ?? $_SERVER['no_proxy'] ?? $_SERVER['NO_PROXY'] ?? '',
+            \CURLOPT_SSL_VERIFYPEER => $options['verify_peer'],
+            \CURLOPT_SSL_VERIFYHOST => $options['verify_host'] ? 2 : 0,
+            \CURLOPT_CAINFO => $options['cafile'],
+            \CURLOPT_CAPATH => $options['capath'],
+            \CURLOPT_SSL_CIPHER_LIST => $options['ciphers'],
+            \CURLOPT_SSLCERT => $options['local_cert'],
+            \CURLOPT_SSLKEY => $options['local_pk'],
+            \CURLOPT_KEYPASSWD => $options['passphrase'],
+            \CURLOPT_CERTINFO => $options['capture_peer_cert_chain'],
+        ];
+
+        if (1.0 === (float) $options['http_version']) {
+            $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_0;
+        } elseif (1.1 === (float) $options['http_version']) {
+            $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_1;
+        } elseif (\defined('CURL_VERSION_HTTP2') && (\CURL_VERSION_HTTP2 & self::$curlVersion['features']) && ('https:' === $scheme || 2.0 === (float) $options['http_version'])) {
+            $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_2_0;
+        }
+
+        if (isset($options['auth_ntlm'])) {
+            $curlopts[\CURLOPT_HTTPAUTH] = \CURLAUTH_NTLM;
+            $curlopts[\CURLOPT_HTTP_VERSION] = \CURL_HTTP_VERSION_1_1;
+
+            if (\is_array($options['auth_ntlm'])) {
+                $count = \count($options['auth_ntlm']);
+                if ($count <= 0 || $count > 2) {
+                    throw new InvalidArgumentException(sprintf('Option "auth_ntlm" must contain 1 or 2 elements, %d given.', $count));
+                }
+
+                $options['auth_ntlm'] = implode(':', $options['auth_ntlm']);
+            }
+
+            if (!\is_string($options['auth_ntlm'])) {
+                throw new InvalidArgumentException(sprintf('Option "auth_ntlm" must be a string or an array, "%s" given.', \gettype($options['auth_ntlm'])));
+            }
+
+            $curlopts[\CURLOPT_USERPWD] = $options['auth_ntlm'];
+        }
+
+        if (!\ZEND_THREAD_SAFE) {
+            $curlopts[\CURLOPT_DNS_USE_GLOBAL_CACHE] = false;
+        }
+
+        if (\defined('CURLOPT_HEADEROPT') && \defined('CURLHEADER_SEPARATE')) {
+            $curlopts[\CURLOPT_HEADEROPT] = \CURLHEADER_SEPARATE;
+        }
+
+        // curl's resolve feature varies by host:port but ours varies by host only, let's handle this with our own DNS map
+        if (isset($this->multi->dnsCache->hostnames[$host])) {
+            $options['resolve'] += [$host => $this->multi->dnsCache->hostnames[$host]];
+        }
+
+        if ($options['resolve'] || $this->multi->dnsCache->evictions) {
+            // First reset any old DNS cache entries then add the new ones
+            $resolve = $this->multi->dnsCache->evictions;
+            $this->multi->dnsCache->evictions = [];
+            $port = parse_url($authority, \PHP_URL_PORT) ?: ('http:' === $scheme ? 80 : 443);
+
+            if ($resolve && 0x072a00 > self::$curlVersion['version_number']) {
+                // DNS cache removals require curl 7.42 or higher
+                // On lower versions, we have to create a new multi handle
+                curl_multi_close($this->multi->handle);
+                $this->multi->handle = (new self())->multi->handle;
+            }
+
+            foreach ($options['resolve'] as $host => $ip) {
+                $resolve[] = null === $ip ? "-$host:$port" : "$host:$port:$ip";
+                $this->multi->dnsCache->hostnames[$host] = $ip;
+                $this->multi->dnsCache->removals["-$host:$port"] = "-$host:$port";
+            }
+
+            $curlopts[\CURLOPT_RESOLVE] = $resolve;
+        }
+
+        if ('POST' === $method) {
+            // Use CURLOPT_POST to have browser-like POST-to-GET redirects for 301, 302 and 303
+            $curlopts[\CURLOPT_POST] = true;
+        } elseif ('HEAD' === $method) {
+            $curlopts[\CURLOPT_NOBODY] = true;
+        } else {
+            $curlopts[\CURLOPT_CUSTOMREQUEST] = $method;
+        }
+
+        if ('\\' !== \DIRECTORY_SEPARATOR && $options['timeout'] < 1) {
+            $curlopts[\CURLOPT_NOSIGNAL] = true;
+        }
+
+        if (\extension_loaded('zlib') && !isset($options['normalized_headers']['accept-encoding'])) {
+            $options['headers'][] = 'Accept-Encoding: gzip'; // Expose only one encoding, some servers mess up when more are provided
+        }
+
+        foreach ($options['headers'] as $header) {
+            if (':' === $header[-2] && \strlen($header) - 2 === strpos($header, ': ')) {
+                // curl requires a special syntax to send empty headers
+                $curlopts[\CURLOPT_HTTPHEADER][] = substr_replace($header, ';', -2);
+            } else {
+                $curlopts[\CURLOPT_HTTPHEADER][] = $header;
+            }
+        }
+
+        // Prevent curl from sending its default Accept and Expect headers
+        foreach (['accept', 'expect'] as $header) {
+            if (!isset($options['normalized_headers'][$header][0])) {
+                $curlopts[\CURLOPT_HTTPHEADER][] = $header.':';
+            }
+        }
+
+        if (!\is_string($body = $options['body'])) {
+            if (\is_resource($body)) {
+                $curlopts[\CURLOPT_INFILE] = $body;
+            } else {
+                $eof = false;
+                $buffer = '';
+                $curlopts[\CURLOPT_READFUNCTION] = static function ($ch, $fd, $length) use ($body, &$buffer, &$eof) {
+                    return self::readRequestBody($length, $body, $buffer, $eof);
+                };
+            }
+
+            if (isset($options['normalized_headers']['content-length'][0])) {
+                $curlopts[\CURLOPT_INFILESIZE] = substr($options['normalized_headers']['content-length'][0], \strlen('Content-Length: '));
+            } elseif (!isset($options['normalized_headers']['transfer-encoding'])) {
+                $curlopts[\CURLOPT_HTTPHEADER][] = 'Transfer-Encoding: chunked'; // Enable chunked request bodies
+            }
+
+            if ('POST' !== $method) {
+                $curlopts[\CURLOPT_UPLOAD] = true;
+            }
+        } elseif ('' !== $body || 'POST' === $method) {
+            $curlopts[\CURLOPT_POSTFIELDS] = $body;
+        }
+
+        if ($options['peer_fingerprint']) {
+            if (!isset($options['peer_fingerprint']['pin-sha256'])) {
+                throw new TransportException(__CLASS__.' supports only "pin-sha256" fingerprints.');
+            }
+
+            $curlopts[\CURLOPT_PINNEDPUBLICKEY] = 'sha256//'.implode(';sha256//', $options['peer_fingerprint']['pin-sha256']);
+        }
+
+        if ($options['bindto']) {
+            if (file_exists($options['bindto'])) {
+                $curlopts[\CURLOPT_UNIX_SOCKET_PATH] = $options['bindto'];
+            } elseif (0 !== strpos($options['bindto'], 'if!') && preg_match('/^(.*):(\d+)$/', $options['bindto'], $matches)) {
+                $curlopts[\CURLOPT_INTERFACE] = $matches[1];
+                $curlopts[\CURLOPT_LOCALPORT] = $matches[2];
+            } else {
+                $curlopts[\CURLOPT_INTERFACE] = $options['bindto'];
+            }
+        }
+
+        if (0 < $options['max_duration']) {
+            $curlopts[\CURLOPT_TIMEOUT_MS] = 1000 * $options['max_duration'];
+        }
+
+        if ($pushedResponse = $this->multi->pushedResponses[$url] ?? null) {
+            unset($this->multi->pushedResponses[$url]);
+
+            if (self::acceptPushForRequest($method, $options, $pushedResponse)) {
+                $this->logger && $this->logger->debug(sprintf('Accepting pushed response: "%s %s"', $method, $url));
+
+                // Reinitialize the pushed response with request's options
+                $ch = $pushedResponse->handle;
+                $pushedResponse = $pushedResponse->response;
+                $pushedResponse->__construct($this->multi, $url, $options, $this->logger);
+            } else {
+                $this->logger && $this->logger->debug(sprintf('Rejecting pushed response: "%s"', $url));
+                $pushedResponse = null;
+            }
+        }
+
+        if (!$pushedResponse) {
+            $ch = curl_init();
+            $this->logger && $this->logger->info(sprintf('Request: "%s %s"', $method, $url));
+        }
+
+        foreach ($curlopts as $opt => $value) {
+            if (null !== $value && !curl_setopt($ch, $opt, $value) && \CURLOPT_CERTINFO !== $opt) {
+                $constants = array_filter(get_defined_constants(), static function ($v, $k) use ($opt) {
+                    return $v === $opt && 'C' === $k[0] && (0 === strpos($k, 'CURLOPT_') || 0 === strpos($k, 'CURLINFO_'));
+                }, \ARRAY_FILTER_USE_BOTH);
+
+                throw new TransportException(sprintf('Curl option "%s" is not supported.', key($constants) ?? $opt));
+            }
+        }
+
+        return $pushedResponse ?? new CurlResponse($this->multi, $ch, $options, $this->logger, $method, self::createRedirectResolver($options, $host), self::$curlVersion['version_number']);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function stream($responses, float $timeout = null): ResponseStreamInterface
+    {
+        if ($responses instanceof CurlResponse) {
+            $responses = [$responses];
+        } elseif (!is_iterable($responses)) {
+            throw new \TypeError(sprintf('"%s()" expects parameter 1 to be an iterable of CurlResponse objects, "%s" given.', __METHOD__, \is_object($responses) ? \get_class($responses) : \gettype($responses)));
+        }
+
+        if (\is_resource($this->multi->handle) || $this->multi->handle instanceof \CurlMultiHandle) {
+            $active = 0;
+            while (\CURLM_CALL_MULTI_PERFORM === curl_multi_exec($this->multi->handle, $active));
+        }
+
+        return new ResponseStream(CurlResponse::stream($responses, $timeout));
+    }
+
+    public function reset()
+    {
+        if ($this->logger) {
+            foreach ($this->multi->pushedResponses as $url => $response) {
+                $this->logger->debug(sprintf('Unused pushed response: "%s"', $url));
+            }
+        }
+
+        $this->multi->pushedResponses = [];
+        $this->multi->dnsCache->evictions = $this->multi->dnsCache->evictions ?: $this->multi->dnsCache->removals;
+        $this->multi->dnsCache->removals = $this->multi->dnsCache->hostnames = [];
+
+        if (\is_resource($this->multi->handle) || $this->multi->handle instanceof \CurlMultiHandle) {
+            if (\defined('CURLMOPT_PUSHFUNCTION')) {
+                curl_multi_setopt($this->multi->handle, \CURLMOPT_PUSHFUNCTION, null);
+            }
+
+            $active = 0;
+            while (\CURLM_CALL_MULTI_PERFORM === curl_multi_exec($this->multi->handle, $active));
+        }
+
+        foreach ($this->multi->openHandles as [$ch]) {
+            if (\is_resource($ch) || $ch instanceof \CurlHandle) {
+                curl_setopt($ch, \CURLOPT_VERBOSE, false);
+            }
+        }
+    }
+
+    public function __sleep()
+    {
+        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+    }
+
+    public function __wakeup()
+    {
+        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+    }
+
+    public function __destruct()
+    {
+        $this->reset();
+    }
+
+    private function handlePush($parent, $pushed, array $requestHeaders, int $maxPendingPushes): int
+    {
+        $headers = [];
+        $origin = curl_getinfo($parent, \CURLINFO_EFFECTIVE_URL);
+
+        foreach ($requestHeaders as $h) {
+            if (false !== $i = strpos($h, ':', 1)) {
+                $headers[substr($h, 0, $i)][] = substr($h, 1 + $i);
+            }
+        }
+
+        if (!isset($headers[':method']) || !isset($headers[':scheme']) || !isset($headers[':authority']) || !isset($headers[':path'])) {
+            $this->logger && $this->logger->debug(sprintf('Rejecting pushed response from "%s": pushed headers are invalid', $origin));
+
+            return \CURL_PUSH_DENY;
+        }
+
+        $url = $headers[':scheme'][0].'://'.$headers[':authority'][0];
+
+        // curl before 7.65 doesn't validate the pushed ":authority" header,
+        // but this is a MUST in the HTTP/2 RFC; let's restrict pushes to the original host,
+        // ignoring domains mentioned as alt-name in the certificate for now (same as curl).
+        if (0 !== strpos($origin, $url.'/')) {
+            $this->logger && $this->logger->debug(sprintf('Rejecting pushed response from "%s": server is not authoritative for "%s"', $origin, $url));
+
+            return \CURL_PUSH_DENY;
+        }
+
+        if ($maxPendingPushes <= \count($this->multi->pushedResponses)) {
+            $fifoUrl = key($this->multi->pushedResponses);
+            unset($this->multi->pushedResponses[$fifoUrl]);
+            $this->logger && $this->logger->debug(sprintf('Evicting oldest pushed response: "%s"', $fifoUrl));
+        }
+
+        $url .= $headers[':path'][0];
+        $this->logger && $this->logger->debug(sprintf('Queueing pushed response: "%s"', $url));
+
+        $this->multi->pushedResponses[$url] = new PushedResponse(new CurlResponse($this->multi, $pushed), $headers, $this->multi->openHandles[(int) $parent][1] ?? [], $pushed);
+
+        return \CURL_PUSH_OK;
+    }
+
+    /**
+     * Accepts pushed responses only if their headers related to authentication match the request.
+     */
+    private static function acceptPushForRequest(string $method, array $options, PushedResponse $pushedResponse): bool
+    {
+        if ('' !== $options['body'] || $method !== $pushedResponse->requestHeaders[':method'][0]) {
+            return false;
+        }
+
+        foreach (['proxy', 'no_proxy', 'bindto', 'local_cert', 'local_pk'] as $k) {
+            if ($options[$k] !== $pushedResponse->parentOptions[$k]) {
+                return false;
+            }
+        }
+
+        foreach (['authorization', 'cookie', 'range', 'proxy-authorization'] as $k) {
+            $normalizedHeaders = $options['normalized_headers'][$k] ?? [];
+            foreach ($normalizedHeaders as $i => $v) {
+                $normalizedHeaders[$i] = substr($v, \strlen($k) + 2);
+            }
+
+            if (($pushedResponse->requestHeaders[$k] ?? []) !== $normalizedHeaders) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Wraps the request's body callback to allow it to return strings longer than curl requested.
+     */
+    private static function readRequestBody(int $length, \Closure $body, string &$buffer, bool &$eof): string
+    {
+        if (!$eof && \strlen($buffer) < $length) {
+            if (!\is_string($data = $body($length))) {
+                throw new TransportException(sprintf('The return value of the "body" option callback must be a string, "%s" returned.', \gettype($data)));
+            }
+
+            $buffer .= $data;
+            $eof = '' === $data;
+        }
+
+        $data = substr($buffer, 0, $length);
+        $buffer = substr($buffer, $length);
+
+        return $data;
+    }
+
+    /**
+     * Resolves relative URLs on redirects and deals with authentication headers.
+     *
+     * Work around CVE-2018-1000007: Authorization and Cookie headers should not follow redirects - fixed in Curl 7.64
+     */
+    private static function createRedirectResolver(array $options, string $host): \Closure
+    {
+        $redirectHeaders = [];
+        if (0 < $options['max_redirects']) {
+            $redirectHeaders['host'] = $host;
+            $redirectHeaders['with_auth'] = $redirectHeaders['no_auth'] = array_filter($options['headers'], static function ($h) {
+                return 0 !== stripos($h, 'Host:');
+            });
+
+            if (isset($options['normalized_headers']['authorization'][0]) || isset($options['normalized_headers']['cookie'][0])) {
+                $redirectHeaders['no_auth'] = array_filter($options['headers'], static function ($h) {
+                    return 0 !== stripos($h, 'Authorization:') && 0 !== stripos($h, 'Cookie:');
+                });
+            }
+        }
+
+        return static function ($ch, string $location) use ($redirectHeaders) {
+            try {
+                $location = self::parseUrl($location);
+            } catch (InvalidArgumentException $e) {
+                return null;
+            }
+
+            if ($redirectHeaders && $host = parse_url('http:'.$location['authority'], \PHP_URL_HOST)) {
+                $requestHeaders = $redirectHeaders['host'] === $host ? $redirectHeaders['with_auth'] : $redirectHeaders['no_auth'];
+                curl_setopt($ch, \CURLOPT_HTTPHEADER, $requestHeaders);
+            }
+
+            $url = self::parseUrl(curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL));
+
+            return implode('', self::resolveUrl($location, $url));
+        };
+    }
+}

vendor/symfony/http-client/DataCollector/HttpClientDataCollector.php

@@ -0,0 +1,142 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\DataCollector;
+
+use Symfony\Component\HttpClient\TraceableHttpClient;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\DataCollector\DataCollector;
+use Symfony\Component\HttpKernel\DataCollector\LateDataCollectorInterface;
+
+/**
+ * @author Jérémy Romey <jeremy@free-agent.fr>
+ */
+final class HttpClientDataCollector extends DataCollector implements LateDataCollectorInterface
+{
+    /**
+     * @var TraceableHttpClient[]
+     */
+    private $clients = [];
+
+    public function registerClient(string $name, TraceableHttpClient $client)
+    {
+        $this->clients[$name] = $client;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param \Throwable|null $exception
+     */
+    public function collect(Request $request, Response $response/*, \Throwable $exception = null*/)
+    {
+        $this->reset();
+
+        foreach ($this->clients as $name => $client) {
+            [$errorCount, $traces] = $this->collectOnClient($client);
+
+            $this->data['clients'][$name] = [
+                'traces' => $traces,
+                'error_count' => $errorCount,
+            ];
+
+            $this->data['request_count'] += \count($traces);
+            $this->data['error_count'] += $errorCount;
+        }
+    }
+
+    public function lateCollect()
+    {
+        foreach ($this->clients as $client) {
+            $client->reset();
+        }
+    }
+
+    public function getClients(): array
+    {
+        return $this->data['clients'] ?? [];
+    }
+
+    public function getRequestCount(): int
+    {
+        return $this->data['request_count'] ?? 0;
+    }
+
+    public function getErrorCount(): int
+    {
+        return $this->data['error_count'] ?? 0;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getName(): string
+    {
+        return 'http_client';
+    }
+
+    public function reset()
+    {
+        $this->data = [
+            'clients' => [],
+            'request_count' => 0,
+            'error_count' => 0,
+        ];
+    }
+
+    private function collectOnClient(TraceableHttpClient $client): array
+    {
+        $traces = $client->getTracedRequests();
+        $errorCount = 0;
+        $baseInfo = [
+            'response_headers' => 1,
+            'redirect_count' => 1,
+            'redirect_url' => 1,
+            'user_data' => 1,
+            'error' => 1,
+            'url' => 1,
+        ];
+
+        foreach ($traces as $i => $trace) {
+            if (400 <= ($trace['info']['http_code'] ?? 0)) {
+                ++$errorCount;
+            }
+
+            $info = $trace['info'];
+            $traces[$i]['http_code'] = $info['http_code'] ?? 0;
+
+            unset($info['filetime'], $info['http_code'], $info['ssl_verify_result'], $info['content_type']);
+
+            if (($info['http_method'] ?? null) === $trace['method']) {
+                unset($info['http_method']);
+            }
+
+            if (($info['url'] ?? null) === $trace['url']) {
+                unset($info['url']);
+            }
+
+            foreach ($info as $k => $v) {
+                if (!$v || (is_numeric($v) && 0 > $v)) {
+                    unset($info[$k]);
+                }
+            }
+
+            $debugInfo = array_diff_key($info, $baseInfo);
+            $info = array_diff_key($info, $debugInfo) + ['debug_info' => $debugInfo];
+            unset($traces[$i]['info']); // break PHP reference used by TraceableHttpClient
+            $traces[$i]['info'] = $this->cloneVar($info);
+            $traces[$i]['options'] = $this->cloneVar($trace['options']);
+        }
+
+        return [$errorCount, $traces];
+    }
+}

vendor/symfony/http-client/DependencyInjection/HttpClientPass.php

@@ -0,0 +1,45 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpClient\TraceableHttpClient;
+
+final class HttpClientPass implements CompilerPassInterface
+{
+    private $clientTag;
+
+    public function __construct(string $clientTag = 'http_client.client')
+    {
+        $this->clientTag = $clientTag;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function process(ContainerBuilder $container)
+    {
+        if (!$container->hasDefinition('data_collector.http_client')) {
+            return;
+        }
+
+        foreach ($container->findTaggedServiceIds($this->clientTag) as $id => $tags) {
+            $container->register('.debug.'.$id, TraceableHttpClient::class)
+                ->setArguments([new Reference('.debug.'.$id.'.inner')])
+                ->setDecoratedService($id);
+            $container->getDefinition('data_collector.http_client')
+                ->addMethodCall('registerClient', [$id, new Reference('.debug.'.$id)]);
+        }
+    }
+}

vendor/symfony/http-client/Exception/ClientException.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Exception;
+
+use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
+
+/**
+ * Represents a 4xx response.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class ClientException extends \RuntimeException implements ClientExceptionInterface
+{
+    use HttpExceptionTrait;
+}

vendor/symfony/http-client/Exception/HttpExceptionTrait.php

@@ -0,0 +1,78 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Exception;
+
+use Symfony\Contracts\HttpClient\ResponseInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+trait HttpExceptionTrait
+{
+    private $response;
+
+    public function __construct(ResponseInterface $response)
+    {
+        $this->response = $response;
+        $code = $response->getInfo('http_code');
+        $url = $response->getInfo('url');
+        $message = sprintf('HTTP %d returned for "%s".', $code, $url);
+
+        $httpCodeFound = false;
+        $isJson = false;
+        foreach (array_reverse($response->getInfo('response_headers')) as $h) {
+            if (0 === strpos($h, 'HTTP/')) {
+                if ($httpCodeFound) {
+                    break;
+                }
+
+                $message = sprintf('%s returned for "%s".', $h, $url);
+                $httpCodeFound = true;
+            }
+
+            if (0 === stripos($h, 'content-type:')) {
+                if (preg_match('/\bjson\b/i', $h)) {
+                    $isJson = true;
+                }
+
+                if ($httpCodeFound) {
+                    break;
+                }
+            }
+        }
+
+        // Try to guess a better error message using common API error formats
+        // The MIME type isn't explicitly checked because some formats inherit from others
+        // Ex: JSON:API follows RFC 7807 semantics, Hydra can be used in any JSON-LD-compatible format
+        if ($isJson && $body = json_decode($response->getContent(false), true)) {
+            if (isset($body['hydra:title']) || isset($body['hydra:description'])) {
+                // see http://www.hydra-cg.com/spec/latest/core/#description-of-http-status-codes-and-errors
+                $separator = isset($body['hydra:title'], $body['hydra:description']) ? "\n\n" : '';
+                $message = ($body['hydra:title'] ?? '').$separator.($body['hydra:description'] ?? '');
+            } elseif ((isset($body['title']) || isset($body['detail']))
+                && (is_scalar($body['title'] ?? '') && is_scalar($body['detail'] ?? ''))) {
+                // see RFC 7807 and https://jsonapi.org/format/#error-objects
+                $separator = isset($body['title'], $body['detail']) ? "\n\n" : '';
+                $message = ($body['title'] ?? '').$separator.($body['detail'] ?? '');
+            }
+        }
+
+        parent::__construct($message, $code);
+    }
+
+    public function getResponse(): ResponseInterface
+    {
+        return $this->response;
+    }
+}

vendor/symfony/http-client/Exception/InvalidArgumentException.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Exception;
+
+use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class InvalidArgumentException extends \InvalidArgumentException implements TransportExceptionInterface
+{
+}

vendor/symfony/http-client/Exception/JsonException.php

@@ -0,0 +1,23 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Exception;
+
+use Symfony\Contracts\HttpClient\Exception\DecodingExceptionInterface;
+
+/**
+ * Thrown by responses' toArray() method when their content cannot be JSON-decoded.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class JsonException extends \JsonException implements DecodingExceptionInterface
+{
+}

vendor/symfony/http-client/Exception/RedirectionException.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Exception;
+
+use Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface;
+
+/**
+ * Represents a 3xx response.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class RedirectionException extends \RuntimeException implements RedirectionExceptionInterface
+{
+    use HttpExceptionTrait;
+}

vendor/symfony/http-client/Exception/ServerException.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Exception;
+
+use Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface;
+
+/**
+ * Represents a 5xx response.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class ServerException extends \RuntimeException implements ServerExceptionInterface
+{
+    use HttpExceptionTrait;
+}

vendor/symfony/http-client/Exception/TransportException.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Exception;
+
+use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class TransportException extends \RuntimeException implements TransportExceptionInterface
+{
+}

vendor/symfony/http-client/HttpClient.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+
+/**
+ * A factory to instantiate the best possible HTTP client for the runtime.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class HttpClient
+{
+    /**
+     * @param array $defaultOptions     Default request's options
+     * @param int   $maxHostConnections The maximum number of connections to a single host
+     * @param int   $maxPendingPushes   The maximum number of pushed responses to accept in the queue
+     *
+     * @see HttpClientInterface::OPTIONS_DEFAULTS for available options
+     */
+    public static function create(array $defaultOptions = [], int $maxHostConnections = 6, int $maxPendingPushes = 50): HttpClientInterface
+    {
+        if (\extension_loaded('curl')) {
+            if ('\\' !== \DIRECTORY_SEPARATOR || isset($defaultOptions['cafile']) || isset($defaultOptions['capath']) || ini_get('curl.cainfo') || ini_get('openssl.cafile') || ini_get('openssl.capath')) {
+                return new CurlHttpClient($defaultOptions, $maxHostConnections, $maxPendingPushes);
+            }
+
+            @trigger_error('Configure the "curl.cainfo", "openssl.cafile" or "openssl.capath" php.ini setting to enable the CurlHttpClient', \E_USER_WARNING);
+        }
+
+        return new NativeHttpClient($defaultOptions, $maxHostConnections);
+    }
+
+    /**
+     * Creates a client that adds options (e.g. authentication headers) only when the request URL matches the provided base URI.
+     */
+    public static function createForBaseUri(string $baseUri, array $defaultOptions = [], int $maxHostConnections = 6, int $maxPendingPushes = 50): HttpClientInterface
+    {
+        $client = self::create([], $maxHostConnections, $maxPendingPushes);
+
+        return ScopingHttpClient::forBaseUri($client, $baseUri, $defaultOptions);
+    }
+}

vendor/symfony/http-client/HttpClientTrait.php

@@ -0,0 +1,568 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Symfony\Component\HttpClient\Exception\InvalidArgumentException;
+
+/**
+ * Provides the common logic from writing HttpClientInterface implementations.
+ *
+ * All methods are static to prevent implementers from creating memory leaks via circular references.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+trait HttpClientTrait
+{
+    private static $CHUNK_SIZE = 16372;
+
+    /**
+     * Validates and normalizes method, URL and options, and merges them with defaults.
+     *
+     * @throws InvalidArgumentException When a not-supported option is found
+     */
+    private static function prepareRequest(?string $method, ?string $url, array $options, array $defaultOptions = [], bool $allowExtraOptions = false): array
+    {
+        if (null !== $method) {
+            if (\strlen($method) !== strspn($method, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')) {
+                throw new InvalidArgumentException(sprintf('Invalid HTTP method "%s", only uppercase letters are accepted.', $method));
+            }
+            if (!$method) {
+                throw new InvalidArgumentException('The HTTP method can not be empty.');
+            }
+        }
+
+        $options = self::mergeDefaultOptions($options, $defaultOptions, $allowExtraOptions);
+
+        $buffer = $options['buffer'] ?? true;
+
+        if ($buffer instanceof \Closure) {
+            $options['buffer'] = static function (array $headers) use ($buffer) {
+                if (!\is_bool($buffer = $buffer($headers))) {
+                    if (!\is_array($bufferInfo = @stream_get_meta_data($buffer))) {
+                        throw new \LogicException(sprintf('The closure passed as option "buffer" must return bool or stream resource, got "%s".', \is_resource($buffer) ? get_resource_type($buffer).' resource' : \gettype($buffer)));
+                    }
+
+                    if (false === strpbrk($bufferInfo['mode'], 'acew+')) {
+                        throw new \LogicException(sprintf('The stream returned by the closure passed as option "buffer" must be writeable, got mode "%s".', $bufferInfo['mode']));
+                    }
+                }
+
+                return $buffer;
+            };
+        } elseif (!\is_bool($buffer)) {
+            if (!\is_array($bufferInfo = @stream_get_meta_data($buffer))) {
+                throw new InvalidArgumentException(sprintf('Option "buffer" must be bool, stream resource or Closure, "%s" given.', \is_resource($buffer) ? get_resource_type($buffer).' resource' : \gettype($buffer)));
+            }
+
+            if (false === strpbrk($bufferInfo['mode'], 'acew+')) {
+                throw new InvalidArgumentException(sprintf('The stream in option "buffer" must be writeable, mode "%s" given.', $bufferInfo['mode']));
+            }
+        }
+
+        if (isset($options['json'])) {
+            if (isset($options['body']) && '' !== $options['body']) {
+                throw new InvalidArgumentException('Define either the "json" or the "body" option, setting both is not supported.');
+            }
+            $options['body'] = self::jsonEncode($options['json']);
+            unset($options['json']);
+
+            if (!isset($options['normalized_headers']['content-type'])) {
+                $options['normalized_headers']['content-type'] = [$options['headers'][] = 'Content-Type: application/json'];
+            }
+        }
+
+        if (!isset($options['normalized_headers']['accept'])) {
+            $options['normalized_headers']['accept'] = [$options['headers'][] = 'Accept: */*'];
+        }
+
+        if (isset($options['body'])) {
+            $options['body'] = self::normalizeBody($options['body']);
+        }
+
+        if (isset($options['peer_fingerprint'])) {
+            $options['peer_fingerprint'] = self::normalizePeerFingerprint($options['peer_fingerprint']);
+        }
+
+        // Validate on_progress
+        if (!\is_callable($onProgress = $options['on_progress'] ?? 'var_dump')) {
+            throw new InvalidArgumentException(sprintf('Option "on_progress" must be callable, "%s" given.', \is_object($onProgress) ? \get_class($onProgress) : \gettype($onProgress)));
+        }
+
+        if (\is_array($options['auth_basic'] ?? null)) {
+            $count = \count($options['auth_basic']);
+            if ($count <= 0 || $count > 2) {
+                throw new InvalidArgumentException(sprintf('Option "auth_basic" must contain 1 or 2 elements, "%s" given.', $count));
+            }
+
+            $options['auth_basic'] = implode(':', $options['auth_basic']);
+        }
+
+        if (!\is_string($options['auth_basic'] ?? '')) {
+            throw new InvalidArgumentException(sprintf('Option "auth_basic" must be string or an array, "%s" given.', \gettype($options['auth_basic'])));
+        }
+
+        if (isset($options['auth_bearer'])) {
+            if (!\is_string($options['auth_bearer'])) {
+                throw new InvalidArgumentException(sprintf('Option "auth_bearer" must be a string, "%s" given.', \gettype($options['auth_bearer'])));
+            }
+            if (preg_match('{[^\x21-\x7E]}', $options['auth_bearer'])) {
+                throw new InvalidArgumentException('Invalid character found in option "auth_bearer": '.json_encode($options['auth_bearer']).'.');
+            }
+        }
+
+        if (isset($options['auth_basic'], $options['auth_bearer'])) {
+            throw new InvalidArgumentException('Define either the "auth_basic" or the "auth_bearer" option, setting both is not supported.');
+        }
+
+        if (null !== $url) {
+            // Merge auth with headers
+            if (($options['auth_basic'] ?? false) && !($options['normalized_headers']['authorization'] ?? false)) {
+                $options['normalized_headers']['authorization'] = [$options['headers'][] = 'Authorization: Basic '.base64_encode($options['auth_basic'])];
+            }
+            // Merge bearer with headers
+            if (($options['auth_bearer'] ?? false) && !($options['normalized_headers']['authorization'] ?? false)) {
+                $options['normalized_headers']['authorization'] = [$options['headers'][] = 'Authorization: Bearer '.$options['auth_bearer']];
+            }
+
+            unset($options['auth_basic'], $options['auth_bearer']);
+
+            // Parse base URI
+            if (\is_string($options['base_uri'])) {
+                $options['base_uri'] = self::parseUrl($options['base_uri']);
+            }
+
+            // Validate and resolve URL
+            $url = self::parseUrl($url, $options['query']);
+            $url = self::resolveUrl($url, $options['base_uri'], $defaultOptions['query'] ?? []);
+        }
+
+        // Finalize normalization of options
+        $options['http_version'] = (string) ($options['http_version'] ?? '') ?: null;
+        $options['timeout'] = (float) ($options['timeout'] ?? ini_get('default_socket_timeout'));
+        $options['max_duration'] = isset($options['max_duration']) ? (float) $options['max_duration'] : 0;
+
+        return [$url, $options];
+    }
+
+    /**
+     * @throws InvalidArgumentException When an invalid option is found
+     */
+    private static function mergeDefaultOptions(array $options, array $defaultOptions, bool $allowExtraOptions = false): array
+    {
+        $options['normalized_headers'] = self::normalizeHeaders($options['headers'] ?? []);
+
+        if ($defaultOptions['headers'] ?? false) {
+            $options['normalized_headers'] += self::normalizeHeaders($defaultOptions['headers']);
+        }
+
+        $options['headers'] = array_merge(...array_values($options['normalized_headers']) ?: [[]]);
+
+        if ($resolve = $options['resolve'] ?? false) {
+            $options['resolve'] = [];
+            foreach ($resolve as $k => $v) {
+                $options['resolve'][substr(self::parseUrl('http://'.$k)['authority'], 2)] = (string) $v;
+            }
+        }
+
+        // Option "query" is never inherited from defaults
+        $options['query'] = $options['query'] ?? [];
+
+        foreach ($defaultOptions as $k => $v) {
+            if ('normalized_headers' !== $k && !isset($options[$k])) {
+                $options[$k] = $v;
+            }
+        }
+
+        if (isset($defaultOptions['extra'])) {
+            $options['extra'] += $defaultOptions['extra'];
+        }
+
+        if ($resolve = $defaultOptions['resolve'] ?? false) {
+            foreach ($resolve as $k => $v) {
+                $options['resolve'] += [substr(self::parseUrl('http://'.$k)['authority'], 2) => (string) $v];
+            }
+        }
+
+        if ($allowExtraOptions || !$defaultOptions) {
+            return $options;
+        }
+
+        // Look for unsupported options
+        foreach ($options as $name => $v) {
+            if (\array_key_exists($name, $defaultOptions) || 'normalized_headers' === $name) {
+                continue;
+            }
+
+            if ('auth_ntlm' === $name) {
+                if (!\extension_loaded('curl')) {
+                    $msg = 'try installing the "curl" extension to use "%s" instead.';
+                } else {
+                    $msg = 'try using "%s" instead.';
+                }
+
+                throw new InvalidArgumentException(sprintf('Option "auth_ntlm" is not supported by "%s", '.$msg, __CLASS__, CurlHttpClient::class));
+            }
+
+            $alternatives = [];
+
+            foreach ($defaultOptions as $key => $v) {
+                if (levenshtein($name, $key) <= \strlen($name) / 3 || false !== strpos($key, $name)) {
+                    $alternatives[] = $key;
+                }
+            }
+
+            throw new InvalidArgumentException(sprintf('Unsupported option "%s" passed to "%s", did you mean "%s"?', $name, __CLASS__, implode('", "', $alternatives ?: array_keys($defaultOptions))));
+        }
+
+        return $options;
+    }
+
+    /**
+     * @return string[][]
+     *
+     * @throws InvalidArgumentException When an invalid header is found
+     */
+    private static function normalizeHeaders(array $headers): array
+    {
+        $normalizedHeaders = [];
+
+        foreach ($headers as $name => $values) {
+            if (\is_object($values) && method_exists($values, '__toString')) {
+                $values = (string) $values;
+            }
+
+            if (\is_int($name)) {
+                if (!\is_string($values)) {
+                    throw new InvalidArgumentException(sprintf('Invalid value for header "%s": expected string, "%s" given.', $name, \gettype($values)));
+                }
+                [$name, $values] = explode(':', $values, 2);
+                $values = [ltrim($values)];
+            } elseif (!is_iterable($values)) {
+                if (\is_object($values)) {
+                    throw new InvalidArgumentException(sprintf('Invalid value for header "%s": expected string, "%s" given.', $name, \get_class($values)));
+                }
+
+                $values = (array) $values;
+            }
+
+            $lcName = strtolower($name);
+            $normalizedHeaders[$lcName] = [];
+
+            foreach ($values as $value) {
+                $normalizedHeaders[$lcName][] = $value = $name.': '.$value;
+
+                if (\strlen($value) !== strcspn($value, "\r\n\0")) {
+                    throw new InvalidArgumentException(sprintf('Invalid header: CR/LF/NUL found in "%s".', $value));
+                }
+            }
+        }
+
+        return $normalizedHeaders;
+    }
+
+    /**
+     * @param array|string|resource|\Traversable|\Closure $body
+     *
+     * @return string|resource|\Closure
+     *
+     * @throws InvalidArgumentException When an invalid body is passed
+     */
+    private static function normalizeBody($body)
+    {
+        if (\is_array($body)) {
+            return http_build_query($body, '', '&', \PHP_QUERY_RFC1738);
+        }
+
+        if ($body instanceof \Traversable) {
+            $body = function () use ($body) { yield from $body; };
+        }
+
+        if ($body instanceof \Closure) {
+            $r = new \ReflectionFunction($body);
+            $body = $r->getClosure();
+
+            if ($r->isGenerator()) {
+                $body = $body(self::$CHUNK_SIZE);
+                $body = function () use ($body) {
+                    while ($body->valid()) {
+                        $chunk = $body->current();
+                        $body->next();
+
+                        if ('' !== $chunk) {
+                            return $chunk;
+                        }
+                    }
+
+                    return '';
+                };
+            }
+
+            return $body;
+        }
+
+        if (!\is_string($body) && !\is_array(@stream_get_meta_data($body))) {
+            throw new InvalidArgumentException(sprintf('Option "body" must be string, stream resource, iterable or callable, "%s" given.', \is_resource($body) ? get_resource_type($body) : \gettype($body)));
+        }
+
+        return $body;
+    }
+
+    /**
+     * @param string|string[] $fingerprint
+     *
+     * @throws InvalidArgumentException When an invalid fingerprint is passed
+     */
+    private static function normalizePeerFingerprint($fingerprint): array
+    {
+        if (\is_string($fingerprint)) {
+            switch (\strlen($fingerprint = str_replace(':', '', $fingerprint))) {
+                case 32: $fingerprint = ['md5' => $fingerprint]; break;
+                case 40: $fingerprint = ['sha1' => $fingerprint]; break;
+                case 44: $fingerprint = ['pin-sha256' => [$fingerprint]]; break;
+                case 64: $fingerprint = ['sha256' => $fingerprint]; break;
+                default: throw new InvalidArgumentException(sprintf('Cannot auto-detect fingerprint algorithm for "%s".', $fingerprint));
+            }
+        } elseif (\is_array($fingerprint)) {
+            foreach ($fingerprint as $algo => $hash) {
+                $fingerprint[$algo] = 'pin-sha256' === $algo ? (array) $hash : str_replace(':', '', $hash);
+            }
+        } else {
+            throw new InvalidArgumentException(sprintf('Option "peer_fingerprint" must be string or array, "%s" given.', \gettype($fingerprint)));
+        }
+
+        return $fingerprint;
+    }
+
+    /**
+     * @param mixed $value
+     *
+     * @throws InvalidArgumentException When the value cannot be json-encoded
+     */
+    private static function jsonEncode($value, int $flags = null, int $maxDepth = 512): string
+    {
+        $flags = $flags ?? (\JSON_HEX_TAG | \JSON_HEX_APOS | \JSON_HEX_AMP | \JSON_HEX_QUOT | \JSON_PRESERVE_ZERO_FRACTION);
+
+        try {
+            $value = json_encode($value, $flags | (\PHP_VERSION_ID >= 70300 ? \JSON_THROW_ON_ERROR : 0), $maxDepth);
+        } catch (\JsonException $e) {
+            throw new InvalidArgumentException('Invalid value for "json" option: '.$e->getMessage());
+        }
+
+        if (\PHP_VERSION_ID < 70300 && \JSON_ERROR_NONE !== json_last_error() && (false === $value || !($flags & \JSON_PARTIAL_OUTPUT_ON_ERROR))) {
+            throw new InvalidArgumentException('Invalid value for "json" option: '.json_last_error_msg());
+        }
+
+        return $value;
+    }
+
+    /**
+     * Resolves a URL against a base URI.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-5.2.2
+     *
+     * @throws InvalidArgumentException When an invalid URL is passed
+     */
+    private static function resolveUrl(array $url, ?array $base, array $queryDefaults = []): array
+    {
+        if (null !== $base && '' === ($base['scheme'] ?? '').($base['authority'] ?? '')) {
+            throw new InvalidArgumentException(sprintf('Invalid "base_uri" option: host or scheme is missing in "%s".', implode('', $base)));
+        }
+
+        if (null === $url['scheme'] && (null === $base || null === $base['scheme'])) {
+            throw new InvalidArgumentException(sprintf('Invalid URL: scheme is missing in "%s". Did you forget to add "http(s)://"?', implode('', $base ?? $url)));
+        }
+
+        if (null === $base && '' === $url['scheme'].$url['authority']) {
+            throw new InvalidArgumentException(sprintf('Invalid URL: no "base_uri" option was provided and host or scheme is missing in "%s".', implode('', $url)));
+        }
+
+        if (null !== $url['scheme']) {
+            $url['path'] = self::removeDotSegments($url['path'] ?? '');
+        } else {
+            if (null !== $url['authority']) {
+                $url['path'] = self::removeDotSegments($url['path'] ?? '');
+            } else {
+                if (null === $url['path']) {
+                    $url['path'] = $base['path'];
+                    $url['query'] = $url['query'] ?? $base['query'];
+                } else {
+                    if ('/' !== $url['path'][0]) {
+                        if (null === $base['path']) {
+                            $url['path'] = '/'.$url['path'];
+                        } else {
+                            $segments = explode('/', $base['path']);
+                            array_splice($segments, -1, 1, [$url['path']]);
+                            $url['path'] = implode('/', $segments);
+                        }
+                    }
+
+                    $url['path'] = self::removeDotSegments($url['path']);
+                }
+
+                $url['authority'] = $base['authority'];
+
+                if ($queryDefaults) {
+                    $url['query'] = '?'.self::mergeQueryString(substr($url['query'] ?? '', 1), $queryDefaults, false);
+                }
+            }
+
+            $url['scheme'] = $base['scheme'];
+        }
+
+        if ('' === ($url['path'] ?? '')) {
+            $url['path'] = '/';
+        }
+
+        return $url;
+    }
+
+    /**
+     * Parses a URL and fixes its encoding if needed.
+     *
+     * @throws InvalidArgumentException When an invalid URL is passed
+     */
+    private static function parseUrl(string $url, array $query = [], array $allowedSchemes = ['http' => 80, 'https' => 443]): array
+    {
+        if (false === $parts = parse_url($url)) {
+            throw new InvalidArgumentException(sprintf('Malformed URL "%s".', $url));
+        }
+
+        if ($query) {
+            $parts['query'] = self::mergeQueryString($parts['query'] ?? null, $query, true);
+        }
+
+        $port = $parts['port'] ?? 0;
+
+        if (null !== $scheme = $parts['scheme'] ?? null) {
+            if (!isset($allowedSchemes[$scheme = strtolower($scheme)])) {
+                throw new InvalidArgumentException(sprintf('Unsupported scheme in "%s".', $url));
+            }
+
+            $port = $allowedSchemes[$scheme] === $port ? 0 : $port;
+            $scheme .= ':';
+        }
+
+        if (null !== $host = $parts['host'] ?? null) {
+            if (!\defined('INTL_IDNA_VARIANT_UTS46') && preg_match('/[\x80-\xFF]/', $host)) {
+                throw new InvalidArgumentException(sprintf('Unsupported IDN "%s", try enabling the "intl" PHP extension or running "composer require symfony/polyfill-intl-idn".', $host));
+            }
+
+            $host = \defined('INTL_IDNA_VARIANT_UTS46') ? idn_to_ascii($host, \IDNA_DEFAULT, \INTL_IDNA_VARIANT_UTS46) ?: strtolower($host) : strtolower($host);
+            $host .= $port ? ':'.$port : '';
+        }
+
+        foreach (['user', 'pass', 'path', 'query', 'fragment'] as $part) {
+            if (!isset($parts[$part])) {
+                continue;
+            }
+
+            if (false !== strpos($parts[$part], '%')) {
+                // https://tools.ietf.org/html/rfc3986#section-2.3
+                $parts[$part] = preg_replace_callback('/%(?:2[DE]|3[0-9]|[46][1-9A-F]|5F|[57][0-9A]|7E)++/i', function ($m) { return rawurldecode($m[0]); }, $parts[$part]);
+            }
+
+            // https://tools.ietf.org/html/rfc3986#section-3.3
+            $parts[$part] = preg_replace_callback("#[^-A-Za-z0-9._~!$&/'()*+,;=:@%]++#", function ($m) { return rawurlencode($m[0]); }, $parts[$part]);
+        }
+
+        return [
+            'scheme' => $scheme,
+            'authority' => null !== $host ? '//'.(isset($parts['user']) ? $parts['user'].(isset($parts['pass']) ? ':'.$parts['pass'] : '').'@' : '').$host : null,
+            'path' => isset($parts['path'][0]) ? $parts['path'] : null,
+            'query' => isset($parts['query']) ? '?'.$parts['query'] : null,
+            'fragment' => isset($parts['fragment']) ? '#'.$parts['fragment'] : null,
+        ];
+    }
+
+    /**
+     * Removes dot-segments from a path.
+     *
+     * @see https://tools.ietf.org/html/rfc3986#section-5.2.4
+     */
+    private static function removeDotSegments(string $path)
+    {
+        $result = '';
+
+        while (!\in_array($path, ['', '.', '..'], true)) {
+            if ('.' === $path[0] && (0 === strpos($path, $p = '../') || 0 === strpos($path, $p = './'))) {
+                $path = substr($path, \strlen($p));
+            } elseif ('/.' === $path || 0 === strpos($path, '/./')) {
+                $path = substr_replace($path, '/', 0, 3);
+            } elseif ('/..' === $path || 0 === strpos($path, '/../')) {
+                $i = strrpos($result, '/');
+                $result = $i ? substr($result, 0, $i) : '';
+                $path = substr_replace($path, '/', 0, 4);
+            } else {
+                $i = strpos($path, '/', 1) ?: \strlen($path);
+                $result .= substr($path, 0, $i);
+                $path = substr($path, $i);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Merges and encodes a query array with a query string.
+     *
+     * @throws InvalidArgumentException When an invalid query-string value is passed
+     */
+    private static function mergeQueryString(?string $queryString, array $queryArray, bool $replace): ?string
+    {
+        if (!$queryArray) {
+            return $queryString;
+        }
+
+        $query = [];
+
+        if (null !== $queryString) {
+            foreach (explode('&', $queryString) as $v) {
+                if ('' !== $v) {
+                    $k = urldecode(explode('=', $v, 2)[0]);
+                    $query[$k] = (isset($query[$k]) ? $query[$k].'&' : '').$v;
+                }
+            }
+        }
+
+        if ($replace) {
+            foreach ($queryArray as $k => $v) {
+                if (null === $v) {
+                    unset($query[$k]);
+                }
+            }
+        }
+
+        $queryString = http_build_query($queryArray, '', '&', \PHP_QUERY_RFC3986);
+        $queryArray = [];
+
+        if ($queryString) {
+            foreach (explode('&', $queryString) as $v) {
+                $queryArray[rawurldecode(explode('=', $v, 2)[0])] = $v;
+            }
+        }
+
+        return implode('&', $replace ? array_replace($query, $queryArray) : ($query + $queryArray));
+    }
+
+    private static function shouldBuffer(array $headers): bool
+    {
+        if (null === $contentType = $headers['content-type'][0] ?? null) {
+            return false;
+        }
+
+        if (false !== $i = strpos($contentType, ';')) {
+            $contentType = substr($contentType, 0, $i);
+        }
+
+        return $contentType && preg_match('#^(?:text/|application/(?:.+\+)?(?:json|xml)$)#i', $contentType);
+    }
+}

vendor/symfony/http-client/HttpOptions.php

@@ -0,0 +1,321 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+
+/**
+ * A helper providing autocompletion for available options.
+ *
+ * @see HttpClientInterface for a description of each options.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class HttpOptions
+{
+    private $options = [];
+
+    public function toArray(): array
+    {
+        return $this->options;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setAuthBasic(string $user, string $password = '')
+    {
+        $this->options['auth_basic'] = $user;
+
+        if ('' !== $password) {
+            $this->options['auth_basic'] .= ':'.$password;
+        }
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setAuthBearer(string $token)
+    {
+        $this->options['auth_bearer'] = $token;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setQuery(array $query)
+    {
+        $this->options['query'] = $query;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setHeaders(iterable $headers)
+    {
+        $this->options['headers'] = $headers;
+
+        return $this;
+    }
+
+    /**
+     * @param array|string|resource|\Traversable|\Closure $body
+     *
+     * @return $this
+     */
+    public function setBody($body)
+    {
+        $this->options['body'] = $body;
+
+        return $this;
+    }
+
+    /**
+     * @param mixed $json
+     *
+     * @return $this
+     */
+    public function setJson($json)
+    {
+        $this->options['json'] = $json;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setUserData($data)
+    {
+        $this->options['user_data'] = $data;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setMaxRedirects(int $max)
+    {
+        $this->options['max_redirects'] = $max;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setHttpVersion(string $version)
+    {
+        $this->options['http_version'] = $version;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setBaseUri(string $uri)
+    {
+        $this->options['base_uri'] = $uri;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function buffer(bool $buffer)
+    {
+        $this->options['buffer'] = $buffer;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setOnProgress(callable $callback)
+    {
+        $this->options['on_progress'] = $callback;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function resolve(array $hostIps)
+    {
+        $this->options['resolve'] = $hostIps;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setProxy(string $proxy)
+    {
+        $this->options['proxy'] = $proxy;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setNoProxy(string $noProxy)
+    {
+        $this->options['no_proxy'] = $noProxy;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setTimeout(float $timeout)
+    {
+        $this->options['timeout'] = $timeout;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function bindTo(string $bindto)
+    {
+        $this->options['bindto'] = $bindto;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function verifyPeer(bool $verify)
+    {
+        $this->options['verify_peer'] = $verify;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function verifyHost(bool $verify)
+    {
+        $this->options['verify_host'] = $verify;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setCaFile(string $cafile)
+    {
+        $this->options['cafile'] = $cafile;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setCaPath(string $capath)
+    {
+        $this->options['capath'] = $capath;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setLocalCert(string $cert)
+    {
+        $this->options['local_cert'] = $cert;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setLocalPk(string $pk)
+    {
+        $this->options['local_pk'] = $pk;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setPassphrase(string $passphrase)
+    {
+        $this->options['passphrase'] = $passphrase;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setCiphers(string $ciphers)
+    {
+        $this->options['ciphers'] = $ciphers;
+
+        return $this;
+    }
+
+    /**
+     * @param string|array $fingerprint
+     *
+     * @return $this
+     */
+    public function setPeerFingerprint($fingerprint)
+    {
+        $this->options['peer_fingerprint'] = $fingerprint;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function capturePeerCertChain(bool $capture)
+    {
+        $this->options['capture_peer_cert_chain'] = $capture;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setExtra(string $name, $value)
+    {
+        $this->options['extra'][$name] = $value;
+
+        return $this;
+    }
+}

vendor/symfony/http-client/HttplugClient.php

@@ -0,0 +1,257 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use GuzzleHttp\Promise\Promise as GuzzlePromise;
+use GuzzleHttp\Promise\RejectedPromise;
+use Http\Client\Exception\NetworkException;
+use Http\Client\Exception\RequestException;
+use Http\Client\HttpAsyncClient;
+use Http\Client\HttpClient as HttplugInterface;
+use Http\Discovery\Exception\NotFoundException;
+use Http\Discovery\Psr17FactoryDiscovery;
+use Http\Message\RequestFactory;
+use Http\Message\StreamFactory;
+use Http\Message\UriFactory;
+use Http\Promise\Promise;
+use Nyholm\Psr7\Factory\Psr17Factory;
+use Nyholm\Psr7\Request;
+use Nyholm\Psr7\Uri;
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface as Psr7ResponseInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UriFactoryInterface;
+use Psr\Http\Message\UriInterface;
+use Symfony\Component\HttpClient\Internal\HttplugWaitLoop;
+use Symfony\Component\HttpClient\Response\HttplugPromise;
+use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+
+if (!interface_exists(HttplugInterface::class)) {
+    throw new \LogicException('You cannot use "Symfony\Component\HttpClient\HttplugClient" as the "php-http/httplug" package is not installed. Try running "composer require php-http/httplug".');
+}
+
+if (!interface_exists(RequestFactory::class)) {
+    throw new \LogicException('You cannot use "Symfony\Component\HttpClient\HttplugClient" as the "php-http/message-factory" package is not installed. Try running "composer require nyholm/psr7".');
+}
+
+/**
+ * An adapter to turn a Symfony HttpClientInterface into an Httplug client.
+ *
+ * Run "composer require nyholm/psr7" to install an efficient implementation of response
+ * and stream factories with flex-provided autowiring aliases.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class HttplugClient implements HttplugInterface, HttpAsyncClient, RequestFactory, StreamFactory, UriFactory
+{
+    private $client;
+    private $responseFactory;
+    private $streamFactory;
+    private $promisePool;
+    private $waitLoop;
+
+    public function __construct(HttpClientInterface $client = null, ResponseFactoryInterface $responseFactory = null, StreamFactoryInterface $streamFactory = null)
+    {
+        $this->client = $client ?? HttpClient::create();
+        $this->responseFactory = $responseFactory;
+        $this->streamFactory = $streamFactory ?? ($responseFactory instanceof StreamFactoryInterface ? $responseFactory : null);
+        $this->promisePool = \function_exists('GuzzleHttp\Promise\queue') ? new \SplObjectStorage() : null;
+
+        if (null === $this->responseFactory || null === $this->streamFactory) {
+            if (!class_exists(Psr17Factory::class) && !class_exists(Psr17FactoryDiscovery::class)) {
+                throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\HttplugClient" as no PSR-17 factories have been provided. Try running "composer require nyholm/psr7".');
+            }
+
+            try {
+                $psr17Factory = class_exists(Psr17Factory::class, false) ? new Psr17Factory() : null;
+                $this->responseFactory = $this->responseFactory ?? $psr17Factory ?? Psr17FactoryDiscovery::findResponseFactory();
+                $this->streamFactory = $this->streamFactory ?? $psr17Factory ?? Psr17FactoryDiscovery::findStreamFactory();
+            } catch (NotFoundException $e) {
+                throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\HttplugClient" as no PSR-17 factories have been found. Try running "composer require nyholm/psr7".', 0, $e);
+            }
+        }
+
+        $this->waitLoop = new HttplugWaitLoop($this->client, $this->promisePool, $this->responseFactory, $this->streamFactory);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function sendRequest(RequestInterface $request): Psr7ResponseInterface
+    {
+        try {
+            return $this->waitLoop->createPsr7Response($this->sendPsr7Request($request));
+        } catch (TransportExceptionInterface $e) {
+            throw new NetworkException($e->getMessage(), $request, $e);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return HttplugPromise
+     */
+    public function sendAsyncRequest(RequestInterface $request): Promise
+    {
+        if (!$promisePool = $this->promisePool) {
+            throw new \LogicException(sprintf('You cannot use "%s()" as the "guzzlehttp/promises" package is not installed. Try running "composer require guzzlehttp/promises".', __METHOD__));
+        }
+
+        try {
+            $response = $this->sendPsr7Request($request, true);
+        } catch (NetworkException $e) {
+            return new HttplugPromise(new RejectedPromise($e));
+        }
+
+        $waitLoop = $this->waitLoop;
+
+        $promise = new GuzzlePromise(static function () use ($response, $waitLoop) {
+            $waitLoop->wait($response);
+        }, static function () use ($response, $promisePool) {
+            $response->cancel();
+            unset($promisePool[$response]);
+        });
+
+        $promisePool[$response] = [$request, $promise];
+
+        return new HttplugPromise($promise);
+    }
+
+    /**
+     * Resolves pending promises that complete before the timeouts are reached.
+     *
+     * When $maxDuration is null and $idleTimeout is reached, promises are rejected.
+     *
+     * @return int The number of remaining pending promises
+     */
+    public function wait(float $maxDuration = null, float $idleTimeout = null): int
+    {
+        return $this->waitLoop->wait(null, $maxDuration, $idleTimeout);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createRequest($method, $uri, array $headers = [], $body = null, $protocolVersion = '1.1'): RequestInterface
+    {
+        if ($this->responseFactory instanceof RequestFactoryInterface) {
+            $request = $this->responseFactory->createRequest($method, $uri);
+        } elseif (class_exists(Request::class)) {
+            $request = new Request($method, $uri);
+        } elseif (class_exists(Psr17FactoryDiscovery::class)) {
+            $request = Psr17FactoryDiscovery::findRequestFactory()->createRequest($method, $uri);
+        } else {
+            throw new \LogicException(sprintf('You cannot use "%s()" as the "nyholm/psr7" package is not installed. Try running "composer require nyholm/psr7".', __METHOD__));
+        }
+
+        $request = $request
+            ->withProtocolVersion($protocolVersion)
+            ->withBody($this->createStream($body))
+        ;
+
+        foreach ($headers as $name => $value) {
+            $request = $request->withAddedHeader($name, $value);
+        }
+
+        return $request;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createStream($body = null): StreamInterface
+    {
+        if ($body instanceof StreamInterface) {
+            return $body;
+        }
+
+        if (\is_string($body ?? '')) {
+            $stream = $this->streamFactory->createStream($body ?? '');
+        } elseif (\is_resource($body)) {
+            $stream = $this->streamFactory->createStreamFromResource($body);
+        } else {
+            throw new \InvalidArgumentException(sprintf('"%s()" expects string, resource or StreamInterface, "%s" given.', __METHOD__, \gettype($body)));
+        }
+
+        if ($stream->isSeekable()) {
+            $stream->seek(0);
+        }
+
+        return $stream;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createUri($uri): UriInterface
+    {
+        if ($uri instanceof UriInterface) {
+            return $uri;
+        }
+
+        if ($this->responseFactory instanceof UriFactoryInterface) {
+            return $this->responseFactory->createUri($uri);
+        }
+
+        if (class_exists(Uri::class)) {
+            return new Uri($uri);
+        }
+
+        if (class_exists(Psr17FactoryDiscovery::class)) {
+            return Psr17FactoryDiscovery::findUrlFactory()->createUri($uri);
+        }
+
+        throw new \LogicException(sprintf('You cannot use "%s()" as the "nyholm/psr7" package is not installed. Try running "composer require nyholm/psr7".', __METHOD__));
+    }
+
+    public function __sleep()
+    {
+        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+    }
+
+    public function __wakeup()
+    {
+        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+    }
+
+    public function __destruct()
+    {
+        $this->wait();
+    }
+
+    private function sendPsr7Request(RequestInterface $request, bool $buffer = null): ResponseInterface
+    {
+        try {
+            $body = $request->getBody();
+
+            if ($body->isSeekable()) {
+                $body->seek(0);
+            }
+
+            return $this->client->request($request->getMethod(), (string) $request->getUri(), [
+                'headers' => $request->getHeaders(),
+                'body' => $body->getContents(),
+                'http_version' => '1.0' === $request->getProtocolVersion() ? '1.0' : null,
+                'buffer' => $buffer,
+            ]);
+        } catch (\InvalidArgumentException $e) {
+            throw new RequestException($e->getMessage(), $request, $e);
+        } catch (TransportExceptionInterface $e) {
+            throw new NetworkException($e->getMessage(), $request, $e);
+        }
+    }
+}

vendor/symfony/http-client/Internal/Canary.php

@@ -0,0 +1,40 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Internal;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+final class Canary
+{
+    private $canceller;
+
+    public function __construct(\Closure $canceller)
+    {
+        $this->canceller = $canceller;
+    }
+
+    public function cancel()
+    {
+        if (($canceller = $this->canceller) instanceof \Closure) {
+            $this->canceller = null;
+            $canceller();
+        }
+    }
+
+    public function __destruct()
+    {
+        $this->cancel();
+    }
+}

vendor/symfony/http-client/Internal/ClientState.php

@@ -0,0 +1,25 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Internal;
+
+/**
+ * Internal representation of the client state.
+ *
+ * @author Alexander M. Turek <me@derrabus.de>
+ *
+ * @internal
+ */
+class ClientState
+{
+    public $handlesActivity = [];
+    public $openHandles = [];
+}

vendor/symfony/http-client/Internal/CurlClientState.php

@@ -0,0 +1,35 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Internal;
+
+/**
+ * Internal representation of the cURL client's state.
+ *
+ * @author Alexander M. Turek <me@derrabus.de>
+ *
+ * @internal
+ */
+final class CurlClientState extends ClientState
+{
+    /** @var \CurlMultiHandle|resource */
+    public $handle;
+    /** @var PushedResponse[] */
+    public $pushedResponses = [];
+    /** @var DnsCache */
+    public $dnsCache;
+
+    public function __construct()
+    {
+        $this->handle = curl_multi_init();
+        $this->dnsCache = new DnsCache();
+    }
+}

vendor/symfony/http-client/Internal/DnsCache.php

@@ -0,0 +1,39 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Internal;
+
+/**
+ * Cache for resolved DNS queries.
+ *
+ * @author Alexander M. Turek <me@derrabus.de>
+ *
+ * @internal
+ */
+final class DnsCache
+{
+    /**
+     * Resolved hostnames (hostname => IP address).
+     *
+     * @var string[]
+     */
+    public $hostnames = [];
+
+    /**
+     * @var string[]
+     */
+    public $removals = [];
+
+    /**
+     * @var string[]
+     */
+    public $evictions = [];
+}

vendor/symfony/http-client/Internal/HttplugWaitLoop.php

@@ -0,0 +1,136 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Internal;
+
+use Http\Client\Exception\NetworkException;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface as Psr7ResponseInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Symfony\Component\HttpClient\Response\ResponseTrait;
+use Symfony\Component\HttpClient\Response\StreamWrapper;
+use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+final class HttplugWaitLoop
+{
+    private $client;
+    private $promisePool;
+    private $responseFactory;
+    private $streamFactory;
+
+    public function __construct(HttpClientInterface $client, ?\SplObjectStorage $promisePool, ResponseFactoryInterface $responseFactory, StreamFactoryInterface $streamFactory)
+    {
+        $this->client = $client;
+        $this->promisePool = $promisePool;
+        $this->responseFactory = $responseFactory;
+        $this->streamFactory = $streamFactory;
+    }
+
+    public function wait(?ResponseInterface $pendingResponse, float $maxDuration = null, float $idleTimeout = null): int
+    {
+        if (!$this->promisePool) {
+            return 0;
+        }
+
+        $guzzleQueue = \GuzzleHttp\Promise\queue();
+
+        if (0.0 === $remainingDuration = $maxDuration) {
+            $idleTimeout = 0.0;
+        } elseif (null !== $maxDuration) {
+            $startTime = microtime(true);
+            $idleTimeout = max(0.0, min($maxDuration / 5, $idleTimeout ?? $maxDuration));
+        }
+
+        do {
+            foreach ($this->client->stream($this->promisePool, $idleTimeout) as $response => $chunk) {
+                try {
+                    if (null !== $maxDuration && $chunk->isTimeout()) {
+                        goto check_duration;
+                    }
+
+                    if ($chunk->isFirst()) {
+                        // Deactivate throwing on 3/4/5xx
+                        $response->getStatusCode();
+                    }
+
+                    if (!$chunk->isLast()) {
+                        goto check_duration;
+                    }
+
+                    if ([$request, $promise] = $this->promisePool[$response] ?? null) {
+                        unset($this->promisePool[$response]);
+                        $promise->resolve($this->createPsr7Response($response, true));
+                    }
+                } catch (\Exception $e) {
+                    if ([$request, $promise] = $this->promisePool[$response] ?? null) {
+                        unset($this->promisePool[$response]);
+
+                        if ($e instanceof TransportExceptionInterface) {
+                            $e = new NetworkException($e->getMessage(), $request, $e);
+                        }
+
+                        $promise->reject($e);
+                    }
+                }
+
+                $guzzleQueue->run();
+
+                if ($pendingResponse === $response) {
+                    return $this->promisePool->count();
+                }
+
+                check_duration:
+                if (null !== $maxDuration && $idleTimeout && $idleTimeout > $remainingDuration = max(0.0, $maxDuration - microtime(true) + $startTime)) {
+                    $idleTimeout = $remainingDuration / 5;
+                    break;
+                }
+            }
+
+            if (!$count = $this->promisePool->count()) {
+                return 0;
+            }
+        } while (null === $maxDuration || 0 < $remainingDuration);
+
+        return $count;
+    }
+
+    public function createPsr7Response(ResponseInterface $response, bool $buffer = false): Psr7ResponseInterface
+    {
+        $psrResponse = $this->responseFactory->createResponse($response->getStatusCode());
+
+        foreach ($response->getHeaders(false) as $name => $values) {
+            foreach ($values as $value) {
+                $psrResponse = $psrResponse->withAddedHeader($name, $value);
+            }
+        }
+
+        if (isset(class_uses($response)[ResponseTrait::class])) {
+            $body = $this->streamFactory->createStreamFromResource($response->toStream(false));
+        } elseif (!$buffer) {
+            $body = $this->streamFactory->createStreamFromResource(StreamWrapper::createResource($response, $this->client));
+        } else {
+            $body = $this->streamFactory->createStream($response->getContent(false));
+        }
+
+        if ($body->isSeekable()) {
+            $body->seek(0);
+        }
+
+        return $psrResponse->withBody($body);
+    }
+}

vendor/symfony/http-client/Internal/NativeClientState.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Internal;
+
+/**
+ * Internal representation of the native client's state.
+ *
+ * @author Alexander M. Turek <me@derrabus.de>
+ *
+ * @internal
+ */
+final class NativeClientState extends ClientState
+{
+    /** @var int */
+    public $id;
+    /** @var int */
+    public $maxHostConnections = \PHP_INT_MAX;
+    /** @var int */
+    public $responseCount = 0;
+    /** @var string[] */
+    public $dnsCache = [];
+    /** @var bool */
+    public $sleep = false;
+
+    public function __construct()
+    {
+        $this->id = random_int(\PHP_INT_MIN, \PHP_INT_MAX);
+    }
+}

vendor/symfony/http-client/Internal/PushedResponse.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Internal;
+
+use Symfony\Component\HttpClient\Response\CurlResponse;
+
+/**
+ * A pushed response with its request headers.
+ *
+ * @author Alexander M. Turek <me@derrabus.de>
+ *
+ * @internal
+ */
+final class PushedResponse
+{
+    public $response;
+
+    /** @var string[] */
+    public $requestHeaders;
+
+    public $parentOptions = [];
+
+    public $handle;
+
+    public function __construct(CurlResponse $response, array $requestHeaders, array $parentOptions, $handle)
+    {
+        $this->response = $response;
+        $this->requestHeaders = $requestHeaders;
+        $this->parentOptions = $parentOptions;
+        $this->handle = $handle;
+    }
+}

vendor/symfony/http-client/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018-2021 Fabien Potencier
+
+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/symfony/http-client/MockHttpClient.php

@@ -0,0 +1,91 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Symfony\Component\HttpClient\Exception\TransportException;
+use Symfony\Component\HttpClient\Response\MockResponse;
+use Symfony\Component\HttpClient\Response\ResponseStream;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+
+/**
+ * A test-friendly HttpClient that doesn't make actual HTTP requests.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class MockHttpClient implements HttpClientInterface
+{
+    use HttpClientTrait;
+
+    private $responseFactory;
+    private $baseUri;
+
+    /**
+     * @param callable|ResponseInterface|ResponseInterface[]|iterable|null $responseFactory
+     */
+    public function __construct($responseFactory = null, string $baseUri = null)
+    {
+        if ($responseFactory instanceof ResponseInterface) {
+            $responseFactory = [$responseFactory];
+        }
+
+        if (!$responseFactory instanceof \Iterator && null !== $responseFactory && !\is_callable($responseFactory)) {
+            $responseFactory = (static function () use ($responseFactory) {
+                yield from $responseFactory;
+            })();
+        }
+
+        $this->responseFactory = $responseFactory;
+        $this->baseUri = $baseUri;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function request(string $method, string $url, array $options = []): ResponseInterface
+    {
+        [$url, $options] = $this->prepareRequest($method, $url, $options, ['base_uri' => $this->baseUri], true);
+        $url = implode('', $url);
+
+        if (null === $this->responseFactory) {
+            $response = new MockResponse();
+        } elseif (\is_callable($this->responseFactory)) {
+            $response = ($this->responseFactory)($method, $url, $options);
+        } elseif (!$this->responseFactory->valid()) {
+            throw new TransportException('The response factory iterator passed to MockHttpClient is empty.');
+        } else {
+            $response = $this->responseFactory->current();
+            $this->responseFactory->next();
+        }
+
+        if (!$response instanceof ResponseInterface) {
+            throw new TransportException(sprintf('The response factory passed to MockHttpClient must return/yield an instance of ResponseInterface, "%s" given.', \is_object($response) ? \get_class($response) : \gettype($response)));
+        }
+
+        return MockResponse::fromRequest($method, $url, $options, $response);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function stream($responses, float $timeout = null): ResponseStreamInterface
+    {
+        if ($responses instanceof ResponseInterface) {
+            $responses = [$responses];
+        } elseif (!is_iterable($responses)) {
+            throw new \TypeError(sprintf('"%s()" expects parameter 1 to be an iterable of MockResponse objects, "%s" given.', __METHOD__, \is_object($responses) ? \get_class($responses) : \gettype($responses)));
+        }
+
+        return new ResponseStream(MockResponse::stream($responses, $timeout));
+    }
+}

vendor/symfony/http-client/NativeHttpClient.php

@@ -0,0 +1,484 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Psr\Log\LoggerAwareInterface;
+use Psr\Log\LoggerAwareTrait;
+use Symfony\Component\HttpClient\Exception\InvalidArgumentException;
+use Symfony\Component\HttpClient\Exception\TransportException;
+use Symfony\Component\HttpClient\Internal\NativeClientState;
+use Symfony\Component\HttpClient\Response\NativeResponse;
+use Symfony\Component\HttpClient\Response\ResponseStream;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+
+/**
+ * A portable implementation of the HttpClientInterface contracts based on PHP stream wrappers.
+ *
+ * PHP stream wrappers are able to fetch response bodies concurrently,
+ * but each request is opened synchronously.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class NativeHttpClient implements HttpClientInterface, LoggerAwareInterface
+{
+    use HttpClientTrait;
+    use LoggerAwareTrait;
+
+    private $defaultOptions = self::OPTIONS_DEFAULTS;
+
+    /** @var NativeClientState */
+    private $multi;
+
+    /**
+     * @param array $defaultOptions     Default request's options
+     * @param int   $maxHostConnections The maximum number of connections to open
+     *
+     * @see HttpClientInterface::OPTIONS_DEFAULTS for available options
+     */
+    public function __construct(array $defaultOptions = [], int $maxHostConnections = 6)
+    {
+        $this->defaultOptions['buffer'] = $this->defaultOptions['buffer'] ?? \Closure::fromCallable([__CLASS__, 'shouldBuffer']);
+
+        if ($defaultOptions) {
+            [, $this->defaultOptions] = self::prepareRequest(null, null, $defaultOptions, $this->defaultOptions);
+        }
+
+        $this->multi = new NativeClientState();
+        $this->multi->maxHostConnections = 0 < $maxHostConnections ? $maxHostConnections : \PHP_INT_MAX;
+    }
+
+    /**
+     * @see HttpClientInterface::OPTIONS_DEFAULTS for available options
+     *
+     * {@inheritdoc}
+     */
+    public function request(string $method, string $url, array $options = []): ResponseInterface
+    {
+        [$url, $options] = self::prepareRequest($method, $url, $options, $this->defaultOptions);
+
+        if ($options['bindto']) {
+            if (file_exists($options['bindto'])) {
+                throw new TransportException(__CLASS__.' cannot bind to local Unix sockets, use e.g. CurlHttpClient instead.');
+            }
+            if (0 === strpos($options['bindto'], 'if!')) {
+                throw new TransportException(__CLASS__.' cannot bind to network interfaces, use e.g. CurlHttpClient instead.');
+            }
+            if (0 === strpos($options['bindto'], 'host!')) {
+                $options['bindto'] = substr($options['bindto'], 5);
+            }
+        }
+
+        $options['body'] = self::getBodyAsString($options['body']);
+
+        if ('' !== $options['body'] && 'POST' === $method && !isset($options['normalized_headers']['content-type'])) {
+            $options['headers'][] = 'Content-Type: application/x-www-form-urlencoded';
+        }
+
+        if (\extension_loaded('zlib') && !isset($options['normalized_headers']['accept-encoding'])) {
+            // gzip is the most widely available algo, no need to deal with deflate
+            $options['headers'][] = 'Accept-Encoding: gzip';
+        }
+
+        if ($options['peer_fingerprint']) {
+            if (isset($options['peer_fingerprint']['pin-sha256']) && 1 === \count($options['peer_fingerprint'])) {
+                throw new TransportException(__CLASS__.' cannot verify "pin-sha256" fingerprints, please provide a "sha256" one.');
+            }
+
+            unset($options['peer_fingerprint']['pin-sha256']);
+        }
+
+        $info = [
+            'response_headers' => [],
+            'url' => $url,
+            'error' => null,
+            'canceled' => false,
+            'http_method' => $method,
+            'http_code' => 0,
+            'redirect_count' => 0,
+            'start_time' => 0.0,
+            'connect_time' => 0.0,
+            'redirect_time' => 0.0,
+            'pretransfer_time' => 0.0,
+            'starttransfer_time' => 0.0,
+            'total_time' => 0.0,
+            'namelookup_time' => 0.0,
+            'size_upload' => 0,
+            'size_download' => 0,
+            'size_body' => \strlen($options['body']),
+            'primary_ip' => '',
+            'primary_port' => 'http:' === $url['scheme'] ? 80 : 443,
+            'debug' => \extension_loaded('curl') ? '' : "* Enable the curl extension for better performance\n",
+        ];
+
+        if ($onProgress = $options['on_progress']) {
+            // Memoize the last progress to ease calling the callback periodically when no network transfer happens
+            $lastProgress = [0, 0];
+            $maxDuration = 0 < $options['max_duration'] ? $options['max_duration'] : \INF;
+            $onProgress = static function (...$progress) use ($onProgress, &$lastProgress, &$info, $maxDuration) {
+                if ($info['total_time'] >= $maxDuration) {
+                    throw new TransportException(sprintf('Max duration was reached for "%s".', implode('', $info['url'])));
+                }
+
+                $progressInfo = $info;
+                $progressInfo['url'] = implode('', $info['url']);
+                unset($progressInfo['size_body']);
+
+                if ($progress && -1 === $progress[0]) {
+                    // Response completed
+                    $lastProgress[0] = max($lastProgress);
+                } else {
+                    $lastProgress = $progress ?: $lastProgress;
+                }
+
+                $onProgress($lastProgress[0], $lastProgress[1], $progressInfo);
+            };
+        } elseif (0 < $options['max_duration']) {
+            $maxDuration = $options['max_duration'];
+            $onProgress = static function () use (&$info, $maxDuration): void {
+                if ($info['total_time'] >= $maxDuration) {
+                    throw new TransportException(sprintf('Max duration was reached for "%s".', implode('', $info['url'])));
+                }
+            };
+        }
+
+        // Always register a notification callback to compute live stats about the response
+        $notification = static function (int $code, int $severity, ?string $msg, int $msgCode, int $dlNow, int $dlSize) use ($onProgress, &$info) {
+            $info['total_time'] = microtime(true) - $info['start_time'];
+
+            if (\STREAM_NOTIFY_PROGRESS === $code) {
+                $info['starttransfer_time'] = $info['starttransfer_time'] ?: $info['total_time'];
+                $info['size_upload'] += $dlNow ? 0 : $info['size_body'];
+                $info['size_download'] = $dlNow;
+            } elseif (\STREAM_NOTIFY_CONNECT === $code) {
+                $info['connect_time'] = $info['total_time'];
+                $info['debug'] .= $info['request_header'];
+                unset($info['request_header']);
+            } else {
+                return;
+            }
+
+            if ($onProgress) {
+                $onProgress($dlNow, $dlSize);
+            }
+        };
+
+        if ($options['resolve']) {
+            $this->multi->dnsCache = $options['resolve'] + $this->multi->dnsCache;
+        }
+
+        $this->logger && $this->logger->info(sprintf('Request: "%s %s"', $method, implode('', $url)));
+
+        [$host, $port] = self::parseHostPort($url, $info);
+
+        if (!isset($options['normalized_headers']['host'])) {
+            $options['headers'][] = 'Host: '.$host.$port;
+        }
+
+        if (!isset($options['normalized_headers']['user-agent'])) {
+            $options['headers'][] = 'User-Agent: Symfony HttpClient/Native';
+        }
+
+        if (0 < $options['max_duration']) {
+            $options['timeout'] = min($options['max_duration'], $options['timeout']);
+        }
+
+        $bindto = $options['bindto'];
+        if (!$bindto && (70322 === \PHP_VERSION_ID || 70410 === \PHP_VERSION_ID)) {
+            $bindto = '0:0';
+        }
+
+        $context = [
+            'http' => [
+                'protocol_version' => min($options['http_version'] ?: '1.1', '1.1'),
+                'method' => $method,
+                'content' => $options['body'],
+                'ignore_errors' => true,
+                'curl_verify_ssl_peer' => $options['verify_peer'],
+                'curl_verify_ssl_host' => $options['verify_host'],
+                'auto_decode' => false, // Disable dechunk filter, it's incompatible with stream_select()
+                'timeout' => $options['timeout'],
+                'follow_location' => false, // We follow redirects ourselves - the native logic is too limited
+            ],
+            'ssl' => array_filter([
+                'verify_peer' => $options['verify_peer'],
+                'verify_peer_name' => $options['verify_host'],
+                'cafile' => $options['cafile'],
+                'capath' => $options['capath'],
+                'local_cert' => $options['local_cert'],
+                'local_pk' => $options['local_pk'],
+                'passphrase' => $options['passphrase'],
+                'ciphers' => $options['ciphers'],
+                'peer_fingerprint' => $options['peer_fingerprint'],
+                'capture_peer_cert_chain' => $options['capture_peer_cert_chain'],
+                'allow_self_signed' => (bool) $options['peer_fingerprint'],
+                'SNI_enabled' => true,
+                'disable_compression' => true,
+            ], static function ($v) { return null !== $v; }),
+            'socket' => [
+                'bindto' => $bindto,
+                'tcp_nodelay' => true,
+            ],
+        ];
+
+        $proxy = self::getProxy($options['proxy'], $url);
+        $noProxy = $options['no_proxy'] ?? $_SERVER['no_proxy'] ?? $_SERVER['NO_PROXY'] ?? '';
+        $noProxy = $noProxy ? preg_split('/[\s,]+/', $noProxy) : [];
+
+        $resolveRedirect = self::createRedirectResolver($options, $host, $proxy, $noProxy, $info, $onProgress);
+        $context = stream_context_create($context, ['notification' => $notification]);
+
+        if (!self::configureHeadersAndProxy($context, $host, $options['headers'], $proxy, $noProxy, 'https:' === $url['scheme'])) {
+            $ip = self::dnsResolve($host, $this->multi, $info, $onProgress);
+            $url['authority'] = substr_replace($url['authority'], $ip, -\strlen($host) - \strlen($port), \strlen($host));
+        }
+
+        return new NativeResponse($this->multi, $context, implode('', $url), $options, $info, $resolveRedirect, $onProgress, $this->logger);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function stream($responses, float $timeout = null): ResponseStreamInterface
+    {
+        if ($responses instanceof NativeResponse) {
+            $responses = [$responses];
+        } elseif (!is_iterable($responses)) {
+            throw new \TypeError(sprintf('"%s()" expects parameter 1 to be an iterable of NativeResponse objects, "%s" given.', __METHOD__, \is_object($responses) ? \get_class($responses) : \gettype($responses)));
+        }
+
+        return new ResponseStream(NativeResponse::stream($responses, $timeout));
+    }
+
+    private static function getBodyAsString($body): string
+    {
+        if (\is_resource($body)) {
+            return stream_get_contents($body);
+        }
+
+        if (!$body instanceof \Closure) {
+            return $body;
+        }
+
+        $result = '';
+
+        while ('' !== $data = $body(self::$CHUNK_SIZE)) {
+            if (!\is_string($data)) {
+                throw new TransportException(sprintf('Return value of the "body" option callback must be string, "%s" returned.', \gettype($data)));
+            }
+
+            $result .= $data;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Loads proxy configuration from the same environment variables as curl when no proxy is explicitly set.
+     */
+    private static function getProxy(?string $proxy, array $url): ?array
+    {
+        if (null === $proxy) {
+            // Ignore HTTP_PROXY except on the CLI to work around httpoxy set of vulnerabilities
+            $proxy = $_SERVER['http_proxy'] ?? (\in_array(\PHP_SAPI, ['cli', 'phpdbg'], true) ? $_SERVER['HTTP_PROXY'] ?? null : null) ?? $_SERVER['all_proxy'] ?? $_SERVER['ALL_PROXY'] ?? null;
+
+            if ('https:' === $url['scheme']) {
+                $proxy = $_SERVER['https_proxy'] ?? $_SERVER['HTTPS_PROXY'] ?? $proxy;
+            }
+        }
+
+        if (null === $proxy) {
+            return null;
+        }
+
+        $proxy = (parse_url($proxy) ?: []) + ['scheme' => 'http'];
+
+        if (!isset($proxy['host'])) {
+            throw new TransportException('Invalid HTTP proxy: host is missing.');
+        }
+
+        if ('http' === $proxy['scheme']) {
+            $proxyUrl = 'tcp://'.$proxy['host'].':'.($proxy['port'] ?? '80');
+        } elseif ('https' === $proxy['scheme']) {
+            $proxyUrl = 'ssl://'.$proxy['host'].':'.($proxy['port'] ?? '443');
+        } else {
+            throw new TransportException(sprintf('Unsupported proxy scheme "%s": "http" or "https" expected.', $proxy['scheme']));
+        }
+
+        return [
+            'url' => $proxyUrl,
+            'auth' => isset($proxy['user']) ? 'Basic '.base64_encode(rawurldecode($proxy['user']).':'.rawurldecode($proxy['pass'] ?? '')) : null,
+        ];
+    }
+
+    /**
+     * Extracts the host and the port from the URL.
+     */
+    private static function parseHostPort(array $url, array &$info): array
+    {
+        if ($port = parse_url($url['authority'], \PHP_URL_PORT) ?: '') {
+            $info['primary_port'] = $port;
+            $port = ':'.$port;
+        } else {
+            $info['primary_port'] = 'http:' === $url['scheme'] ? 80 : 443;
+        }
+
+        return [parse_url($url['authority'], \PHP_URL_HOST), $port];
+    }
+
+    /**
+     * Resolves the IP of the host using the local DNS cache if possible.
+     */
+    private static function dnsResolve($host, NativeClientState $multi, array &$info, ?\Closure $onProgress): string
+    {
+        if (null === $ip = $multi->dnsCache[$host] ?? null) {
+            $info['debug'] .= "* Hostname was NOT found in DNS cache\n";
+            $now = microtime(true);
+
+            if (!$ip = gethostbynamel($host)) {
+                throw new TransportException(sprintf('Could not resolve host "%s".', $host));
+            }
+
+            $info['namelookup_time'] = microtime(true) - ($info['start_time'] ?: $now);
+            $multi->dnsCache[$host] = $ip = $ip[0];
+            $info['debug'] .= "* Added {$host}:0:{$ip} to DNS cache\n";
+        } else {
+            $info['debug'] .= "* Hostname was found in DNS cache\n";
+        }
+
+        $info['primary_ip'] = $ip;
+
+        if ($onProgress) {
+            // Notify DNS resolution
+            $onProgress();
+        }
+
+        return $ip;
+    }
+
+    /**
+     * Handles redirects - the native logic is too buggy to be used.
+     */
+    private static function createRedirectResolver(array $options, string $host, ?array $proxy, array $noProxy, array &$info, ?\Closure $onProgress): \Closure
+    {
+        $redirectHeaders = [];
+        if (0 < $maxRedirects = $options['max_redirects']) {
+            $redirectHeaders = ['host' => $host];
+            $redirectHeaders['with_auth'] = $redirectHeaders['no_auth'] = array_filter($options['headers'], static function ($h) {
+                return 0 !== stripos($h, 'Host:');
+            });
+
+            if (isset($options['normalized_headers']['authorization']) || isset($options['normalized_headers']['cookie'])) {
+                $redirectHeaders['no_auth'] = array_filter($redirectHeaders['no_auth'], static function ($h) {
+                    return 0 !== stripos($h, 'Authorization:') && 0 !== stripos($h, 'Cookie:');
+                });
+            }
+        }
+
+        return static function (NativeClientState $multi, ?string $location, $context) use ($redirectHeaders, $proxy, $noProxy, &$info, $maxRedirects, $onProgress): ?string {
+            if (null === $location || $info['http_code'] < 300 || 400 <= $info['http_code']) {
+                $info['redirect_url'] = null;
+
+                return null;
+            }
+
+            try {
+                $url = self::parseUrl($location);
+            } catch (InvalidArgumentException $e) {
+                $info['redirect_url'] = null;
+
+                return null;
+            }
+
+            $url = self::resolveUrl($url, $info['url']);
+            $info['redirect_url'] = implode('', $url);
+
+            if ($info['redirect_count'] >= $maxRedirects) {
+                return null;
+            }
+
+            $info['url'] = $url;
+            ++$info['redirect_count'];
+            $info['redirect_time'] = microtime(true) - $info['start_time'];
+
+            // Do like curl and browsers: turn POST to GET on 301, 302 and 303
+            if (\in_array($info['http_code'], [301, 302, 303], true)) {
+                $options = stream_context_get_options($context)['http'];
+
+                if ('POST' === $options['method'] || 303 === $info['http_code']) {
+                    $info['http_method'] = $options['method'] = 'HEAD' === $options['method'] ? 'HEAD' : 'GET';
+                    $options['content'] = '';
+                    $options['header'] = array_filter($options['header'], static function ($h) {
+                        return 0 !== stripos($h, 'Content-Length:') && 0 !== stripos($h, 'Content-Type:');
+                    });
+
+                    stream_context_set_option($context, ['http' => $options]);
+                }
+            }
+
+            [$host, $port] = self::parseHostPort($url, $info);
+
+            if (false !== (parse_url($location, \PHP_URL_HOST) ?? false)) {
+                // Authorization and Cookie headers MUST NOT follow except for the initial host name
+                $requestHeaders = $redirectHeaders['host'] === $host ? $redirectHeaders['with_auth'] : $redirectHeaders['no_auth'];
+                $requestHeaders[] = 'Host: '.$host.$port;
+                $dnsResolve = !self::configureHeadersAndProxy($context, $host, $requestHeaders, $proxy, $noProxy, 'https:' === $url['scheme']);
+            } else {
+                $dnsResolve = isset(stream_context_get_options($context)['ssl']['peer_name']);
+            }
+
+            if ($dnsResolve) {
+                $ip = self::dnsResolve($host, $multi, $info, $onProgress);
+                $url['authority'] = substr_replace($url['authority'], $ip, -\strlen($host) - \strlen($port), \strlen($host));
+            }
+
+            return implode('', $url);
+        };
+    }
+
+    private static function configureHeadersAndProxy($context, string $host, array $requestHeaders, ?array $proxy, array $noProxy, bool $isSsl): bool
+    {
+        if (null === $proxy) {
+            stream_context_set_option($context, 'http', 'header', $requestHeaders);
+            stream_context_set_option($context, 'ssl', 'peer_name', $host);
+
+            return false;
+        }
+
+        // Matching "no_proxy" should follow the behavior of curl
+
+        foreach ($noProxy as $rule) {
+            $dotRule = '.'.ltrim($rule, '.');
+
+            if ('*' === $rule || $host === $rule || substr($host, -\strlen($dotRule)) === $dotRule) {
+                stream_context_set_option($context, 'http', 'proxy', null);
+                stream_context_set_option($context, 'http', 'request_fulluri', false);
+                stream_context_set_option($context, 'http', 'header', $requestHeaders);
+                stream_context_set_option($context, 'ssl', 'peer_name', $host);
+
+                return false;
+            }
+        }
+
+        if (null !== $proxy['auth']) {
+            $requestHeaders[] = 'Proxy-Authorization: '.$proxy['auth'];
+        }
+
+        stream_context_set_option($context, 'http', 'proxy', $proxy['url']);
+        stream_context_set_option($context, 'http', 'request_fulluri', !$isSsl);
+        stream_context_set_option($context, 'http', 'header', $requestHeaders);
+        stream_context_set_option($context, 'ssl', 'peer_name', null);
+
+        return true;
+    }
+}

vendor/symfony/http-client/Psr18Client.php

@@ -0,0 +1,231 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Http\Discovery\Exception\NotFoundException;
+use Http\Discovery\Psr17FactoryDiscovery;
+use Nyholm\Psr7\Factory\Psr17Factory;
+use Nyholm\Psr7\Request;
+use Nyholm\Psr7\Uri;
+use Psr\Http\Client\ClientInterface;
+use Psr\Http\Client\NetworkExceptionInterface;
+use Psr\Http\Client\RequestExceptionInterface;
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UriFactoryInterface;
+use Psr\Http\Message\UriInterface;
+use Symfony\Component\HttpClient\Response\ResponseTrait;
+use Symfony\Component\HttpClient\Response\StreamWrapper;
+use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+
+if (!interface_exists(RequestFactoryInterface::class)) {
+    throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\Psr18Client" as the "psr/http-factory" package is not installed. Try running "composer require nyholm/psr7".');
+}
+
+if (!interface_exists(ClientInterface::class)) {
+    throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\Psr18Client" as the "psr/http-client" package is not installed. Try running "composer require psr/http-client".');
+}
+
+/**
+ * An adapter to turn a Symfony HttpClientInterface into a PSR-18 ClientInterface.
+ *
+ * Run "composer require psr/http-client" to install the base ClientInterface. Run
+ * "composer require nyholm/psr7" to install an efficient implementation of response
+ * and stream factories with flex-provided autowiring aliases.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class Psr18Client implements ClientInterface, RequestFactoryInterface, StreamFactoryInterface, UriFactoryInterface
+{
+    private $client;
+    private $responseFactory;
+    private $streamFactory;
+
+    public function __construct(HttpClientInterface $client = null, ResponseFactoryInterface $responseFactory = null, StreamFactoryInterface $streamFactory = null)
+    {
+        $this->client = $client ?? HttpClient::create();
+        $this->responseFactory = $responseFactory;
+        $this->streamFactory = $streamFactory ?? ($responseFactory instanceof StreamFactoryInterface ? $responseFactory : null);
+
+        if (null !== $this->responseFactory && null !== $this->streamFactory) {
+            return;
+        }
+
+        if (!class_exists(Psr17Factory::class) && !class_exists(Psr17FactoryDiscovery::class)) {
+            throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\Psr18Client" as no PSR-17 factories have been provided. Try running "composer require nyholm/psr7".');
+        }
+
+        try {
+            $psr17Factory = class_exists(Psr17Factory::class, false) ? new Psr17Factory() : null;
+            $this->responseFactory = $this->responseFactory ?? $psr17Factory ?? Psr17FactoryDiscovery::findResponseFactory();
+            $this->streamFactory = $this->streamFactory ?? $psr17Factory ?? Psr17FactoryDiscovery::findStreamFactory();
+        } catch (NotFoundException $e) {
+            throw new \LogicException('You cannot use the "Symfony\Component\HttpClient\HttplugClient" as no PSR-17 factories have been found. Try running "composer require nyholm/psr7".', 0, $e);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function sendRequest(RequestInterface $request): ResponseInterface
+    {
+        try {
+            $body = $request->getBody();
+
+            if ($body->isSeekable()) {
+                $body->seek(0);
+            }
+
+            $response = $this->client->request($request->getMethod(), (string) $request->getUri(), [
+                'headers' => $request->getHeaders(),
+                'body' => $body->getContents(),
+                'http_version' => '1.0' === $request->getProtocolVersion() ? '1.0' : null,
+            ]);
+
+            $psrResponse = $this->responseFactory->createResponse($response->getStatusCode());
+
+            foreach ($response->getHeaders(false) as $name => $values) {
+                foreach ($values as $value) {
+                    $psrResponse = $psrResponse->withAddedHeader($name, $value);
+                }
+            }
+
+            $body = isset(class_uses($response)[ResponseTrait::class]) ? $response->toStream(false) : StreamWrapper::createResource($response, $this->client);
+            $body = $this->streamFactory->createStreamFromResource($body);
+
+            if ($body->isSeekable()) {
+                $body->seek(0);
+            }
+
+            return $psrResponse->withBody($body);
+        } catch (TransportExceptionInterface $e) {
+            if ($e instanceof \InvalidArgumentException) {
+                throw new Psr18RequestException($e, $request);
+            }
+
+            throw new Psr18NetworkException($e, $request);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createRequest(string $method, $uri): RequestInterface
+    {
+        if ($this->responseFactory instanceof RequestFactoryInterface) {
+            return $this->responseFactory->createRequest($method, $uri);
+        }
+
+        if (class_exists(Request::class)) {
+            return new Request($method, $uri);
+        }
+
+        if (class_exists(Psr17FactoryDiscovery::class)) {
+            return Psr17FactoryDiscovery::findRequestFactory()->createRequest($method, $uri);
+        }
+
+        throw new \LogicException(sprintf('You cannot use "%s()" as the "nyholm/psr7" package is not installed. Try running "composer require nyholm/psr7".', __METHOD__));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createStream(string $content = ''): StreamInterface
+    {
+        $stream = $this->streamFactory->createStream($content);
+
+        if ($stream->isSeekable()) {
+            $stream->seek(0);
+        }
+
+        return $stream;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createStreamFromFile(string $filename, string $mode = 'r'): StreamInterface
+    {
+        return $this->streamFactory->createStreamFromFile($filename, $mode);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createStreamFromResource($resource): StreamInterface
+    {
+        return $this->streamFactory->createStreamFromResource($resource);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createUri(string $uri = ''): UriInterface
+    {
+        if ($this->responseFactory instanceof UriFactoryInterface) {
+            return $this->responseFactory->createUri($uri);
+        }
+
+        if (class_exists(Uri::class)) {
+            return new Uri($uri);
+        }
+
+        if (class_exists(Psr17FactoryDiscovery::class)) {
+            return Psr17FactoryDiscovery::findUrlFactory()->createUri($uri);
+        }
+
+        throw new \LogicException(sprintf('You cannot use "%s()" as the "nyholm/psr7" package is not installed. Try running "composer require nyholm/psr7".', __METHOD__));
+    }
+}
+
+/**
+ * @internal
+ */
+class Psr18NetworkException extends \RuntimeException implements NetworkExceptionInterface
+{
+    private $request;
+
+    public function __construct(TransportExceptionInterface $e, RequestInterface $request)
+    {
+        parent::__construct($e->getMessage(), 0, $e);
+        $this->request = $request;
+    }
+
+    public function getRequest(): RequestInterface
+    {
+        return $this->request;
+    }
+}
+
+/**
+ * @internal
+ */
+class Psr18RequestException extends \InvalidArgumentException implements RequestExceptionInterface
+{
+    private $request;
+
+    public function __construct(TransportExceptionInterface $e, RequestInterface $request)
+    {
+        parent::__construct($e->getMessage(), 0, $e);
+        $this->request = $request;
+    }
+
+    public function getRequest(): RequestInterface
+    {
+        return $this->request;
+    }
+}

vendor/symfony/http-client/Response/CurlResponse.php

@@ -0,0 +1,413 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Response;
+
+use Psr\Log\LoggerInterface;
+use Symfony\Component\HttpClient\Chunk\FirstChunk;
+use Symfony\Component\HttpClient\Chunk\InformationalChunk;
+use Symfony\Component\HttpClient\Exception\TransportException;
+use Symfony\Component\HttpClient\Internal\Canary;
+use Symfony\Component\HttpClient\Internal\ClientState;
+use Symfony\Component\HttpClient\Internal\CurlClientState;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+final class CurlResponse implements ResponseInterface
+{
+    use ResponseTrait {
+        getContent as private doGetContent;
+    }
+
+    private static $performing = false;
+    private $multi;
+    private $debugBuffer;
+
+    /**
+     * @param \CurlHandle|resource|string $ch
+     *
+     * @internal
+     */
+    public function __construct(CurlClientState $multi, $ch, array $options = null, LoggerInterface $logger = null, string $method = 'GET', callable $resolveRedirect = null, int $curlVersion = null)
+    {
+        $this->multi = $multi;
+
+        if (\is_resource($ch) || $ch instanceof \CurlHandle) {
+            $this->handle = $ch;
+            $this->debugBuffer = fopen('php://temp', 'w+');
+            if (0x074000 === $curlVersion) {
+                fwrite($this->debugBuffer, 'Due to a bug in curl 7.64.0, the debug log is disabled; use another version to work around the issue.');
+            } else {
+                curl_setopt($ch, \CURLOPT_VERBOSE, true);
+                curl_setopt($ch, \CURLOPT_STDERR, $this->debugBuffer);
+            }
+        } else {
+            $this->info['url'] = $ch;
+            $ch = $this->handle;
+        }
+
+        $this->id = $id = (int) $ch;
+        $this->logger = $logger;
+        $this->shouldBuffer = $options['buffer'] ?? true;
+        $this->timeout = $options['timeout'] ?? null;
+        $this->info['http_method'] = $method;
+        $this->info['user_data'] = $options['user_data'] ?? null;
+        $this->info['start_time'] = $this->info['start_time'] ?? microtime(true);
+        $info = &$this->info;
+        $headers = &$this->headers;
+        $debugBuffer = $this->debugBuffer;
+
+        if (!$info['response_headers']) {
+            // Used to keep track of what we're waiting for
+            curl_setopt($ch, \CURLOPT_PRIVATE, \in_array($method, ['GET', 'HEAD', 'OPTIONS', 'TRACE'], true) && 1.0 < (float) ($options['http_version'] ?? 1.1) ? 'H2' : 'H0'); // H = headers + retry counter
+        }
+
+        curl_setopt($ch, \CURLOPT_HEADERFUNCTION, static function ($ch, string $data) use (&$info, &$headers, $options, $multi, $id, &$location, $resolveRedirect, $logger): int {
+            if (0 !== substr_compare($data, "\r\n", -2)) {
+                return 0;
+            }
+
+            $len = 0;
+
+            foreach (explode("\r\n", substr($data, 0, -2)) as $data) {
+                $len += 2 + self::parseHeaderLine($ch, $data, $info, $headers, $options, $multi, $id, $location, $resolveRedirect, $logger);
+            }
+
+            return $len;
+        });
+
+        if (null === $options) {
+            // Pushed response: buffer until requested
+            curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
+                $multi->handlesActivity[$id][] = $data;
+                curl_pause($ch, \CURLPAUSE_RECV);
+
+                return \strlen($data);
+            });
+
+            return;
+        }
+
+        $this->inflate = !isset($options['normalized_headers']['accept-encoding']);
+        curl_pause($ch, \CURLPAUSE_CONT);
+
+        if ($onProgress = $options['on_progress']) {
+            $url = isset($info['url']) ? ['url' => $info['url']] : [];
+            curl_setopt($ch, \CURLOPT_NOPROGRESS, false);
+            curl_setopt($ch, \CURLOPT_PROGRESSFUNCTION, static function ($ch, $dlSize, $dlNow) use ($onProgress, &$info, $url, $multi, $debugBuffer) {
+                try {
+                    rewind($debugBuffer);
+                    $debug = ['debug' => stream_get_contents($debugBuffer)];
+                    $onProgress($dlNow, $dlSize, $url + curl_getinfo($ch) + $info + $debug);
+                } catch (\Throwable $e) {
+                    $multi->handlesActivity[(int) $ch][] = null;
+                    $multi->handlesActivity[(int) $ch][] = $e;
+
+                    return 1; // Abort the request
+                }
+
+                return null;
+            });
+        }
+
+        curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
+            if ('H' === (curl_getinfo($ch, \CURLINFO_PRIVATE)[0] ?? null)) {
+                $multi->handlesActivity[$id][] = null;
+                $multi->handlesActivity[$id][] = new TransportException(sprintf('Unsupported protocol for "%s"', curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL)));
+
+                return 0;
+            }
+
+            curl_setopt($ch, \CURLOPT_WRITEFUNCTION, static function ($ch, string $data) use ($multi, $id): int {
+                $multi->handlesActivity[$id][] = $data;
+
+                return \strlen($data);
+            });
+
+            $multi->handlesActivity[$id][] = $data;
+
+            return \strlen($data);
+        });
+
+        $this->initializer = static function (self $response) {
+            $waitFor = curl_getinfo($ch = $response->handle, \CURLINFO_PRIVATE);
+
+            return 'H' === $waitFor[0];
+        };
+
+        // Schedule the request in a non-blocking way
+        $multi->openHandles[$id] = [$ch, $options];
+        curl_multi_add_handle($multi->handle, $ch);
+
+        $this->canary = new Canary(static function () use ($ch, $multi, $id) {
+            unset($multi->openHandles[$id], $multi->handlesActivity[$id]);
+            curl_setopt($ch, \CURLOPT_PRIVATE, '_0');
+
+            if (self::$performing) {
+                return;
+            }
+
+            curl_multi_remove_handle($multi->handle, $ch);
+            curl_setopt_array($ch, [
+                \CURLOPT_NOPROGRESS => true,
+                \CURLOPT_PROGRESSFUNCTION => null,
+                \CURLOPT_HEADERFUNCTION => null,
+                \CURLOPT_WRITEFUNCTION => null,
+                \CURLOPT_READFUNCTION => null,
+                \CURLOPT_INFILE => null,
+            ]);
+
+            if (!$multi->openHandles) {
+                // Schedule DNS cache eviction for the next request
+                $multi->dnsCache->evictions = $multi->dnsCache->evictions ?: $multi->dnsCache->removals;
+                $multi->dnsCache->removals = $multi->dnsCache->hostnames = [];
+            }
+        });
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getInfo(string $type = null)
+    {
+        if (!$info = $this->finalInfo) {
+            $info = array_merge($this->info, curl_getinfo($this->handle));
+            $info['url'] = $this->info['url'] ?? $info['url'];
+            $info['redirect_url'] = $this->info['redirect_url'] ?? null;
+
+            // workaround curl not subtracting the time offset for pushed responses
+            if (isset($this->info['url']) && $info['start_time'] / 1000 < $info['total_time']) {
+                $info['total_time'] -= $info['starttransfer_time'] ?: $info['total_time'];
+                $info['starttransfer_time'] = 0.0;
+            }
+
+            rewind($this->debugBuffer);
+            $info['debug'] = stream_get_contents($this->debugBuffer);
+            $waitFor = curl_getinfo($this->handle, \CURLINFO_PRIVATE);
+
+            if ('H' !== $waitFor[0] && 'C' !== $waitFor[0]) {
+                curl_setopt($this->handle, \CURLOPT_VERBOSE, false);
+                rewind($this->debugBuffer);
+                ftruncate($this->debugBuffer, 0);
+                $this->finalInfo = $info;
+            }
+        }
+
+        return null !== $type ? $info[$type] ?? null : $info;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getContent(bool $throw = true): string
+    {
+        $performing = self::$performing;
+        self::$performing = $performing || '_0' === curl_getinfo($this->handle, \CURLINFO_PRIVATE);
+
+        try {
+            return $this->doGetContent($throw);
+        } finally {
+            self::$performing = $performing;
+        }
+    }
+
+    public function __destruct()
+    {
+        curl_setopt($this->handle, \CURLOPT_VERBOSE, false);
+
+        if (null === $this->timeout) {
+            return; // Unused pushed response
+        }
+
+        $this->doDestruct();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    private static function schedule(self $response, array &$runningResponses): void
+    {
+        if (isset($runningResponses[$i = (int) $response->multi->handle])) {
+            $runningResponses[$i][1][$response->id] = $response;
+        } else {
+            $runningResponses[$i] = [$response->multi, [$response->id => $response]];
+        }
+
+        if ('_0' === curl_getinfo($ch = $response->handle, \CURLINFO_PRIVATE)) {
+            // Response already completed
+            $response->multi->handlesActivity[$response->id][] = null;
+            $response->multi->handlesActivity[$response->id][] = null !== $response->info['error'] ? new TransportException($response->info['error']) : null;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param CurlClientState $multi
+     */
+    private static function perform(ClientState $multi, array &$responses = null): void
+    {
+        if (self::$performing) {
+            if ($responses) {
+                $response = current($responses);
+                $multi->handlesActivity[(int) $response->handle][] = null;
+                $multi->handlesActivity[(int) $response->handle][] = new TransportException(sprintf('Userland callback cannot use the client nor the response while processing "%s".', curl_getinfo($response->handle, \CURLINFO_EFFECTIVE_URL)));
+            }
+
+            return;
+        }
+
+        try {
+            self::$performing = true;
+            $active = 0;
+            while (\CURLM_CALL_MULTI_PERFORM === curl_multi_exec($multi->handle, $active));
+
+            while ($info = curl_multi_info_read($multi->handle)) {
+                $result = $info['result'];
+                $id = (int) $ch = $info['handle'];
+                $waitFor = @curl_getinfo($ch, \CURLINFO_PRIVATE) ?: '_0';
+
+                if (\in_array($result, [\CURLE_SEND_ERROR, \CURLE_RECV_ERROR, /*CURLE_HTTP2*/ 16, /*CURLE_HTTP2_STREAM*/ 92], true) && $waitFor[1] && 'C' !== $waitFor[0]) {
+                    curl_multi_remove_handle($multi->handle, $ch);
+                    $waitFor[1] = (string) ((int) $waitFor[1] - 1); // decrement the retry counter
+                    curl_setopt($ch, \CURLOPT_PRIVATE, $waitFor);
+                    curl_setopt($ch, \CURLOPT_FORBID_REUSE, true);
+
+                    if (0 === curl_multi_add_handle($multi->handle, $ch)) {
+                        continue;
+                    }
+                }
+
+                $multi->handlesActivity[$id][] = null;
+                $multi->handlesActivity[$id][] = \in_array($result, [\CURLE_OK, \CURLE_TOO_MANY_REDIRECTS], true) || '_0' === $waitFor || curl_getinfo($ch, \CURLINFO_SIZE_DOWNLOAD) === curl_getinfo($ch, \CURLINFO_CONTENT_LENGTH_DOWNLOAD) ? null : new TransportException(sprintf('%s for "%s".', curl_strerror($result), curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL)));
+            }
+        } finally {
+            self::$performing = false;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param CurlClientState $multi
+     */
+    private static function select(ClientState $multi, float $timeout): int
+    {
+        if (\PHP_VERSION_ID < 70123 || (70200 <= \PHP_VERSION_ID && \PHP_VERSION_ID < 70211)) {
+            // workaround https://bugs.php.net/76480
+            $timeout = min($timeout, 0.01);
+        }
+
+        return curl_multi_select($multi->handle, $timeout);
+    }
+
+    /**
+     * Parses header lines as curl yields them to us.
+     */
+    private static function parseHeaderLine($ch, string $data, array &$info, array &$headers, ?array $options, CurlClientState $multi, int $id, ?string &$location, ?callable $resolveRedirect, ?LoggerInterface $logger, &$content = null): int
+    {
+        $waitFor = @curl_getinfo($ch, \CURLINFO_PRIVATE) ?: '_0';
+
+        if ('H' !== $waitFor[0]) {
+            return \strlen($data); // Ignore HTTP trailers
+        }
+
+        if ('' !== $data) {
+            try {
+                // Regular header line: add it to the list
+                self::addResponseHeaders([$data], $info, $headers);
+            } catch (TransportException $e) {
+                $multi->handlesActivity[$id][] = null;
+                $multi->handlesActivity[$id][] = $e;
+
+                return \strlen($data);
+            }
+
+            if (0 !== strpos($data, 'HTTP/')) {
+                if (0 === stripos($data, 'Location:')) {
+                    $location = trim(substr($data, 9));
+                }
+
+                return \strlen($data);
+            }
+
+            if (\function_exists('openssl_x509_read') && $certinfo = curl_getinfo($ch, \CURLINFO_CERTINFO)) {
+                $info['peer_certificate_chain'] = array_map('openssl_x509_read', array_column($certinfo, 'Cert'));
+            }
+
+            if (300 <= $info['http_code'] && $info['http_code'] < 400) {
+                if (curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT) === $options['max_redirects']) {
+                    curl_setopt($ch, \CURLOPT_FOLLOWLOCATION, false);
+                } elseif (303 === $info['http_code'] || ('POST' === $info['http_method'] && \in_array($info['http_code'], [301, 302], true))) {
+                    $info['http_method'] = 'HEAD' === $info['http_method'] ? 'HEAD' : 'GET';
+                    curl_setopt($ch, \CURLOPT_POSTFIELDS, '');
+                }
+            }
+
+            return \strlen($data);
+        }
+
+        // End of headers: handle informational responses, redirects, etc.
+
+        if (200 > $statusCode = curl_getinfo($ch, \CURLINFO_RESPONSE_CODE)) {
+            $multi->handlesActivity[$id][] = new InformationalChunk($statusCode, $headers);
+            $location = null;
+
+            return \strlen($data);
+        }
+
+        $info['redirect_url'] = null;
+
+        if (300 <= $statusCode && $statusCode < 400 && null !== $location) {
+            if (null === $info['redirect_url'] = $resolveRedirect($ch, $location)) {
+                $options['max_redirects'] = curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT);
+                curl_setopt($ch, \CURLOPT_FOLLOWLOCATION, false);
+                curl_setopt($ch, \CURLOPT_MAXREDIRS, $options['max_redirects']);
+            } else {
+                $url = parse_url($location ?? ':');
+
+                if (isset($url['host']) && null !== $ip = $multi->dnsCache->hostnames[$url['host'] = strtolower($url['host'])] ?? null) {
+                    // Populate DNS cache for redirects if needed
+                    $port = $url['port'] ?? ('http' === ($url['scheme'] ?? parse_url(curl_getinfo($ch, \CURLINFO_EFFECTIVE_URL), \PHP_URL_SCHEME)) ? 80 : 443);
+                    curl_setopt($ch, \CURLOPT_RESOLVE, ["{$url['host']}:$port:$ip"]);
+                    $multi->dnsCache->removals["-{$url['host']}:$port"] = "-{$url['host']}:$port";
+                }
+            }
+        }
+
+        if (401 === $statusCode && isset($options['auth_ntlm']) && 0 === strncasecmp($headers['www-authenticate'][0] ?? '', 'NTLM ', 5)) {
+            // Continue with NTLM auth
+        } elseif ($statusCode < 300 || 400 <= $statusCode || null === $location || curl_getinfo($ch, \CURLINFO_REDIRECT_COUNT) === $options['max_redirects']) {
+            // Headers and redirects completed, time to get the response's content
+            $multi->handlesActivity[$id][] = new FirstChunk();
+
+            if ('HEAD' === $info['http_method'] || \in_array($statusCode, [204, 304], true)) {
+                $waitFor = '_0'; // no content expected
+                $multi->handlesActivity[$id][] = null;
+                $multi->handlesActivity[$id][] = null;
+            } else {
+                $waitFor[0] = 'C'; // C = content
+            }
+
+            curl_setopt($ch, \CURLOPT_PRIVATE, $waitFor);
+        } elseif (null !== $info['redirect_url'] && $logger) {
+            $logger->info(sprintf('Redirecting: "%s %s"', $info['http_code'], $info['redirect_url']));
+        }
+
+        $location = null;
+
+        return \strlen($data);
+    }
+}

vendor/symfony/http-client/Response/HttplugPromise.php

@@ -0,0 +1,65 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Response;
+
+use GuzzleHttp\Promise\PromiseInterface as GuzzlePromiseInterface;
+use Http\Promise\Promise as HttplugPromiseInterface;
+use Psr\Http\Message\ResponseInterface as Psr7ResponseInterface;
+
+/**
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ *
+ * @internal
+ */
+final class HttplugPromise implements HttplugPromiseInterface
+{
+    private $promise;
+
+    public function __construct(GuzzlePromiseInterface $promise)
+    {
+        $this->promise = $promise;
+    }
+
+    public function then(callable $onFulfilled = null, callable $onRejected = null): self
+    {
+        return new self($this->promise->then($onFulfilled, $onRejected));
+    }
+
+    public function cancel(): void
+    {
+        $this->promise->cancel();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getState(): string
+    {
+        return $this->promise->getState();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return Psr7ResponseInterface|mixed
+     */
+    public function wait($unwrap = true)
+    {
+        $result = $this->promise->wait($unwrap);
+
+        while ($result instanceof HttplugPromiseInterface || $result instanceof GuzzlePromiseInterface) {
+            $result = $result->wait($unwrap);
+        }
+
+        return $result;
+    }
+}

vendor/symfony/http-client/Response/MockResponse.php

@@ -0,0 +1,301 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Response;
+
+use Symfony\Component\HttpClient\Chunk\ErrorChunk;
+use Symfony\Component\HttpClient\Chunk\FirstChunk;
+use Symfony\Component\HttpClient\Exception\InvalidArgumentException;
+use Symfony\Component\HttpClient\Exception\TransportException;
+use Symfony\Component\HttpClient\Internal\ClientState;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+
+/**
+ * A test-friendly response.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class MockResponse implements ResponseInterface
+{
+    use ResponseTrait {
+        doDestruct as public __destruct;
+    }
+
+    private $body;
+    private $requestOptions = [];
+
+    private static $mainMulti;
+    private static $idSequence = 0;
+
+    /**
+     * @param string|string[]|iterable $body The response body as a string or an iterable of strings,
+     *                                       yielding an empty string simulates an idle timeout,
+     *                                       exceptions are turned to TransportException
+     *
+     * @see ResponseInterface::getInfo() for possible info, e.g. "response_headers"
+     */
+    public function __construct($body = '', array $info = [])
+    {
+        $this->body = is_iterable($body) ? $body : (string) $body;
+        $this->info = $info + ['http_code' => 200] + $this->info;
+
+        if (!isset($info['response_headers'])) {
+            return;
+        }
+
+        $responseHeaders = [];
+
+        foreach ($info['response_headers'] as $k => $v) {
+            foreach ((array) $v as $v) {
+                $responseHeaders[] = (\is_string($k) ? $k.': ' : '').$v;
+            }
+        }
+
+        $this->info['response_headers'] = [];
+        self::addResponseHeaders($responseHeaders, $this->info, $this->headers);
+    }
+
+    /**
+     * Returns the options used when doing the request.
+     */
+    public function getRequestOptions(): array
+    {
+        return $this->requestOptions;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getInfo(string $type = null)
+    {
+        return null !== $type ? $this->info[$type] ?? null : $this->info;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function cancel(): void
+    {
+        $this->info['canceled'] = true;
+        $this->info['error'] = 'Response has been canceled.';
+        $this->body = null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function close(): void
+    {
+        $this->inflate = null;
+        $this->body = [];
+    }
+
+    /**
+     * @internal
+     */
+    public static function fromRequest(string $method, string $url, array $options, ResponseInterface $mock): self
+    {
+        $response = new self([]);
+        $response->requestOptions = $options;
+        $response->id = ++self::$idSequence;
+        $response->shouldBuffer = $options['buffer'] ?? true;
+        $response->initializer = static function (self $response) {
+            return \is_array($response->body[0] ?? null);
+        };
+
+        $response->info['redirect_count'] = 0;
+        $response->info['redirect_url'] = null;
+        $response->info['start_time'] = microtime(true);
+        $response->info['http_method'] = $method;
+        $response->info['http_code'] = 0;
+        $response->info['user_data'] = $options['user_data'] ?? null;
+        $response->info['url'] = $url;
+
+        if ($mock instanceof self) {
+            $mock->requestOptions = $response->requestOptions;
+        }
+
+        self::writeRequest($response, $options, $mock);
+        $response->body[] = [$options, $mock];
+
+        return $response;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected static function schedule(self $response, array &$runningResponses): void
+    {
+        if (!$response->id) {
+            throw new InvalidArgumentException('MockResponse instances must be issued by MockHttpClient before processing.');
+        }
+
+        $multi = self::$mainMulti ?? self::$mainMulti = new ClientState();
+
+        if (!isset($runningResponses[0])) {
+            $runningResponses[0] = [$multi, []];
+        }
+
+        $runningResponses[0][1][$response->id] = $response;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected static function perform(ClientState $multi, array &$responses): void
+    {
+        foreach ($responses as $response) {
+            $id = $response->id;
+
+            if (null === $response->body) {
+                // Canceled response
+                $response->body = [];
+            } elseif ([] === $response->body) {
+                // Error chunk
+                $multi->handlesActivity[$id][] = null;
+                $multi->handlesActivity[$id][] = null !== $response->info['error'] ? new TransportException($response->info['error']) : null;
+            } elseif (null === $chunk = array_shift($response->body)) {
+                // Last chunk
+                $multi->handlesActivity[$id][] = null;
+                $multi->handlesActivity[$id][] = array_shift($response->body);
+            } elseif (\is_array($chunk)) {
+                // First chunk
+                try {
+                    $offset = 0;
+                    $chunk[1]->getStatusCode();
+                    $chunk[1]->getHeaders(false);
+                    self::readResponse($response, $chunk[0], $chunk[1], $offset);
+                    $multi->handlesActivity[$id][] = new FirstChunk();
+                    $buffer = $response->requestOptions['buffer'] ?? null;
+
+                    if ($buffer instanceof \Closure && $response->content = $buffer($response->headers) ?: null) {
+                        $response->content = \is_resource($response->content) ? $response->content : fopen('php://temp', 'w+');
+                    }
+                } catch (\Throwable $e) {
+                    $multi->handlesActivity[$id][] = null;
+                    $multi->handlesActivity[$id][] = $e;
+                }
+            } else {
+                // Data or timeout chunk
+                $multi->handlesActivity[$id][] = $chunk;
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected static function select(ClientState $multi, float $timeout): int
+    {
+        return 42;
+    }
+
+    /**
+     * Simulates sending the request.
+     */
+    private static function writeRequest(self $response, array $options, ResponseInterface $mock)
+    {
+        $onProgress = $options['on_progress'] ?? static function () {};
+        $response->info += $mock->getInfo() ?: [];
+
+        // simulate "size_upload" if it is set
+        if (isset($response->info['size_upload'])) {
+            $response->info['size_upload'] = 0.0;
+        }
+
+        // simulate "total_time" if it is not set
+        if (!isset($response->info['total_time'])) {
+            $response->info['total_time'] = microtime(true) - $response->info['start_time'];
+        }
+
+        // "notify" DNS resolution
+        $onProgress(0, 0, $response->info);
+
+        // consume the request body
+        if (\is_resource($body = $options['body'] ?? '')) {
+            $data = stream_get_contents($body);
+            if (isset($response->info['size_upload'])) {
+                $response->info['size_upload'] += \strlen($data);
+            }
+        } elseif ($body instanceof \Closure) {
+            while ('' !== $data = $body(16372)) {
+                if (!\is_string($data)) {
+                    throw new TransportException(sprintf('Return value of the "body" option callback must be string, "%s" returned.', \gettype($data)));
+                }
+
+                // "notify" upload progress
+                if (isset($response->info['size_upload'])) {
+                    $response->info['size_upload'] += \strlen($data);
+                }
+
+                $onProgress(0, 0, $response->info);
+            }
+        }
+    }
+
+    /**
+     * Simulates reading the response.
+     */
+    private static function readResponse(self $response, array $options, ResponseInterface $mock, int &$offset)
+    {
+        $onProgress = $options['on_progress'] ?? static function () {};
+
+        // populate info related to headers
+        $info = $mock->getInfo() ?: [];
+        $response->info['http_code'] = ($info['http_code'] ?? 0) ?: $mock->getStatusCode() ?: 200;
+        $response->addResponseHeaders($info['response_headers'] ?? [], $response->info, $response->headers);
+        $dlSize = isset($response->headers['content-encoding']) || 'HEAD' === $response->info['http_method'] || \in_array($response->info['http_code'], [204, 304], true) ? 0 : (int) ($response->headers['content-length'][0] ?? 0);
+
+        $response->info = [
+            'start_time' => $response->info['start_time'],
+            'user_data' => $response->info['user_data'],
+            'http_code' => $response->info['http_code'],
+        ] + $info + $response->info;
+
+        if (!isset($response->info['total_time'])) {
+            $response->info['total_time'] = microtime(true) - $response->info['start_time'];
+        }
+
+        // "notify" headers arrival
+        $onProgress(0, $dlSize, $response->info);
+
+        // cast response body to activity list
+        $body = $mock instanceof self ? $mock->body : $mock->getContent(false);
+
+        if (!\is_string($body)) {
+            foreach ($body as $chunk) {
+                if ('' === $chunk = (string) $chunk) {
+                    // simulate an idle timeout
+                    $response->body[] = new ErrorChunk($offset, sprintf('Idle timeout reached for "%s".', $response->info['url']));
+                } else {
+                    $response->body[] = $chunk;
+                    $offset += \strlen($chunk);
+                    // "notify" download progress
+                    $onProgress($offset, $dlSize, $response->info);
+                }
+            }
+        } elseif ('' !== $body) {
+            $response->body[] = $body;
+            $offset = \strlen($body);
+        }
+
+        if (!isset($response->info['total_time'])) {
+            $response->info['total_time'] = microtime(true) - $response->info['start_time'];
+        }
+
+        // "notify" completion
+        $onProgress($offset, $dlSize, $response->info);
+
+        if ($dlSize && $offset !== $dlSize) {
+            throw new TransportException(sprintf('Transfer closed with %d bytes remaining to read.', $dlSize - $offset));
+        }
+    }
+}

vendor/symfony/http-client/Response/NativeResponse.php

@@ -0,0 +1,331 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Response;
+
+use Psr\Log\LoggerInterface;
+use Symfony\Component\HttpClient\Chunk\FirstChunk;
+use Symfony\Component\HttpClient\Exception\TransportException;
+use Symfony\Component\HttpClient\Internal\Canary;
+use Symfony\Component\HttpClient\Internal\ClientState;
+use Symfony\Component\HttpClient\Internal\NativeClientState;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+final class NativeResponse implements ResponseInterface
+{
+    use ResponseTrait;
+
+    private $context;
+    private $url;
+    private $resolveRedirect;
+    private $onProgress;
+    private $remaining;
+    private $buffer;
+    private $multi;
+    private $debugBuffer;
+    private $shouldBuffer;
+
+    /**
+     * @internal
+     */
+    public function __construct(NativeClientState $multi, $context, string $url, array $options, array &$info, callable $resolveRedirect, ?callable $onProgress, ?LoggerInterface $logger)
+    {
+        $this->multi = $multi;
+        $this->id = $id = (int) $context;
+        $this->context = $context;
+        $this->url = $url;
+        $this->logger = $logger;
+        $this->timeout = $options['timeout'];
+        $this->info = &$info;
+        $this->resolveRedirect = $resolveRedirect;
+        $this->onProgress = $onProgress;
+        $this->inflate = !isset($options['normalized_headers']['accept-encoding']);
+        $this->shouldBuffer = $options['buffer'] ?? true;
+
+        // Temporary resource to dechunk the response stream
+        $this->buffer = fopen('php://temp', 'w+');
+
+        $info['user_data'] = $options['user_data'];
+        ++$multi->responseCount;
+
+        $this->initializer = static function (self $response) {
+            return null === $response->remaining;
+        };
+
+        $this->canary = new Canary(static function () use ($multi, $id) {
+            unset($multi->openHandles[$id], $multi->handlesActivity[$id]);
+        });
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getInfo(string $type = null)
+    {
+        if (!$info = $this->finalInfo) {
+            $info = $this->info;
+            $info['url'] = implode('', $info['url']);
+            unset($info['size_body'], $info['request_header']);
+
+            if (null === $this->buffer) {
+                $this->finalInfo = $info;
+            }
+        }
+
+        return null !== $type ? $info[$type] ?? null : $info;
+    }
+
+    public function __destruct()
+    {
+        try {
+            $this->doDestruct();
+        } finally {
+            // Clear the DNS cache when all requests completed
+            if (0 >= --$this->multi->responseCount) {
+                $this->multi->responseCount = 0;
+                $this->multi->dnsCache = [];
+            }
+        }
+    }
+
+    private function open(): void
+    {
+        $url = $this->url;
+
+        set_error_handler(function ($type, $msg) use (&$url) {
+            if (\E_NOTICE !== $type || 'fopen(): Content-type not specified assuming application/x-www-form-urlencoded' !== $msg) {
+                throw new TransportException($msg);
+            }
+
+            $this->logger && $this->logger->info(sprintf('%s for "%s".', $msg, $url ?? $this->url));
+        });
+
+        try {
+            $this->info['start_time'] = microtime(true);
+
+            while (true) {
+                $context = stream_context_get_options($this->context);
+
+                if ($proxy = $context['http']['proxy'] ?? null) {
+                    $this->info['debug'] .= "* Establish HTTP proxy tunnel to {$proxy}\n";
+                    $this->info['request_header'] = $url;
+                } else {
+                    $this->info['debug'] .= "*   Trying {$this->info['primary_ip']}...\n";
+                    $this->info['request_header'] = $this->info['url']['path'].$this->info['url']['query'];
+                }
+
+                $this->info['request_header'] = sprintf("> %s %s HTTP/%s \r\n", $context['http']['method'], $this->info['request_header'], $context['http']['protocol_version']);
+                $this->info['request_header'] .= implode("\r\n", $context['http']['header'])."\r\n\r\n";
+
+                if (\array_key_exists('peer_name', $context['ssl']) && null === $context['ssl']['peer_name']) {
+                    unset($context['ssl']['peer_name']);
+                    $this->context = stream_context_create([], ['options' => $context] + stream_context_get_params($this->context));
+                }
+
+                // Send request and follow redirects when needed
+                $this->handle = $h = fopen($url, 'r', false, $this->context);
+                self::addResponseHeaders(stream_get_meta_data($h)['wrapper_data'], $this->info, $this->headers, $this->info['debug']);
+                $url = ($this->resolveRedirect)($this->multi, $this->headers['location'][0] ?? null, $this->context);
+
+                if (null === $url) {
+                    break;
+                }
+
+                $this->logger && $this->logger->info(sprintf('Redirecting: "%s %s"', $this->info['http_code'], $url ?? $this->url));
+            }
+        } catch (\Throwable $e) {
+            $this->close();
+            $this->multi->handlesActivity[$this->id][] = null;
+            $this->multi->handlesActivity[$this->id][] = $e;
+
+            return;
+        } finally {
+            $this->info['pretransfer_time'] = $this->info['total_time'] = microtime(true) - $this->info['start_time'];
+            restore_error_handler();
+        }
+
+        if (isset($context['ssl']['capture_peer_cert_chain']) && isset(($context = stream_context_get_options($this->context))['ssl']['peer_certificate_chain'])) {
+            $this->info['peer_certificate_chain'] = $context['ssl']['peer_certificate_chain'];
+        }
+
+        stream_set_blocking($h, false);
+        $this->context = $this->resolveRedirect = null;
+
+        // Create dechunk buffers
+        if (isset($this->headers['content-length'])) {
+            $this->remaining = (int) $this->headers['content-length'][0];
+        } elseif ('chunked' === ($this->headers['transfer-encoding'][0] ?? null)) {
+            stream_filter_append($this->buffer, 'dechunk', \STREAM_FILTER_WRITE);
+            $this->remaining = -1;
+        } else {
+            $this->remaining = -2;
+        }
+
+        $this->multi->handlesActivity[$this->id] = [new FirstChunk()];
+
+        if ('HEAD' === $context['http']['method'] || \in_array($this->info['http_code'], [204, 304], true)) {
+            $this->multi->handlesActivity[$this->id][] = null;
+            $this->multi->handlesActivity[$this->id][] = null;
+
+            return;
+        }
+
+        $this->multi->openHandles[$this->id] = [$h, $this->buffer, $this->onProgress, &$this->remaining, &$this->info];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    private function close(): void
+    {
+        $this->canary->cancel();
+        $this->handle = $this->buffer = $this->inflate = $this->onProgress = null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    private static function schedule(self $response, array &$runningResponses): void
+    {
+        if (!isset($runningResponses[$i = $response->multi->id])) {
+            $runningResponses[$i] = [$response->multi, []];
+        }
+
+        $runningResponses[$i][1][$response->id] = $response;
+
+        if (null === $response->buffer) {
+            // Response already completed
+            $response->multi->handlesActivity[$response->id][] = null;
+            $response->multi->handlesActivity[$response->id][] = null !== $response->info['error'] ? new TransportException($response->info['error']) : null;
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param NativeClientState $multi
+     */
+    private static function perform(ClientState $multi, array &$responses = null): void
+    {
+        foreach ($multi->openHandles as $i => [$h, $buffer, $onProgress]) {
+            $hasActivity = false;
+            $remaining = &$multi->openHandles[$i][3];
+            $info = &$multi->openHandles[$i][4];
+            $e = null;
+
+            // Read incoming buffer and write it to the dechunk one
+            try {
+                if ($remaining && '' !== $data = (string) fread($h, 0 > $remaining ? 16372 : $remaining)) {
+                    fwrite($buffer, $data);
+                    $hasActivity = true;
+                    $multi->sleep = false;
+
+                    if (-1 !== $remaining) {
+                        $remaining -= \strlen($data);
+                    }
+                }
+            } catch (\Throwable $e) {
+                $hasActivity = $onProgress = false;
+            }
+
+            if (!$hasActivity) {
+                if ($onProgress) {
+                    try {
+                        // Notify the progress callback so that it can e.g. cancel
+                        // the request if the stream is inactive for too long
+                        $info['total_time'] = microtime(true) - $info['start_time'];
+                        $onProgress();
+                    } catch (\Throwable $e) {
+                        // no-op
+                    }
+                }
+            } elseif ('' !== $data = stream_get_contents($buffer, -1, 0)) {
+                rewind($buffer);
+                ftruncate($buffer, 0);
+
+                if (null === $e) {
+                    $multi->handlesActivity[$i][] = $data;
+                }
+            }
+
+            if (null !== $e || !$remaining || feof($h)) {
+                // Stream completed
+                $info['total_time'] = microtime(true) - $info['start_time'];
+                $info['starttransfer_time'] = $info['starttransfer_time'] ?: $info['total_time'];
+
+                if ($onProgress) {
+                    try {
+                        $onProgress(-1);
+                    } catch (\Throwable $e) {
+                        // no-op
+                    }
+                }
+
+                if (null === $e) {
+                    if (0 < $remaining) {
+                        $e = new TransportException(sprintf('Transfer closed with %s bytes remaining to read.', $remaining));
+                    } elseif (-1 === $remaining && fwrite($buffer, '-') && '' !== stream_get_contents($buffer, -1, 0)) {
+                        $e = new TransportException('Transfer closed with outstanding data remaining from chunked response.');
+                    }
+                }
+
+                $multi->handlesActivity[$i][] = null;
+                $multi->handlesActivity[$i][] = $e;
+                unset($multi->openHandles[$i]);
+                $multi->sleep = false;
+            }
+        }
+
+        if (null === $responses) {
+            return;
+        }
+
+        // Create empty activity lists to tell ResponseTrait::stream() we still have pending requests
+        foreach ($responses as $i => $response) {
+            if (null === $response->remaining && null !== $response->buffer) {
+                $multi->handlesActivity[$i] = [];
+            }
+        }
+
+        if (\count($multi->openHandles) >= $multi->maxHostConnections) {
+            return;
+        }
+
+        // Open the next pending request - this is a blocking operation so we do only one of them
+        foreach ($responses as $i => $response) {
+            if (null === $response->remaining && null !== $response->buffer) {
+                $response->open();
+                $multi->sleep = false;
+                self::perform($multi);
+
+                break;
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param NativeClientState $multi
+     */
+    private static function select(ClientState $multi, float $timeout): int
+    {
+        $_ = [];
+        $handles = array_column($multi->openHandles, 0);
+
+        return (!$multi->sleep = !$multi->sleep) ? -1 : stream_select($handles, $_, $_, (int) $timeout, (int) (1E6 * ($timeout - (int) $timeout)));
+    }
+}

vendor/symfony/http-client/Response/ResponseStream.php

@@ -0,0 +1,54 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Response;
+
+use Symfony\Contracts\HttpClient\ChunkInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class ResponseStream implements ResponseStreamInterface
+{
+    private $generator;
+
+    public function __construct(\Generator $generator)
+    {
+        $this->generator = $generator;
+    }
+
+    public function key(): ResponseInterface
+    {
+        return $this->generator->key();
+    }
+
+    public function current(): ChunkInterface
+    {
+        return $this->generator->current();
+    }
+
+    public function next(): void
+    {
+        $this->generator->next();
+    }
+
+    public function rewind(): void
+    {
+        $this->generator->rewind();
+    }
+
+    public function valid(): bool
+    {
+        return $this->generator->valid();
+    }
+}

vendor/symfony/http-client/Response/ResponseTrait.php

@@ -0,0 +1,469 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Response;
+
+use Symfony\Component\HttpClient\Chunk\DataChunk;
+use Symfony\Component\HttpClient\Chunk\ErrorChunk;
+use Symfony\Component\HttpClient\Chunk\FirstChunk;
+use Symfony\Component\HttpClient\Chunk\LastChunk;
+use Symfony\Component\HttpClient\Exception\ClientException;
+use Symfony\Component\HttpClient\Exception\JsonException;
+use Symfony\Component\HttpClient\Exception\RedirectionException;
+use Symfony\Component\HttpClient\Exception\ServerException;
+use Symfony\Component\HttpClient\Exception\TransportException;
+use Symfony\Component\HttpClient\Internal\ClientState;
+use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
+use Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface;
+use Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface;
+use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
+
+/**
+ * Implements the common logic for response classes.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+trait ResponseTrait
+{
+    private $logger;
+    private $headers = [];
+    private $canary;
+
+    /**
+     * @var callable|null A callback that initializes the two previous properties
+     */
+    private $initializer;
+
+    private $info = [
+        'response_headers' => [],
+        'http_code' => 0,
+        'error' => null,
+        'canceled' => false,
+    ];
+
+    /** @var object|resource */
+    private $handle;
+    private $id;
+    private $timeout = 0;
+    private $inflate;
+    private $shouldBuffer;
+    private $content;
+    private $finalInfo;
+    private $offset = 0;
+    private $jsonData;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getStatusCode(): int
+    {
+        if ($this->initializer) {
+            self::initialize($this);
+        }
+
+        return $this->info['http_code'];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getHeaders(bool $throw = true): array
+    {
+        if ($this->initializer) {
+            self::initialize($this);
+        }
+
+        if ($throw) {
+            $this->checkStatusCode();
+        }
+
+        return $this->headers;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getContent(bool $throw = true): string
+    {
+        if ($this->initializer) {
+            self::initialize($this);
+        }
+
+        if ($throw) {
+            $this->checkStatusCode();
+        }
+
+        if (null === $this->content) {
+            $content = null;
+
+            foreach (self::stream([$this]) as $chunk) {
+                if (!$chunk->isLast()) {
+                    $content .= $chunk->getContent();
+                }
+            }
+
+            if (null !== $content) {
+                return $content;
+            }
+
+            if (null === $this->content) {
+                throw new TransportException('Cannot get the content of the response twice: buffering is disabled.');
+            }
+        } else {
+            foreach (self::stream([$this]) as $chunk) {
+                // Chunks are buffered in $this->content already
+            }
+        }
+
+        rewind($this->content);
+
+        return stream_get_contents($this->content);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function toArray(bool $throw = true): array
+    {
+        if ('' === $content = $this->getContent($throw)) {
+            throw new JsonException('Response body is empty.');
+        }
+
+        if (null !== $this->jsonData) {
+            return $this->jsonData;
+        }
+
+        try {
+            $content = json_decode($content, true, 512, \JSON_BIGINT_AS_STRING | (\PHP_VERSION_ID >= 70300 ? \JSON_THROW_ON_ERROR : 0));
+        } catch (\JsonException $e) {
+            throw new JsonException($e->getMessage().sprintf(' for "%s".', $this->getInfo('url')), $e->getCode());
+        }
+
+        if (\PHP_VERSION_ID < 70300 && \JSON_ERROR_NONE !== json_last_error()) {
+            throw new JsonException(json_last_error_msg().sprintf(' for "%s".', $this->getInfo('url')), json_last_error());
+        }
+
+        if (!\is_array($content)) {
+            throw new JsonException(sprintf('JSON content was expected to decode to an array, "%s" returned for "%s".', \gettype($content), $this->getInfo('url')));
+        }
+
+        if (null !== $this->content) {
+            // Option "buffer" is true
+            return $this->jsonData = $content;
+        }
+
+        return $content;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function cancel(): void
+    {
+        $this->info['canceled'] = true;
+        $this->info['error'] = 'Response has been canceled.';
+        $this->close();
+    }
+
+    /**
+     * Casts the response to a PHP stream resource.
+     *
+     * @return resource
+     *
+     * @throws TransportExceptionInterface   When a network error occurs
+     * @throws RedirectionExceptionInterface On a 3xx when $throw is true and the "max_redirects" option has been reached
+     * @throws ClientExceptionInterface      On a 4xx when $throw is true
+     * @throws ServerExceptionInterface      On a 5xx when $throw is true
+     */
+    public function toStream(bool $throw = true)
+    {
+        if ($throw) {
+            // Ensure headers arrived
+            $this->getHeaders($throw);
+        }
+
+        $stream = StreamWrapper::createResource($this);
+        stream_get_meta_data($stream)['wrapper_data']
+            ->bindHandles($this->handle, $this->content);
+
+        return $stream;
+    }
+
+    public function __sleep()
+    {
+        throw new \BadMethodCallException('Cannot serialize '.__CLASS__);
+    }
+
+    public function __wakeup()
+    {
+        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
+    }
+
+    /**
+     * Closes the response and all its network handles.
+     */
+    private function close(): void
+    {
+        $this->canary->cancel();
+        $this->inflate = null;
+    }
+
+    /**
+     * Adds pending responses to the activity list.
+     */
+    abstract protected static function schedule(self $response, array &$runningResponses): void;
+
+    /**
+     * Performs all pending non-blocking operations.
+     */
+    abstract protected static function perform(ClientState $multi, array &$responses): void;
+
+    /**
+     * Waits for network activity.
+     */
+    abstract protected static function select(ClientState $multi, float $timeout): int;
+
+    private static function initialize(self $response): void
+    {
+        if (null !== $response->info['error']) {
+            throw new TransportException($response->info['error']);
+        }
+
+        try {
+            if (($response->initializer)($response)) {
+                foreach (self::stream([$response]) as $chunk) {
+                    if ($chunk->isFirst()) {
+                        break;
+                    }
+                }
+            }
+        } catch (\Throwable $e) {
+            // Persist timeouts thrown during initialization
+            $response->info['error'] = $e->getMessage();
+            $response->close();
+            throw $e;
+        }
+
+        $response->initializer = null;
+    }
+
+    private static function addResponseHeaders(array $responseHeaders, array &$info, array &$headers, string &$debug = ''): void
+    {
+        foreach ($responseHeaders as $h) {
+            if (11 <= \strlen($h) && '/' === $h[4] && preg_match('#^HTTP/\d+(?:\.\d+)? ([1-9]\d\d)(?: |$)#', $h, $m)) {
+                if ($headers) {
+                    $debug .= "< \r\n";
+                    $headers = [];
+                }
+                $info['http_code'] = (int) $m[1];
+            } elseif (2 === \count($m = explode(':', $h, 2))) {
+                $headers[strtolower($m[0])][] = ltrim($m[1]);
+            }
+
+            $debug .= "< {$h}\r\n";
+            $info['response_headers'][] = $h;
+        }
+
+        $debug .= "< \r\n";
+
+        if (!$info['http_code']) {
+            throw new TransportException(sprintf('Invalid or missing HTTP status line for "%s".', implode('', $info['url'])));
+        }
+    }
+
+    private function checkStatusCode()
+    {
+        if (500 <= $this->info['http_code']) {
+            throw new ServerException($this);
+        }
+
+        if (400 <= $this->info['http_code']) {
+            throw new ClientException($this);
+        }
+
+        if (300 <= $this->info['http_code']) {
+            throw new RedirectionException($this);
+        }
+    }
+
+    /**
+     * Ensures the request is always sent and that the response code was checked.
+     */
+    private function doDestruct()
+    {
+        $this->shouldBuffer = true;
+
+        if ($this->initializer && null === $this->info['error']) {
+            self::initialize($this);
+            $this->checkStatusCode();
+        }
+    }
+
+    /**
+     * Implements an event loop based on a buffer activity queue.
+     *
+     * @internal
+     */
+    public static function stream(iterable $responses, float $timeout = null): \Generator
+    {
+        $runningResponses = [];
+
+        foreach ($responses as $response) {
+            self::schedule($response, $runningResponses);
+        }
+
+        $lastActivity = microtime(true);
+        $elapsedTimeout = 0;
+
+        while (true) {
+            $hasActivity = false;
+            $timeoutMax = 0;
+            $timeoutMin = $timeout ?? \INF;
+
+            /** @var ClientState $multi */
+            foreach ($runningResponses as $i => [$multi]) {
+                $responses = &$runningResponses[$i][1];
+                self::perform($multi, $responses);
+
+                foreach ($responses as $j => $response) {
+                    $timeoutMax = $timeout ?? max($timeoutMax, $response->timeout);
+                    $timeoutMin = min($timeoutMin, $response->timeout, 1);
+                    $chunk = false;
+
+                    if (isset($multi->handlesActivity[$j])) {
+                        // no-op
+                    } elseif (!isset($multi->openHandles[$j])) {
+                        unset($responses[$j]);
+                        continue;
+                    } elseif ($elapsedTimeout >= $timeoutMax) {
+                        $multi->handlesActivity[$j] = [new ErrorChunk($response->offset, sprintf('Idle timeout reached for "%s".', $response->getInfo('url')))];
+                    } else {
+                        continue;
+                    }
+
+                    while ($multi->handlesActivity[$j] ?? false) {
+                        $hasActivity = true;
+                        $elapsedTimeout = 0;
+
+                        if (\is_string($chunk = array_shift($multi->handlesActivity[$j]))) {
+                            if (null !== $response->inflate && false === $chunk = @inflate_add($response->inflate, $chunk)) {
+                                $multi->handlesActivity[$j] = [null, new TransportException(sprintf('Error while processing content unencoding for "%s".', $response->getInfo('url')))];
+                                continue;
+                            }
+
+                            if ('' !== $chunk && null !== $response->content && \strlen($chunk) !== fwrite($response->content, $chunk)) {
+                                $multi->handlesActivity[$j] = [null, new TransportException(sprintf('Failed writing %d bytes to the response buffer.', \strlen($chunk)))];
+                                continue;
+                            }
+
+                            $chunkLen = \strlen($chunk);
+                            $chunk = new DataChunk($response->offset, $chunk);
+                            $response->offset += $chunkLen;
+                        } elseif (null === $chunk) {
+                            $e = $multi->handlesActivity[$j][0];
+                            unset($responses[$j], $multi->handlesActivity[$j]);
+                            $response->close();
+
+                            if (null !== $e) {
+                                $response->info['error'] = $e->getMessage();
+
+                                if ($e instanceof \Error) {
+                                    throw $e;
+                                }
+
+                                $chunk = new ErrorChunk($response->offset, $e);
+                            } else {
+                                if (0 === $response->offset && null === $response->content) {
+                                    $response->content = fopen('php://memory', 'w+');
+                                }
+
+                                $chunk = new LastChunk($response->offset);
+                            }
+                        } elseif ($chunk instanceof ErrorChunk) {
+                            unset($responses[$j]);
+                            $elapsedTimeout = $timeoutMax;
+                        } elseif ($chunk instanceof FirstChunk) {
+                            if ($response->logger) {
+                                $info = $response->getInfo();
+                                $response->logger->info(sprintf('Response: "%s %s"', $info['http_code'], $info['url']));
+                            }
+
+                            $response->inflate = \extension_loaded('zlib') && $response->inflate && 'gzip' === ($response->headers['content-encoding'][0] ?? null) ? inflate_init(\ZLIB_ENCODING_GZIP) : null;
+
+                            if ($response->shouldBuffer instanceof \Closure) {
+                                try {
+                                    $response->shouldBuffer = ($response->shouldBuffer)($response->headers);
+
+                                    if (null !== $response->info['error']) {
+                                        throw new TransportException($response->info['error']);
+                                    }
+                                } catch (\Throwable $e) {
+                                    $response->close();
+                                    $multi->handlesActivity[$j] = [null, $e];
+                                }
+                            }
+
+                            if (true === $response->shouldBuffer) {
+                                $response->content = fopen('php://temp', 'w+');
+                            } elseif (\is_resource($response->shouldBuffer)) {
+                                $response->content = $response->shouldBuffer;
+                            }
+                            $response->shouldBuffer = null;
+
+                            yield $response => $chunk;
+
+                            if ($response->initializer && null === $response->info['error']) {
+                                // Ensure the HTTP status code is always checked
+                                $response->getHeaders(true);
+                            }
+
+                            continue;
+                        }
+
+                        yield $response => $chunk;
+                    }
+
+                    unset($multi->handlesActivity[$j]);
+
+                    if ($chunk instanceof ErrorChunk && !$chunk->didThrow()) {
+                        // Ensure transport exceptions are always thrown
+                        $chunk->getContent();
+                    }
+                }
+
+                if (!$responses) {
+                    unset($runningResponses[$i]);
+                }
+
+                // Prevent memory leaks
+                $multi->handlesActivity = $multi->handlesActivity ?: [];
+                $multi->openHandles = $multi->openHandles ?: [];
+            }
+
+            if (!$runningResponses) {
+                break;
+            }
+
+            if ($hasActivity) {
+                $lastActivity = microtime(true);
+                continue;
+            }
+
+            if (-1 === self::select($multi, min($timeoutMin, $timeoutMax - $elapsedTimeout))) {
+                usleep(min(500, 1E6 * $timeoutMin));
+            }
+
+            $elapsedTimeout = microtime(true) - $lastActivity;
+        }
+    }
+}

vendor/symfony/http-client/Response/StreamWrapper.php

@@ -0,0 +1,296 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient\Response;
+
+use Symfony\Contracts\HttpClient\Exception\ExceptionInterface;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+
+/**
+ * Allows turning ResponseInterface instances to PHP streams.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class StreamWrapper
+{
+    /** @var resource|string|null */
+    public $context;
+
+    /** @var HttpClientInterface */
+    private $client;
+
+    /** @var ResponseInterface */
+    private $response;
+
+    /** @var resource|null */
+    private $content;
+
+    /** @var resource|null */
+    private $handle;
+
+    private $blocking = true;
+    private $timeout;
+    private $eof = false;
+    private $offset = 0;
+
+    /**
+     * Creates a PHP stream resource from a ResponseInterface.
+     *
+     * @return resource
+     */
+    public static function createResource(ResponseInterface $response, HttpClientInterface $client = null)
+    {
+        if (null === $client && !method_exists($response, 'stream')) {
+            throw new \InvalidArgumentException(sprintf('Providing a client to "%s()" is required when the response doesn\'t have any "stream()" method.', __CLASS__));
+        }
+
+        if (false === stream_wrapper_register('symfony', __CLASS__)) {
+            throw new \RuntimeException(error_get_last()['message'] ?? 'Registering the "symfony" stream wrapper failed.');
+        }
+
+        try {
+            $context = [
+                'client' => $client ?? $response,
+                'response' => $response,
+            ];
+
+            return fopen('symfony://'.$response->getInfo('url'), 'r', false, stream_context_create(['symfony' => $context])) ?: null;
+        } finally {
+            stream_wrapper_unregister('symfony');
+        }
+    }
+
+    public function getResponse(): ResponseInterface
+    {
+        return $this->response;
+    }
+
+    /**
+     * @param resource|null $handle  The resource handle that should be monitored when
+     *                               stream_select() is used on the created stream
+     * @param resource|null $content The seekable resource where the response body is buffered
+     */
+    public function bindHandles(&$handle, &$content): void
+    {
+        $this->handle = &$handle;
+        $this->content = &$content;
+    }
+
+    public function stream_open(string $path, string $mode, int $options): bool
+    {
+        if ('r' !== $mode) {
+            if ($options & \STREAM_REPORT_ERRORS) {
+                trigger_error(sprintf('Invalid mode "%s": only "r" is supported.', $mode), \E_USER_WARNING);
+            }
+
+            return false;
+        }
+
+        $context = stream_context_get_options($this->context)['symfony'] ?? null;
+        $this->client = $context['client'] ?? null;
+        $this->response = $context['response'] ?? null;
+        $this->context = null;
+
+        if (null !== $this->client && null !== $this->response) {
+            return true;
+        }
+
+        if ($options & \STREAM_REPORT_ERRORS) {
+            trigger_error('Missing options "client" or "response" in "symfony" stream context.', \E_USER_WARNING);
+        }
+
+        return false;
+    }
+
+    public function stream_read(int $count)
+    {
+        if (\is_resource($this->content)) {
+            // Empty the internal activity list
+            foreach ($this->client->stream([$this->response], 0) as $chunk) {
+                try {
+                    if (!$chunk->isTimeout() && $chunk->isFirst()) {
+                        $this->response->getStatusCode(); // ignore 3/4/5xx
+                    }
+                } catch (ExceptionInterface $e) {
+                    trigger_error($e->getMessage(), \E_USER_WARNING);
+
+                    return false;
+                }
+            }
+
+            if (0 !== fseek($this->content, $this->offset)) {
+                return false;
+            }
+
+            if ('' !== $data = fread($this->content, $count)) {
+                fseek($this->content, 0, \SEEK_END);
+                $this->offset += \strlen($data);
+
+                return $data;
+            }
+        }
+
+        if (\is_string($this->content)) {
+            if (\strlen($this->content) <= $count) {
+                $data = $this->content;
+                $this->content = null;
+            } else {
+                $data = substr($this->content, 0, $count);
+                $this->content = substr($this->content, $count);
+            }
+            $this->offset += \strlen($data);
+
+            return $data;
+        }
+
+        foreach ($this->client->stream([$this->response], $this->blocking ? $this->timeout : 0) as $chunk) {
+            try {
+                $this->eof = true;
+                $this->eof = !$chunk->isTimeout();
+                $this->eof = $chunk->isLast();
+
+                if ($chunk->isFirst()) {
+                    $this->response->getStatusCode(); // ignore 3/4/5xx
+                }
+
+                if ('' !== $data = $chunk->getContent()) {
+                    if (\strlen($data) > $count) {
+                        if (null === $this->content) {
+                            $this->content = substr($data, $count);
+                        }
+                        $data = substr($data, 0, $count);
+                    }
+                    $this->offset += \strlen($data);
+
+                    return $data;
+                }
+            } catch (ExceptionInterface $e) {
+                trigger_error($e->getMessage(), \E_USER_WARNING);
+
+                return false;
+            }
+        }
+
+        return '';
+    }
+
+    public function stream_set_option(int $option, int $arg1, ?int $arg2): bool
+    {
+        if (\STREAM_OPTION_BLOCKING === $option) {
+            $this->blocking = (bool) $arg1;
+        } elseif (\STREAM_OPTION_READ_TIMEOUT === $option) {
+            $this->timeout = $arg1 + $arg2 / 1e6;
+        } else {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function stream_tell(): int
+    {
+        return $this->offset;
+    }
+
+    public function stream_eof(): bool
+    {
+        return $this->eof && !\is_string($this->content);
+    }
+
+    public function stream_seek(int $offset, int $whence = \SEEK_SET): bool
+    {
+        if (!\is_resource($this->content) || 0 !== fseek($this->content, 0, \SEEK_END)) {
+            return false;
+        }
+
+        $size = ftell($this->content);
+
+        if (\SEEK_CUR === $whence) {
+            $offset += $this->offset;
+        }
+
+        if (\SEEK_END === $whence || $size < $offset) {
+            foreach ($this->client->stream([$this->response]) as $chunk) {
+                try {
+                    if ($chunk->isFirst()) {
+                        $this->response->getStatusCode(); // ignore 3/4/5xx
+                    }
+
+                    // Chunks are buffered in $this->content already
+                    $size += \strlen($chunk->getContent());
+
+                    if (\SEEK_END !== $whence && $offset <= $size) {
+                        break;
+                    }
+                } catch (ExceptionInterface $e) {
+                    trigger_error($e->getMessage(), \E_USER_WARNING);
+
+                    return false;
+                }
+            }
+
+            if (\SEEK_END === $whence) {
+                $offset += $size;
+            }
+        }
+
+        if (0 <= $offset && $offset <= $size) {
+            $this->eof = false;
+            $this->offset = $offset;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public function stream_cast(int $castAs)
+    {
+        if (\STREAM_CAST_FOR_SELECT === $castAs) {
+            $this->response->getHeaders(false);
+
+            return $this->handle ?? false;
+        }
+
+        return false;
+    }
+
+    public function stream_stat(): array
+    {
+        try {
+            $headers = $this->response->getHeaders(false);
+        } catch (ExceptionInterface $e) {
+            trigger_error($e->getMessage(), \E_USER_WARNING);
+            $headers = [];
+        }
+
+        return [
+            'dev' => 0,
+            'ino' => 0,
+            'mode' => 33060,
+            'nlink' => 0,
+            'uid' => 0,
+            'gid' => 0,
+            'rdev' => 0,
+            'size' => (int) ($headers['content-length'][0] ?? -1),
+            'atime' => 0,
+            'mtime' => strtotime($headers['last-modified'][0] ?? '') ?: 0,
+            'ctime' => 0,
+            'blksize' => 0,
+            'blocks' => 0,
+        ];
+    }
+
+    private function __construct()
+    {
+    }
+}

vendor/symfony/http-client/ScopingHttpClient.php

@@ -0,0 +1,108 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Symfony\Component\HttpClient\Exception\InvalidArgumentException;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+use Symfony\Contracts\Service\ResetInterface;
+
+/**
+ * Auto-configure the default options based on the requested URL.
+ *
+ * @author Anthony Martin <anthony.martin@sensiolabs.com>
+ */
+class ScopingHttpClient implements HttpClientInterface, ResetInterface
+{
+    use HttpClientTrait;
+
+    private $client;
+    private $defaultOptionsByRegexp;
+    private $defaultRegexp;
+
+    public function __construct(HttpClientInterface $client, array $defaultOptionsByRegexp, string $defaultRegexp = null)
+    {
+        $this->client = $client;
+        $this->defaultOptionsByRegexp = $defaultOptionsByRegexp;
+        $this->defaultRegexp = $defaultRegexp;
+
+        if (null !== $defaultRegexp && !isset($defaultOptionsByRegexp[$defaultRegexp])) {
+            throw new InvalidArgumentException(sprintf('No options are mapped to the provided "%s" default regexp.', $defaultRegexp));
+        }
+    }
+
+    public static function forBaseUri(HttpClientInterface $client, string $baseUri, array $defaultOptions = [], $regexp = null): self
+    {
+        if (null === $regexp) {
+            $regexp = preg_quote(implode('', self::resolveUrl(self::parseUrl('.'), self::parseUrl($baseUri))));
+        }
+
+        $defaultOptions['base_uri'] = $baseUri;
+
+        return new self($client, [$regexp => $defaultOptions], $regexp);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function request(string $method, string $url, array $options = []): ResponseInterface
+    {
+        $e = null;
+        $url = self::parseUrl($url, $options['query'] ?? []);
+
+        if (\is_string($options['base_uri'] ?? null)) {
+            $options['base_uri'] = self::parseUrl($options['base_uri']);
+        }
+
+        try {
+            $url = implode('', self::resolveUrl($url, $options['base_uri'] ?? null));
+        } catch (InvalidArgumentException $e) {
+            if (null === $this->defaultRegexp) {
+                throw $e;
+            }
+
+            $defaultOptions = $this->defaultOptionsByRegexp[$this->defaultRegexp];
+            $options = self::mergeDefaultOptions($options, $defaultOptions, true);
+            if (\is_string($options['base_uri'] ?? null)) {
+                $options['base_uri'] = self::parseUrl($options['base_uri']);
+            }
+            $url = implode('', self::resolveUrl($url, $options['base_uri'] ?? null, $defaultOptions['query'] ?? []));
+        }
+
+        foreach ($this->defaultOptionsByRegexp as $regexp => $defaultOptions) {
+            if (preg_match("{{$regexp}}A", $url)) {
+                if (null === $e || $regexp !== $this->defaultRegexp) {
+                    $options = self::mergeDefaultOptions($options, $defaultOptions, true);
+                }
+                break;
+            }
+        }
+
+        return $this->client->request($method, $url, $options);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function stream($responses, float $timeout = null): ResponseStreamInterface
+    {
+        return $this->client->stream($responses, $timeout);
+    }
+
+    public function reset()
+    {
+        if ($this->client instanceof ResetInterface) {
+            $this->client->reset();
+        }
+    }
+}

vendor/symfony/http-client/TraceableHttpClient.php

@@ -0,0 +1,78 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\HttpClient;
+
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Symfony\Contracts\HttpClient\ResponseStreamInterface;
+use Symfony\Contracts\Service\ResetInterface;
+
+/**
+ * @author Jérémy Romey <jeremy@free-agent.fr>
+ */
+final class TraceableHttpClient implements HttpClientInterface, ResetInterface
+{
+    private $client;
+    private $tracedRequests = [];
+
+    public function __construct(HttpClientInterface $client)
+    {
+        $this->client = $client;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function request(string $method, string $url, array $options = []): ResponseInterface
+    {
+        $traceInfo = [];
+        $this->tracedRequests[] = [
+            'method' => $method,
+            'url' => $url,
+            'options' => $options,
+            'info' => &$traceInfo,
+        ];
+        $onProgress = $options['on_progress'] ?? null;
+
+        $options['on_progress'] = function (int $dlNow, int $dlSize, array $info) use (&$traceInfo, $onProgress) {
+            $traceInfo = $info;
+
+            if (null !== $onProgress) {
+                $onProgress($dlNow, $dlSize, $info);
+            }
+        };
+
+        return $this->client->request($method, $url, $options);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function stream($responses, float $timeout = null): ResponseStreamInterface
+    {
+        return $this->client->stream($responses, $timeout);
+    }
+
+    public function getTracedRequests(): array
+    {
+        return $this->tracedRequests;
+    }
+
+    public function reset()
+    {
+        if ($this->client instanceof ResetInterface) {
+            $this->client->reset();
+        }
+
+        $this->tracedRequests = [];
+    }
+}