Version v0.1.3

vendor/autoload.php

@@ -0,0 +1,7 @@
+<?php
+
+// autoload.php @generated by Composer
+
+require_once __DIR__ . '/composer/autoload_real.php';
+
+return ComposerAutoloaderInitd5eff77d7f1a34fed3451f7ca63a1583::getLoader();

vendor/clue/connection-manager-extra/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Christian Lück
+
+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/clue/connection-manager-extra/src/ConnectionManagerDelay.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace ConnectionManager\Extra;
+
+use React\Socket\ConnectorInterface;
+use React\EventLoop\LoopInterface;
+use React\Promise\Timer;
+
+class ConnectionManagerDelay implements ConnectorInterface
+{
+    private $connectionManager;
+    private $delay;
+    private $loop;
+
+    public function __construct(ConnectorInterface $connectionManager, $delay, LoopInterface $loop)
+    {
+        $this->connectionManager = $connectionManager;
+        $this->delay = $delay;
+        $this->loop = $loop;
+    }
+
+    public function connect($uri)
+    {
+        $connectionManager = $this->connectionManager;
+
+        return Timer\resolve($this->delay, $this->loop)->then(function () use ($connectionManager, $uri) {
+            return $connectionManager->connect($uri);
+        });
+    }
+}

vendor/clue/connection-manager-extra/src/ConnectionManagerReject.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace ConnectionManager\Extra;
+
+use React\Socket\ConnectorInterface;
+use React\Promise;
+use Exception;
+
+// a simple connection manager that rejects every single connection attempt
+class ConnectionManagerReject implements ConnectorInterface
+{
+    private $reason = 'Connection rejected';
+
+    /**
+     * @param null|string|callable $reason
+     */
+    public function __construct($reason = null)
+    {
+        if ($reason !== null) {
+            $this->reason = $reason;
+        }
+    }
+
+    public function connect($uri)
+    {
+        $reason = $this->reason;
+        if (!is_string($reason)) {
+            try {
+                $reason = $reason($uri);
+            } catch (\Exception $e) {
+                $reason = $e;
+            }
+        }
+
+        if (!$reason instanceof \Exception) {
+            $reason = new Exception($reason);
+        }
+
+        return Promise\reject($reason);
+    }
+}

vendor/clue/connection-manager-extra/src/ConnectionManagerRepeat.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace ConnectionManager\Extra;
+
+use React\Socket\ConnectorInterface;
+use InvalidArgumentException;
+use Exception;
+use React\Promise\Promise;
+use React\Promise\CancellablePromiseInterface;
+
+class ConnectionManagerRepeat implements ConnectorInterface
+{
+    protected $connectionManager;
+    protected $maximumTries;
+
+    public function __construct(ConnectorInterface $connectionManager, $maximumTries)
+    {
+        if ($maximumTries < 1) {
+            throw new InvalidArgumentException('Maximum number of tries must be >= 1');
+        }
+        $this->connectionManager = $connectionManager;
+        $this->maximumTries = $maximumTries;
+    }
+
+    public function connect($uri)
+    {
+        $tries = $this->maximumTries;
+        $connector = $this->connectionManager;
+
+        return new Promise(function ($resolve, $reject) use ($uri, &$pending, &$tries, $connector) {
+            $try = function ($error = null) use (&$try, &$pending, &$tries, $uri, $connector, $resolve, $reject) {
+                if ($tries > 0) {
+                    --$tries;
+                    $pending = $connector->connect($uri);
+                    $pending->then($resolve, $try);
+                } else {
+                    $reject(new Exception('Connection still fails even after retrying', 0, $error));
+                }
+            };
+
+            $try();
+        }, function ($_, $reject) use (&$pending, &$tries) {
+            // stop retrying, reject results and cancel pending attempt
+            $tries = 0;
+            $reject(new \RuntimeException('Cancelled'));
+
+            if ($pending instanceof CancellablePromiseInterface) {
+                $pending->cancel();
+            }
+        });
+    }
+}

vendor/clue/connection-manager-extra/src/ConnectionManagerSwappable.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ConnectionManager\Extra;
+
+use React\Socket\ConnectorInterface;
+
+// connection manager decorator which simplifies exchanging the actual connection manager during runtime
+class ConnectionManagerSwappable implements ConnectorInterface
+{
+    protected $connectionManager;
+
+    public function __construct(ConnectorInterface $connectionManager)
+    {
+        $this->connectionManager = $connectionManager;
+    }
+
+    public function connect($uri)
+    {
+        return $this->connectionManager->connect($uri);
+    }
+
+    public function setConnectionManager(ConnectorInterface $connectionManager)
+    {
+        $this->connectionManager = $connectionManager;
+    }
+}

vendor/clue/connection-manager-extra/src/ConnectionManagerTimeout.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace ConnectionManager\Extra;
+
+use React\Socket\ConnectorInterface;
+use React\EventLoop\LoopInterface;
+use React\Promise\Timer;
+
+class ConnectionManagerTimeout implements ConnectorInterface
+{
+    private $connectionManager;
+    private $timeout;
+    private $loop;
+
+    public function __construct(ConnectorInterface $connectionManager, $timeout, LoopInterface $loop)
+    {
+        $this->connectionManager = $connectionManager;
+        $this->timeout = $timeout;
+        $this->loop = $loop;
+    }
+
+    public function connect($uri)
+    {
+        $promise = $this->connectionManager->connect($uri);
+
+        return Timer\timeout($promise, $this->timeout, $this->loop)->then(null, function ($e) use ($promise) {
+            // connection successfully established but timeout already expired => close successful connection
+            $promise->then(function ($connection) {
+                $connection->end();
+            });
+
+            throw $e;
+        });
+    }
+}

vendor/clue/connection-manager-extra/src/Multiple/ConnectionManagerConcurrent.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace ConnectionManager\Extra\Multiple;
+
+use ConnectionManager\Extra\Multiple\ConnectionManagerConsecutive;
+use React\Promise;
+use React\Promise\CancellablePromiseInterface;
+
+class ConnectionManagerConcurrent extends ConnectionManagerConsecutive
+{
+    public function connect($uri)
+    {
+        $all = array();
+        foreach ($this->managers as $connector) {
+            /* @var $connection Connector */
+            $all []= $connector->connect($uri);
+        }
+        return Promise\any($all)->then(function ($conn) use ($all) {
+            // a connection attempt succeeded
+            // => cancel all pending connection attempts
+            foreach ($all as $promise) {
+                if ($promise instanceof CancellablePromiseInterface) {
+                    $promise->cancel();
+                }
+
+                // if promise resolves despite cancellation, immediately close stream
+                $promise->then(function ($stream) use ($conn) {
+                    if ($stream !== $conn) {
+                        $stream->close();
+                    }
+                });
+            }
+            return $conn;
+        });
+    }
+}

vendor/clue/connection-manager-extra/src/Multiple/ConnectionManagerConsecutive.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace ConnectionManager\Extra\Multiple;
+
+use React\Socket\ConnectorInterface;
+use React\Promise;
+use UnderflowException;
+use React\Promise\CancellablePromiseInterface;
+
+class ConnectionManagerConsecutive implements ConnectorInterface
+{
+    protected $managers;
+
+    /**
+     *
+     * @param ConnectorInterface[] $managers
+     */
+    public function __construct(array $managers)
+    {
+        if (!$managers) {
+            throw new \InvalidArgumentException('List of connectors must not be empty');
+        }
+        $this->managers = $managers;
+    }
+
+    public function connect($uri)
+    {
+        return $this->tryConnection($this->managers, $uri);
+    }
+
+    /**
+     *
+     * @param ConnectorInterface[] $managers
+     * @param string $uri
+     * @return Promise
+     * @internal
+     */
+    public function tryConnection(array $managers, $uri)
+    {
+        return new Promise\Promise(function ($resolve, $reject) use (&$managers, &$pending, $uri) {
+            $try = function () use (&$try, &$managers, $uri, $resolve, $reject, &$pending) {
+                if (!$managers) {
+                    return $reject(new UnderflowException('No more managers to try to connect through'));
+                }
+
+                $manager = array_shift($managers);
+                $pending = $manager->connect($uri);
+                $pending->then($resolve, $try);
+            };
+
+            $try();
+        }, function ($_, $reject) use (&$managers, &$pending) {
+            // stop retrying, reject results and cancel pending attempt
+            $managers = array();
+            $reject(new \RuntimeException('Cancelled'));
+
+            if ($pending instanceof CancellablePromiseInterface) {
+                $pending->cancel();
+            }
+        });
+    }
+}

vendor/clue/connection-manager-extra/src/Multiple/ConnectionManagerRandom.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace ConnectionManager\Extra\Multiple;
+
+class ConnectionManagerRandom extends ConnectionManagerConsecutive
+{
+    public function connect($uri)
+    {
+        $managers = $this->managers;
+        shuffle($managers);
+
+        return $this->tryConnection($managers, $uri);
+    }
+}

vendor/clue/connection-manager-extra/src/Multiple/ConnectionManagerSelective.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace ConnectionManager\Extra\Multiple;
+
+use React\Socket\ConnectorInterface;
+use React\Promise;
+use UnderflowException;
+use InvalidArgumentException;
+
+class ConnectionManagerSelective implements ConnectorInterface
+{
+    private $managers;
+
+    /**
+     *
+     * @param ConnectorInterface[] $managers
+     */
+    public function __construct(array $managers)
+    {
+        foreach ($managers as $filter => $manager) {
+            $host = $filter;
+            $portMin = 0;
+            $portMax = 65535;
+
+            // search colon (either single one OR preceded by "]" due to IPv6)
+            $colon = strrpos($host, ':');
+            if ($colon !== false && (strpos($host, ':') === $colon || substr($host, $colon - 1, 1) === ']' )) {
+                if (!isset($host[$colon + 1])) {
+                    throw new InvalidArgumentException('Entry "' . $filter . '" has no port after colon');
+                }
+
+                $minus = strpos($host, '-', $colon);
+                if ($minus === false) {
+                    $portMin = $portMax = (int)substr($host, $colon + 1);
+
+                    if (substr($host, $colon + 1) !== (string)$portMin) {
+                        throw new InvalidArgumentException('Entry "' . $filter . '" has no valid port after colon');
+                    }
+                } else {
+                    $portMin = (int)substr($host, $colon + 1, ($minus - $colon));
+                    $portMax = (int)substr($host, $minus + 1);
+
+                    if (substr($host, $colon + 1) !== ($portMin . '-' . $portMax)) {
+                        throw new InvalidArgumentException('Entry "' . $filter . '" has no valid port range after colon');
+                    }
+
+                    if ($portMin > $portMax) {
+                        throw new InvalidArgumentException('Entry "' . $filter . '" has port range mixed up');
+                    }
+                }
+                $host = substr($host, 0, $colon);
+            }
+
+            if ($host === '') {
+                throw new InvalidArgumentException('Entry "' . $filter . '" has an empty host');
+            }
+
+            if (!$manager instanceof ConnectorInterface) {
+                throw new InvalidArgumentException('Entry "' . $filter . '" is not a valid connector');
+            }
+        }
+
+        $this->managers = $managers;
+    }
+
+    public function connect($uri)
+    {
+        $parts = parse_url((strpos($uri, '://') === false ? 'tcp://' : '') . $uri);
+        if (!isset($parts) || !isset($parts['scheme'], $parts['host'], $parts['port'])) {
+            return Promise\reject(new InvalidArgumentException('Invalid URI'));
+        }
+
+        $connector = $this->getConnectorForTarget(
+            trim($parts['host'], '[]'),
+            $parts['port']
+        );
+
+        if ($connector === null) {
+            return Promise\reject(new UnderflowException('No connector for given target found'));
+        }
+
+        return $connector->connect($uri);
+    }
+
+    private function getConnectorForTarget($targetHost, $targetPort)
+    {
+        foreach ($this->managers as $host => $connector) {
+            $portMin = 0;
+            $portMax = 65535;
+
+            // search colon (either single one OR preceded by "]" due to IPv6)
+            $colon = strrpos($host, ':');
+            if ($colon !== false && (strpos($host, ':') === $colon || substr($host, $colon - 1, 1) === ']' )) {
+                $minus = strpos($host, '-', $colon);
+                if ($minus === false) {
+                    $portMin = $portMax = (int)substr($host, $colon + 1);
+                } else {
+                    $portMin = (int)substr($host, $colon + 1, ($minus - $colon));
+                    $portMax = (int)substr($host, $minus + 1);
+                }
+                $host = trim(substr($host, 0, $colon), '[]');
+            }
+
+            if ($targetPort >= $portMin && $targetPort <= $portMax && fnmatch($host, $targetHost)) {
+                return $connector;
+            }
+        }
+
+        return null;
+    }
+}

vendor/clue/http-proxy-react/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Christian Lück
+
+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/clue/http-proxy-react/src/ProxyConnector.php

@@ -0,0 +1,199 @@
+<?php
+
+namespace Clue\React\HttpProxy;
+
+use React\Socket\ConnectorInterface;
+use Exception;
+use InvalidArgumentException;
+use RuntimeException;
+use RingCentral\Psr7;
+use React\Promise;
+use React\Promise\Deferred;
+use React\Socket\ConnectionInterface;
+
+/**
+ * A simple Connector that uses an HTTP CONNECT proxy to create plain TCP/IP connections to any destination
+ *
+ * [you] -> [proxy] -> [destination]
+ *
+ * This is most frequently used to issue HTTPS requests to your destination.
+ * However, this is actually performed on a higher protocol layer and this
+ * connector is actually inherently a general-purpose plain TCP/IP connector.
+ *
+ * Note that HTTP CONNECT proxies often restrict which ports one may connect to.
+ * Many (public) proxy servers do in fact limit this to HTTPS (443) only.
+ *
+ * If you want to establish a TLS connection (such as HTTPS) between you and
+ * your destination, you may want to wrap this connector in a SecureConnector
+ * instance.
+ *
+ * Note that communication between the client and the proxy is usually via an
+ * unencrypted, plain TCP/IP HTTP connection. Note that this is the most common
+ * setup, because you can still establish a TLS connection between you and the
+ * destination host as above.
+ *
+ * If you want to connect to a (rather rare) HTTPS proxy, you may want use its
+ * HTTPS port (443) and use a SecureConnector instance to create a secure
+ * connection to the proxy.
+ *
+ * @link https://tools.ietf.org/html/rfc7231#section-4.3.6
+ */
+class ProxyConnector implements ConnectorInterface
+{
+    private $connector;
+    private $proxyUri;
+    private $proxyAuth = '';
+
+    /**
+     * Instantiate a new ProxyConnector which uses the given $proxyUrl
+     *
+     * @param string $proxyUrl The proxy URL may or may not contain a scheme and
+     *     port definition. The default port will be `80` for HTTP (or `443` for
+     *     HTTPS), but many common HTTP proxy servers use custom ports.
+     * @param ConnectorInterface $connector In its most simple form, the given
+     *     connector will be a \React\Socket\Connector if you want to connect to
+     *     a given IP address.
+     * @throws InvalidArgumentException if the proxy URL is invalid
+     */
+    public function __construct($proxyUrl, ConnectorInterface $connector)
+    {
+        if (strpos($proxyUrl, '://') === false) {
+            $proxyUrl = 'http://' . $proxyUrl;
+        }
+
+        $parts = parse_url($proxyUrl);
+        if (!$parts || !isset($parts['scheme'], $parts['host']) || ($parts['scheme'] !== 'http' && $parts['scheme'] !== 'https')) {
+            throw new InvalidArgumentException('Invalid proxy URL');
+        }
+
+        // apply default port and TCP/TLS transport for given scheme
+        if (!isset($parts['port'])) {
+            $parts['port'] = $parts['scheme'] === 'https' ? 443 : 80;
+        }
+        $parts['scheme'] = $parts['scheme'] === 'https' ? 'tls' : 'tcp';
+
+        $this->connector = $connector;
+        $this->proxyUri = $parts['scheme'] . '://' . $parts['host'] . ':' . $parts['port'];
+
+        // prepare Proxy-Authorization header if URI contains username/password
+        if (isset($parts['user']) || isset($parts['pass'])) {
+            $this->proxyAuth = 'Proxy-Authorization: Basic ' . base64_encode(
+                rawurldecode($parts['user'] . ':' . (isset($parts['pass']) ? $parts['pass'] : ''))
+            ) . "\r\n";
+        }
+    }
+
+    public function connect($uri)
+    {
+        if (strpos($uri, '://') === false) {
+            $uri = 'tcp://' . $uri;
+        }
+
+        $parts = parse_url($uri);
+        if (!$parts || !isset($parts['scheme'], $parts['host'], $parts['port']) || $parts['scheme'] !== 'tcp') {
+            return Promise\reject(new InvalidArgumentException('Invalid target URI specified'));
+        }
+
+        $host = trim($parts['host'], '[]');
+        $port = $parts['port'];
+
+        // construct URI to HTTP CONNECT proxy server to connect to
+        $proxyUri = $this->proxyUri;
+
+        // append path from URI if given
+        if (isset($parts['path'])) {
+            $proxyUri .= $parts['path'];
+        }
+
+        // parse query args
+        $args = array();
+        if (isset($parts['query'])) {
+            parse_str($parts['query'], $args);
+        }
+
+        // append hostname from URI to query string unless explicitly given
+        if (!isset($args['hostname'])) {
+            $args['hostname'] = $parts['host'];
+        }
+
+        // append query string
+        $proxyUri .= '?' . http_build_query($args, '', '&');;
+
+        // append fragment from URI if given
+        if (isset($parts['fragment'])) {
+            $proxyUri .= '#' . $parts['fragment'];
+        }
+
+        $auth = $this->proxyAuth;
+
+        return $this->connector->connect($proxyUri)->then(function (ConnectionInterface $stream) use ($host, $port, $auth) {
+            $deferred = new Deferred(function ($_, $reject) use ($stream) {
+                $reject(new RuntimeException('Connection canceled while waiting for response from proxy (ECONNABORTED)', defined('SOCKET_ECONNABORTED') ? SOCKET_ECONNABORTED : 103));
+                $stream->close();
+            });
+
+            // keep buffering data until headers are complete
+            $buffer = '';
+            $fn = function ($chunk) use (&$buffer, &$fn, $deferred, $stream) {
+                $buffer .= $chunk;
+
+                $pos = strpos($buffer, "\r\n\r\n");
+                if ($pos !== false) {
+                    // end of headers received => stop buffering
+                    $stream->removeListener('data', $fn);
+
+                    // try to parse headers as response message
+                    try {
+                        $response = Psr7\parse_response(substr($buffer, 0, $pos));
+                    } catch (Exception $e) {
+                        $deferred->reject(new RuntimeException('Invalid response received from proxy (EBADMSG)', defined('SOCKET_EBADMSG') ? SOCKET_EBADMSG: 71, $e));
+                        $stream->close();
+                        return;
+                    }
+
+                    if ($response->getStatusCode() === 407) {
+                        // map status code 407 (Proxy Authentication Required) to EACCES
+                        $deferred->reject(new RuntimeException('Proxy denied connection due to invalid authentication ' . $response->getStatusCode() . ' (' . $response->getReasonPhrase() . ') (EACCES)', defined('SOCKET_EACCES') ? SOCKET_EACCES : 13));
+                        return $stream->close();
+                    } elseif ($response->getStatusCode() < 200 || $response->getStatusCode() >= 300) {
+                        // map non-2xx status code to ECONNREFUSED
+                        $deferred->reject(new RuntimeException('Proxy refused connection with HTTP error code ' . $response->getStatusCode() . ' (' . $response->getReasonPhrase() . ') (ECONNREFUSED)', defined('SOCKET_ECONNREFUSED') ? SOCKET_ECONNREFUSED : 111));
+                        return $stream->close();
+                    }
+
+                    // all okay, resolve with stream instance
+                    $deferred->resolve($stream);
+
+                    // emit remaining incoming as data event
+                    $buffer = (string)substr($buffer, $pos + 4);
+                    if ($buffer !== '') {
+                        $stream->emit('data', array($buffer));
+                        $buffer = '';
+                    }
+                    return;
+                }
+
+                // stop buffering when 8 KiB have been read
+                if (isset($buffer[8192])) {
+                    $deferred->reject(new RuntimeException('Proxy must not send more than 8 KiB of headers (EMSGSIZE)', defined('SOCKET_EMSGSIZE') ? SOCKET_EMSGSIZE : 90));
+                    $stream->close();
+                }
+            };
+            $stream->on('data', $fn);
+
+            $stream->on('error', function (Exception $e) use ($deferred) {
+                $deferred->reject(new RuntimeException('Stream error while waiting for response from proxy (EIO)', defined('SOCKET_EIO') ? SOCKET_EIO : 5, $e));
+            });
+
+            $stream->on('close', function () use ($deferred) {
+                $deferred->reject(new RuntimeException('Connection to proxy lost while waiting for response (ECONNRESET)', defined('SOCKET_ECONNRESET') ? SOCKET_ECONNRESET : 104));
+            });
+
+            $stream->write("CONNECT " . $host . ":" . $port . " HTTP/1.1\r\nHost: " . $host . ":" . $port . "\r\n" . $auth . "\r\n");
+
+            return $deferred->promise();
+        }, function (Exception $e) use ($proxyUri) {
+            throw new RuntimeException('Unable to connect to proxy (ECONNREFUSED)', defined('SOCKET_ECONNREFUSED') ? SOCKET_ECONNREFUSED : 111, $e);
+        });
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Factory.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Clue\Redis\Protocol;
+
+use Clue\Redis\Protocol\Parser\ParserInterface;
+use Clue\Redis\Protocol\Parser\ResponseParser;
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+use Clue\Redis\Protocol\Serializer\RecursiveSerializer;
+use Clue\Redis\Protocol\Parser\RequestParser;
+
+/**
+ * Provides factory methods used to instantiate the best available protocol implementation
+ */
+class Factory
+{
+    /**
+     * instantiate the best available protocol response parser implementation
+     *
+     * This is the parser every redis client implementation should use in order
+     * to parse incoming response messages from a redis server.
+     *
+     * @return ParserInterface
+     */
+    public function createResponseParser()
+    {
+        return new ResponseParser();
+    }
+
+    /**
+     * instantiate the best available protocol request parser implementation
+     *
+     * This is most useful for a redis server implementation which needs to
+     * process client requests.
+     *
+     * @return ParserInterface
+     */
+    public function createRequestParser()
+    {
+        return new RequestParser();
+    }
+
+    /**
+     * instantiate the best available protocol serializer implementation
+     *
+     * @return SerializerInterface
+     */
+    public function createSerializer()
+    {
+        return new RecursiveSerializer();
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Model/BulkReply.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Clue\Redis\Protocol\Model;
+
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+
+class BulkReply implements ModelInterface
+{
+    private $value;
+
+    /**
+     * create bulk reply (string reply)
+     *
+     * @param string|null $data
+     */
+    public function __construct($value)
+    {
+        if ($value !== null) {
+            $value = (string)$value;
+        }
+        $this->value = $value;
+    }
+
+    public function getValueNative()
+    {
+        return $this->value;
+    }
+
+    public function getMessageSerialized(SerializerInterface $serializer)
+    {
+        return $serializer->getBulkMessage($this->value);
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Model/ErrorReply.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Clue\Redis\Protocol\Model;
+
+use Exception;
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+
+/**
+ *
+ * @link http://redis.io/topics/protocol#status-reply
+ */
+class ErrorReply extends Exception implements ModelInterface
+{
+    /**
+     * create error status reply (single line error message)
+     *
+     * @param string|ErrorReplyException $message
+     * @return string
+     */
+    public function __construct($message, $code = 0, $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+    }
+
+    public function getValueNative()
+    {
+        return $this->getMessage();
+    }
+
+    public function getMessageSerialized(SerializerInterface $serializer)
+    {
+        return $serializer->getErrorMessage($this->getMessage());
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Model/IntegerReply.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Clue\Redis\Protocol\Model;
+
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+
+class IntegerReply implements ModelInterface
+{
+    private $value;
+
+    /**
+     * create integer reply
+     *
+     * @param int $data
+     */
+    public function __construct($value)
+    {
+        $this->value = (int)$value;
+    }
+
+    public function getValueNative()
+    {
+        return $this->value;
+    }
+
+    public function getMessageSerialized(SerializerInterface $serializer)
+    {
+        return $serializer->getIntegerMessage($this->value);
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Model/ModelInterface.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Clue\Redis\Protocol\Model;
+
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+
+interface ModelInterface
+{
+    /**
+     * Returns value of this model as a native representation for PHP
+     *
+     * @return mixed
+     */
+    public function getValueNative();
+
+    /**
+     * Returns the serialized representation of this protocol message
+     *
+     * @param SerializerInterface $serializer;
+     * @return string
+     */
+    public function getMessageSerialized(SerializerInterface $serializer);
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Model/MultiBulkReply.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Clue\Redis\Protocol\Model;
+
+use InvalidArgumentException;
+use UnexpectedValueException;
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+
+class MultiBulkReply implements ModelInterface
+{
+    /**
+     * @var array|null
+     */
+    private $data;
+
+    /**
+     * create multi bulk reply (an array of other replies, usually bulk replies)
+     *
+     * @param array|null $data
+     * @throws InvalidArgumentException
+     */
+    public function __construct(array $data = null)
+    {
+        $this->data = $data;
+    }
+
+    public function getValueNative()
+    {
+        if ($this->data === null) {
+            return null;
+        }
+
+        $ret = array();
+        foreach ($this->data as $one) {
+            if ($one instanceof ModelInterface) {
+                $ret []= $one->getValueNative();
+            } else {
+                $ret []= $one;
+            }
+        }
+        return $ret;
+    }
+
+    public function getMessageSerialized(SerializerInterface $serializer)
+    {
+        return $serializer->getMultiBulkMessage($this->data);
+    }
+
+    /**
+     * Checks whether this model represents a valid unified request protocol message
+     *
+     * The new unified protocol was introduced in Redis 1.2, but it became the
+     * standard way for talking with the Redis server in Redis 2.0. The unified
+     * request protocol is what Redis already uses in replies in order to send
+     * list of items to clients, and is called a Multi Bulk Reply.
+     *
+     * @return boolean
+     * @link http://redis.io/topics/protocol
+     */
+    public function isRequest()
+    {
+        if (!$this->data) {
+            return false;
+        }
+
+        foreach ($this->data as $one) {
+            if (!($one instanceof BulkReply) && !is_string($one)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function getRequestModel()
+    {
+        if (!$this->data) {
+            throw new UnexpectedValueException('Null-multi-bulk message can not be represented as a request, must contain string/bulk values');
+        }
+
+        $command = null;
+        $args = array();
+
+        foreach ($this->data as $one) {
+            if ($one instanceof BulkReply) {
+                $one = $one->getValueNative();
+            } elseif (!is_string($one)) {
+                throw new UnexpectedValueException('Message can not be represented as a request, must only contain string/bulk values');
+            }
+
+            if ($command === null) {
+                $command = $one;
+            } else {
+                $args []= $one;
+            }
+        }
+
+        return new Request($command, $args);
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Model/Request.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Clue\Redis\Protocol\Model;
+
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Model\BulkReply;
+use Clue\Redis\Protocol\Model\MultiBulkReply;
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+
+class Request implements ModelInterface
+{
+    private $command;
+    private $args;
+
+    public function __construct($command, array $args = array())
+    {
+        $this->command = $command;
+        $this->args    = $args;
+    }
+
+    public function getCommand()
+    {
+        return $this->command;
+    }
+
+    public function getArgs()
+    {
+        return $this->args;
+    }
+
+    public function getReplyModel()
+    {
+        $models = array(new BulkReply($this->command));
+        foreach ($this->args as $arg) {
+            $models []= new BulkReply($arg);
+        }
+
+        return new MultiBulkReply($models);
+    }
+
+    public function getValueNative()
+    {
+        $ret = $this->args;
+        array_unshift($ret, $this->command);
+
+        return $ret;
+    }
+
+    public function getMessageSerialized(SerializerInterface $serializer)
+    {
+        return $serializer->getRequestMessage($this->command, $this->args);
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Model/StatusReply.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Clue\Redis\Protocol\Model;
+
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+/**
+ *
+ * @link http://redis.io/topics/protocol#status-reply
+ */
+class StatusReply implements ModelInterface
+{
+    private $message;
+
+    /**
+     * create status reply (single line message)
+     *
+     * @param string|Status $message
+     * @return string
+     */
+    public function __construct($message)
+    {
+        $this->message = $message;
+    }
+
+    public function getValueNative()
+    {
+        return $this->message;
+    }
+
+    public function getMessageSerialized(SerializerInterface $serializer)
+    {
+        return $serializer->getStatusMessage($this->message);
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Parser/MessageBuffer.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Clue\Redis\Protocol\Parser;
+
+use UnderflowException;
+
+class MessageBuffer implements ParserInterface
+{
+    private $parser;
+    private $incomingQueue = array();
+
+    public function __construct(ParserInterface $parser)
+    {
+        $this->parser = $parser;
+    }
+
+    public function popIncomingModel()
+    {
+        if (!$this->incomingQueue) {
+            throw new UnderflowException('Incoming message queue is empty');
+        }
+        return array_shift($this->incomingQueue);
+    }
+
+    public function hasIncomingModel()
+    {
+        return ($this->incomingQueue) ? true : false;
+    }
+
+    public function pushIncoming($data)
+    {
+        $ret = $this->parser->pushIncoming($data);
+
+        foreach ($ret as $one) {
+            $this->incomingQueue []= $one;
+        }
+
+        return $ret;
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Parser/ParserException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Clue\Redis\Protocol\Parser;
+
+use UnexpectedValueException;
+
+class ParserException extends UnexpectedValueException
+{
+
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Parser/ParserInterface.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Clue\Redis\Protocol\Parser;
+
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Parser\ParserException;
+
+interface ParserInterface
+{
+    /**
+     * push a chunk of the redis protocol message into the buffer and parse
+     *
+     * You can push any number of bytes of a redis protocol message into the
+     * parser and it will try to parse messages from its data stream. So you can
+     * pass data directly from your socket stream and the parser will return the
+     * right amount of message model objects for you.
+     *
+     * If you pass an incomplete message, expect it to return an empty array. If
+     * your incomplete message is split to across multiple chunks, the parsed
+     * message model will be returned once the parser has sufficient data.
+     *
+     * @param string $dataChunk
+     * @return ModelInterface[] 0+ message models
+     * @throws ParserException if the message can not be parsed
+     * @see self::popIncomingModel()
+     */
+    public function pushIncoming($dataChunk);
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Parser/RequestParser.php

@@ -0,0 +1,125 @@
+<?php
+
+namespace Clue\Redis\Protocol\Parser;
+
+use Clue\Redis\Protocol\Parser\ParserException;
+use Clue\Redis\Protocol\Model\Request;
+
+class RequestParser implements ParserInterface
+{
+    const CRLF = "\r\n";
+
+    private $incomingBuffer = '';
+    private $incomingOffset = 0;
+
+    public function pushIncoming($dataChunk)
+    {
+        $this->incomingBuffer .= $dataChunk;
+
+        $parsed = array();
+
+        do {
+            $saved = $this->incomingOffset;
+            $message = $this->readRequest();
+            if ($message === null) {
+                // restore previous position for next parsing attempt
+                $this->incomingOffset = $saved;
+                break;
+            }
+
+            if ($message !== false) {
+                $parsed []= $message;
+            }
+        } while($this->incomingBuffer !== '');
+
+        if ($this->incomingOffset !== 0) {
+            $this->incomingBuffer = (string)substr($this->incomingBuffer, $this->incomingOffset);
+            $this->incomingOffset = 0;
+        }
+
+        return $parsed;
+    }
+
+    /**
+     * try to parse request from incoming buffer
+     *
+     * @throws ParserException if the incoming buffer is invalid
+     * @return Request|null
+     */
+    private function readRequest()
+    {
+        $crlf = strpos($this->incomingBuffer, "\r\n", $this->incomingOffset);
+        if ($crlf === false) {
+            return null;
+        }
+
+        // line starts with a multi-bulk header "*"
+        if (isset($this->incomingBuffer[$this->incomingOffset]) && $this->incomingBuffer[$this->incomingOffset] === '*') {
+            $line = substr($this->incomingBuffer, $this->incomingOffset + 1, $crlf - $this->incomingOffset + 1);
+            $this->incomingOffset = $crlf + 2;
+            $count = (int)$line;
+
+            if ($count <= 0) {
+                return false;
+            }
+            $command = null;
+            $args    = array();
+            for ($i = 0; $i < $count; ++$i) {
+                $sub = $this->readBulk();
+                if ($sub === null) {
+                    return null;
+                }
+                if ($command === null) {
+                    $command = $sub;
+                } else {
+                    $args []= $sub;
+                }
+            }
+            return new Request($command, $args);
+        }
+
+        // parse an old inline request instead
+        $line = substr($this->incomingBuffer, $this->incomingOffset, $crlf - $this->incomingOffset);
+        $this->incomingOffset = $crlf + 2;
+
+        $args = preg_split('/ +/', trim($line, ' '));
+        $command = array_shift($args);
+
+        if ($command === '') {
+            return false;
+        }
+
+        return new Request($command, $args);
+    }
+
+    private function readBulk()
+    {
+        $crlf = strpos($this->incomingBuffer, "\r\n", $this->incomingOffset);
+        if ($crlf === false) {
+            return null;
+        }
+
+        // line has to start with a bulk header "$"
+        if (!isset($this->incomingBuffer[$this->incomingOffset]) || $this->incomingBuffer[$this->incomingOffset] !== '$') {
+            throw new ParserException('ERR Protocol error: expected \'$\', got \'' . substr($this->incomingBuffer, $this->incomingOffset, 1) . '\'');
+        }
+
+        $line = substr($this->incomingBuffer, $this->incomingOffset + 1, $crlf - $this->incomingOffset + 1);
+        $this->incomingOffset = $crlf + 2;
+        $size = (int)$line;
+
+        if ($size < 0) {
+            throw new ParserException('ERR Protocol error: invalid bulk length');
+        }
+
+        if (!isset($this->incomingBuffer[$this->incomingOffset + $size + 1])) {
+            // check enough bytes + crlf are buffered
+            return null;
+        }
+
+        $ret = substr($this->incomingBuffer, $this->incomingOffset, $size);
+        $this->incomingOffset += $size + 2;
+
+        return $ret;
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Parser/ResponseParser.php

@@ -0,0 +1,151 @@
+<?php
+
+namespace Clue\Redis\Protocol\Parser;
+
+use Clue\Redis\Protocol\Parser\ParserInterface;
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Model\BulkReply;
+use Clue\Redis\Protocol\Model\ErrorReply;
+use Clue\Redis\Protocol\Model\IntegerReply;
+use Clue\Redis\Protocol\Model\MultiBulkReply;
+use Clue\Redis\Protocol\Model\StatusReply;
+use Clue\Redis\Protocol\Parser\ParserException;
+
+/**
+ * Simple recursive redis wire protocol parser
+ *
+ * Heavily influenced by blocking parser implementation from jpd/redisent.
+ *
+ * @link https://github.com/jdp/redisent
+ * @link http://redis.io/topics/protocol
+ */
+class ResponseParser implements ParserInterface
+{
+    const CRLF = "\r\n";
+
+    private $incomingBuffer = '';
+    private $incomingOffset = 0;
+
+    public function pushIncoming($dataChunk)
+    {
+        $this->incomingBuffer .= $dataChunk;
+
+        return $this->tryParsingIncomingMessages();
+    }
+
+    private function tryParsingIncomingMessages()
+    {
+        $messages = array();
+
+        do {
+            $message = $this->readResponse();
+            if ($message === null) {
+                // restore previous position for next parsing attempt
+                $this->incomingOffset = 0;
+                break;
+            }
+
+            $messages []= $message;
+
+            $this->incomingBuffer = (string)substr($this->incomingBuffer, $this->incomingOffset);
+            $this->incomingOffset = 0;
+        } while($this->incomingBuffer !== '');
+
+        return $messages;
+    }
+
+    private function readLine()
+    {
+        $pos = strpos($this->incomingBuffer, "\r\n", $this->incomingOffset);
+
+        if ($pos === false) {
+            return null;
+        }
+
+        $ret = (string)substr($this->incomingBuffer, $this->incomingOffset, $pos - $this->incomingOffset);
+        $this->incomingOffset = $pos + 2;
+
+        return $ret;
+    }
+
+    private function readLength($len)
+    {
+        $ret = substr($this->incomingBuffer, $this->incomingOffset, $len);
+        if (strlen($ret) !== $len) {
+            return null;
+        }
+
+        $this->incomingOffset += $len;
+
+        return $ret;
+    }
+
+    /**
+     * try to parse response from incoming buffer
+     *
+     * ripped from jdp/redisent, with some minor modifications to read from
+     * the incoming buffer instead of issuing a blocking fread on a stream
+     *
+     * @throws ParserException if the incoming buffer is invalid
+     * @return ModelInterface|null
+     * @link https://github.com/jdp/redisent
+     */
+    private function readResponse()
+    {
+        /* Parse the response based on the reply identifier */
+        $reply = $this->readLine();
+        if ($reply === null) {
+            return null;
+        }
+        switch (substr($reply, 0, 1)) {
+            /* Error reply */
+            case '-':
+                $response = new ErrorReply(substr($reply, 1));
+                break;
+                /* Inline reply */
+            case '+':
+                $response = new StatusReply(substr($reply, 1));
+                break;
+                /* Bulk reply */
+            case '$':
+                $size = (int)substr($reply, 1);
+                if ($size === -1) {
+                    return new BulkReply(null);
+                }
+                $data = $this->readLength($size);
+                if ($data === null) {
+                    return null;
+                }
+                if ($this->readLength(2) === null) { /* discard crlf */
+                    return null;
+                }
+                $response = new BulkReply($data);
+                break;
+                /* Multi-bulk reply */
+            case '*':
+                $count = (int)substr($reply, 1);
+                if ($count === -1) {
+                    return new MultiBulkReply(null);
+                }
+                $response = array();
+                for ($i = 0; $i < $count; $i++) {
+                    $sub = $this->readResponse();
+                    if ($sub === null) {
+                        return null;
+                    }
+                    $response []= $sub;
+                }
+                $response = new MultiBulkReply($response);
+                break;
+                /* Integer reply */
+            case ':':
+                $response = new IntegerReply(substr($reply, 1));
+                break;
+            default:
+                throw new ParserException('Invalid message can not be parsed: "' . $reply . '"');
+                break;
+        }
+        /* Party on */
+        return $response;
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Serializer/RecursiveSerializer.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Clue\Redis\Protocol\Serializer;
+
+use Clue\Redis\Protocol\Model\StatusReply;
+use InvalidArgumentException;
+use Exception;
+use Clue\Redis\Protocol\Model\BulkReply;
+use Clue\Redis\Protocol\Model\IntegerReply;
+use Clue\Redis\Protocol\Model\ErrorReply;
+use Clue\Redis\Protocol\Model\MultiBulkReply;
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Model\Request;
+
+class RecursiveSerializer implements SerializerInterface
+{
+    const CRLF = "\r\n";
+
+    public function getRequestMessage($command, array $args = array())
+    {
+        $data = '*' . (count($args) + 1) . "\r\n$" . strlen($command) . "\r\n" . $command . "\r\n";
+        foreach ($args as $arg) {
+            $data .= '$' . strlen($arg) . "\r\n" . $arg . "\r\n";
+        }
+        return $data;
+    }
+
+    public function createRequestModel($command, array $args = array())
+    {
+        return new Request($command, $args);
+    }
+
+    public function getReplyMessage($data)
+    {
+        if (is_string($data) || $data === null) {
+            return $this->getBulkMessage($data);
+        } else if (is_int($data) || is_float($data) || is_bool($data)) {
+            return $this->getIntegerMessage($data);
+        } else if ($data instanceof Exception) {
+            return $this->getErrorMessage($data->getMessage());
+        } else if (is_array($data)) {
+            return $this->getMultiBulkMessage($data);
+        } else {
+            throw new InvalidArgumentException('Invalid data type passed for serialization');
+        }
+    }
+
+    public function createReplyModel($data)
+    {
+        if (is_string($data) || $data === null) {
+            return new BulkReply($data);
+        } else if (is_int($data) || is_float($data) || is_bool($data)) {
+            return new IntegerReply($data);
+        } else if ($data instanceof Exception) {
+            return new ErrorReply($data->getMessage());
+        } else if (is_array($data)) {
+            $models = array();
+            foreach ($data as $one) {
+                $models []= $this->createReplyModel($one);
+            }
+            return new MultiBulkReply($models);
+        } else {
+            throw new InvalidArgumentException('Invalid data type passed for serialization');
+        }
+    }
+
+    public function getBulkMessage($data)
+    {
+        if ($data === null) {
+            /* null bulk reply */
+            return '$-1' . self::CRLF;
+        }
+        /* bulk reply */
+        return '$' . strlen($data) . self::CRLF . $data . self::CRLF;
+    }
+
+    public function getErrorMessage($data)
+    {
+        /* error status reply */
+        return '-' . $data . self::CRLF;
+    }
+
+    public function getIntegerMessage($data)
+    {
+        return ':' . (int)$data . self::CRLF;
+    }
+
+    public function getMultiBulkMessage($data)
+    {
+        if ($data === null) {
+            /* null multi bulk reply */
+            return '*-1' . self::CRLF;
+        }
+        /* multi bulk reply */
+        $ret = '*' . count($data) . self::CRLF;
+        foreach ($data as $one) {
+            if ($one instanceof ModelInterface) {
+                $ret .= $one->getMessageSerialized($this);
+            } else {
+                $ret .= $this->getReplyMessage($one);
+            }
+        }
+        return $ret;
+    }
+
+    public function getStatusMessage($data)
+    {
+        /* status reply */
+        return '+' . $data . self::CRLF;
+    }
+}

vendor/clue/redis-protocol/src/Clue/Redis/Protocol/Serializer/SerializerInterface.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Clue\Redis\Protocol\Serializer;
+
+use Clue\Redis\Protocol\Model\ErrorReplyException;
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Model\MultiBulkReply;
+
+interface SerializerInterface
+{
+    /**
+     * create a serialized unified request protocol message
+     *
+     * This is the *one* method most redis client libraries will likely want to
+     * use in order to send a serialized message (a request) over the* wire to
+     * your redis server instance.
+     *
+     * This method should be used in favor of constructing a request model and
+     * then serializing it. While its effect might be equivalent, this method
+     * is likely to (i.e. it /could/) provide a faster implementation.
+     *
+     * @param string $command
+     * @param array $args
+     * @return string
+     * @see self::createRequestMessage()
+     */
+    public function getRequestMessage($command, array $args = array());
+
+    /**
+     * create a unified request protocol message model
+     *
+     * @param string $command
+     * @param array $args
+     * @return MultiBulkReply
+     */
+    public function createRequestModel($command, array $args = array());
+
+    /**
+     * create a serialized unified protocol reply message
+     *
+     * This is most useful for a redis server implementation which needs to
+     * process client requests and send resulting reply messages.
+     *
+     * This method does its best to guess to right reply type and then returns
+     * a serialized version of the message. It follows the "redis to lua
+     * conversion table" (see link) which means most basic types can be mapped
+     * as is.
+     *
+     * This method should be used in favor of constructing a reply model and
+     * then serializing it. While its effect might be equivalent, this method
+     * is likely to (i.e. it /could/) provide a faster implementation.
+     *
+     * Note however, you may still want to explicitly create a nested reply
+     * model hierarchy if you need more control over the serialized message. For
+     * instance, a null value will always be returned as a Null-Bulk-Reply, so
+     * there's no way to express a Null-Multi-Bulk-Reply, unless you construct
+     * it explicitly.
+     *
+     * @param mixed $data
+     * @return string
+     * @see self::createReplyModel()
+     * @link http://redis.io/commands/eval
+     */
+    public function getReplyMessage($data);
+
+    /**
+     * create response message by determining datatype from given argument
+     *
+     * @param mixed $data
+     * @return ModelInterface
+     */
+    public function createReplyModel($data);
+
+    public function getBulkMessage($data);
+
+    public function getErrorMessage($data);
+
+    public function getIntegerMessage($data);
+
+    public function getMultiBulkMessage($data);
+
+    public function getStatusMessage($data);
+}

vendor/clue/redis-react/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Christian Lück
+
+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/clue/redis-react/src/Client.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Clue\React\Redis;
+
+use Evenement\EventEmitterInterface;
+use React\Promise\PromiseInterface;
+
+/**
+ * Simple interface for executing redis commands
+ *
+ * @event error(Exception $error)
+ * @event close()
+ *
+ * @event message($channel, $message)
+ * @event subscribe($channel, $numberOfChannels)
+ * @event unsubscribe($channel, $numberOfChannels)
+ *
+ * @event pmessage($pattern, $channel, $message)
+ * @event psubscribe($channel, $numberOfChannels)
+ * @event punsubscribe($channel, $numberOfChannels)
+ */
+interface Client extends EventEmitterInterface
+{
+    /**
+     * Invoke the given command and return a Promise that will be resolved when the request has been replied to
+     *
+     * This is a magic method that will be invoked when calling any redis
+     * command on this instance.
+     *
+     * @param string   $name
+     * @param string[] $args
+     * @return PromiseInterface Promise<mixed, Exception>
+     */
+    public function __call($name, $args);
+
+    /**
+     * end connection once all pending requests have been replied to
+     *
+     * @uses self::close() once all replies have been received
+     * @see self::close() for closing the connection immediately
+     */
+    public function end();
+
+    /**
+     * close connection immediately
+     *
+     * This will emit the "close" event.
+     *
+     * @see self::end() for closing the connection once the client is idle
+     */
+    public function close();
+}

vendor/clue/redis-react/src/Factory.php

@@ -0,0 +1,140 @@
+<?php
+
+namespace Clue\React\Redis;
+
+use Clue\React\Redis\StreamingClient;
+use Clue\Redis\Protocol\Factory as ProtocolFactory;
+use React\EventLoop\LoopInterface;
+use React\Promise;
+use React\Socket\ConnectionInterface;
+use React\Socket\Connector;
+use React\Socket\ConnectorInterface;
+use InvalidArgumentException;
+
+class Factory
+{
+    private $connector;
+    private $protocol;
+
+    /**
+     * @param LoopInterface $loop
+     * @param ConnectorInterface|null $connector [optional] Connector to use.
+     *     Should be `null` in order to use default Connector.
+     * @param ProtocolFactory|null $protocol
+     */
+    public function __construct(LoopInterface $loop, ConnectorInterface $connector = null, ProtocolFactory $protocol = null)
+    {
+        if ($connector === null) {
+            $connector = new Connector($loop);
+        }
+
+        if ($protocol === null) {
+            $protocol = new ProtocolFactory();
+        }
+
+        $this->connector = $connector;
+        $this->protocol = $protocol;
+    }
+
+    /**
+     * create redis client connected to address of given redis instance
+     *
+     * @param string $target Redis server URI to connect to
+     * @return \React\Promise\PromiseInterface resolves with Client or rejects with \Exception
+     */
+    public function createClient($target)
+    {
+        try {
+            $parts = $this->parseUrl($target);
+        } catch (InvalidArgumentException $e) {
+            return Promise\reject($e);
+        }
+
+        $protocol = $this->protocol;
+
+        $promise = $this->connector->connect($parts['host'] . ':' . $parts['port'])->then(function (ConnectionInterface $stream) use ($protocol) {
+            return new StreamingClient($stream, $protocol->createResponseParser(), $protocol->createSerializer());
+        });
+
+        if (isset($parts['auth'])) {
+            $promise = $promise->then(function (StreamingClient $client) use ($parts) {
+                return $client->auth($parts['auth'])->then(
+                    function () use ($client) {
+                        return $client;
+                    },
+                    function ($error) use ($client) {
+                        $client->close();
+                        throw $error;
+                    }
+                );
+            });
+        }
+
+        if (isset($parts['db'])) {
+            $promise = $promise->then(function (StreamingClient $client) use ($parts) {
+                return $client->select($parts['db'])->then(
+                    function () use ($client) {
+                        return $client;
+                    },
+                    function ($error) use ($client) {
+                        $client->close();
+                        throw $error;
+                    }
+                );
+            });
+        }
+
+        return $promise;
+    }
+
+    /**
+     * @param string $target
+     * @return array with keys host, port, auth and db
+     * @throws InvalidArgumentException
+     */
+    private function parseUrl($target)
+    {
+        if (strpos($target, '://') === false) {
+            $target = 'redis://' . $target;
+        }
+
+        $parts = parse_url($target);
+        if ($parts === false || !isset($parts['scheme'], $parts['host']) || !in_array($parts['scheme'], array('redis', 'rediss'))) {
+            throw new InvalidArgumentException('Given URL can not be parsed');
+        }
+
+        if (!isset($parts['port'])) {
+            $parts['port'] = 6379;
+        }
+
+        if (isset($parts['pass'])) {
+            $parts['auth'] = rawurldecode($parts['pass']);
+        }
+
+        if (isset($parts['path']) && $parts['path'] !== '') {
+            // skip first slash
+            $parts['db'] = substr($parts['path'], 1);
+        }
+
+        if ($parts['scheme'] === 'rediss') {
+            $parts['host'] = 'tls://' . $parts['host'];
+        }
+
+        if (isset($parts['query'])) {
+            $args = array();
+            parse_str($parts['query'], $args);
+
+            if (isset($args['password'])) {
+                $parts['auth'] = $args['password'];
+            }
+
+            if (isset($args['db'])) {
+                $parts['db'] = $args['db'];
+            }
+        }
+
+        unset($parts['scheme'], $parts['user'], $parts['pass'], $parts['path']);
+
+        return $parts;
+    }
+}

vendor/clue/redis-react/src/StreamingClient.php

@@ -0,0 +1,180 @@
+<?php
+
+namespace Clue\React\Redis;
+
+use Evenement\EventEmitter;
+use Clue\Redis\Protocol\Parser\ParserInterface;
+use Clue\Redis\Protocol\Parser\ParserException;
+use Clue\Redis\Protocol\Serializer\SerializerInterface;
+use Clue\Redis\Protocol\Factory as ProtocolFactory;
+use UnderflowException;
+use RuntimeException;
+use InvalidArgumentException;
+use React\Promise\Deferred;
+use Clue\Redis\Protocol\Model\ErrorReply;
+use Clue\Redis\Protocol\Model\ModelInterface;
+use Clue\Redis\Protocol\Model\MultiBulkReply;
+use React\Stream\DuplexStreamInterface;
+
+/**
+ * @internal
+ */
+class StreamingClient extends EventEmitter implements Client
+{
+    private $stream;
+    private $parser;
+    private $serializer;
+    private $requests = array();
+    private $ending = false;
+    private $closed = false;
+
+    private $subscribed = 0;
+    private $psubscribed = 0;
+
+    public function __construct(DuplexStreamInterface $stream, ParserInterface $parser = null, SerializerInterface $serializer = null)
+    {
+        if ($parser === null || $serializer === null) {
+            $factory = new ProtocolFactory();
+            if ($parser === null) {
+                $parser = $factory->createResponseParser();
+            }
+            if ($serializer === null) {
+                $serializer = $factory->createSerializer();
+            }
+        }
+
+        $that = $this;
+        $stream->on('data', function($chunk) use ($parser, $that) {
+            try {
+                $models = $parser->pushIncoming($chunk);
+            }
+            catch (ParserException $error) {
+                $that->emit('error', array($error));
+                $that->close();
+                return;
+            }
+
+            foreach ($models as $data) {
+                try {
+                    $that->handleMessage($data);
+                }
+                catch (UnderflowException $error) {
+                    $that->emit('error', array($error));
+                    $that->close();
+                    return;
+                }
+            }
+        });
+
+        $stream->on('close', array($this, 'close'));
+
+        $this->stream = $stream;
+        $this->parser = $parser;
+        $this->serializer = $serializer;
+    }
+
+    public function __call($name, $args)
+    {
+        $request = new Deferred();
+        $promise = $request->promise();
+
+        $name = strtolower($name);
+
+        // special (p)(un)subscribe commands only accept a single parameter and have custom response logic applied
+        static $pubsubs = array('subscribe', 'unsubscribe', 'psubscribe', 'punsubscribe');
+
+        if ($this->ending) {
+            $request->reject(new RuntimeException('Connection closed'));
+        } elseif (count($args) !== 1 && in_array($name, $pubsubs)) {
+            $request->reject(new InvalidArgumentException('PubSub commands limited to single argument'));
+        } elseif ($name === 'monitor') {
+            $request->reject(new \BadMethodCallException('MONITOR command explicitly not supported'));
+        } else {
+            $this->stream->write($this->serializer->getRequestMessage($name, $args));
+            $this->requests []= $request;
+        }
+
+        if (in_array($name, $pubsubs)) {
+            $that = $this;
+            $subscribed =& $this->subscribed;
+            $psubscribed =& $this->psubscribed;
+
+            $promise->then(function ($array) use ($that, &$subscribed, &$psubscribed) {
+                $first = array_shift($array);
+
+                // (p)(un)subscribe messages are to be forwarded
+                $that->emit($first, $array);
+
+                // remember number of (p)subscribe topics
+                if ($first === 'subscribe' || $first === 'unsubscribe') {
+                    $subscribed = $array[1];
+                } else {
+                    $psubscribed = $array[1];
+                }
+            });
+        }
+
+        return $promise;
+    }
+
+    public function handleMessage(ModelInterface $message)
+    {
+        if (($this->subscribed !== 0 || $this->psubscribed !== 0) && $message instanceof MultiBulkReply) {
+            $array = $message->getValueNative();
+            $first = array_shift($array);
+
+            // pub/sub messages are to be forwarded and should not be processed as request responses
+            if (in_array($first, array('message', 'pmessage'))) {
+                $this->emit($first, $array);
+                return;
+            }
+        }
+
+        if (!$this->requests) {
+            throw new UnderflowException('Unexpected reply received, no matching request found');
+        }
+
+        $request = array_shift($this->requests);
+        /* @var $request Deferred */
+
+        if ($message instanceof ErrorReply) {
+            $request->reject($message);
+        } else {
+            $request->resolve($message->getValueNative());
+        }
+
+        if ($this->ending && !$this->requests) {
+            $this->close();
+        }
+    }
+
+    public function end()
+    {
+        $this->ending = true;
+
+        if (!$this->requests) {
+            $this->close();
+        }
+    }
+
+    public function close()
+    {
+        if ($this->closed) {
+            return;
+        }
+
+        $this->ending = true;
+        $this->closed = true;
+
+        $this->stream->close();
+
+        $this->emit('close');
+
+        // reject all remaining requests in the queue
+        while($this->requests) {
+            $request = array_shift($this->requests);
+            /* @var $request Request */
+            $request->reject(new RuntimeException('Connection closing'));
+        }
+    }
+}

vendor/clue/socks-react/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011 Christian Lück
+
+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/clue/socks-react/src/Client.php

@@ -0,0 +1,368 @@
+<?php
+
+namespace Clue\React\Socks;
+
+use React\Promise;
+use React\Promise\PromiseInterface;
+use React\Promise\Deferred;
+use React\Socket\ConnectionInterface;
+use React\Socket\ConnectorInterface;
+use \Exception;
+use \InvalidArgumentException;
+use RuntimeException;
+
+class Client implements ConnectorInterface
+{
+    /**
+     *
+     * @var ConnectorInterface
+     */
+    private $connector;
+
+    private $socksUri;
+
+    private $protocolVersion = null;
+
+    private $auth = null;
+
+    public function __construct($socksUri, ConnectorInterface $connector)
+    {
+        // assume default scheme if none is given
+        if (strpos($socksUri, '://') === false) {
+            $socksUri = 'socks://' . $socksUri;
+        }
+
+        // parse URI into individual parts
+        $parts = parse_url($socksUri);
+        if (!$parts || !isset($parts['scheme'], $parts['host'])) {
+            throw new \InvalidArgumentException('Invalid SOCKS server URI "' . $socksUri . '"');
+        }
+
+        // assume default port
+        if (!isset($parts['port'])) {
+            $parts['port'] = 1080;
+        }
+
+        // user or password in URI => SOCKS5 authentication
+        if (isset($parts['user']) || isset($parts['pass'])) {
+            if ($parts['scheme'] === 'socks') {
+                // default to using SOCKS5 if not given explicitly
+                $parts['scheme'] = 'socks5';
+            } elseif ($parts['scheme'] !== 'socks5') {
+                // fail if any other protocol version given explicitly
+                throw new InvalidArgumentException('Authentication requires SOCKS5. Consider using protocol version 5 or waive authentication');
+            }
+            $parts += array('user' => '', 'pass' => '');
+            $this->setAuth(rawurldecode($parts['user']), rawurldecode($parts['pass']));
+        }
+
+        // check for valid protocol version from URI scheme
+        $this->setProtocolVersionFromScheme($parts['scheme']);
+
+        $this->socksUri = $parts['host'] . ':' . $parts['port'];
+        $this->connector = $connector;
+    }
+
+    private function setProtocolVersionFromScheme($scheme)
+    {
+        if ($scheme === 'socks' || $scheme === 'socks4a') {
+            $this->protocolVersion = '4a';
+        } elseif ($scheme === 'socks5') {
+            $this->protocolVersion = '5';
+        } elseif ($scheme === 'socks4') {
+            $this->protocolVersion = '4';
+        } else {
+            throw new InvalidArgumentException('Invalid protocol version given');
+        }
+    }
+
+    /**
+     * set login data for username/password authentication method (RFC1929)
+     *
+     * @param string $username
+     * @param string $password
+     * @link http://tools.ietf.org/html/rfc1929
+     */
+    private function setAuth($username, $password)
+    {
+        if (strlen($username) > 255 || strlen($password) > 255) {
+            throw new InvalidArgumentException('Both username and password MUST NOT exceed a length of 255 bytes each');
+        }
+        $this->auth = pack('C2', 0x01, strlen($username)) . $username . pack('C', strlen($password)) . $password;
+    }
+
+    /**
+     * Establish a TCP/IP connection to the given target URI through the SOCKS server
+     *
+     * Many higher-level networking protocols build on top of TCP. It you're dealing
+     * with one such client implementation,  it probably uses/accepts an instance
+     * implementing React's `ConnectorInterface` (and usually its default `Connector`
+     * instance). In this case you can also pass this `Connector` instance instead
+     * to make this client implementation SOCKS-aware. That's it.
+     *
+     * @param string $uri
+     * @return PromiseInterface Promise<ConnectionInterface,Exception>
+     */
+    public function connect($uri)
+    {
+        if (strpos($uri, '://') === false) {
+            $uri = 'tcp://' . $uri;
+        }
+
+        $parts = parse_url($uri);
+        if (!$parts || !isset($parts['scheme'], $parts['host'], $parts['port']) || $parts['scheme'] !== 'tcp') {
+            return Promise\reject(new InvalidArgumentException('Invalid target URI specified'));
+        }
+
+        $host = trim($parts['host'], '[]');
+        $port = $parts['port'];
+
+        if ($this->protocolVersion === '4' && false === filter_var($host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
+            return Promise\reject(new InvalidArgumentException('Requires an IPv4 address for SOCKS4'));
+        }
+
+        if (strlen($host) > 255 || $port > 65535 || $port < 0 || (string)$port !== (string)(int)$port) {
+            return Promise\reject(new InvalidArgumentException('Invalid target specified'));
+        }
+
+        // construct URI to SOCKS server to connect to
+        $socksUri = $this->socksUri;
+
+        // append path from URI if given
+        if (isset($parts['path'])) {
+            $socksUri .= $parts['path'];
+        }
+
+        // parse query args
+        $args = array();
+        if (isset($parts['query'])) {
+            parse_str($parts['query'], $args);
+        }
+
+        // append hostname from URI to query string unless explicitly given
+        if (!isset($args['hostname'])) {
+            $args['hostname'] = $host;
+        }
+
+        // append query string
+        $socksUri .= '?' . http_build_query($args, '', '&');
+
+        // append fragment from URI if given
+        if (isset($parts['fragment'])) {
+            $socksUri .= '#' . $parts['fragment'];
+        }
+
+        $that = $this;
+
+        // start TCP/IP connection to SOCKS server and then
+        // handle SOCKS protocol once connection is ready
+        // resolve plain connection once SOCKS protocol is completed
+        return $this->connector->connect($socksUri)->then(
+            function (ConnectionInterface $stream) use ($that, $host, $port) {
+                return $that->handleConnectedSocks($stream, $host, $port);
+            },
+            function (Exception $e) {
+                throw new RuntimeException('Unable to connect to proxy (ECONNREFUSED)', defined('SOCKET_ECONNREFUSED') ? SOCKET_ECONNREFUSED : 111, $e);
+            }
+        );
+    }
+
+    /**
+     * Internal helper used to handle the communication with the SOCKS server
+     *
+     * @param ConnectionInterface $stream
+     * @param string              $host
+     * @param int                 $port
+     * @return Promise Promise<ConnectionInterface, Exception>
+     * @internal
+     */
+    public function handleConnectedSocks(ConnectionInterface $stream, $host, $port)
+    {
+        $deferred = new Deferred(function ($_, $reject) {
+            $reject(new RuntimeException('Connection canceled while establishing SOCKS session (ECONNABORTED)', defined('SOCKET_ECONNABORTED') ? SOCKET_ECONNABORTED : 103));
+        });
+
+        $reader = new StreamReader();
+        $stream->on('data', array($reader, 'write'));
+
+        $stream->on('error', $onError = function (Exception $e) use ($deferred) {
+            $deferred->reject(new RuntimeException('Stream error while waiting for response from proxy (EIO)', defined('SOCKET_EIO') ? SOCKET_EIO : 5, $e));
+        });
+
+        $stream->on('close', $onClose = function () use ($deferred) {
+            $deferred->reject(new RuntimeException('Connection to proxy lost while waiting for response (ECONNRESET)', defined('SOCKET_ECONNRESET') ? SOCKET_ECONNRESET : 104));
+        });
+
+        if ($this->protocolVersion === '5') {
+            $promise = $this->handleSocks5($stream, $host, $port, $reader);
+        } else {
+            $promise = $this->handleSocks4($stream, $host, $port, $reader);
+        }
+        $promise->then(function () use ($deferred, $stream) {
+            $deferred->resolve($stream);
+        }, function (Exception $error) use ($deferred) {
+            // pass custom RuntimeException through as-is, otherwise wrap in protocol error
+            if (!$error instanceof RuntimeException) {
+                $error = new RuntimeException('Invalid response received from proxy (EBADMSG)', defined('SOCKET_EBADMSG') ? SOCKET_EBADMSG: 71, $error);
+            }
+
+            $deferred->reject($error);
+        });
+
+        return $deferred->promise()->then(
+            function (ConnectionInterface $stream) use ($reader, $onError, $onClose) {
+                $stream->removeListener('data', array($reader, 'write'));
+                $stream->removeListener('error', $onError);
+                $stream->removeListener('close', $onClose);
+
+                return $stream;
+            },
+            function ($error) use ($stream, $onClose) {
+                $stream->removeListener('close', $onClose);
+                $stream->close();
+
+                throw $error;
+            }
+        );
+    }
+
+    private function handleSocks4(ConnectionInterface $stream, $host, $port, StreamReader $reader)
+    {
+        // do not resolve hostname. only try to convert to IP
+        $ip = ip2long($host);
+
+        // send IP or (0.0.0.1) if invalid
+        $data = pack('C2nNC', 0x04, 0x01, $port, $ip === false ? 1 : $ip, 0x00);
+
+        if ($ip === false) {
+            // host is not a valid IP => send along hostname (SOCKS4a)
+            $data .= $host . pack('C', 0x00);
+        }
+
+        $stream->write($data);
+
+        return $reader->readBinary(array(
+            'null'   => 'C',
+            'status' => 'C',
+            'port'   => 'n',
+            'ip'     => 'N'
+        ))->then(function ($data) {
+            if ($data['null'] !== 0x00) {
+                throw new Exception('Invalid SOCKS response');
+            }
+            if ($data['status'] !== 0x5a) {
+                throw new RuntimeException('Proxy refused connection with SOCKS error code ' . sprintf('0x%02X', $data['status']) . ' (ECONNREFUSED)', defined('SOCKET_ECONNREFUSED') ? SOCKET_ECONNREFUSED : 111);
+            }
+        });
+    }
+
+    private function handleSocks5(ConnectionInterface $stream, $host, $port, StreamReader $reader)
+    {
+        // protocol version 5
+        $data = pack('C', 0x05);
+
+        $auth = $this->auth;
+        if ($auth === null) {
+            // one method, no authentication
+            $data .= pack('C2', 0x01, 0x00);
+        } else {
+            // two methods, username/password and no authentication
+            $data .= pack('C3', 0x02, 0x02, 0x00);
+        }
+        $stream->write($data);
+
+        $that = $this;
+
+        return $reader->readBinary(array(
+            'version' => 'C',
+            'method'  => 'C'
+        ))->then(function ($data) use ($auth, $stream, $reader) {
+            if ($data['version'] !== 0x05) {
+                throw new Exception('Version/Protocol mismatch');
+            }
+
+            if ($data['method'] === 0x02 && $auth !== null) {
+                // username/password authentication requested and provided
+                $stream->write($auth);
+
+                return $reader->readBinary(array(
+                    'version' => 'C',
+                    'status'  => 'C'
+                ))->then(function ($data) {
+                    if ($data['version'] !== 0x01 || $data['status'] !== 0x00) {
+                        throw new RuntimeException('Username/Password authentication failed (EACCES)', defined('SOCKET_EACCES') ? SOCKET_EACCES : 13);
+                    }
+                });
+            } else if ($data['method'] !== 0x00) {
+                // any other method than "no authentication"
+                throw new RuntimeException('No acceptable authentication method found (EACCES)', defined('SOCKET_EACCES') ? SOCKET_EACCES : 13);
+            }
+        })->then(function () use ($stream, $reader, $host, $port) {
+            // do not resolve hostname. only try to convert to (binary/packed) IP
+            $ip = @inet_pton($host);
+
+            $data = pack('C3', 0x05, 0x01, 0x00);
+            if ($ip === false) {
+                // not an IP, send as hostname
+                $data .= pack('C2', 0x03, strlen($host)) . $host;
+            } else {
+                // send as IPv4 / IPv6
+                $data .= pack('C', (strpos($host, ':') === false) ? 0x01 : 0x04) . $ip;
+            }
+            $data .= pack('n', $port);
+
+            $stream->write($data);
+
+            return $reader->readBinary(array(
+                'version' => 'C',
+                'status'  => 'C',
+                'null'    => 'C',
+                'type'    => 'C'
+            ));
+        })->then(function ($data) use ($reader) {
+            if ($data['version'] !== 0x05 || $data['null'] !== 0x00) {
+                throw new Exception('Invalid SOCKS response');
+            }
+            if ($data['status'] !== 0x00) {
+                // map limited list of SOCKS error codes to common socket error conditions
+                // @link https://tools.ietf.org/html/rfc1928#section-6
+                if ($data['status'] === Server::ERROR_GENERAL) {
+                    throw new RuntimeException('SOCKS server reported a general server failure (ECONNREFUSED)', defined('SOCKET_ECONNREFUSED') ? SOCKET_ECONNREFUSED : 111);
+                } elseif ($data['status'] === Server::ERROR_NOT_ALLOWED_BY_RULESET) {
+                    throw new RuntimeException('SOCKS server reported connection is not allowed by ruleset (EACCES)', defined('SOCKET_EACCES') ? SOCKET_EACCES : 13);
+                } elseif ($data['status'] === Server::ERROR_NETWORK_UNREACHABLE) {
+                    throw new RuntimeException('SOCKS server reported network unreachable (ENETUNREACH)', defined('SOCKET_ENETUNREACH') ? SOCKET_ENETUNREACH : 101);
+                } elseif ($data['status'] === Server::ERROR_HOST_UNREACHABLE) {
+                    throw new RuntimeException('SOCKS server reported host unreachable (EHOSTUNREACH)', defined('SOCKET_EHOSTUNREACH') ? SOCKET_EHOSTUNREACH : 113);
+                } elseif ($data['status'] === Server::ERROR_CONNECTION_REFUSED) {
+                    throw new RuntimeException('SOCKS server reported connection refused (ECONNREFUSED)', defined('SOCKET_ECONNREFUSED') ? SOCKET_ECONNREFUSED : 111);
+                } elseif ($data['status'] === Server::ERROR_TTL) {
+                    throw new RuntimeException('SOCKS server reported TTL/timeout expired (ETIMEDOUT)', defined('SOCKET_ETIMEDOUT') ? SOCKET_ETIMEDOUT : 110);
+                } elseif ($data['status'] === Server::ERROR_COMMAND_UNSUPPORTED) {
+                    throw new RuntimeException('SOCKS server does not support the CONNECT command (EPROTO)', defined('SOCKET_EPROTO') ? SOCKET_EPROTO : 71);
+                } elseif ($data['status'] === Server::ERROR_ADDRESS_UNSUPPORTED) {
+                    throw new RuntimeException('SOCKS server does not support this address type (EPROTO)', defined('SOCKET_EPROTO') ? SOCKET_EPROTO : 71);
+                }
+
+                throw new RuntimeException('SOCKS server reported an unassigned error code ' . sprintf('0x%02X', $data['status']) . ' (ECONNREFUSED)', defined('SOCKET_ECONNREFUSED') ? SOCKET_ECONNREFUSED : 111);
+            }
+            if ($data['type'] === 0x01) {
+                // IPv4 address => skip IP and port
+                return $reader->readLength(6);
+            } elseif ($data['type'] === 0x03) {
+                // domain name => read domain name length
+                return $reader->readBinary(array(
+                    'length' => 'C'
+                ))->then(function ($data) use ($reader) {
+                    // skip domain name and port
+                    return $reader->readLength($data['length'] + 2);
+                });
+            } elseif ($data['type'] === 0x04) {
+                // IPv6 address => skip IP and port
+                return $reader->readLength(18);
+            } else {
+                throw new Exception('Invalid SOCKS reponse: Invalid address type');
+            }
+        });
+    }
+}

vendor/clue/socks-react/src/Server.php

@@ -0,0 +1,420 @@
+<?php
+
+namespace Clue\React\Socks;
+
+use Evenement\EventEmitter;
+use React\Socket\ServerInterface;
+use React\Promise;
+use React\Promise\Deferred;
+use React\Promise\PromiseInterface;
+use React\Socket\ConnectorInterface;
+use React\Socket\Connector;
+use React\Socket\ConnectionInterface;
+use React\EventLoop\LoopInterface;
+use \UnexpectedValueException;
+use \InvalidArgumentException;
+use \Exception;
+use React\Promise\Timer\TimeoutException;
+
+class Server extends EventEmitter
+{
+    // the following error codes are only used for SOCKS5 only
+    /** @internal */
+    const ERROR_GENERAL = 0x01;
+    /** @internal */
+    const ERROR_NOT_ALLOWED_BY_RULESET = 0x02;
+    /** @internal */
+    const ERROR_NETWORK_UNREACHABLE = 0x03;
+    /** @internal */
+    const ERROR_HOST_UNREACHABLE = 0x04;
+    /** @internal */
+    const ERROR_CONNECTION_REFUSED = 0x05;
+    /** @internal */
+    const ERROR_TTL = 0x06;
+    /** @internal */
+    const ERROR_COMMAND_UNSUPPORTED = 0x07;
+    /** @internal */
+    const ERROR_ADDRESS_UNSUPPORTED = 0x08;
+
+    protected $loop;
+
+    private $connector;
+
+    private $auth = null;
+
+    private $protocolVersion = null;
+
+    public function __construct(LoopInterface $loop, ServerInterface $serverInterface, ConnectorInterface $connector = null)
+    {
+        if ($connector === null) {
+            $connector = new Connector($loop);
+        }
+
+        $this->loop = $loop;
+        $this->connector = $connector;
+
+        $that = $this;
+        $serverInterface->on('connection', function ($connection) use ($that) {
+            $that->emit('connection', array($connection));
+            $that->onConnection($connection);
+        });
+    }
+
+    public function setProtocolVersion($version)
+    {
+        if ($version !== null) {
+            $version = (string)$version;
+            if (!in_array($version, array('4', '4a', '5'), true)) {
+                throw new InvalidArgumentException('Invalid protocol version given');
+            }
+            if ($version !== '5' && $this->auth !== null){
+                throw new UnexpectedValueException('Unable to change protocol version to anything but SOCKS5 while authentication is used. Consider removing authentication info or sticking to SOCKS5');
+            }
+        }
+        $this->protocolVersion = $version;
+    }
+
+    public function setAuth($auth)
+    {
+        if (!is_callable($auth)) {
+            throw new InvalidArgumentException('Given authenticator is not a valid callable');
+        }
+        if ($this->protocolVersion !== null && $this->protocolVersion !== '5') {
+            throw new UnexpectedValueException('Authentication requires SOCKS5. Consider using protocol version 5 or waive authentication');
+        }
+        // wrap authentication callback in order to cast its return value to a promise
+        $this->auth = function($username, $password, $remote) use ($auth) {
+            $ret = call_user_func($auth, $username, $password, $remote);
+            if ($ret instanceof PromiseInterface) {
+                return $ret;
+            }
+            $deferred = new Deferred();
+            $ret ? $deferred->resolve() : $deferred->reject();
+            return $deferred->promise();
+        };
+    }
+
+    public function setAuthArray(array $login)
+    {
+        $this->setAuth(function ($username, $password) use ($login) {
+            return (isset($login[$username]) && (string)$login[$username] === $password);
+        });
+    }
+
+    public function unsetAuth()
+    {
+        $this->auth = null;
+    }
+
+    public function onConnection(ConnectionInterface $connection)
+    {
+        $that = $this;
+        $handling = $this->handleSocks($connection)->then(function($remote) use ($connection){
+            $connection->emit('ready',array($remote));
+        }, function ($error) use ($connection, $that) {
+            if (!($error instanceof \Exception)) {
+                $error = new \Exception($error);
+            }
+            $connection->emit('error', array($error));
+            $that->endConnection($connection);
+        });
+
+        $connection->on('close', function () use ($handling) {
+            $handling->cancel();
+        });
+    }
+
+    /**
+     * gracefully shutdown connection by flushing all remaining data and closing stream
+     */
+    public function endConnection(ConnectionInterface $stream)
+    {
+        $tid = true;
+        $loop = $this->loop;
+
+        // cancel below timer in case connection is closed in time
+        $stream->once('close', function () use (&$tid, $loop) {
+            // close event called before the timer was set up, so everything is okay
+            if ($tid === true) {
+                // make sure to not start a useless timer
+                $tid = false;
+            } else {
+                $loop->cancelTimer($tid);
+            }
+        });
+
+        // shut down connection by pausing input data, flushing outgoing buffer and then exit
+        $stream->pause();
+        $stream->end();
+
+        // check if connection is not already closed
+        if ($tid === true) {
+            // fall back to forcefully close connection in 3 seconds if buffer can not be flushed
+            $tid = $loop->addTimer(3.0, array($stream,'close'));
+        }
+    }
+
+    private function handleSocks(ConnectionInterface $stream)
+    {
+        $reader = new StreamReader();
+        $stream->on('data', array($reader, 'write'));
+
+        $that = $this;
+        $that = $this;
+
+        $auth = $this->auth;
+        $protocolVersion = $this->protocolVersion;
+
+        // authentication requires SOCKS5
+        if ($auth !== null) {
+        	$protocolVersion = '5';
+        }
+
+        return $reader->readByte()->then(function ($version) use ($stream, $that, $protocolVersion, $auth, $reader){
+            if ($version === 0x04) {
+                if ($protocolVersion === '5') {
+                    throw new UnexpectedValueException('SOCKS4 not allowed due to configuration');
+                }
+                return $that->handleSocks4($stream, $protocolVersion, $reader);
+            } else if ($version === 0x05) {
+                if ($protocolVersion !== null && $protocolVersion !== '5') {
+                    throw new UnexpectedValueException('SOCKS5 not allowed due to configuration');
+                }
+                return $that->handleSocks5($stream, $auth, $reader);
+            }
+            throw new UnexpectedValueException('Unexpected/unknown version number');
+        });
+    }
+
+    public function handleSocks4(ConnectionInterface $stream, $protocolVersion, StreamReader $reader)
+    {
+        // suppliying hostnames is only allowed for SOCKS4a (or automatically detected version)
+        $supportsHostname = ($protocolVersion === null || $protocolVersion === '4a');
+
+        $remote = $stream->getRemoteAddress();
+        if ($remote !== null) {
+            // remove transport scheme and prefix socks4:// instead
+            if (($pos = strpos($remote, '://')) !== false) {
+                $remote = substr($remote, $pos + 3);
+            }
+            $remote = 'socks4://' . $remote;
+        }
+
+        $that = $this;
+        return $reader->readByteAssert(0x01)->then(function () use ($reader) {
+            return $reader->readBinary(array(
+                'port'   => 'n',
+                'ipLong' => 'N',
+                'null'   => 'C'
+            ));
+        })->then(function ($data) use ($reader, $supportsHostname, $remote) {
+            if ($data['null'] !== 0x00) {
+                throw new Exception('Not a null byte');
+            }
+            if ($data['ipLong'] === 0) {
+                throw new Exception('Invalid IP');
+            }
+            if ($data['port'] === 0) {
+                throw new Exception('Invalid port');
+            }
+            if ($data['ipLong'] < 256 && $supportsHostname) {
+                // invalid IP => probably a SOCKS4a request which appends the hostname
+                return $reader->readStringNull()->then(function ($string) use ($data, $remote){
+                    return array($string, $data['port'], $remote);
+                });
+            } else {
+                $ip = long2ip($data['ipLong']);
+                return array($ip, $data['port'], $remote);
+            }
+        })->then(function ($target) use ($stream, $that) {
+            return $that->connectTarget($stream, $target)->then(function (ConnectionInterface $remote) use ($stream){
+                $stream->write(pack('C8', 0x00, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
+
+                return $remote;
+            }, function($error) use ($stream){
+                $stream->end(pack('C8', 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00));
+
+                throw $error;
+            });
+        }, function($error) {
+            throw new UnexpectedValueException('SOCKS4 protocol error',0,$error);
+        });
+    }
+
+    public function handleSocks5(ConnectionInterface $stream, $auth=null, StreamReader $reader)
+    {
+        $remote = $stream->getRemoteAddress();
+        if ($remote !== null) {
+            // remove transport scheme and prefix socks5:// instead
+            if (($pos = strpos($remote, '://')) !== false) {
+                $remote = substr($remote, $pos + 3);
+            }
+            $remote = 'socks5://' . $remote;
+        }
+
+        $that = $this;
+        return $reader->readByte()->then(function ($num) use ($reader) {
+            // $num different authentication mechanisms offered
+            return $reader->readLength($num);
+        })->then(function ($methods) use ($reader, $stream, $auth, &$remote) {
+            if ($auth === null && strpos($methods,"\x00") !== false) {
+                // accept "no authentication"
+                $stream->write(pack('C2', 0x05, 0x00));
+
+                return 0x00;
+            } else if ($auth !== null && strpos($methods,"\x02") !== false) {
+                // username/password authentication (RFC 1929) sub negotiation
+                $stream->write(pack('C2', 0x05, 0x02));
+                return $reader->readByteAssert(0x01)->then(function () use ($reader) {
+                    return $reader->readByte();
+                })->then(function ($length) use ($reader) {
+                    return $reader->readLength($length);
+                })->then(function ($username) use ($reader, $auth, $stream, &$remote) {
+                    return $reader->readByte()->then(function ($length) use ($reader) {
+                        return $reader->readLength($length);
+                    })->then(function ($password) use ($username, $auth, $stream, &$remote) {
+                        // username and password given => authenticate
+
+                        // prefix username/password to remote URI
+                        if ($remote !== null) {
+                            $remote = str_replace('://', '://' . rawurlencode($username) . ':' . rawurlencode($password) . '@', $remote);
+                        }
+
+                        return $auth($username, $password, $remote)->then(function () use ($stream, $username) {
+                            // accept
+                            $stream->emit('auth', array($username));
+                            $stream->write(pack('C2', 0x01, 0x00));
+                        }, function() use ($stream) {
+                            // reject => send any code but 0x00
+                            $stream->end(pack('C2', 0x01, 0xFF));
+                            throw new UnexpectedValueException('Unable to authenticate');
+                        });
+                    });
+                });
+            } else {
+                // reject all offered authentication methods
+                $stream->write(pack('C2', 0x05, 0xFF));
+                throw new UnexpectedValueException('No acceptable authentication mechanism found');
+            }
+        })->then(function ($method) use ($reader, $stream) {
+            return $reader->readBinary(array(
+                'version' => 'C',
+                'command' => 'C',
+                'null'    => 'C',
+                'type'    => 'C'
+            ));
+        })->then(function ($data) use ($reader) {
+            if ($data['version'] !== 0x05) {
+                throw new UnexpectedValueException('Invalid SOCKS version');
+            }
+            if ($data['command'] !== 0x01) {
+                throw new UnexpectedValueException('Only CONNECT requests supported', Server::ERROR_COMMAND_UNSUPPORTED);
+            }
+//             if ($data['null'] !== 0x00) {
+//                 throw new UnexpectedValueException('Reserved byte has to be NULL');
+//             }
+            if ($data['type'] === 0x03) {
+                // target hostname string
+                return $reader->readByte()->then(function ($len) use ($reader) {
+                    return $reader->readLength($len);
+                });
+            } else if ($data['type'] === 0x01) {
+                // target IPv4
+                return $reader->readLength(4)->then(function ($addr) {
+                    return inet_ntop($addr);
+                });
+            } else if ($data['type'] === 0x04) {
+                // target IPv6
+                return $reader->readLength(16)->then(function ($addr) {
+                    return inet_ntop($addr);
+                });
+            } else {
+                throw new UnexpectedValueException('Invalid address type', Server::ERROR_ADDRESS_UNSUPPORTED);
+            }
+        })->then(function ($host) use ($reader, &$remote) {
+            return $reader->readBinary(array('port'=>'n'))->then(function ($data) use ($host, &$remote) {
+                return array($host, $data['port'], $remote);
+            });
+        })->then(function ($target) use ($that, $stream) {
+            return $that->connectTarget($stream, $target);
+        }, function($error) use ($stream) {
+            throw new UnexpectedValueException('SOCKS5 protocol error', $error->getCode(), $error);
+        })->then(function (ConnectionInterface $remote) use ($stream) {
+            $stream->write(pack('C4Nn', 0x05, 0x00, 0x00, 0x01, 0, 0));
+
+            return $remote;
+        }, function(Exception $error) use ($stream){
+            $stream->write(pack('C4Nn', 0x05, $error->getCode() === 0 ? Server::ERROR_GENERAL : $error->getCode(), 0x00, 0x01, 0, 0));
+
+            throw $error;
+        });
+    }
+
+    public function connectTarget(ConnectionInterface $stream, array $target)
+    {
+        $uri = $target[0];
+        if (strpos($uri, ':') !== false) {
+            $uri = '[' . $uri . ']';
+        }
+        $uri .= ':' . $target[1];
+
+        // validate URI so a string hostname can not pass excessive URI parts
+        $parts = parse_url('tcp://' . $uri);
+        if (!$parts || !isset($parts['scheme'], $parts['host'], $parts['port']) || count($parts) !== 3) {
+            return Promise\reject(new InvalidArgumentException('Invalid target URI given'));
+        }
+
+        if (isset($target[2])) {
+            $uri .= '?source=' . rawurlencode($target[2]);
+        }
+
+        $stream->emit('target', $target);
+        $that = $this;
+        $connecting = $this->connector->connect($uri);
+
+        $stream->on('close', function () use ($connecting) {
+            $connecting->cancel();
+        });
+
+        return $connecting->then(function (ConnectionInterface $remote) use ($stream, $that) {
+            $stream->pipe($remote, array('end'=>false));
+            $remote->pipe($stream, array('end'=>false));
+
+            // remote end closes connection => stop reading from local end, try to flush buffer to local and disconnect local
+            $remote->on('end', function() use ($stream, $that) {
+                $stream->emit('shutdown', array('remote', null));
+                $that->endConnection($stream);
+            });
+
+            // local end closes connection => stop reading from remote end, try to flush buffer to remote and disconnect remote
+            $stream->on('end', function() use ($remote, $that) {
+                $that->endConnection($remote);
+            });
+
+            // set bigger buffer size of 100k to improve performance
+            $stream->bufferSize = $remote->bufferSize = 100 * 1024 * 1024;
+
+            return $remote;
+        }, function(Exception $error) {
+            // default to general/unknown error
+            $code = Server::ERROR_GENERAL;
+
+            // map common socket error conditions to limited list of SOCKS error codes
+            if ((defined('SOCKET_EACCES') && $error->getCode() === SOCKET_EACCES) || $error->getCode() === 13) {
+                $code = Server::ERROR_NOT_ALLOWED_BY_RULESET;
+            } elseif ((defined('SOCKET_EHOSTUNREACH') && $error->getCode() === SOCKET_EHOSTUNREACH) || $error->getCode() === 113) {
+                $code = Server::ERROR_HOST_UNREACHABLE;
+            } elseif ((defined('SOCKET_ENETUNREACH') && $error->getCode() === SOCKET_ENETUNREACH) || $error->getCode() === 101) {
+                $code = Server::ERROR_NETWORK_UNREACHABLE;
+            } elseif ((defined('SOCKET_ECONNREFUSED') && $error->getCode() === SOCKET_ECONNREFUSED) || $error->getCode() === 111 || $error->getMessage() === 'Connection refused') {
+                // Socket component does not currently assign an error code for this, so we have to resort to checking the exception message
+                $code = Server::ERROR_CONNECTION_REFUSED;
+            } elseif ((defined('SOCKET_ETIMEDOUT') && $error->getCode() === SOCKET_ETIMEDOUT) || $error->getCode() === 110 || $error instanceof TimeoutException) {
+                // Socket component does not currently assign an error code for this, but we can rely on the TimeoutException
+                $code = Server::ERROR_TTL;
+            }
+
+            throw new UnexpectedValueException('Unable to connect to remote target', $code, $error);
+        });
+    }
+}

vendor/clue/socks-react/src/StreamReader.php

@@ -0,0 +1,149 @@
+<?php
+
+namespace Clue\React\Socks;
+
+use React\Promise\Deferred;
+use \InvalidArgumentException;
+use \UnexpectedValueException;
+
+/**
+ * @internal
+ */
+class StreamReader
+{
+    const RET_DONE = true;
+    const RET_INCOMPLETE = null;
+
+    private $buffer = '';
+    private $queue = array();
+
+    public function write($data)
+    {
+        $this->buffer .= $data;
+
+        do {
+            $current = reset($this->queue);
+
+            if ($current === false) {
+                break;
+            }
+
+            /* @var $current Closure */
+
+            $ret = $current($this->buffer);
+
+            if ($ret === self::RET_INCOMPLETE) {
+                // current is incomplete, so wait for further data to arrive
+                break;
+            } else {
+                // current is done, remove from list and continue with next
+                array_shift($this->queue);
+            }
+        } while (true);
+    }
+
+    public function readBinary($structure)
+    {
+        $length = 0;
+        $unpack = '';
+        foreach ($structure as $name=>$format) {
+            if ($length !== 0) {
+                $unpack .= '/';
+            }
+            $unpack .= $format . $name;
+
+            if ($format === 'C') {
+                ++$length;
+            } else if ($format === 'n') {
+                $length += 2;
+            } else if ($format === 'N') {
+                $length += 4;
+            } else {
+                throw new InvalidArgumentException('Invalid format given');
+            }
+        }
+
+        return $this->readLength($length)->then(function ($response) use ($unpack) {
+            return unpack($unpack, $response);
+        });
+    }
+
+    public function readLength($bytes)
+    {
+        $deferred = new Deferred();
+
+        $this->readBufferCallback(function (&$buffer) use ($bytes, $deferred) {
+            if (strlen($buffer) >= $bytes) {
+                $deferred->resolve((string)substr($buffer, 0, $bytes));
+                $buffer = (string)substr($buffer, $bytes);
+
+                return StreamReader::RET_DONE;
+            }
+        });
+
+        return $deferred->promise();
+    }
+
+    public function readByte()
+    {
+        return $this->readBinary(array(
+            'byte' => 'C'
+        ))->then(function ($data) {
+            return $data['byte'];
+        });
+    }
+
+    public function readByteAssert($expect)
+    {
+        return $this->readByte()->then(function ($byte) use ($expect) {
+            if ($byte !== $expect) {
+                throw new UnexpectedValueException('Unexpected byte encountered');
+            }
+            return $byte;
+        });
+    }
+
+    public function readStringNull()
+    {
+        $deferred = new Deferred();
+        $string = '';
+
+        $that = $this;
+        $readOne = function () use (&$readOne, $that, $deferred, &$string) {
+            $that->readByte()->then(function ($byte) use ($deferred, &$string, $readOne) {
+                if ($byte === 0x00) {
+                    $deferred->resolve($string);
+                } else {
+                    $string .= chr($byte);
+                    $readOne();
+                }
+            });
+        };
+        $readOne();
+
+        return $deferred->promise();
+    }
+
+    public function readBufferCallback(/* callable */ $callable)
+    {
+        if (!is_callable($callable)) {
+            throw new InvalidArgumentException('Given function must be callable');
+        }
+
+        if ($this->queue) {
+            $this->queue []= $callable;
+        } else {
+            $this->queue = array($callable);
+
+            if ($this->buffer !== '') {
+                // this is the first element in the queue and the buffer is filled => trigger write procedure
+                $this->write('');
+            }
+        }
+    }
+
+    public function getBuffer()
+    {
+        return $this->buffer;
+    }
+}

vendor/composer/ClassLoader.php

@@ -0,0 +1,445 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Autoload;
+
+/**
+ * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
+ *
+ *     $loader = new \Composer\Autoload\ClassLoader();
+ *
+ *     // register classes with namespaces
+ *     $loader->add('Symfony\Component', __DIR__.'/component');
+ *     $loader->add('Symfony',           __DIR__.'/framework');
+ *
+ *     // activate the autoloader
+ *     $loader->register();
+ *
+ *     // to enable searching the include path (eg. for PEAR packages)
+ *     $loader->setUseIncludePath(true);
+ *
+ * In this example, if you try to use a class in the Symfony\Component
+ * namespace or one of its children (Symfony\Component\Console for instance),
+ * the autoloader will first look for the class under the component/
+ * directory, and it will then fallback to the framework/ directory if not
+ * found before giving up.
+ *
+ * This class is loosely based on the Symfony UniversalClassLoader.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @see    http://www.php-fig.org/psr/psr-0/
+ * @see    http://www.php-fig.org/psr/psr-4/
+ */
+class ClassLoader
+{
+    // PSR-4
+    private $prefixLengthsPsr4 = array();
+    private $prefixDirsPsr4 = array();
+    private $fallbackDirsPsr4 = array();
+
+    // PSR-0
+    private $prefixesPsr0 = array();
+    private $fallbackDirsPsr0 = array();
+
+    private $useIncludePath = false;
+    private $classMap = array();
+    private $classMapAuthoritative = false;
+    private $missingClasses = array();
+    private $apcuPrefix;
+
+    public function getPrefixes()
+    {
+        if (!empty($this->prefixesPsr0)) {
+            return call_user_func_array('array_merge', $this->prefixesPsr0);
+        }
+
+        return array();
+    }
+
+    public function getPrefixesPsr4()
+    {
+        return $this->prefixDirsPsr4;
+    }
+
+    public function getFallbackDirs()
+    {
+        return $this->fallbackDirsPsr0;
+    }
+
+    public function getFallbackDirsPsr4()
+    {
+        return $this->fallbackDirsPsr4;
+    }
+
+    public function getClassMap()
+    {
+        return $this->classMap;
+    }
+
+    /**
+     * @param array $classMap Class to filename map
+     */
+    public function addClassMap(array $classMap)
+    {
+        if ($this->classMap) {
+            $this->classMap = array_merge($this->classMap, $classMap);
+        } else {
+            $this->classMap = $classMap;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix, either
+     * appending or prepending to the ones previously set for this prefix.
+     *
+     * @param string       $prefix  The prefix
+     * @param array|string $paths   The PSR-0 root directories
+     * @param bool         $prepend Whether to prepend the directories
+     */
+    public function add($prefix, $paths, $prepend = false)
+    {
+        if (!$prefix) {
+            if ($prepend) {
+                $this->fallbackDirsPsr0 = array_merge(
+                    (array) $paths,
+                    $this->fallbackDirsPsr0
+                );
+            } else {
+                $this->fallbackDirsPsr0 = array_merge(
+                    $this->fallbackDirsPsr0,
+                    (array) $paths
+                );
+            }
+
+            return;
+        }
+
+        $first = $prefix[0];
+        if (!isset($this->prefixesPsr0[$first][$prefix])) {
+            $this->prefixesPsr0[$first][$prefix] = (array) $paths;
+
+            return;
+        }
+        if ($prepend) {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                (array) $paths,
+                $this->prefixesPsr0[$first][$prefix]
+            );
+        } else {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                $this->prefixesPsr0[$first][$prefix],
+                (array) $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace, either
+     * appending or prepending to the ones previously set for this namespace.
+     *
+     * @param string       $prefix  The prefix/namespace, with trailing '\\'
+     * @param array|string $paths   The PSR-4 base directories
+     * @param bool         $prepend Whether to prepend the directories
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function addPsr4($prefix, $paths, $prepend = false)
+    {
+        if (!$prefix) {
+            // Register directories for the root namespace.
+            if ($prepend) {
+                $this->fallbackDirsPsr4 = array_merge(
+                    (array) $paths,
+                    $this->fallbackDirsPsr4
+                );
+            } else {
+                $this->fallbackDirsPsr4 = array_merge(
+                    $this->fallbackDirsPsr4,
+                    (array) $paths
+                );
+            }
+        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
+            // Register directories for a new namespace.
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        } elseif ($prepend) {
+            // Prepend directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                (array) $paths,
+                $this->prefixDirsPsr4[$prefix]
+            );
+        } else {
+            // Append directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                $this->prefixDirsPsr4[$prefix],
+                (array) $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix,
+     * replacing any others previously set for this prefix.
+     *
+     * @param string       $prefix The prefix
+     * @param array|string $paths  The PSR-0 base directories
+     */
+    public function set($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr0 = (array) $paths;
+        } else {
+            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace,
+     * replacing any others previously set for this namespace.
+     *
+     * @param string       $prefix The prefix/namespace, with trailing '\\'
+     * @param array|string $paths  The PSR-4 base directories
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function setPsr4($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr4 = (array) $paths;
+        } else {
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Turns on searching the include path for class files.
+     *
+     * @param bool $useIncludePath
+     */
+    public function setUseIncludePath($useIncludePath)
+    {
+        $this->useIncludePath = $useIncludePath;
+    }
+
+    /**
+     * Can be used to check if the autoloader uses the include path to check
+     * for classes.
+     *
+     * @return bool
+     */
+    public function getUseIncludePath()
+    {
+        return $this->useIncludePath;
+    }
+
+    /**
+     * Turns off searching the prefix and fallback directories for classes
+     * that have not been registered with the class map.
+     *
+     * @param bool $classMapAuthoritative
+     */
+    public function setClassMapAuthoritative($classMapAuthoritative)
+    {
+        $this->classMapAuthoritative = $classMapAuthoritative;
+    }
+
+    /**
+     * Should class lookup fail if not found in the current class map?
+     *
+     * @return bool
+     */
+    public function isClassMapAuthoritative()
+    {
+        return $this->classMapAuthoritative;
+    }
+
+    /**
+     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
+     *
+     * @param string|null $apcuPrefix
+     */
+    public function setApcuPrefix($apcuPrefix)
+    {
+        $this->apcuPrefix = function_exists('apcu_fetch') && ini_get('apc.enabled') ? $apcuPrefix : null;
+    }
+
+    /**
+     * The APCu prefix in use, or null if APCu caching is not enabled.
+     *
+     * @return string|null
+     */
+    public function getApcuPrefix()
+    {
+        return $this->apcuPrefix;
+    }
+
+    /**
+     * Registers this instance as an autoloader.
+     *
+     * @param bool $prepend Whether to prepend the autoloader or not
+     */
+    public function register($prepend = false)
+    {
+        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
+    }
+
+    /**
+     * Unregisters this instance as an autoloader.
+     */
+    public function unregister()
+    {
+        spl_autoload_unregister(array($this, 'loadClass'));
+    }
+
+    /**
+     * Loads the given class or interface.
+     *
+     * @param  string    $class The name of the class
+     * @return bool|null True if loaded, null otherwise
+     */
+    public function loadClass($class)
+    {
+        if ($file = $this->findFile($class)) {
+            includeFile($file);
+
+            return true;
+        }
+    }
+
+    /**
+     * Finds the path to the file where the class is defined.
+     *
+     * @param string $class The name of the class
+     *
+     * @return string|false The path if found, false otherwise
+     */
+    public function findFile($class)
+    {
+        // class map lookup
+        if (isset($this->classMap[$class])) {
+            return $this->classMap[$class];
+        }
+        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
+            return false;
+        }
+        if (null !== $this->apcuPrefix) {
+            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
+            if ($hit) {
+                return $file;
+            }
+        }
+
+        $file = $this->findFileWithExtension($class, '.php');
+
+        // Search for Hack files if we are running on HHVM
+        if (false === $file && defined('HHVM_VERSION')) {
+            $file = $this->findFileWithExtension($class, '.hh');
+        }
+
+        if (null !== $this->apcuPrefix) {
+            apcu_add($this->apcuPrefix.$class, $file);
+        }
+
+        if (false === $file) {
+            // Remember that this class does not exist.
+            $this->missingClasses[$class] = true;
+        }
+
+        return $file;
+    }
+
+    private function findFileWithExtension($class, $ext)
+    {
+        // PSR-4 lookup
+        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
+
+        $first = $class[0];
+        if (isset($this->prefixLengthsPsr4[$first])) {
+            $subPath = $class;
+            while (false !== $lastPos = strrpos($subPath, '\\')) {
+                $subPath = substr($subPath, 0, $lastPos);
+                $search = $subPath.'\\';
+                if (isset($this->prefixDirsPsr4[$search])) {
+                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
+                        $length = $this->prefixLengthsPsr4[$first][$search];
+                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $length))) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-4 fallback dirs
+        foreach ($this->fallbackDirsPsr4 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 lookup
+        if (false !== $pos = strrpos($class, '\\')) {
+            // namespaced class name
+            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
+                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
+        } else {
+            // PEAR-like class name
+            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
+        }
+
+        if (isset($this->prefixesPsr0[$first])) {
+            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
+                if (0 === strpos($class, $prefix)) {
+                    foreach ($dirs as $dir) {
+                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-0 fallback dirs
+        foreach ($this->fallbackDirsPsr0 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 include paths.
+        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
+            return $file;
+        }
+
+        return false;
+    }
+}
+
+/**
+ * Scope isolated include.
+ *
+ * Prevents access to $this/self from included files.
+ */
+function includeFile($file)
+{
+    include $file;
+}

vendor/composer/LICENSE

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

vendor/composer/autoload_classmap.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_classmap.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

vendor/composer/autoload_files.php

@@ -0,0 +1,13 @@
+<?php
+
+// autoload_files.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'ad155f8f1cf0d418fe49e248db8c661b' => $vendorDir . '/react/promise/src/functions_include.php',
+    '6b06ce8ccf69c43a60a1e48495a034c9' => $vendorDir . '/react/promise-timer/src/functions.php',
+    'ebf8799635f67b5d7248946fe2154f4a' => $vendorDir . '/ringcentral/psr7/src/functions_include.php',
+    'a0edc8309cc5e1d60e3047b5df6b7052' => $vendorDir . '/guzzlehttp/psr7/src/functions_include.php',
+);

vendor/composer/autoload_namespaces.php

@@ -0,0 +1,12 @@
+<?php
+
+// autoload_namespaces.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'MKraemer' => array($vendorDir . '/mkraemer/react-pcntl/src'),
+    'Evenement' => array($vendorDir . '/evenement/evenement/src'),
+    'Clue\\Redis\\Protocol' => array($vendorDir . '/clue/redis-protocol/src'),
+);

vendor/composer/autoload_psr4.php

@@ -0,0 +1,31 @@
+<?php
+
+// autoload_psr4.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'RingCentral\\Psr7\\' => array($vendorDir . '/ringcentral/psr7/src'),
+    'React\\Stream\\' => array($vendorDir . '/react/stream/src'),
+    'React\\Socket\\' => array($vendorDir . '/react/socket/src'),
+    'React\\Promise\\Timer\\' => array($vendorDir . '/react/promise-timer/src'),
+    'React\\Promise\\' => array($vendorDir . '/react/promise/src'),
+    'React\\Http\\' => array($vendorDir . '/react/http/src'),
+    'React\\HttpClient\\' => array($vendorDir . '/react/http-client/src'),
+    'React\\EventLoop\\' => array($vendorDir . '/react/event-loop/src'),
+    'React\\Dns\\' => array($vendorDir . '/react/dns/src'),
+    'React\\Datagram\\' => array($vendorDir . '/react/datagram/src'),
+    'React\\ChildProcess\\' => array($vendorDir . '/react/child-process/src'),
+    'React\\Cache\\' => array($vendorDir . '/react/cache/src'),
+    'Psr\\Http\\Message\\' => array($vendorDir . '/psr/http-message/src'),
+    'Predis\\' => array($vendorDir . '/predis/predis/src'),
+    'GuzzleHttp\\Stream\\' => array($vendorDir . '/guzzlehttp/streams/src'),
+    'GuzzleHttp\\Ring\\' => array($vendorDir . '/guzzlehttp/ringphp/src'),
+    'GuzzleHttp\\Psr7\\' => array($vendorDir . '/guzzlehttp/psr7/src'),
+    'GuzzleHttp\\' => array($vendorDir . '/guzzlehttp/guzzle/src'),
+    'ConnectionManager\\Extra\\' => array($vendorDir . '/clue/connection-manager-extra/src'),
+    'Clue\\React\\Socks\\' => array($vendorDir . '/clue/socks-react/src'),
+    'Clue\\React\\Redis\\' => array($vendorDir . '/clue/redis-react/src'),
+    'Clue\\React\\HttpProxy\\' => array($vendorDir . '/clue/http-proxy-react/src'),
+);

vendor/composer/autoload_real.php

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

vendor/composer/autoload_static.php

@@ -0,0 +1,177 @@
+<?php
+
+// autoload_static.php @generated by Composer
+
+namespace Composer\Autoload;
+
+class ComposerStaticInitd5eff77d7f1a34fed3451f7ca63a1583
+{
+    public static $files = array (
+        'ad155f8f1cf0d418fe49e248db8c661b' => __DIR__ . '/..' . '/react/promise/src/functions_include.php',
+        '6b06ce8ccf69c43a60a1e48495a034c9' => __DIR__ . '/..' . '/react/promise-timer/src/functions.php',
+        'ebf8799635f67b5d7248946fe2154f4a' => __DIR__ . '/..' . '/ringcentral/psr7/src/functions_include.php',
+        'a0edc8309cc5e1d60e3047b5df6b7052' => __DIR__ . '/..' . '/guzzlehttp/psr7/src/functions_include.php',
+    );
+
+    public static $prefixLengthsPsr4 = array (
+        'R' => 
+        array (
+            'RingCentral\\Psr7\\' => 17,
+            'React\\Stream\\' => 13,
+            'React\\Socket\\' => 13,
+            'React\\Promise\\Timer\\' => 20,
+            'React\\Promise\\' => 14,
+            'React\\Http\\' => 11,
+            'React\\HttpClient\\' => 17,
+            'React\\EventLoop\\' => 16,
+            'React\\Dns\\' => 10,
+            'React\\Datagram\\' => 15,
+            'React\\ChildProcess\\' => 19,
+            'React\\Cache\\' => 12,
+        ),
+        'P' => 
+        array (
+            'Psr\\Http\\Message\\' => 17,
+            'Predis\\' => 7,
+        ),
+        'G' => 
+        array (
+            'GuzzleHttp\\Stream\\' => 18,
+            'GuzzleHttp\\Ring\\' => 16,
+            'GuzzleHttp\\Psr7\\' => 16,
+            'GuzzleHttp\\' => 11,
+        ),
+        'C' => 
+        array (
+            'ConnectionManager\\Extra\\' => 24,
+            'Clue\\React\\Socks\\' => 17,
+            'Clue\\React\\Redis\\' => 17,
+            'Clue\\React\\HttpProxy\\' => 21,
+        ),
+    );
+
+    public static $prefixDirsPsr4 = array (
+        'RingCentral\\Psr7\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/ringcentral/psr7/src',
+        ),
+        'React\\Stream\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/stream/src',
+        ),
+        'React\\Socket\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/socket/src',
+        ),
+        'React\\Promise\\Timer\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/promise-timer/src',
+        ),
+        'React\\Promise\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/promise/src',
+        ),
+        'React\\Http\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/http/src',
+        ),
+        'React\\HttpClient\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/http-client/src',
+        ),
+        'React\\EventLoop\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/event-loop/src',
+        ),
+        'React\\Dns\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/dns/src',
+        ),
+        'React\\Datagram\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/datagram/src',
+        ),
+        'React\\ChildProcess\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/child-process/src',
+        ),
+        'React\\Cache\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/react/cache/src',
+        ),
+        'Psr\\Http\\Message\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/psr/http-message/src',
+        ),
+        'Predis\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/predis/predis/src',
+        ),
+        'GuzzleHttp\\Stream\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/guzzlehttp/streams/src',
+        ),
+        'GuzzleHttp\\Ring\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/guzzlehttp/ringphp/src',
+        ),
+        'GuzzleHttp\\Psr7\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/guzzlehttp/psr7/src',
+        ),
+        'GuzzleHttp\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/guzzlehttp/guzzle/src',
+        ),
+        'ConnectionManager\\Extra\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/clue/connection-manager-extra/src',
+        ),
+        'Clue\\React\\Socks\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/clue/socks-react/src',
+        ),
+        'Clue\\React\\Redis\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/clue/redis-react/src',
+        ),
+        'Clue\\React\\HttpProxy\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/clue/http-proxy-react/src',
+        ),
+    );
+
+    public static $prefixesPsr0 = array (
+        'M' => 
+        array (
+            'MKraemer' => 
+            array (
+                0 => __DIR__ . '/..' . '/mkraemer/react-pcntl/src',
+            ),
+        ),
+        'E' => 
+        array (
+            'Evenement' => 
+            array (
+                0 => __DIR__ . '/..' . '/evenement/evenement/src',
+            ),
+        ),
+        'C' => 
+        array (
+            'Clue\\Redis\\Protocol' => 
+            array (
+                0 => __DIR__ . '/..' . '/clue/redis-protocol/src',
+            ),
+        ),
+    );
+
+    public static function getInitializer(ClassLoader $loader)
+    {
+        return \Closure::bind(function () use ($loader) {
+            $loader->prefixLengthsPsr4 = ComposerStaticInitd5eff77d7f1a34fed3451f7ca63a1583::$prefixLengthsPsr4;
+            $loader->prefixDirsPsr4 = ComposerStaticInitd5eff77d7f1a34fed3451f7ca63a1583::$prefixDirsPsr4;
+            $loader->prefixesPsr0 = ComposerStaticInitd5eff77d7f1a34fed3451f7ca63a1583::$prefixesPsr0;
+
+        }, null, ClassLoader::class);
+    }
+}

vendor/evenement/evenement/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Igor Wiedler
+
+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/evenement/evenement/src/Evenement/EventEmitter.php

@@ -0,0 +1,17 @@
+<?php
+
+/*
+ * This file is part of Evenement.
+ *
+ * (c) Igor Wiedler <igor@wiedler.ch>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Evenement;
+
+class EventEmitter implements EventEmitterInterface
+{
+    use EventEmitterTrait;
+}

vendor/evenement/evenement/src/Evenement/EventEmitterInterface.php

@@ -0,0 +1,22 @@
+<?php
+
+/*
+ * This file is part of Evenement.
+ *
+ * (c) Igor Wiedler <igor@wiedler.ch>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Evenement;
+
+interface EventEmitterInterface
+{
+    public function on($event, callable $listener);
+    public function once($event, callable $listener);
+    public function removeListener($event, callable $listener);
+    public function removeAllListeners($event = null);
+    public function listeners($event);
+    public function emit($event, array $arguments = []);
+}

vendor/evenement/evenement/src/Evenement/EventEmitterTrait.php

@@ -0,0 +1,73 @@
+<?php
+
+/*
+ * This file is part of Evenement.
+ *
+ * (c) Igor Wiedler <igor@wiedler.ch>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Evenement;
+
+trait EventEmitterTrait
+{
+    protected $listeners = [];
+
+    public function on($event, callable $listener)
+    {
+        if (!isset($this->listeners[$event])) {
+            $this->listeners[$event] = [];
+        }
+
+        $this->listeners[$event][] = $listener;
+
+        return $this;
+    }
+
+    public function once($event, callable $listener)
+    {
+        $onceListener = function () use (&$onceListener, $event, $listener) {
+            $this->removeListener($event, $onceListener);
+
+            \call_user_func_array($listener, \func_get_args());
+        };
+
+        $this->on($event, $onceListener);
+    }
+
+    public function removeListener($event, callable $listener)
+    {
+        if (isset($this->listeners[$event])) {
+            $index = \array_search($listener, $this->listeners[$event], true);
+            if (false !== $index) {
+                unset($this->listeners[$event][$index]);
+                if (\count($this->listeners[$event]) === 0) {
+                    unset($this->listeners[$event]);
+                }
+            }
+        }
+    }
+
+    public function removeAllListeners($event = null)
+    {
+        if ($event !== null) {
+            unset($this->listeners[$event]);
+        } else {
+            $this->listeners = [];
+        }
+    }
+
+    public function listeners($event)
+    {
+        return isset($this->listeners[$event]) ? $this->listeners[$event] : [];
+    }
+
+    public function emit($event, array $arguments = [])
+    {
+        foreach ($this->listeners($event) as $listener) {
+            \call_user_func_array($listener, $arguments);
+        }
+    }
+}

vendor/guzzlehttp/guzzle/LICENSE

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

vendor/guzzlehttp/guzzle/src/BatchResults.php

@@ -0,0 +1,148 @@
+<?php
+namespace GuzzleHttp;
+
+/**
+ * Represents the result of a batch operation. This result container is
+ * iterable, countable, and you can can get a result by value using the
+ * getResult function.
+ *
+ * Successful results are anything other than exceptions. Failure results are
+ * exceptions.
+ *
+ * @package GuzzleHttp
+ */
+class BatchResults implements \Countable, \IteratorAggregate, \ArrayAccess
+{
+    private $hash;
+
+    /**
+     * @param \SplObjectStorage $hash Hash of key objects to result values.
+     */
+    public function __construct(\SplObjectStorage $hash)
+    {
+        $this->hash = $hash;
+    }
+
+    /**
+     * Get the keys that are available on the batch result.
+     *
+     * @return array
+     */
+    public function getKeys()
+    {
+        return iterator_to_array($this->hash);
+    }
+
+    /**
+     * Gets a result from the container for the given object. When getting
+     * results for a batch of requests, provide the request object.
+     *
+     * @param object $forObject Object to retrieve the result for.
+     *
+     * @return mixed|null
+     */
+    public function getResult($forObject)
+    {
+        return isset($this->hash[$forObject]) ? $this->hash[$forObject] : null;
+    }
+
+    /**
+     * Get an array of successful results.
+     *
+     * @return array
+     */
+    public function getSuccessful()
+    {
+        $results = [];
+        foreach ($this->hash as $key) {
+            if (!($this->hash[$key] instanceof \Exception)) {
+                $results[] = $this->hash[$key];
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Get an array of failed results.
+     *
+     * @return array
+     */
+    public function getFailures()
+    {
+        $results = [];
+        foreach ($this->hash as $key) {
+            if ($this->hash[$key] instanceof \Exception) {
+                $results[] = $this->hash[$key];
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Allows iteration over all batch result values.
+     *
+     * @return \ArrayIterator
+     */
+    public function getIterator()
+    {
+        $results = [];
+        foreach ($this->hash as $key) {
+            $results[] = $this->hash[$key];
+        }
+
+        return new \ArrayIterator($results);
+    }
+
+    /**
+     * Counts the number of elements in the batch result.
+     *
+     * @return int
+     */
+    public function count()
+    {
+        return count($this->hash);
+    }
+
+    /**
+     * Checks if the batch contains a specific numerical array index.
+     *
+     * @param int $key Index to access
+     *
+     * @return bool
+     */
+    public function offsetExists($key)
+    {
+        return $key < count($this->hash);
+    }
+
+    /**
+     * Allows access of the batch using a numerical array index.
+     *
+     * @param int $key Index to access.
+     *
+     * @return mixed|null
+     */
+    public function offsetGet($key)
+    {
+        $i = -1;
+        foreach ($this->hash as $obj) {
+            if ($key === ++$i) {
+                return $this->hash[$obj];
+            }
+        }
+
+        return null;
+    }
+
+    public function offsetUnset($key)
+    {
+        throw new \RuntimeException('Not implemented');
+    }
+
+    public function offsetSet($key, $value)
+    {
+        throw new \RuntimeException('Not implemented');
+    }
+}

vendor/guzzlehttp/guzzle/src/Client.php

@@ -0,0 +1,355 @@
+<?php
+namespace GuzzleHttp;
+
+use GuzzleHttp\Event\HasEmitterTrait;
+use GuzzleHttp\Message\MessageFactory;
+use GuzzleHttp\Message\MessageFactoryInterface;
+use GuzzleHttp\Message\RequestInterface;
+use GuzzleHttp\Message\FutureResponse;
+use GuzzleHttp\Ring\Core;
+use GuzzleHttp\Ring\Future\FutureInterface;
+use GuzzleHttp\Exception\RequestException;
+use React\Promise\FulfilledPromise;
+use React\Promise\RejectedPromise;
+
+/**
+ * HTTP client
+ */
+class Client implements ClientInterface
+{
+    use HasEmitterTrait;
+
+    /** @var MessageFactoryInterface Request factory used by the client */
+    private $messageFactory;
+
+    /** @var Url Base URL of the client */
+    private $baseUrl;
+
+    /** @var array Default request options */
+    private $defaults;
+
+    /** @var callable Request state machine */
+    private $fsm;
+
+    /**
+     * Clients accept an array of constructor parameters.
+     *
+     * Here's an example of creating a client using an URI template for the
+     * client's base_url and an array of default request options to apply
+     * to each request:
+     *
+     *     $client = new Client([
+     *         'base_url' => [
+     *              'http://www.foo.com/{version}/',
+     *              ['version' => '123']
+     *          ],
+     *         'defaults' => [
+     *             'timeout'         => 10,
+     *             'allow_redirects' => false,
+     *             'proxy'           => '192.168.16.1:10'
+     *         ]
+     *     ]);
+     *
+     * @param array $config Client configuration settings
+     *     - base_url: Base URL of the client that is merged into relative URLs.
+     *       Can be a string or an array that contains a URI template followed
+     *       by an associative array of expansion variables to inject into the
+     *       URI template.
+     *     - handler: callable RingPHP handler used to transfer requests
+     *     - message_factory: Factory used to create request and response object
+     *     - defaults: Default request options to apply to each request
+     *     - emitter: Event emitter used for request events
+     *     - fsm: (internal use only) The request finite state machine. A
+     *       function that accepts a transaction and optional final state. The
+     *       function is responsible for transitioning a request through its
+     *       lifecycle events.
+     */
+    public function __construct(array $config = [])
+    {
+        $this->configureBaseUrl($config);
+        $this->configureDefaults($config);
+
+        if (isset($config['emitter'])) {
+            $this->emitter = $config['emitter'];
+        }
+
+        $this->messageFactory = isset($config['message_factory'])
+            ? $config['message_factory']
+            : new MessageFactory();
+
+        if (isset($config['fsm'])) {
+            $this->fsm = $config['fsm'];
+        } else {
+            if (isset($config['handler'])) {
+                $handler = $config['handler'];
+            } elseif (isset($config['adapter'])) {
+                $handler = $config['adapter'];
+            } else {
+                $handler = Utils::getDefaultHandler();
+            }
+            $this->fsm = new RequestFsm($handler, $this->messageFactory);
+        }
+    }
+
+    public function getDefaultOption($keyOrPath = null)
+    {
+        return $keyOrPath === null
+            ? $this->defaults
+            : Utils::getPath($this->defaults, $keyOrPath);
+    }
+
+    public function setDefaultOption($keyOrPath, $value)
+    {
+        Utils::setPath($this->defaults, $keyOrPath, $value);
+    }
+
+    public function getBaseUrl()
+    {
+        return (string) $this->baseUrl;
+    }
+
+    public function createRequest($method, $url = null, array $options = [])
+    {
+        $options = $this->mergeDefaults($options);
+        // Use a clone of the client's emitter
+        $options['config']['emitter'] = clone $this->getEmitter();
+        $url = $url || (is_string($url) && strlen($url))
+            ? $this->buildUrl($url)
+            : (string) $this->baseUrl;
+
+        return $this->messageFactory->createRequest($method, $url, $options);
+    }
+
+    public function get($url = null, $options = [])
+    {
+        return $this->send($this->createRequest('GET', $url, $options));
+    }
+
+    public function head($url = null, array $options = [])
+    {
+        return $this->send($this->createRequest('HEAD', $url, $options));
+    }
+
+    public function delete($url = null, array $options = [])
+    {
+        return $this->send($this->createRequest('DELETE', $url, $options));
+    }
+
+    public function put($url = null, array $options = [])
+    {
+        return $this->send($this->createRequest('PUT', $url, $options));
+    }
+
+    public function patch($url = null, array $options = [])
+    {
+        return $this->send($this->createRequest('PATCH', $url, $options));
+    }
+
+    public function post($url = null, array $options = [])
+    {
+        return $this->send($this->createRequest('POST', $url, $options));
+    }
+
+    public function options($url = null, array $options = [])
+    {
+        return $this->send($this->createRequest('OPTIONS', $url, $options));
+    }
+
+    public function send(RequestInterface $request)
+    {
+        $isFuture = $request->getConfig()->get('future');
+        $trans = new Transaction($this, $request, $isFuture);
+        $fn = $this->fsm;
+
+        try {
+            $fn($trans);
+            if ($isFuture) {
+                // Turn the normal response into a future if needed.
+                return $trans->response instanceof FutureInterface
+                    ? $trans->response
+                    : new FutureResponse(new FulfilledPromise($trans->response));
+            }
+            // Resolve deep futures if this is not a future
+            // transaction. This accounts for things like retries
+            // that do not have an immediate side-effect.
+            while ($trans->response instanceof FutureInterface) {
+                $trans->response = $trans->response->wait();
+            }
+            return $trans->response;
+        } catch (\Exception $e) {
+            if ($isFuture) {
+                // Wrap the exception in a promise
+                return new FutureResponse(new RejectedPromise($e));
+            }
+            throw RequestException::wrapException($trans->request, $e);
+        }
+    }
+
+    /**
+     * Get an array of default options to apply to the client
+     *
+     * @return array
+     */
+    protected function getDefaultOptions()
+    {
+        $settings = [
+            'allow_redirects' => true,
+            'exceptions'      => true,
+            'decode_content'  => true,
+            'verify'          => true
+        ];
+
+        // Use the standard Linux HTTP_PROXY and HTTPS_PROXY if set.
+        // We can only trust the HTTP_PROXY environment variable in a CLI
+        // process due to the fact that PHP has no reliable mechanism to
+        // get environment variables that start with "HTTP_".
+        if (php_sapi_name() == 'cli' && getenv('HTTP_PROXY')) {
+            $settings['proxy']['http'] = getenv('HTTP_PROXY');
+        }
+
+        if ($proxy = getenv('HTTPS_PROXY')) {
+            $settings['proxy']['https'] = $proxy;
+        }
+
+        return $settings;
+    }
+
+    /**
+     * Expand a URI template and inherit from the base URL if it's relative
+     *
+     * @param string|array $url URL or an array of the URI template to expand
+     *                          followed by a hash of template varnames.
+     * @return string
+     * @throws \InvalidArgumentException
+     */
+    private function buildUrl($url)
+    {
+        // URI template (absolute or relative)
+        if (!is_array($url)) {
+            return strpos($url, '://')
+                ? (string) $url
+                : (string) $this->baseUrl->combine($url);
+        }
+
+        if (!isset($url[1])) {
+            throw new \InvalidArgumentException('You must provide a hash of '
+                . 'varname options in the second element of a URL array.');
+        }
+
+        // Absolute URL
+        if (strpos($url[0], '://')) {
+            return Utils::uriTemplate($url[0], $url[1]);
+        }
+
+        // Combine the relative URL with the base URL
+        return (string) $this->baseUrl->combine(
+            Utils::uriTemplate($url[0], $url[1])
+        );
+    }
+
+    private function configureBaseUrl(&$config)
+    {
+        if (!isset($config['base_url'])) {
+            $this->baseUrl = new Url('', '');
+        } elseif (!is_array($config['base_url'])) {
+            $this->baseUrl = Url::fromString($config['base_url']);
+        } elseif (count($config['base_url']) < 2) {
+            throw new \InvalidArgumentException('You must provide a hash of '
+                . 'varname options in the second element of a base_url array.');
+        } else {
+            $this->baseUrl = Url::fromString(
+                Utils::uriTemplate(
+                    $config['base_url'][0],
+                    $config['base_url'][1]
+                )
+            );
+            $config['base_url'] = (string) $this->baseUrl;
+        }
+    }
+
+    private function configureDefaults($config)
+    {
+        if (!isset($config['defaults'])) {
+            $this->defaults = $this->getDefaultOptions();
+        } else {
+            $this->defaults = array_replace(
+                $this->getDefaultOptions(),
+                $config['defaults']
+            );
+        }
+
+        // Add the default user-agent header
+        if (!isset($this->defaults['headers'])) {
+            $this->defaults['headers'] = [
+                'User-Agent' => Utils::getDefaultUserAgent()
+            ];
+        } elseif (!Core::hasHeader($this->defaults, 'User-Agent')) {
+            // Add the User-Agent header if one was not already set
+            $this->defaults['headers']['User-Agent'] = Utils::getDefaultUserAgent();
+        }
+    }
+
+    /**
+     * Merges default options into the array passed by reference.
+     *
+     * @param array $options Options to modify by reference
+     *
+     * @return array
+     */
+    private function mergeDefaults($options)
+    {
+        $defaults = $this->defaults;
+
+        // Case-insensitively merge in default headers if both defaults and
+        // options have headers specified.
+        if (!empty($defaults['headers']) && !empty($options['headers'])) {
+            // Create a set of lowercased keys that are present.
+            $lkeys = [];
+            foreach (array_keys($options['headers']) as $k) {
+                $lkeys[strtolower($k)] = true;
+            }
+            // Merge in lowercase default keys when not present in above set.
+            foreach ($defaults['headers'] as $key => $value) {
+                if (!isset($lkeys[strtolower($key)])) {
+                    $options['headers'][$key] = $value;
+                }
+            }
+            // No longer need to merge in headers.
+            unset($defaults['headers']);
+        }
+
+        $result = array_replace_recursive($defaults, $options);
+        foreach ($options as $k => $v) {
+            if ($v === null) {
+                unset($result[$k]);
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * @deprecated Use {@see GuzzleHttp\Pool} instead.
+     * @see GuzzleHttp\Pool
+     */
+    public function sendAll($requests, array $options = [])
+    {
+        Pool::send($this, $requests, $options);
+    }
+
+    /**
+     * @deprecated Use GuzzleHttp\Utils::getDefaultHandler
+     */
+    public static function getDefaultHandler()
+    {
+        return Utils::getDefaultHandler();
+    }
+
+    /**
+     * @deprecated Use GuzzleHttp\Utils::getDefaultUserAgent
+     */
+    public static function getDefaultUserAgent()
+    {
+        return Utils::getDefaultUserAgent();
+    }
+}

vendor/guzzlehttp/guzzle/src/ClientInterface.php

@@ -0,0 +1,150 @@
+<?php
+namespace GuzzleHttp;
+
+use GuzzleHttp\Event\HasEmitterInterface;
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Message\RequestInterface;
+use GuzzleHttp\Message\ResponseInterface;
+
+/**
+ * Client interface for sending HTTP requests
+ */
+interface ClientInterface extends HasEmitterInterface
+{
+    const VERSION = '5.3.1';
+
+    /**
+     * Create and return a new {@see RequestInterface} object.
+     *
+     * Use an absolute path to override the base path of the client, or a
+     * relative path to append to the base path of the client. The URL can
+     * contain the query string as well. Use an array to provide a URL
+     * template and additional variables to use in the URL template expansion.
+     *
+     * @param string           $method  HTTP method
+     * @param string|array|Url $url     URL or URI template
+     * @param array            $options Array of request options to apply.
+     *
+     * @return RequestInterface
+     */
+    public function createRequest($method, $url = null, array $options = []);
+
+    /**
+     * Send a GET request
+     *
+     * @param string|array|Url $url     URL or URI template
+     * @param array            $options Array of request options to apply.
+     *
+     * @return ResponseInterface
+     * @throws RequestException When an error is encountered
+     */
+    public function get($url = null, $options = []);
+
+    /**
+     * Send a HEAD request
+     *
+     * @param string|array|Url $url     URL or URI template
+     * @param array            $options Array of request options to apply.
+     *
+     * @return ResponseInterface
+     * @throws RequestException When an error is encountered
+     */
+    public function head($url = null, array $options = []);
+
+    /**
+     * Send a DELETE request
+     *
+     * @param string|array|Url $url     URL or URI template
+     * @param array            $options Array of request options to apply.
+     *
+     * @return ResponseInterface
+     * @throws RequestException When an error is encountered
+     */
+    public function delete($url = null, array $options = []);
+
+    /**
+     * Send a PUT request
+     *
+     * @param string|array|Url $url     URL or URI template
+     * @param array            $options Array of request options to apply.
+     *
+     * @return ResponseInterface
+     * @throws RequestException When an error is encountered
+     */
+    public function put($url = null, array $options = []);
+
+    /**
+     * Send a PATCH request
+     *
+     * @param string|array|Url $url     URL or URI template
+     * @param array            $options Array of request options to apply.
+     *
+     * @return ResponseInterface
+     * @throws RequestException When an error is encountered
+     */
+    public function patch($url = null, array $options = []);
+
+    /**
+     * Send a POST request
+     *
+     * @param string|array|Url $url     URL or URI template
+     * @param array            $options Array of request options to apply.
+     *
+     * @return ResponseInterface
+     * @throws RequestException When an error is encountered
+     */
+    public function post($url = null, array $options = []);
+
+    /**
+     * Send an OPTIONS request
+     *
+     * @param string|array|Url $url     URL or URI template
+     * @param array            $options Array of request options to apply.
+     *
+     * @return ResponseInterface
+     * @throws RequestException When an error is encountered
+     */
+    public function options($url = null, array $options = []);
+
+    /**
+     * Sends a single request
+     *
+     * @param RequestInterface $request Request to send
+     *
+     * @return \GuzzleHttp\Message\ResponseInterface
+     * @throws \LogicException When the handler does not populate a response
+     * @throws RequestException When an error is encountered
+     */
+    public function send(RequestInterface $request);
+
+    /**
+     * Get default request options of the client.
+     *
+     * @param string|null $keyOrPath The Path to a particular default request
+     *     option to retrieve or pass null to retrieve all default request
+     *     options. The syntax uses "/" to denote a path through nested PHP
+     *     arrays. For example, "headers/content-type".
+     *
+     * @return mixed
+     */
+    public function getDefaultOption($keyOrPath = null);
+
+    /**
+     * Set a default request option on the client so that any request created
+     * by the client will use the provided default value unless overridden
+     * explicitly when creating a request.
+     *
+     * @param string|null $keyOrPath The Path to a particular configuration
+     *     value to set. The syntax uses a path notation that allows you to
+     *     specify nested configuration values (e.g., 'headers/content-type').
+     * @param mixed $value Default request option value to set
+     */
+    public function setDefaultOption($keyOrPath, $value);
+
+    /**
+     * Get the base URL of the client.
+     *
+     * @return string Returns the base URL if present
+     */
+    public function getBaseUrl();
+}

vendor/guzzlehttp/guzzle/src/Collection.php

@@ -0,0 +1,236 @@
+<?php
+namespace GuzzleHttp;
+
+/**
+ * Key value pair collection object
+ */
+class Collection implements
+    \ArrayAccess,
+    \IteratorAggregate,
+    \Countable,
+    ToArrayInterface
+{
+    use HasDataTrait;
+
+    /**
+     * @param array $data Associative array of data to set
+     */
+    public function __construct(array $data = [])
+    {
+        $this->data = $data;
+    }
+
+    /**
+     * Create a new collection from an array, validate the keys, and add default
+     * values where missing
+     *
+     * @param array $config   Configuration values to apply.
+     * @param array $defaults Default parameters
+     * @param array $required Required parameter names
+     *
+     * @return self
+     * @throws \InvalidArgumentException if a parameter is missing
+     */
+    public static function fromConfig(
+        array $config = [],
+        array $defaults = [],
+        array $required = []
+    ) {
+        $data = $config + $defaults;
+
+        if ($missing = array_diff($required, array_keys($data))) {
+            throw new \InvalidArgumentException(
+                'Config is missing the following keys: ' .
+                implode(', ', $missing));
+        }
+
+        return new self($data);
+    }
+
+    /**
+     * Removes all key value pairs
+     */
+    public function clear()
+    {
+        $this->data = [];
+    }
+
+    /**
+     * Get a specific key value.
+     *
+     * @param string $key Key to retrieve.
+     *
+     * @return mixed|null Value of the key or NULL
+     */
+    public function get($key)
+    {
+        return isset($this->data[$key]) ? $this->data[$key] : null;
+    }
+
+    /**
+     * Set a key value pair
+     *
+     * @param string $key   Key to set
+     * @param mixed  $value Value to set
+     */
+    public function set($key, $value)
+    {
+        $this->data[$key] = $value;
+    }
+
+    /**
+     * Add a value to a key.  If a key of the same name has already been added,
+     * the key value will be converted into an array and the new value will be
+     * pushed to the end of the array.
+     *
+     * @param string $key   Key to add
+     * @param mixed  $value Value to add to the key
+     */
+    public function add($key, $value)
+    {
+        if (!array_key_exists($key, $this->data)) {
+            $this->data[$key] = $value;
+        } elseif (is_array($this->data[$key])) {
+            $this->data[$key][] = $value;
+        } else {
+            $this->data[$key] = array($this->data[$key], $value);
+        }
+    }
+
+    /**
+     * Remove a specific key value pair
+     *
+     * @param string $key A key to remove
+     */
+    public function remove($key)
+    {
+        unset($this->data[$key]);
+    }
+
+    /**
+     * Get all keys in the collection
+     *
+     * @return array
+     */
+    public function getKeys()
+    {
+        return array_keys($this->data);
+    }
+
+    /**
+     * Returns whether or not the specified key is present.
+     *
+     * @param string $key The key for which to check the existence.
+     *
+     * @return bool
+     */
+    public function hasKey($key)
+    {
+        return array_key_exists($key, $this->data);
+    }
+
+    /**
+     * Checks if any keys contains a certain value
+     *
+     * @param string $value Value to search for
+     *
+     * @return mixed Returns the key if the value was found FALSE if the value
+     *     was not found.
+     */
+    public function hasValue($value)
+    {
+        return array_search($value, $this->data, true);
+    }
+
+    /**
+     * Replace the data of the object with the value of an array
+     *
+     * @param array $data Associative array of data
+     */
+    public function replace(array $data)
+    {
+        $this->data = $data;
+    }
+
+    /**
+     * Add and merge in a Collection or array of key value pair data.
+     *
+     * @param Collection|array $data Associative array of key value pair data
+     */
+    public function merge($data)
+    {
+        foreach ($data as $key => $value) {
+            $this->add($key, $value);
+        }
+    }
+
+    /**
+     * Overwrite key value pairs in this collection with all of the data from
+     * an array or collection.
+     *
+     * @param array|\Traversable $data Values to override over this config
+     */
+    public function overwriteWith($data)
+    {
+        if (is_array($data)) {
+            $this->data = $data + $this->data;
+        } elseif ($data instanceof Collection) {
+            $this->data = $data->toArray() + $this->data;
+        } else {
+            foreach ($data as $key => $value) {
+                $this->data[$key] = $value;
+            }
+        }
+    }
+
+    /**
+     * Returns a Collection containing all the elements of the collection after
+     * applying the callback function to each one.
+     *
+     * The callable should accept three arguments:
+     * - (string) $key
+     * - (string) $value
+     * - (array) $context
+     *
+     * The callable must return a the altered or unaltered value.
+     *
+     * @param callable $closure Map function to apply
+     * @param array    $context Context to pass to the callable
+     *
+     * @return Collection
+     */
+    public function map(callable $closure, array $context = [])
+    {
+        $collection = new static();
+        foreach ($this as $key => $value) {
+            $collection[$key] = $closure($key, $value, $context);
+        }
+
+        return $collection;
+    }
+
+    /**
+     * Iterates over each key value pair in the collection passing them to the
+     * callable. If the callable returns true, the current value from input is
+     * returned into the result Collection.
+     *
+     * The callable must accept two arguments:
+     * - (string) $key
+     * - (string) $value
+     *
+     * @param callable $closure Evaluation function
+     *
+     * @return Collection
+     */
+    public function filter(callable $closure)
+    {
+        $collection = new static();
+        foreach ($this->data as $key => $value) {
+            if ($closure($key, $value)) {
+                $collection[$key] = $value;
+            }
+        }
+
+        return $collection;
+    }
+}

vendor/guzzlehttp/guzzle/src/Cookie/CookieJar.php

@@ -0,0 +1,248 @@
+<?php
+namespace GuzzleHttp\Cookie;
+
+use GuzzleHttp\Message\RequestInterface;
+use GuzzleHttp\Message\ResponseInterface;
+use GuzzleHttp\ToArrayInterface;
+
+/**
+ * Cookie jar that stores cookies an an array
+ */
+class CookieJar implements CookieJarInterface, ToArrayInterface
+{
+    /** @var SetCookie[] Loaded cookie data */
+    private $cookies = [];
+
+    /** @var bool */
+    private $strictMode;
+
+    /**
+     * @param bool $strictMode   Set to true to throw exceptions when invalid
+     *                           cookies are added to the cookie jar.
+     * @param array $cookieArray Array of SetCookie objects or a hash of arrays
+     *                           that can be used with the SetCookie constructor
+     */
+    public function __construct($strictMode = false, $cookieArray = [])
+    {
+        $this->strictMode = $strictMode;
+
+        foreach ($cookieArray as $cookie) {
+            if (!($cookie instanceof SetCookie)) {
+                $cookie = new SetCookie($cookie);
+            }
+            $this->setCookie($cookie);
+        }
+    }
+
+    /**
+     * Create a new Cookie jar from an associative array and domain.
+     *
+     * @param array  $cookies Cookies to create the jar from
+     * @param string $domain  Domain to set the cookies to
+     *
+     * @return self
+     */
+    public static function fromArray(array $cookies, $domain)
+    {
+        $cookieJar = new self();
+        foreach ($cookies as $name => $value) {
+            $cookieJar->setCookie(new SetCookie([
+                'Domain'  => $domain,
+                'Name'    => $name,
+                'Value'   => $value,
+                'Discard' => true
+            ]));
+        }
+
+        return $cookieJar;
+    }
+
+    /**
+     * Quote the cookie value if it is not already quoted and it contains
+     * problematic characters.
+     *
+     * @param string $value Value that may or may not need to be quoted
+     *
+     * @return string
+     */
+    public static function getCookieValue($value)
+    {
+        if (substr($value, 0, 1) !== '"' &&
+            substr($value, -1, 1) !== '"' &&
+            strpbrk($value, ';,')
+        ) {
+            $value = '"' . $value . '"';
+        }
+
+        return $value;
+    }
+
+    public function toArray()
+    {
+        return array_map(function (SetCookie $cookie) {
+            return $cookie->toArray();
+        }, $this->getIterator()->getArrayCopy());
+    }
+
+    public function clear($domain = null, $path = null, $name = null)
+    {
+        if (!$domain) {
+            $this->cookies = [];
+            return;
+        } elseif (!$path) {
+            $this->cookies = array_filter(
+                $this->cookies,
+                function (SetCookie $cookie) use ($path, $domain) {
+                    return !$cookie->matchesDomain($domain);
+                }
+            );
+        } elseif (!$name) {
+            $this->cookies = array_filter(
+                $this->cookies,
+                function (SetCookie $cookie) use ($path, $domain) {
+                    return !($cookie->matchesPath($path) &&
+                        $cookie->matchesDomain($domain));
+                }
+            );
+        } else {
+            $this->cookies = array_filter(
+                $this->cookies,
+                function (SetCookie $cookie) use ($path, $domain, $name) {
+                    return !($cookie->getName() == $name &&
+                        $cookie->matchesPath($path) &&
+                        $cookie->matchesDomain($domain));
+                }
+            );
+        }
+    }
+
+    public function clearSessionCookies()
+    {
+        $this->cookies = array_filter(
+            $this->cookies,
+            function (SetCookie $cookie) {
+                return !$cookie->getDiscard() && $cookie->getExpires();
+            }
+        );
+    }
+
+    public function setCookie(SetCookie $cookie)
+    {
+        // Only allow cookies with set and valid domain, name, value
+        $result = $cookie->validate();
+        if ($result !== true) {
+            if ($this->strictMode) {
+                throw new \RuntimeException('Invalid cookie: ' . $result);
+            } else {
+                $this->removeCookieIfEmpty($cookie);
+                return false;
+            }
+        }
+
+        // Resolve conflicts with previously set cookies
+        foreach ($this->cookies as $i => $c) {
+
+            // Two cookies are identical, when their path, and domain are
+            // identical.
+            if ($c->getPath() != $cookie->getPath() ||
+                $c->getDomain() != $cookie->getDomain() ||
+                $c->getName() != $cookie->getName()
+            ) {
+                continue;
+            }
+
+            // The previously set cookie is a discard cookie and this one is
+            // not so allow the new cookie to be set
+            if (!$cookie->getDiscard() && $c->getDiscard()) {
+                unset($this->cookies[$i]);
+                continue;
+            }
+
+            // If the new cookie's expiration is further into the future, then
+            // replace the old cookie
+            if ($cookie->getExpires() > $c->getExpires()) {
+                unset($this->cookies[$i]);
+                continue;
+            }
+
+            // If the value has changed, we better change it
+            if ($cookie->getValue() !== $c->getValue()) {
+                unset($this->cookies[$i]);
+                continue;
+            }
+
+            // The cookie exists, so no need to continue
+            return false;
+        }
+
+        $this->cookies[] = $cookie;
+
+        return true;
+    }
+
+    public function count()
+    {
+        return count($this->cookies);
+    }
+
+    public function getIterator()
+    {
+        return new \ArrayIterator(array_values($this->cookies));
+    }
+
+    public function extractCookies(
+        RequestInterface $request,
+        ResponseInterface $response
+    ) {
+        if ($cookieHeader = $response->getHeaderAsArray('Set-Cookie')) {
+            foreach ($cookieHeader as $cookie) {
+                $sc = SetCookie::fromString($cookie);
+                if (!$sc->getDomain()) {
+                    $sc->setDomain($request->getHost());
+                }
+                $this->setCookie($sc);
+            }
+        }
+    }
+
+    public function addCookieHeader(RequestInterface $request)
+    {
+        $values = [];
+        $scheme = $request->getScheme();
+        $host = $request->getHost();
+        $path = $request->getPath();
+
+        foreach ($this->cookies as $cookie) {
+            if ($cookie->matchesPath($path) &&
+                $cookie->matchesDomain($host) &&
+                !$cookie->isExpired() &&
+                (!$cookie->getSecure() || $scheme == 'https')
+            ) {
+                $values[] = $cookie->getName() . '='
+                    . self::getCookieValue($cookie->getValue());
+            }
+        }
+
+        if ($values) {
+            $request->setHeader('Cookie', implode('; ', $values));
+        }
+    }
+
+    /**
+     * If a cookie already exists and the server asks to set it again with a
+     * null value, the cookie must be deleted.
+     *
+     * @param SetCookie $cookie
+     */
+    private function removeCookieIfEmpty(SetCookie $cookie)
+    {
+        $cookieValue = $cookie->getValue();
+        if ($cookieValue === null || $cookieValue === '') {
+            $this->clear(
+                $cookie->getDomain(),
+                $cookie->getPath(),
+                $cookie->getName()
+            );
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Cookie/CookieJarInterface.php

@@ -0,0 +1,75 @@
+<?php
+namespace GuzzleHttp\Cookie;
+
+use GuzzleHttp\Message\RequestInterface;
+use GuzzleHttp\Message\ResponseInterface;
+
+/**
+ * Stores HTTP cookies.
+ *
+ * It extracts cookies from HTTP requests, and returns them in HTTP responses.
+ * CookieJarInterface instances automatically expire contained cookies when
+ * necessary. Subclasses are also responsible for storing and retrieving
+ * cookies from a file, database, etc.
+ *
+ * @link http://docs.python.org/2/library/cookielib.html Inspiration
+ */
+interface CookieJarInterface extends \Countable, \IteratorAggregate
+{
+    /**
+     * Add a Cookie header to a request.
+     *
+     * If no matching cookies are found in the cookie jar, then no Cookie
+     * header is added to the request.
+     *
+     * @param RequestInterface $request Request object to update
+     */
+    public function addCookieHeader(RequestInterface $request);
+
+    /**
+     * Extract cookies from an HTTP response and store them in the CookieJar.
+     *
+     * @param RequestInterface  $request  Request that was sent
+     * @param ResponseInterface $response Response that was received
+     */
+    public function extractCookies(
+        RequestInterface $request,
+        ResponseInterface $response
+    );
+
+    /**
+     * Sets a cookie in the cookie jar.
+     *
+     * @param SetCookie $cookie Cookie to set.
+     *
+     * @return bool Returns true on success or false on failure
+     */
+    public function setCookie(SetCookie $cookie);
+
+    /**
+     * Remove cookies currently held in the cookie jar.
+     *
+     * Invoking this method without arguments will empty the whole cookie jar.
+     * If given a $domain argument only cookies belonging to that domain will
+     * be removed. If given a $domain and $path argument, cookies belonging to
+     * the specified path within that domain are removed. If given all three
+     * arguments, then the cookie with the specified name, path and domain is
+     * removed.
+     *
+     * @param string $domain Clears cookies matching a domain
+     * @param string $path   Clears cookies matching a domain and path
+     * @param string $name   Clears cookies matching a domain, path, and name
+     *
+     * @return CookieJarInterface
+     */
+    public function clear($domain = null, $path = null, $name = null);
+
+    /**
+     * Discard all sessions cookies.
+     *
+     * Removes cookies that don't have an expire field or a have a discard
+     * field set to true. To be called when the user agent shuts down according
+     * to RFC 2965.
+     */
+    public function clearSessionCookies();
+}

vendor/guzzlehttp/guzzle/src/Cookie/FileCookieJar.php

@@ -0,0 +1,86 @@
+<?php
+namespace GuzzleHttp\Cookie;
+
+use GuzzleHttp\Utils;
+
+/**
+ * Persists non-session cookies using a JSON formatted file
+ */
+class FileCookieJar extends CookieJar
+{
+    /** @var string filename */
+    private $filename;
+
+    /**
+     * Create a new FileCookieJar object
+     *
+     * @param string $cookieFile File to store the cookie data
+     *
+     * @throws \RuntimeException if the file cannot be found or created
+     */
+    public function __construct($cookieFile)
+    {
+        $this->filename = $cookieFile;
+
+        if (file_exists($cookieFile)) {
+            $this->load($cookieFile);
+        }
+    }
+
+    /**
+     * Saves the file when shutting down
+     */
+    public function __destruct()
+    {
+        $this->save($this->filename);
+    }
+
+    /**
+     * Saves the cookies to a file.
+     *
+     * @param string $filename File to save
+     * @throws \RuntimeException if the file cannot be found or created
+     */
+    public function save($filename)
+    {
+        $json = [];
+        foreach ($this as $cookie) {
+            if ($cookie->getExpires() && !$cookie->getDiscard()) {
+                $json[] = $cookie->toArray();
+            }
+        }
+
+        if (false === file_put_contents($filename, json_encode($json))) {
+            // @codeCoverageIgnoreStart
+            throw new \RuntimeException("Unable to save file {$filename}");
+            // @codeCoverageIgnoreEnd
+        }
+    }
+
+    /**
+     * Load cookies from a JSON formatted file.
+     *
+     * Old cookies are kept unless overwritten by newly loaded ones.
+     *
+     * @param string $filename Cookie file to load.
+     * @throws \RuntimeException if the file cannot be loaded.
+     */
+    public function load($filename)
+    {
+        $json = file_get_contents($filename);
+        if (false === $json) {
+            // @codeCoverageIgnoreStart
+            throw new \RuntimeException("Unable to load file {$filename}");
+            // @codeCoverageIgnoreEnd
+        }
+
+        $data = Utils::jsonDecode($json, true);
+        if (is_array($data)) {
+            foreach (Utils::jsonDecode($json, true) as $cookie) {
+                $this->setCookie(new SetCookie($cookie));
+            }
+        } elseif (strlen($data)) {
+            throw new \RuntimeException("Invalid cookie file: {$filename}");
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Cookie/SessionCookieJar.php

@@ -0,0 +1,66 @@
+<?php
+namespace GuzzleHttp\Cookie;
+
+use GuzzleHttp\Utils;
+
+/**
+ * Persists cookies in the client session
+ */
+class SessionCookieJar extends CookieJar
+{
+    /** @var string session key */
+    private $sessionKey;
+
+    /**
+     * Create a new SessionCookieJar object
+     *
+     * @param string $sessionKey Session key name to store the cookie data in session
+     */
+    public function __construct($sessionKey)
+    {
+        $this->sessionKey = $sessionKey;
+        $this->load();
+    }
+
+    /**
+     * Saves cookies to session when shutting down
+     */
+    public function __destruct()
+    {
+        $this->save();
+    }
+
+    /**
+     * Save cookies to the client session
+     */
+    public function save()
+    {
+        $json = [];
+        foreach ($this as $cookie) {
+            if ($cookie->getExpires() && !$cookie->getDiscard()) {
+                $json[] = $cookie->toArray();
+            }
+        }
+
+        $_SESSION[$this->sessionKey] = json_encode($json);
+    }
+
+    /**
+     * Load the contents of the client session into the data array
+     */
+    protected function load()
+    {
+        $cookieJar = isset($_SESSION[$this->sessionKey])
+            ? $_SESSION[$this->sessionKey]
+            : null;
+
+        $data = Utils::jsonDecode($cookieJar, true);
+        if (is_array($data)) {
+            foreach ($data as $cookie) {
+                $this->setCookie(new SetCookie($cookie));
+            }
+        } elseif (strlen($data)) {
+            throw new \RuntimeException("Invalid cookie data");
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Cookie/SetCookie.php

@@ -0,0 +1,373 @@
+<?php
+namespace GuzzleHttp\Cookie;
+
+use GuzzleHttp\ToArrayInterface;
+
+/**
+ * Set-Cookie object
+ */
+class SetCookie implements ToArrayInterface
+{
+    /** @var array */
+    private static $defaults = [
+        'Name'     => null,
+        'Value'    => null,
+        'Domain'   => null,
+        'Path'     => '/',
+        'Max-Age'  => null,
+        'Expires'  => null,
+        'Secure'   => false,
+        'Discard'  => false,
+        'HttpOnly' => false
+    ];
+
+    /** @var array Cookie data */
+    private $data;
+
+    /**
+     * Create a new SetCookie object from a string
+     *
+     * @param string $cookie Set-Cookie header string
+     *
+     * @return self
+     */
+    public static function fromString($cookie)
+    {
+        // Create the default return array
+        $data = self::$defaults;
+        // Explode the cookie string using a series of semicolons
+        $pieces = array_filter(array_map('trim', explode(';', $cookie)));
+        // The name of the cookie (first kvp) must include an equal sign.
+        if (empty($pieces) || !strpos($pieces[0], '=')) {
+            return new self($data);
+        }
+
+        // Add the cookie pieces into the parsed data array
+        foreach ($pieces as $part) {
+
+            $cookieParts = explode('=', $part, 2);
+            $key = trim($cookieParts[0]);
+            $value = isset($cookieParts[1])
+                ? trim($cookieParts[1], " \n\r\t\0\x0B\"")
+                : true;
+
+            // Only check for non-cookies when cookies have been found
+            if (empty($data['Name'])) {
+                $data['Name'] = $key;
+                $data['Value'] = $value;
+            } else {
+                foreach (array_keys(self::$defaults) as $search) {
+                    if (!strcasecmp($search, $key)) {
+                        $data[$search] = $value;
+                        continue 2;
+                    }
+                }
+                $data[$key] = $value;
+            }
+        }
+
+        return new self($data);
+    }
+
+    /**
+     * @param array $data Array of cookie data provided by a Cookie parser
+     */
+    public function __construct(array $data = [])
+    {
+        $this->data = array_replace(self::$defaults, $data);
+        // Extract the Expires value and turn it into a UNIX timestamp if needed
+        if (!$this->getExpires() && $this->getMaxAge()) {
+            // Calculate the Expires date
+            $this->setExpires(time() + $this->getMaxAge());
+        } elseif ($this->getExpires() && !is_numeric($this->getExpires())) {
+            $this->setExpires($this->getExpires());
+        }
+    }
+
+    public function __toString()
+    {
+        $str = $this->data['Name'] . '=' . $this->data['Value'] . '; ';
+        foreach ($this->data as $k => $v) {
+            if ($k != 'Name' && $k != 'Value' && $v !== null && $v !== false) {
+                if ($k == 'Expires') {
+                    $str .= 'Expires=' . gmdate('D, d M Y H:i:s \G\M\T', $v) . '; ';
+                } else {
+                    $str .= ($v === true ? $k : "{$k}={$v}") . '; ';
+                }
+            }
+        }
+
+        return rtrim($str, '; ');
+    }
+
+    public function toArray()
+    {
+        return $this->data;
+    }
+
+    /**
+     * Get the cookie name
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->data['Name'];
+    }
+
+    /**
+     * Set the cookie name
+     *
+     * @param string $name Cookie name
+     */
+    public function setName($name)
+    {
+        $this->data['Name'] = $name;
+    }
+
+    /**
+     * Get the cookie value
+     *
+     * @return string
+     */
+    public function getValue()
+    {
+        return $this->data['Value'];
+    }
+
+    /**
+     * Set the cookie value
+     *
+     * @param string $value Cookie value
+     */
+    public function setValue($value)
+    {
+        $this->data['Value'] = $value;
+    }
+
+    /**
+     * Get the domain
+     *
+     * @return string|null
+     */
+    public function getDomain()
+    {
+        return $this->data['Domain'];
+    }
+
+    /**
+     * Set the domain of the cookie
+     *
+     * @param string $domain
+     */
+    public function setDomain($domain)
+    {
+        $this->data['Domain'] = $domain;
+    }
+
+    /**
+     * Get the path
+     *
+     * @return string
+     */
+    public function getPath()
+    {
+        return $this->data['Path'];
+    }
+
+    /**
+     * Set the path of the cookie
+     *
+     * @param string $path Path of the cookie
+     */
+    public function setPath($path)
+    {
+        $this->data['Path'] = $path;
+    }
+
+    /**
+     * Maximum lifetime of the cookie in seconds
+     *
+     * @return int|null
+     */
+    public function getMaxAge()
+    {
+        return $this->data['Max-Age'];
+    }
+
+    /**
+     * Set the max-age of the cookie
+     *
+     * @param int $maxAge Max age of the cookie in seconds
+     */
+    public function setMaxAge($maxAge)
+    {
+        $this->data['Max-Age'] = $maxAge;
+    }
+
+    /**
+     * The UNIX timestamp when the cookie Expires
+     *
+     * @return mixed
+     */
+    public function getExpires()
+    {
+        return $this->data['Expires'];
+    }
+
+    /**
+     * Set the unix timestamp for which the cookie will expire
+     *
+     * @param int $timestamp Unix timestamp
+     */
+    public function setExpires($timestamp)
+    {
+        $this->data['Expires'] = is_numeric($timestamp)
+            ? (int) $timestamp
+            : strtotime($timestamp);
+    }
+
+    /**
+     * Get whether or not this is a secure cookie
+     *
+     * @return null|bool
+     */
+    public function getSecure()
+    {
+        return $this->data['Secure'];
+    }
+
+    /**
+     * Set whether or not the cookie is secure
+     *
+     * @param bool $secure Set to true or false if secure
+     */
+    public function setSecure($secure)
+    {
+        $this->data['Secure'] = $secure;
+    }
+
+    /**
+     * Get whether or not this is a session cookie
+     *
+     * @return null|bool
+     */
+    public function getDiscard()
+    {
+        return $this->data['Discard'];
+    }
+
+    /**
+     * Set whether or not this is a session cookie
+     *
+     * @param bool $discard Set to true or false if this is a session cookie
+     */
+    public function setDiscard($discard)
+    {
+        $this->data['Discard'] = $discard;
+    }
+
+    /**
+     * Get whether or not this is an HTTP only cookie
+     *
+     * @return bool
+     */
+    public function getHttpOnly()
+    {
+        return $this->data['HttpOnly'];
+    }
+
+    /**
+     * Set whether or not this is an HTTP only cookie
+     *
+     * @param bool $httpOnly Set to true or false if this is HTTP only
+     */
+    public function setHttpOnly($httpOnly)
+    {
+        $this->data['HttpOnly'] = $httpOnly;
+    }
+
+    /**
+     * Check if the cookie matches a path value
+     *
+     * @param string $path Path to check against
+     *
+     * @return bool
+     */
+    public function matchesPath($path)
+    {
+        return !$this->getPath() || 0 === stripos($path, $this->getPath());
+    }
+
+    /**
+     * Check if the cookie matches a domain value
+     *
+     * @param string $domain Domain to check against
+     *
+     * @return bool
+     */
+    public function matchesDomain($domain)
+    {
+        // Remove the leading '.' as per spec in RFC 6265.
+        // http://tools.ietf.org/html/rfc6265#section-5.2.3
+        $cookieDomain = ltrim($this->getDomain(), '.');
+
+        // Domain not set or exact match.
+        if (!$cookieDomain || !strcasecmp($domain, $cookieDomain)) {
+            return true;
+        }
+
+        // Matching the subdomain according to RFC 6265.
+        // http://tools.ietf.org/html/rfc6265#section-5.1.3
+        if (filter_var($domain, FILTER_VALIDATE_IP)) {
+            return false;
+        }
+
+        return (bool) preg_match('/\.' . preg_quote($cookieDomain) . '$/i', $domain);
+    }
+
+    /**
+     * Check if the cookie is expired
+     *
+     * @return bool
+     */
+    public function isExpired()
+    {
+        return $this->getExpires() && time() > $this->getExpires();
+    }
+
+    /**
+     * Check if the cookie is valid according to RFC 6265
+     *
+     * @return bool|string Returns true if valid or an error message if invalid
+     */
+    public function validate()
+    {
+        // Names must not be empty, but can be 0
+        $name = $this->getName();
+        if (empty($name) && !is_numeric($name)) {
+            return 'The cookie name must not be empty';
+        }
+
+        // Check if any of the invalid characters are present in the cookie name
+        if (preg_match("/[=,; \t\r\n\013\014]/", $name)) {
+            return "Cookie name must not cannot invalid characters: =,; \\t\\r\\n\\013\\014";
+        }
+
+        // Value must not be empty, but can be 0
+        $value = $this->getValue();
+        if (empty($value) && !is_numeric($value)) {
+            return 'The cookie value must not be empty';
+        }
+
+        // Domains must not be empty, but can be 0
+        // A "0" is not a valid internet domain, but may be used as server name
+        // in a private network.
+        $domain = $this->getDomain();
+        if (empty($domain) && !is_numeric($domain)) {
+            return 'The cookie domain must not be empty';
+        }
+
+        return true;
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/AbstractEvent.php

@@ -0,0 +1,20 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Basic event class that can be extended.
+ */
+abstract class AbstractEvent implements EventInterface
+{
+    private $propagationStopped = false;
+
+    public function isPropagationStopped()
+    {
+        return $this->propagationStopped;
+    }
+
+    public function stopPropagation()
+    {
+        $this->propagationStopped = true;
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/AbstractRequestEvent.php

@@ -0,0 +1,61 @@
+<?php
+namespace GuzzleHttp\Event;
+
+use GuzzleHttp\Transaction;
+use GuzzleHttp\ClientInterface;
+use GuzzleHttp\Message\RequestInterface;
+
+/**
+ * Base class for request events, providing a request and client getter.
+ */
+abstract class AbstractRequestEvent extends AbstractEvent
+{
+    /** @var Transaction */
+    protected $transaction;
+
+    /**
+     * @param Transaction $transaction
+     */
+    public function __construct(Transaction $transaction)
+    {
+        $this->transaction = $transaction;
+    }
+
+    /**
+     * Get the HTTP client associated with the event.
+     *
+     * @return ClientInterface
+     */
+    public function getClient()
+    {
+        return $this->transaction->client;
+    }
+
+    /**
+     * Get the request object
+     *
+     * @return RequestInterface
+     */
+    public function getRequest()
+    {
+        return $this->transaction->request;
+    }
+
+    /**
+     * Get the number of transaction retries.
+     *
+     * @return int
+     */
+    public function getRetryCount()
+    {
+        return $this->transaction->retries;
+    }
+
+    /**
+     * @return Transaction
+     */
+    public function getTransaction()
+    {
+        return $this->transaction;
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/AbstractRetryableEvent.php

@@ -0,0 +1,40 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Abstract request event that can be retried.
+ */
+class AbstractRetryableEvent extends AbstractTransferEvent
+{
+    /**
+     * Mark the request as needing a retry and stop event propagation.
+     *
+     * This action allows you to retry a request without emitting the "end"
+     * event multiple times for a given request. When retried, the request
+     * emits a before event and is then sent again using the client that sent
+     * the original request.
+     *
+     * When retrying, it is important to limit the number of retries you allow
+     * to prevent infinite loops.
+     *
+     * This action can only be taken during the "complete" and "error" events.
+     *
+     * @param int $afterDelay If specified, the amount of time in milliseconds
+     *                        to delay before retrying. Note that this must
+     *                        be supported by the underlying RingPHP handler
+     *                        to work properly. Set to 0 or provide no value
+     *                        to retry immediately.
+     */
+    public function retry($afterDelay = 0)
+    {
+        // Setting the transition state to 'retry' will cause the next state
+        // transition of the transaction to retry the request.
+        $this->transaction->state = 'retry';
+
+        if ($afterDelay) {
+            $this->transaction->request->getConfig()->set('delay', $afterDelay);
+        }
+
+        $this->stopPropagation();
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/AbstractTransferEvent.php

@@ -0,0 +1,63 @@
+<?php
+namespace GuzzleHttp\Event;
+
+use GuzzleHttp\Message\ResponseInterface;
+use GuzzleHttp\Ring\Future\FutureInterface;
+
+/**
+ * Event that contains transfer statistics, and can be intercepted.
+ */
+abstract class AbstractTransferEvent extends AbstractRequestEvent
+{
+    /**
+     * Get all transfer information as an associative array if no $name
+     * argument is supplied, or gets a specific transfer statistic if
+     * a $name attribute is supplied (e.g., 'total_time').
+     *
+     * @param string $name Name of the transfer stat to retrieve
+     *
+     * @return mixed|null|array
+     */
+    public function getTransferInfo($name = null)
+    {
+        if (!$name) {
+            return $this->transaction->transferInfo;
+        }
+
+        return isset($this->transaction->transferInfo[$name])
+            ? $this->transaction->transferInfo[$name]
+            : null;
+    }
+
+    /**
+     * Returns true/false if a response is available.
+     *
+     * @return bool
+     */
+    public function hasResponse()
+    {
+        return !($this->transaction->response instanceof FutureInterface);
+    }
+
+    /**
+     * Get the response.
+     *
+     * @return ResponseInterface|null
+     */
+    public function getResponse()
+    {
+        return $this->hasResponse() ? $this->transaction->response : null;
+    }
+
+    /**
+     * Intercept the request and associate a response
+     *
+     * @param ResponseInterface $response Response to set
+     */
+    public function intercept(ResponseInterface $response)
+    {
+        $this->transaction->response = $response;
+        $this->transaction->exception = null;
+        $this->stopPropagation();
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/BeforeEvent.php

@@ -0,0 +1,26 @@
+<?php
+namespace GuzzleHttp\Event;
+
+use GuzzleHttp\Message\ResponseInterface;
+
+/**
+ * Event object emitted before a request is sent.
+ *
+ * This event MAY be emitted multiple times (i.e., if a request is retried).
+ * You MAY change the Response associated with the request using the
+ * intercept() method of the event.
+ */
+class BeforeEvent extends AbstractRequestEvent
+{
+    /**
+     * Intercept the request and associate a response
+     *
+     * @param ResponseInterface $response Response to set
+     */
+    public function intercept(ResponseInterface $response)
+    {
+        $this->transaction->response = $response;
+        $this->transaction->exception = null;
+        $this->stopPropagation();
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/CompleteEvent.php

@@ -0,0 +1,14 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Event object emitted after a request has been completed.
+ *
+ * This event MAY be emitted multiple times for a single request. You MAY
+ * change the Response associated with the request using the intercept()
+ * method of the event.
+ *
+ * This event allows the request to be retried if necessary using the retry()
+ * method of the event.
+ */
+class CompleteEvent extends AbstractRetryableEvent {}

vendor/guzzlehttp/guzzle/src/Event/Emitter.php

@@ -0,0 +1,145 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Guzzle event emitter.
+ *
+ * Some of this class is based on the Symfony EventDispatcher component, which
+ * ships with the following license:
+ *
+ *     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.
+ *
+ * @link https://github.com/symfony/symfony/tree/master/src/Symfony/Component/EventDispatcher
+ */
+class Emitter implements EmitterInterface
+{
+    /** @var array */
+    private $listeners = [];
+
+    /** @var array */
+    private $sorted = [];
+
+    public function on($eventName, callable $listener, $priority = 0)
+    {
+        if ($priority === 'first') {
+            $priority = isset($this->listeners[$eventName])
+                ? max(array_keys($this->listeners[$eventName])) + 1
+                : 1;
+        } elseif ($priority === 'last') {
+            $priority = isset($this->listeners[$eventName])
+                ? min(array_keys($this->listeners[$eventName])) - 1
+                : -1;
+        }
+
+        $this->listeners[$eventName][$priority][] = $listener;
+        unset($this->sorted[$eventName]);
+    }
+
+    public function once($eventName, callable $listener, $priority = 0)
+    {
+        $onceListener = function (
+            EventInterface $event
+        ) use (&$onceListener, $eventName, $listener, $priority) {
+            $this->removeListener($eventName, $onceListener);
+            $listener($event, $eventName);
+        };
+
+        $this->on($eventName, $onceListener, $priority);
+    }
+
+    public function removeListener($eventName, callable $listener)
+    {
+        if (empty($this->listeners[$eventName])) {
+            return;
+        }
+
+        foreach ($this->listeners[$eventName] as $priority => $listeners) {
+            if (false !== ($key = array_search($listener, $listeners, true))) {
+                unset(
+                    $this->listeners[$eventName][$priority][$key],
+                    $this->sorted[$eventName]
+                );
+            }
+        }
+    }
+
+    public function listeners($eventName = null)
+    {
+        // Return all events in a sorted priority order
+        if ($eventName === null) {
+            foreach (array_keys($this->listeners) as $eventName) {
+                if (empty($this->sorted[$eventName])) {
+                    $this->listeners($eventName);
+                }
+            }
+            return $this->sorted;
+        }
+
+        // Return the listeners for a specific event, sorted in priority order
+        if (empty($this->sorted[$eventName])) {
+            $this->sorted[$eventName] = [];
+            if (isset($this->listeners[$eventName])) {
+                krsort($this->listeners[$eventName], SORT_NUMERIC);
+                foreach ($this->listeners[$eventName] as $listeners) {
+                    foreach ($listeners as $listener) {
+                        $this->sorted[$eventName][] = $listener;
+                    }
+                }
+            }
+        }
+
+        return $this->sorted[$eventName];
+    }
+
+    public function hasListeners($eventName)
+    {
+        return !empty($this->listeners[$eventName]);
+    }
+
+    public function emit($eventName, EventInterface $event)
+    {
+        if (isset($this->listeners[$eventName])) {
+            foreach ($this->listeners($eventName) as $listener) {
+                $listener($event, $eventName);
+                if ($event->isPropagationStopped()) {
+                    break;
+                }
+            }
+        }
+
+        return $event;
+    }
+
+    public function attach(SubscriberInterface $subscriber)
+    {
+        foreach ($subscriber->getEvents() as $eventName => $listeners) {
+            if (is_array($listeners[0])) {
+                foreach ($listeners as $listener) {
+                    $this->on(
+                        $eventName,
+                        [$subscriber, $listener[0]],
+                        isset($listener[1]) ? $listener[1] : 0
+                    );
+                }
+            } else {
+                $this->on(
+                    $eventName,
+                    [$subscriber, $listeners[0]],
+                    isset($listeners[1]) ? $listeners[1] : 0
+                );
+            }
+        }
+    }
+
+    public function detach(SubscriberInterface $subscriber)
+    {
+        foreach ($subscriber->getEvents() as $eventName => $listener) {
+            $this->removeListener($eventName, [$subscriber, $listener[0]]);
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/EmitterInterface.php

@@ -0,0 +1,96 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Guzzle event emitter.
+ */
+interface EmitterInterface
+{
+    /**
+     * Binds a listener to a specific event.
+     *
+     * @param string     $eventName Name of the event to bind to.
+     * @param callable   $listener  Listener to invoke when triggered.
+     * @param int|string $priority  The higher this value, the earlier an event
+     *     listener will be triggered in the chain (defaults to 0). You can
+     *     pass "first" or "last" to dynamically specify the event priority
+     *     based on the current event priorities associated with the given
+     *     event name in the emitter. Use "first" to set the priority to the
+     *     current highest priority plus one. Use "last" to set the priority to
+     *     the current lowest event priority minus one.
+     */
+    public function on($eventName, callable $listener, $priority = 0);
+
+    /**
+     * Binds a listener to a specific event. After the listener is triggered
+     * once, it is removed as a listener.
+     *
+     * @param string   $eventName Name of the event to bind to.
+     * @param callable $listener  Listener to invoke when triggered.
+     * @param int      $priority  The higher this value, the earlier an event
+     *     listener will be triggered in the chain (defaults to 0)
+     */
+    public function once($eventName, callable $listener, $priority = 0);
+
+    /**
+     * Removes an event listener from the specified event.
+     *
+     * @param string   $eventName The event to remove a listener from
+     * @param callable $listener  The listener to remove
+     */
+    public function removeListener($eventName, callable $listener);
+
+    /**
+     * Gets the listeners of a specific event or all listeners if no event is
+     * specified.
+     *
+     * @param string $eventName The name of the event. Pass null (the default)
+     *     to retrieve all listeners.
+     *
+     * @return array The event listeners for the specified event, or all event
+     *   listeners by event name. The format of the array when retrieving a
+     *   specific event list is an array of callables. The format of the array
+     *   when retrieving all listeners is an associative array of arrays of
+     *   callables.
+     */
+    public function listeners($eventName = null);
+
+    /**
+     * Checks if the emitter has listeners by the given name.
+     *
+     * @param string $eventName The name of the event to check.
+     *
+     * @return bool
+     */
+    public function hasListeners($eventName);
+
+    /**
+     * Emits an event to all registered listeners.
+     *
+     * Each event that is bound to the emitted eventName receives a
+     * EventInterface, the name of the event, and the event emitter.
+     *
+     * @param string         $eventName The name of the event to dispatch.
+     * @param EventInterface $event     The event to pass to the event handlers/listeners.
+     *
+     * @return EventInterface Returns the provided event object
+     */
+    public function emit($eventName, EventInterface $event);
+
+    /**
+     * Attaches an event subscriber.
+     *
+     * The subscriber is asked for all the events it is interested in and added
+     * as an event listener for each event.
+     *
+     * @param SubscriberInterface $subscriber Subscriber to attach.
+     */
+    public function attach(SubscriberInterface $subscriber);
+
+    /**
+     * Detaches an event subscriber.
+     *
+     * @param SubscriberInterface $subscriber Subscriber to detach.
+     */
+    public function detach(SubscriberInterface $subscriber);
+}

vendor/guzzlehttp/guzzle/src/Event/EndEvent.php

@@ -0,0 +1,28 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * A terminal event that is emitted when a request transaction has ended.
+ *
+ * This event is emitted for both successful responses and responses that
+ * encountered an exception. You need to check if an exception is present
+ * in your listener to know the difference.
+ *
+ * You MAY intercept the response associated with the event if needed, but keep
+ * in mind that the "complete" event will not be triggered as a result.
+ */
+class EndEvent extends AbstractTransferEvent
+{
+    /**
+     * Get the exception that was encountered (if any).
+     *
+     * This method should be used to check if the request was sent successfully
+     * or if it encountered errors.
+     *
+     * @return \Exception|null
+     */
+    public function getException()
+    {
+        return $this->transaction->exception;
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/ErrorEvent.php

@@ -0,0 +1,27 @@
+<?php
+namespace GuzzleHttp\Event;
+
+use GuzzleHttp\Exception\RequestException;
+
+/**
+ * Event emitted when an error occurs while sending a request.
+ *
+ * This event MAY be emitted multiple times. You MAY intercept the exception
+ * and inject a response into the event to rescue the request using the
+ * intercept() method of the event.
+ *
+ * This event allows the request to be retried using the "retry" method of the
+ * event.
+ */
+class ErrorEvent extends AbstractRetryableEvent
+{
+    /**
+     * Get the exception that was encountered
+     *
+     * @return RequestException
+     */
+    public function getException()
+    {
+        return $this->transaction->exception;
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/EventInterface.php

@@ -0,0 +1,23 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Base event interface used when dispatching events to listeners using an
+ * event emitter.
+ */
+interface EventInterface
+{
+    /**
+     * Returns whether or not stopPropagation was called on the event.
+     *
+     * @return bool
+     * @see Event::stopPropagation
+     */
+    public function isPropagationStopped();
+
+    /**
+     * Stops the propagation of the event, preventing subsequent listeners
+     * registered to the same event from being invoked.
+     */
+    public function stopPropagation();
+}

vendor/guzzlehttp/guzzle/src/Event/HasEmitterInterface.php

@@ -0,0 +1,15 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Holds an event emitter
+ */
+interface HasEmitterInterface
+{
+    /**
+     * Get the event emitter of the object
+     *
+     * @return EmitterInterface
+     */
+    public function getEmitter();
+}

vendor/guzzlehttp/guzzle/src/Event/HasEmitterTrait.php

@@ -0,0 +1,20 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Trait that implements the methods of HasEmitterInterface
+ */
+trait HasEmitterTrait
+{
+    /** @var EmitterInterface */
+    private $emitter;
+
+    public function getEmitter()
+    {
+        if (!$this->emitter) {
+            $this->emitter = new Emitter();
+        }
+
+        return $this->emitter;
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/ListenerAttacherTrait.php

@@ -0,0 +1,88 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Trait that provides methods for extract event listeners specified in an array
+ * and attaching them to an emitter owned by the object or one of its direct
+ * dependencies.
+ */
+trait ListenerAttacherTrait
+{
+    /**
+     * Attaches event listeners and properly sets their priorities and whether
+     * or not they are are only executed once.
+     *
+     * @param HasEmitterInterface $object    Object that has the event emitter.
+     * @param array               $listeners Array of hashes representing event
+     *                                       event listeners. Each item contains
+     *                                       "name", "fn", "priority", & "once".
+     */
+    private function attachListeners(HasEmitterInterface $object, array $listeners)
+    {
+        $emitter = $object->getEmitter();
+        foreach ($listeners as $el) {
+            if ($el['once']) {
+                $emitter->once($el['name'], $el['fn'], $el['priority']);
+            } else {
+                $emitter->on($el['name'], $el['fn'], $el['priority']);
+            }
+        }
+    }
+
+    /**
+     * Extracts the allowed events from the provided array, and ignores anything
+     * else in the array. The event listener must be specified as a callable or
+     * as an array of event listener data ("name", "fn", "priority", "once").
+     *
+     * @param array $source Array containing callables or hashes of data to be
+     *                      prepared as event listeners.
+     * @param array $events Names of events to look for in the provided $source
+     *                      array. Other keys are ignored.
+     * @return array
+     */
+    private function prepareListeners(array $source, array $events)
+    {
+        $listeners = [];
+        foreach ($events as $name) {
+            if (isset($source[$name])) {
+                $this->buildListener($name, $source[$name], $listeners);
+            }
+        }
+
+        return $listeners;
+    }
+
+    /**
+     * Creates a complete event listener definition from the provided array of
+     * listener data. Also works recursively if more than one listeners are
+     * contained in the provided array.
+     *
+     * @param string         $name      Name of the event the listener is for.
+     * @param array|callable $data      Event listener data to prepare.
+     * @param array          $listeners Array of listeners, passed by reference.
+     *
+     * @throws \InvalidArgumentException if the event data is malformed.
+     */
+    private function buildListener($name, $data, &$listeners)
+    {
+        static $defaults = ['priority' => 0, 'once' => false];
+
+        // If a callable is provided, normalize it to the array format.
+        if (is_callable($data)) {
+            $data = ['fn' => $data];
+        }
+
+        // Prepare the listener and add it to the array, recursively.
+        if (isset($data['fn'])) {
+            $data['name'] = $name;
+            $listeners[] = $data + $defaults;
+        } elseif (is_array($data)) {
+            foreach ($data as $listenerData) {
+                $this->buildListener($name, $listenerData, $listeners);
+            }
+        } else {
+            throw new \InvalidArgumentException('Each event listener must be a '
+                . 'callable or an associative array containing a "fn" key.');
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/ProgressEvent.php

@@ -0,0 +1,51 @@
+<?php
+namespace GuzzleHttp\Event;
+
+use GuzzleHttp\Transaction;
+
+/**
+ * Event object emitted when upload or download progress is made.
+ *
+ * You can access the progress values using their corresponding public
+ * properties:
+ *
+ * - $downloadSize: The number of bytes that will be downloaded (if known)
+ * - $downloaded: The number of bytes that have been downloaded
+ * - $uploadSize: The number of bytes that will be uploaded (if known)
+ * - $uploaded: The number of bytes that have been uploaded
+ */
+class ProgressEvent extends AbstractRequestEvent
+{
+    /** @var int Amount of data to be downloaded */
+    public $downloadSize;
+
+    /** @var int Amount of data that has been downloaded */
+    public $downloaded;
+
+    /** @var int Amount of data to upload */
+    public $uploadSize;
+
+    /** @var int Amount of data that has been uploaded */
+    public $uploaded;
+
+    /**
+     * @param Transaction $transaction  Transaction being sent.
+     * @param int         $downloadSize Amount of data to download (if known)
+     * @param int         $downloaded   Amount of data that has been downloaded
+     * @param int         $uploadSize   Amount of data to upload (if known)
+     * @param int         $uploaded     Amount of data that had been uploaded
+     */
+    public function __construct(
+        Transaction $transaction,
+        $downloadSize,
+        $downloaded,
+        $uploadSize,
+        $uploaded
+    ) {
+        parent::__construct($transaction);
+        $this->downloadSize = $downloadSize;
+        $this->downloaded = $downloaded;
+        $this->uploadSize = $uploadSize;
+        $this->uploaded = $uploaded;
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/RequestEvents.php

@@ -0,0 +1,56 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * Contains methods used to manage the request event lifecycle.
+ */
+final class RequestEvents
+{
+    // Generic event priorities
+    const EARLY = 10000;
+    const LATE = -10000;
+
+    // "before" priorities
+    const PREPARE_REQUEST = -100;
+    const SIGN_REQUEST = -10000;
+
+    // "complete" and "error" response priorities
+    const VERIFY_RESPONSE = 100;
+    const REDIRECT_RESPONSE = 200;
+
+    /**
+     * Converts an array of event options into a formatted array of valid event
+     * configuration.
+     *
+     * @param array $options Event array to convert
+     * @param array $events  Event names to convert in the options array.
+     * @param mixed $handler Event handler to utilize
+     *
+     * @return array
+     * @throws \InvalidArgumentException if the event config is invalid
+     * @internal
+     */
+    public static function convertEventArray(
+        array $options,
+        array $events,
+        $handler
+    ) {
+        foreach ($events as $name) {
+            if (!isset($options[$name])) {
+                $options[$name] = [$handler];
+            } elseif (is_callable($options[$name])) {
+                $options[$name] = [$options[$name], $handler];
+            } elseif (is_array($options[$name])) {
+                if (isset($options[$name]['fn'])) {
+                    $options[$name] = [$options[$name], $handler];
+                } else {
+                    $options[$name][] = $handler;
+                }
+            } else {
+                throw new \InvalidArgumentException('Invalid event format');
+            }
+        }
+
+        return $options;
+    }
+}

vendor/guzzlehttp/guzzle/src/Event/SubscriberInterface.php

@@ -0,0 +1,34 @@
+<?php
+namespace GuzzleHttp\Event;
+
+/**
+ * SubscriberInterface provides an array of events to an
+ * EventEmitterInterface when it is registered. The emitter then binds the
+ * listeners specified by the EventSubscriber.
+ *
+ * This interface is based on the SubscriberInterface of the Symfony.
+ * @link https://github.com/symfony/symfony/tree/master/src/Symfony/Component/EventDispatcher
+ */
+interface SubscriberInterface
+{
+    /**
+     * Returns an array of event names this subscriber wants to listen to.
+     *
+     * The returned array keys MUST map to an event name. Each array value
+     * MUST be an array in which the first element is the name of a function
+     * on the EventSubscriber OR an array of arrays in the aforementioned
+     * format. The second element in the array is optional, and if specified,
+     * designates the event priority.
+     *
+     * For example, the following are all valid:
+     *
+     *  - ['eventName' => ['methodName']]
+     *  - ['eventName' => ['methodName', $priority]]
+     *  - ['eventName' => [['methodName'], ['otherMethod']]
+     *  - ['eventName' => [['methodName'], ['otherMethod', $priority]]
+     *  - ['eventName' => [['methodName', $priority], ['otherMethod', $priority]]
+     *
+     * @return array
+     */
+    public function getEvents();
+}

vendor/guzzlehttp/guzzle/src/Exception/BadResponseException.php

@@ -0,0 +1,7 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+/**
+ * Exception when an HTTP error occurs (4xx or 5xx error)
+ */
+class BadResponseException extends RequestException {}

vendor/guzzlehttp/guzzle/src/Exception/ClientException.php

@@ -0,0 +1,7 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+/**
+ * Exception when a client error is encountered (4xx codes)
+ */
+class ClientException extends BadResponseException {}

vendor/guzzlehttp/guzzle/src/Exception/ConnectException.php

@@ -0,0 +1,4 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+class ConnectException extends RequestException {}

vendor/guzzlehttp/guzzle/src/Exception/CouldNotRewindStreamException.php

@@ -0,0 +1,4 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+class CouldNotRewindStreamException extends RequestException {}

vendor/guzzlehttp/guzzle/src/Exception/ParseException.php

@@ -0,0 +1,31 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+use GuzzleHttp\Message\ResponseInterface;
+
+/**
+ * Exception when a client is unable to parse the response body as XML or JSON
+ */
+class ParseException extends TransferException
+{
+    /** @var ResponseInterface */
+    private $response;
+
+    public function __construct(
+        $message = '',
+        ResponseInterface $response = null,
+        \Exception $previous = null
+    ) {
+        parent::__construct($message, 0, $previous);
+        $this->response = $response;
+    }
+    /**
+     * Get the associated response
+     *
+     * @return ResponseInterface|null
+     */
+    public function getResponse()
+    {
+        return $this->response;
+    }
+}

vendor/guzzlehttp/guzzle/src/Exception/RequestException.php

@@ -0,0 +1,121 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+use GuzzleHttp\Message\RequestInterface;
+use GuzzleHttp\Message\ResponseInterface;
+use GuzzleHttp\Ring\Exception\ConnectException;
+use GuzzleHttp\Exception\ConnectException as HttpConnectException;
+use GuzzleHttp\Ring\Future\FutureInterface;
+
+/**
+ * HTTP Request exception
+ */
+class RequestException extends TransferException
+{
+    /** @var RequestInterface */
+    private $request;
+
+    /** @var ResponseInterface */
+    private $response;
+
+    public function __construct(
+        $message,
+        RequestInterface $request,
+        ResponseInterface $response = null,
+        \Exception $previous = null
+    ) {
+        // Set the code of the exception if the response is set and not future.
+        $code = $response && !($response instanceof FutureInterface)
+            ? $response->getStatusCode()
+            : 0;
+        parent::__construct($message, $code, $previous);
+        $this->request = $request;
+        $this->response = $response;
+    }
+
+    /**
+     * Wrap non-RequestExceptions with a RequestException
+     *
+     * @param RequestInterface $request
+     * @param \Exception       $e
+     *
+     * @return RequestException
+     */
+    public static function wrapException(RequestInterface $request, \Exception $e)
+    {
+        if ($e instanceof RequestException) {
+            return $e;
+        } elseif ($e instanceof ConnectException) {
+            return new HttpConnectException($e->getMessage(), $request, null, $e);
+        } else {
+            return new RequestException($e->getMessage(), $request, null, $e);
+        }
+    }
+
+    /**
+     * Factory method to create a new exception with a normalized error message
+     *
+     * @param RequestInterface  $request  Request
+     * @param ResponseInterface $response Response received
+     * @param \Exception        $previous Previous exception
+     *
+     * @return self
+     */
+    public static function create(
+        RequestInterface $request,
+        ResponseInterface $response = null,
+        \Exception $previous = null
+    ) {
+        if (!$response) {
+            return new self('Error completing request', $request, null, $previous);
+        }
+
+        $level = floor($response->getStatusCode() / 100);
+        if ($level == '4') {
+            $label = 'Client error response';
+            $className = __NAMESPACE__ . '\\ClientException';
+        } elseif ($level == '5') {
+            $label = 'Server error response';
+            $className = __NAMESPACE__ . '\\ServerException';
+        } else {
+            $label = 'Unsuccessful response';
+            $className = __CLASS__;
+        }
+
+        $message = $label . ' [url] ' . $request->getUrl()
+            . ' [status code] ' . $response->getStatusCode()
+            . ' [reason phrase] ' . $response->getReasonPhrase();
+
+        return new $className($message, $request, $response, $previous);
+    }
+
+    /**
+     * Get the request that caused the exception
+     *
+     * @return RequestInterface
+     */
+    public function getRequest()
+    {
+        return $this->request;
+    }
+
+    /**
+     * Get the associated response
+     *
+     * @return ResponseInterface|null
+     */
+    public function getResponse()
+    {
+        return $this->response;
+    }
+
+    /**
+     * Check if a response was received
+     *
+     * @return bool
+     */
+    public function hasResponse()
+    {
+        return $this->response !== null;
+    }
+}

vendor/guzzlehttp/guzzle/src/Exception/ServerException.php

@@ -0,0 +1,7 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+/**
+ * Exception when a server error is encountered (5xx codes)
+ */
+class ServerException extends BadResponseException {}

vendor/guzzlehttp/guzzle/src/Exception/StateException.php

@@ -0,0 +1,4 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+class StateException extends TransferException {};

vendor/guzzlehttp/guzzle/src/Exception/TooManyRedirectsException.php

@@ -0,0 +1,4 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+class TooManyRedirectsException extends RequestException {}

vendor/guzzlehttp/guzzle/src/Exception/TransferException.php

@@ -0,0 +1,4 @@
+<?php
+namespace GuzzleHttp\Exception;
+
+class TransferException extends \RuntimeException {}

vendor/guzzlehttp/guzzle/src/Exception/XmlParseException.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace GuzzleHttp\Exception;
+
+use GuzzleHttp\Message\ResponseInterface;
+
+/**
+ * Exception when a client is unable to parse the response body as XML
+ */
+class XmlParseException extends ParseException
+{
+    /** @var \LibXMLError */
+    protected $error;
+
+    public function __construct(
+        $message = '',
+        ResponseInterface $response = null,
+        \Exception $previous = null,
+        \LibXMLError $error = null
+    ) {
+        parent::__construct($message, $response, $previous);
+        $this->error = $error;
+    }
+
+    /**
+     * Get the associated error
+     *
+     * @return \LibXMLError|null
+     */
+    public function getError()
+    {
+        return $this->error;
+    }
+}

vendor/guzzlehttp/guzzle/src/HasDataTrait.php

@@ -0,0 +1,75 @@
+<?php
+namespace GuzzleHttp;
+
+/**
+ * Trait implementing ToArrayInterface, \ArrayAccess, \Countable,
+ * \IteratorAggregate, and some path style methods.
+ */
+trait HasDataTrait
+{
+    /** @var array */
+    protected $data = [];
+
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->data);
+    }
+
+    public function offsetGet($offset)
+    {
+        return isset($this->data[$offset]) ? $this->data[$offset] : null;
+    }
+
+    public function offsetSet($offset, $value)
+    {
+        $this->data[$offset] = $value;
+    }
+
+    public function offsetExists($offset)
+    {
+        return isset($this->data[$offset]);
+    }
+
+    public function offsetUnset($offset)
+    {
+        unset($this->data[$offset]);
+    }
+
+    public function toArray()
+    {
+        return $this->data;
+    }
+
+    public function count()
+    {
+        return count($this->data);
+    }
+
+    /**
+     * Get a value from the collection using a path syntax to retrieve nested
+     * data.
+     *
+     * @param string $path Path to traverse and retrieve a value from
+     *
+     * @return mixed|null
+     */
+    public function getPath($path)
+    {
+        return Utils::getPath($this->data, $path);
+    }
+
+    /**
+     * Set a value into a nested array key. Keys will be created as needed to
+     * set the value.
+     *
+     * @param string $path  Path to set
+     * @param mixed  $value Value to set at the key
+     *
+     * @throws \RuntimeException when trying to setPath using a nested path
+     *     that travels through a scalar value
+     */
+    public function setPath($path, $value)
+    {
+        Utils::setPath($this->data, $path, $value);
+    }
+}

vendor/guzzlehttp/guzzle/src/Message/AbstractMessage.php

@@ -0,0 +1,253 @@
+<?php
+namespace GuzzleHttp\Message;
+
+use GuzzleHttp\Stream\StreamInterface;
+
+abstract class AbstractMessage implements MessageInterface
+{
+    /** @var array HTTP header collection */
+    private $headers = [];
+
+    /** @var array mapping a lowercase header name to its name over the wire */
+    private $headerNames = [];
+
+    /** @var StreamInterface Message body */
+    private $body;
+
+    /** @var string HTTP protocol version of the message */
+    private $protocolVersion = '1.1';
+
+    public function __toString()
+    {
+        return static::getStartLineAndHeaders($this)
+            . "\r\n\r\n" . $this->getBody();
+    }
+
+    public function getProtocolVersion()
+    {
+        return $this->protocolVersion;
+    }
+
+    public function getBody()
+    {
+        return $this->body;
+    }
+
+    public function setBody(StreamInterface $body = null)
+    {
+        if ($body === null) {
+            // Setting a null body will remove the body of the request
+            $this->removeHeader('Content-Length');
+            $this->removeHeader('Transfer-Encoding');
+        }
+
+        $this->body = $body;
+    }
+
+    public function addHeader($header, $value)
+    {
+        if (is_array($value)) {
+            $current = array_merge($this->getHeaderAsArray($header), $value);
+        } else {
+            $current = $this->getHeaderAsArray($header);
+            $current[] = (string) $value;
+        }
+
+        $this->setHeader($header, $current);
+    }
+
+    public function addHeaders(array $headers)
+    {
+        foreach ($headers as $name => $header) {
+            $this->addHeader($name, $header);
+        }
+    }
+
+    public function getHeader($header)
+    {
+        $name = strtolower($header);
+        return isset($this->headers[$name])
+            ? implode(', ', $this->headers[$name])
+            : '';
+    }
+
+    public function getHeaderAsArray($header)
+    {
+        $name = strtolower($header);
+        return isset($this->headers[$name]) ? $this->headers[$name] : [];
+    }
+
+    public function getHeaders()
+    {
+        $headers = [];
+        foreach ($this->headers as $name => $values) {
+            $headers[$this->headerNames[$name]] = $values;
+        }
+
+        return $headers;
+    }
+
+    public function setHeader($header, $value)
+    {
+        $header = trim($header);
+        $name = strtolower($header);
+        $this->headerNames[$name] = $header;
+
+        if (is_array($value)) {
+            foreach ($value as &$v) {
+                $v = trim($v);
+            }
+            $this->headers[$name] = $value;
+        } else {
+            $this->headers[$name] = [trim($value)];
+        }
+    }
+
+    public function setHeaders(array $headers)
+    {
+        $this->headers = $this->headerNames = [];
+        foreach ($headers as $key => $value) {
+            $this->addHeader($key, $value);
+        }
+    }
+
+    public function hasHeader($header)
+    {
+        return isset($this->headers[strtolower($header)]);
+    }
+
+    public function removeHeader($header)
+    {
+        $name = strtolower($header);
+        unset($this->headers[$name], $this->headerNames[$name]);
+    }
+
+    /**
+     * Parse an array of header values containing ";" separated data into an
+     * array of associative arrays representing the header key value pair
+     * data of the header. When a parameter does not contain a value, but just
+     * contains a key, this function will inject a key with a '' string value.
+     *
+     * @param MessageInterface $message That contains the header
+     * @param string           $header  Header to retrieve from the message
+     *
+     * @return array Returns the parsed header values.
+     */
+    public static function parseHeader(MessageInterface $message, $header)
+    {
+        static $trimmed = "\"'  \n\t\r";
+        $params = $matches = [];
+
+        foreach (self::normalizeHeader($message, $header) as $val) {
+            $part = [];
+            foreach (preg_split('/;(?=([^"]*"[^"]*")*[^"]*$)/', $val) as $kvp) {
+                if (preg_match_all('/<[^>]+>|[^=]+/', $kvp, $matches)) {
+                    $m = $matches[0];
+                    if (isset($m[1])) {
+                        $part[trim($m[0], $trimmed)] = trim($m[1], $trimmed);
+                    } else {
+                        $part[] = trim($m[0], $trimmed);
+                    }
+                }
+            }
+            if ($part) {
+                $params[] = $part;
+            }
+        }
+
+        return $params;
+    }
+
+    /**
+     * Converts an array of header values that may contain comma separated
+     * headers into an array of headers with no comma separated values.
+     *
+     * @param MessageInterface $message That contains the header
+     * @param string              $header  Header to retrieve from the message
+     *
+     * @return array Returns the normalized header field values.
+     */
+    public static function normalizeHeader(MessageInterface $message, $header)
+    {
+        $h = $message->getHeaderAsArray($header);
+        for ($i = 0, $total = count($h); $i < $total; $i++) {
+            if (strpos($h[$i], ',') === false) {
+                continue;
+            }
+            foreach (preg_split('/,(?=([^"]*"[^"]*")*[^"]*$)/', $h[$i]) as $v) {
+                $h[] = trim($v);
+            }
+            unset($h[$i]);
+        }
+
+        return $h;
+    }
+
+    /**
+     * Gets the start-line and headers of a message as a string
+     *
+     * @param MessageInterface $message
+     *
+     * @return string
+     */
+    public static function getStartLineAndHeaders(MessageInterface $message)
+    {
+        return static::getStartLine($message)
+            . self::getHeadersAsString($message);
+    }
+
+    /**
+     * Gets the headers of a message as a string
+     *
+     * @param MessageInterface $message
+     *
+     * @return string
+     */
+    public static function getHeadersAsString(MessageInterface $message)
+    {
+        $result  = '';
+        foreach ($message->getHeaders() as $name => $values) {
+            $result .= "\r\n{$name}: " . implode(', ', $values);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Gets the start line of a message
+     *
+     * @param MessageInterface $message
+     *
+     * @return string
+     * @throws \InvalidArgumentException
+     */
+    public static function getStartLine(MessageInterface $message)
+    {
+        if ($message instanceof RequestInterface) {
+            return trim($message->getMethod() . ' '
+                . $message->getResource())
+                . ' HTTP/' . $message->getProtocolVersion();
+        } elseif ($message instanceof ResponseInterface) {
+            return 'HTTP/' . $message->getProtocolVersion() . ' '
+                . $message->getStatusCode() . ' '
+                . $message->getReasonPhrase();
+        } else {
+            throw new \InvalidArgumentException('Unknown message type');
+        }
+    }
+
+    /**
+     * Accepts and modifies the options provided to the message in the
+     * constructor.
+     *
+     * Can be overridden in subclasses as necessary.
+     *
+     * @param array $options Options array passed by reference.
+     */
+    protected function handleOptions(array &$options)
+    {
+        if (isset($options['protocol_version'])) {
+            $this->protocolVersion = $options['protocol_version'];
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Message/AppliesHeadersInterface.php

@@ -0,0 +1,24 @@
+<?php
+namespace GuzzleHttp\Message;
+
+/**
+ * Applies headers to a request.
+ *
+ * This interface can be used with Guzzle streams to apply body specific
+ * headers to a request during the PREPARE_REQUEST priority of the before event
+ *
+ * NOTE: a body that implements this interface will prevent a default
+ * content-type from being added to a request during the before event. If you
+ * want a default content-type to be added, then it will need to be done
+ * manually (e.g., using {@see GuzzleHttp\Mimetypes}).
+ */
+interface AppliesHeadersInterface
+{
+    /**
+     * Apply headers to a request appropriate for the current state of the
+     * object.
+     *
+     * @param RequestInterface $request Request
+     */
+    public function applyRequestHeaders(RequestInterface $request);
+}

vendor/guzzlehttp/guzzle/src/Message/FutureResponse.php

@@ -0,0 +1,158 @@
+<?php
+namespace GuzzleHttp\Message;
+
+use GuzzleHttp\Ring\Future\MagicFutureTrait;
+use GuzzleHttp\Ring\Future\FutureInterface;
+use GuzzleHttp\Stream\StreamInterface;
+
+/**
+ * Represents a response that has not been fulfilled.
+ *
+ * When created, you must provide a function that is used to dereference the
+ * future result and return it's value. The function has no arguments and MUST
+ * return an instance of a {@see GuzzleHttp\Message\ResponseInterface} object.
+ *
+ * You can optionally provide a function in the constructor that can be used to
+ * cancel the future from completing if possible. This function has no
+ * arguments and returns a boolean value representing whether or not the
+ * response could be cancelled.
+ *
+ * @property ResponseInterface $_value
+ */
+class FutureResponse implements ResponseInterface, FutureInterface
+{
+    use MagicFutureTrait;
+
+    /**
+     * Returns a FutureResponse that wraps another future.
+     *
+     * @param FutureInterface $future      Future to wrap with a new future
+     * @param callable        $onFulfilled Invoked when the future fulfilled
+     * @param callable        $onRejected  Invoked when the future rejected
+     * @param callable        $onProgress  Invoked when the future progresses
+     *
+     * @return FutureResponse
+     */
+    public static function proxy(
+        FutureInterface $future,
+        callable $onFulfilled = null,
+        callable $onRejected = null,
+        callable $onProgress = null
+    ) {
+        return new FutureResponse(
+            $future->then($onFulfilled, $onRejected, $onProgress),
+            [$future, 'wait'],
+            [$future, 'cancel']
+        );
+    }
+
+    public function getStatusCode()
+    {
+        return $this->_value->getStatusCode();
+    }
+
+    public function setStatusCode($code)
+    {
+        $this->_value->setStatusCode($code);
+    }
+
+    public function getReasonPhrase()
+    {
+        return $this->_value->getReasonPhrase();
+    }
+
+    public function setReasonPhrase($phrase)
+    {
+        $this->_value->setReasonPhrase($phrase);
+    }
+
+    public function getEffectiveUrl()
+    {
+        return $this->_value->getEffectiveUrl();
+    }
+
+    public function setEffectiveUrl($url)
+    {
+        $this->_value->setEffectiveUrl($url);
+    }
+
+    public function json(array $config = [])
+    {
+        return $this->_value->json($config);
+    }
+
+    public function xml(array $config = [])
+    {
+        return $this->_value->xml($config);
+    }
+
+    public function __toString()
+    {
+        try {
+            return $this->_value->__toString();
+        } catch (\Exception $e) {
+            trigger_error($e->getMessage(), E_USER_WARNING);
+            return '';
+        }
+    }
+
+    public function getProtocolVersion()
+    {
+        return $this->_value->getProtocolVersion();
+    }
+
+    public function setBody(StreamInterface $body = null)
+    {
+        $this->_value->setBody($body);
+    }
+
+    public function getBody()
+    {
+        return $this->_value->getBody();
+    }
+
+    public function getHeaders()
+    {
+        return $this->_value->getHeaders();
+    }
+
+    public function getHeader($header)
+    {
+        return $this->_value->getHeader($header);
+    }
+
+    public function getHeaderAsArray($header)
+    {
+        return $this->_value->getHeaderAsArray($header);
+    }
+
+    public function hasHeader($header)
+    {
+        return $this->_value->hasHeader($header);
+    }
+
+    public function removeHeader($header)
+    {
+        $this->_value->removeHeader($header);
+    }
+
+    public function addHeader($header, $value)
+    {
+        $this->_value->addHeader($header, $value);
+    }
+
+    public function addHeaders(array $headers)
+    {
+        $this->_value->addHeaders($headers);
+    }
+
+    public function setHeader($header, $value)
+    {
+        $this->_value->setHeader($header, $value);
+    }
+
+    public function setHeaders(array $headers)
+    {
+        $this->_value->setHeaders($headers);
+    }
+}

vendor/guzzlehttp/guzzle/src/Message/MessageFactory.php

@@ -0,0 +1,364 @@
+<?php
+namespace GuzzleHttp\Message;
+
+use GuzzleHttp\Cookie\CookieJar;
+use GuzzleHttp\Cookie\CookieJarInterface;
+use GuzzleHttp\Event\ListenerAttacherTrait;
+use GuzzleHttp\Post\PostBody;
+use GuzzleHttp\Post\PostFile;
+use GuzzleHttp\Post\PostFileInterface;
+use GuzzleHttp\Query;
+use GuzzleHttp\Stream\Stream;
+use GuzzleHttp\Subscriber\Cookie;
+use GuzzleHttp\Subscriber\HttpError;
+use GuzzleHttp\Subscriber\Redirect;
+use GuzzleHttp\Url;
+use \InvalidArgumentException as Iae;
+
+/**
+ * Default HTTP request factory used to create Request and Response objects.
+ */
+class MessageFactory implements MessageFactoryInterface
+{
+    use ListenerAttacherTrait;
+
+    /** @var HttpError */
+    private $errorPlugin;
+
+    /** @var Redirect */
+    private $redirectPlugin;
+
+    /** @var array */
+    private $customOptions;
+
+    /** @var array Request options passed through to request Config object */
+    private static $configMap = [
+        'connect_timeout' => 1, 'timeout' => 1, 'verify' => 1, 'ssl_key' => 1,
+        'cert' => 1, 'proxy' => 1, 'debug' => 1, 'save_to' => 1, 'stream' => 1,
+        'expect' => 1, 'future' => 1
+    ];
+
+    /** @var array Default allow_redirects request option settings  */
+    private static $defaultRedirect = [
+        'max'       => 5,
+        'strict'    => false,
+        'referer'   => false,
+        'protocols' => ['http', 'https']
+    ];
+
+    /**
+     * @param array $customOptions Associative array of custom request option
+     *                             names mapping to functions used to apply
+     *                             the option. The function accepts the request
+     *                             and the option value to apply.
+     */
+    public function __construct(array $customOptions = [])
+    {
+        $this->errorPlugin = new HttpError();
+        $this->redirectPlugin = new Redirect();
+        $this->customOptions = $customOptions;
+    }
+
+    public function createResponse(
+        $statusCode,
+        array $headers = [],
+        $body = null,
+        array $options = []
+    ) {
+        if (null !== $body) {
+            $body = Stream::factory($body);
+        }
+
+        return new Response($statusCode, $headers, $body, $options);
+    }
+
+    public function createRequest($method, $url, array $options = [])
+    {
+        // Handle the request protocol version option that needs to be
+        // specified in the request constructor.
+        if (isset($options['version'])) {
+            $options['config']['protocol_version'] = $options['version'];
+            unset($options['version']);
+        }
+
+        $request = new Request($method, $url, [], null,
+            isset($options['config']) ? $options['config'] : []);
+
+        unset($options['config']);
+
+        // Use a POST body by default
+        if (strtoupper($method) == 'POST'
+            && !isset($options['body'])
+            && !isset($options['json'])
+        ) {
+            $options['body'] = [];
+        }
+
+        if ($options) {
+            $this->applyOptions($request, $options);
+        }
+
+        return $request;
+    }
+
+    /**
+     * Create a request or response object from an HTTP message string
+     *
+     * @param string $message Message to parse
+     *
+     * @return RequestInterface|ResponseInterface
+     * @throws \InvalidArgumentException if unable to parse a message
+     */
+    public function fromMessage($message)
+    {
+        static $parser;
+        if (!$parser) {
+            $parser = new MessageParser();
+        }
+
+        // Parse a response
+        if (strtoupper(substr($message, 0, 4)) == 'HTTP') {
+            $data = $parser->parseResponse($message);
+            return $this->createResponse(
+                $data['code'],
+                $data['headers'],
+                $data['body'] === '' ? null : $data['body'],
+                $data
+            );
+        }
+
+        // Parse a request
+        if (!($data = ($parser->parseRequest($message)))) {
+            throw new \InvalidArgumentException('Unable to parse request');
+        }
+
+        return $this->createRequest(
+            $data['method'],
+            Url::buildUrl($data['request_url']),
+            [
+                'headers' => $data['headers'],
+                'body' => $data['body'] === '' ? null : $data['body'],
+                'config' => [
+                    'protocol_version' => $data['protocol_version']
+                ]
+            ]
+        );
+    }
+
+    /**
+     * Apply POST fields and files to a request to attempt to give an accurate
+     * representation.
+     *
+     * @param RequestInterface $request Request to update
+     * @param array            $body    Body to apply
+     */
+    protected function addPostData(RequestInterface $request, array $body)
+    {
+        static $fields = ['string' => true, 'array' => true, 'NULL' => true,
+            'boolean' => true, 'double' => true, 'integer' => true];
+
+        $post = new PostBody();
+        foreach ($body as $key => $value) {
+            if (isset($fields[gettype($value)])) {
+                $post->setField($key, $value);
+            } elseif ($value instanceof PostFileInterface) {
+                $post->addFile($value);
+            } else {
+                $post->addFile(new PostFile($key, $value));
+            }
+        }
+
+        if ($request->getHeader('Content-Type') == 'multipart/form-data') {
+            $post->forceMultipartUpload(true);
+        }
+
+        $request->setBody($post);
+    }
+
+    protected function applyOptions(
+        RequestInterface $request,
+        array $options = []
+    ) {
+        $config = $request->getConfig();
+        $emitter = $request->getEmitter();
+
+        foreach ($options as $key => $value) {
+
+            if (isset(self::$configMap[$key])) {
+                $config[$key] = $value;
+                continue;
+            }
+
+            switch ($key) {
+
+            case 'allow_redirects':
+
+                if ($value === false) {
+                    continue;
+                }
+
+                if ($value === true) {
+                    $value = self::$defaultRedirect;
+                } elseif (!is_array($value)) {
+                    throw new Iae('allow_redirects must be true, false, or array');
+                } else {
+                    // Merge the default settings with the provided settings
+                    $value += self::$defaultRedirect;
+                }
+
+                $config['redirect'] = $value;
+                $emitter->attach($this->redirectPlugin);
+                break;
+
+            case 'decode_content':
+
+                if ($value === false) {
+                    continue;
+                }
+
+                $config['decode_content'] = true;
+                if ($value !== true) {
+                    $request->setHeader('Accept-Encoding', $value);
+                }
+                break;
+
+            case 'headers':
+
+                if (!is_array($value)) {
+                    throw new Iae('header value must be an array');
+                }
+                foreach ($value as $k => $v) {
+                    $request->setHeader($k, $v);
+                }
+                break;
+
+            case 'exceptions':
+
+                if ($value === true) {
+                    $emitter->attach($this->errorPlugin);
+                }
+                break;
+
+            case 'body':
+
+                if (is_array($value)) {
+                    $this->addPostData($request, $value);
+                } elseif ($value !== null) {
+                    $request->setBody(Stream::factory($value));
+                }
+                break;
+
+            case 'auth':
+
+                if (!$value) {
+                    continue;
+                }
+
+                if (is_array($value)) {
+                    $type = isset($value[2]) ? strtolower($value[2]) : 'basic';
+                } else {
+                    $type = strtolower($value);
+                }
+
+                $config['auth'] = $value;
+
+                if ($type == 'basic') {
+                    $request->setHeader(
+                        'Authorization',
+                        'Basic ' . base64_encode("$value[0]:$value[1]")
+                    );
+                } elseif ($type == 'digest') {
+                    // @todo: Do not rely on curl
+                    $config->setPath('curl/' . CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
+                    $config->setPath('curl/' . CURLOPT_USERPWD, "$value[0]:$value[1]");
+                }
+                break;
+
+            case 'query':
+
+                if ($value instanceof Query) {
+                    $original = $request->getQuery();
+                    // Do not overwrite existing query string variables by
+                    // overwriting the object with the query string data passed
+                    // in the URL
+                    $value->overwriteWith($original->toArray());
+                    $request->setQuery($value);
+                } elseif (is_array($value)) {
+                    // Do not overwrite existing query string variables
+                    $query = $request->getQuery();
+                    foreach ($value as $k => $v) {
+                        if (!isset($query[$k])) {
+                            $query[$k] = $v;
+                        }
+                    }
+                } else {
+                    throw new Iae('query must be an array or Query object');
+                }
+                break;
+
+            case 'cookies':
+
+                if ($value === true) {
+                    static $cookie = null;
+                    if (!$cookie) {
+                        $cookie = new Cookie();
+                    }
+                    $emitter->attach($cookie);
+                } elseif (is_array($value)) {
+                    $emitter->attach(
+                        new Cookie(CookieJar::fromArray($value, $request->getHost()))
+                    );
+                } elseif ($value instanceof CookieJarInterface) {
+                    $emitter->attach(new Cookie($value));
+                } elseif ($value !== false) {
+                    throw new Iae('cookies must be an array, true, or CookieJarInterface');
+                }
+                break;
+
+            case 'events':
+
+                if (!is_array($value)) {
+                    throw new Iae('events must be an array');
+                }
+
+                $this->attachListeners($request,
+                    $this->prepareListeners(
+                        $value,
+                        ['before', 'complete', 'error', 'progress', 'end']
+                    )
+                );
+                break;
+
+            case 'subscribers':
+
+                if (!is_array($value)) {
+                    throw new Iae('subscribers must be an array');
+                }
+
+                foreach ($value as $subscribers) {
+                    $emitter->attach($subscribers);
+                }
+                break;
+
+            case 'json':
+
+                $request->setBody(Stream::factory(json_encode($value)));
+                if (!$request->hasHeader('Content-Type')) {
+                    $request->setHeader('Content-Type', 'application/json');
+                }
+                break;
+
+            default:
+
+                // Check for custom handler functions.
+                if (isset($this->customOptions[$key])) {
+                    $fn = $this->customOptions[$key];
+                    $fn($request, $value);
+                    continue;
+                }
+
+                throw new Iae("No method can handle the {$key} config key");
+            }
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Message/MessageFactoryInterface.php

@@ -0,0 +1,71 @@
+<?php
+namespace GuzzleHttp\Message;
+
+use GuzzleHttp\Url;
+
+/**
+ * Request and response factory
+ */
+interface MessageFactoryInterface
+{
+    /**
+     * Creates a response
+     *
+     * @param string $statusCode HTTP status code
+     * @param array  $headers    Response headers
+     * @param mixed  $body       Response body
+     * @param array  $options    Response options
+     *     - protocol_version: HTTP protocol version
+     *     - header_factory: Factory used to create headers
+     *     - And any other options used by a concrete message implementation
+     *
+     * @return ResponseInterface
+     */
+    public function createResponse(
+        $statusCode,
+        array $headers = [],
+        $body = null,
+        array $options = []
+    );
+
+    /**
+     * Create a new request based on the HTTP method.
+     *
+     * This method accepts an associative array of request options. Below is a
+     * brief description of each parameter. See
+     * http://docs.guzzlephp.org/en/latest/clients.html#request-options for a much more
+     * in-depth description of each parameter.
+     *
+     * - headers: Associative array of headers to add to the request
+     * - body: string|resource|array|StreamInterface request body to send
+     * - json: mixed Uploads JSON encoded data using an application/json Content-Type header.
+     * - query: Associative array of query string values to add to the request
+     * - auth: array|string HTTP auth settings (user, pass[, type="basic"])
+     * - version: The HTTP protocol version to use with the request
+     * - cookies: true|false|CookieJarInterface To enable or disable cookies
+     * - allow_redirects: true|false|array Controls HTTP redirects
+     * - save_to: string|resource|StreamInterface Where the response is saved
+     * - events: Associative array of event names to callables or arrays
+     * - subscribers: Array of event subscribers to add to the request
+     * - exceptions: Specifies whether or not exceptions are thrown for HTTP protocol errors
+     * - timeout: Timeout of the request in seconds. Use 0 to wait indefinitely
+     * - connect_timeout: Number of seconds to wait while trying to connect. (0 to wait indefinitely)
+     * - verify: SSL validation. True/False or the path to a PEM file
+     * - cert: Path a SSL cert or array of (path, pwd)
+     * - ssl_key: Path to a private SSL key or array of (path, pwd)
+     * - proxy: Specify an HTTP proxy or hash of protocols to proxies
+     * - debug: Set to true or a resource to view handler specific debug info
+     * - stream: Set to true to stream a response body rather than download it all up front
+     * - expect: true/false/integer Controls the "Expect: 100-Continue" header
+     * - config: Associative array of request config collection options
+     * - decode_content: true/false/string to control decoding content-encoding responses
+     *
+     * @param string     $method  HTTP method (GET, POST, PUT, etc.)
+     * @param string|Url $url     HTTP URL to connect to
+     * @param array      $options Array of options to apply to the request
+     *
+     * @return RequestInterface
+     * @link http://docs.guzzlephp.org/en/latest/clients.html#request-options
+     */
+    public function createRequest($method, $url, array $options = []);
+}

vendor/guzzlehttp/guzzle/src/Message/MessageInterface.php

@@ -0,0 +1,136 @@
+<?php
+namespace GuzzleHttp\Message;
+
+use GuzzleHttp\Stream\StreamInterface;
+
+/**
+ * Request and response message interface
+ */
+interface MessageInterface
+{
+    /**
+     * Get a string representation of the message
+     *
+     * @return string
+     */
+    public function __toString();
+
+    /**
+     * Get the HTTP protocol version of the message
+     *
+     * @return string
+     */
+    public function getProtocolVersion();
+
+    /**
+     * Sets the body of the message.
+     *
+     * The body MUST be a StreamInterface object. Setting the body to null MUST
+     * remove the existing body.
+     *
+     * @param StreamInterface|null $body Body.
+     */
+    public function setBody(StreamInterface $body = null);
+
+    /**
+     * Get the body of the message
+     *
+     * @return StreamInterface|null
+     */
+    public function getBody();
+
+    /**
+     * Gets all message headers.
+     *
+     * The keys represent the header name as it will be sent over the wire, and
+     * each value is an array of strings associated with the header.
+     *
+     *     // Represent the headers as a string
+     *     foreach ($message->getHeaders() as $name => $values) {
+     *         echo $name . ": " . implode(", ", $values);
+     *     }
+     *
+     * @return array Returns an associative array of the message's headers.
+     */
+    public function getHeaders();
+
+    /**
+     * Retrieve a header by the given case-insensitive name.
+     *
+     * @param string $header Case-insensitive header name.
+     *
+     * @return string
+     */
+    public function getHeader($header);
+
+    /**
+     * Retrieves a header by the given case-insensitive name as an array of strings.
+     *
+     * @param string $header Case-insensitive header name.
+     *
+     * @return string[]
+     */
+    public function getHeaderAsArray($header);
+
+    /**
+     * Checks if a header exists by the given case-insensitive name.
+     *
+     * @param string $header Case-insensitive header name.
+     *
+     * @return bool Returns true if any header names match the given header
+     *     name using a case-insensitive string comparison. Returns false if
+     *     no matching header name is found in the message.
+     */
+    public function hasHeader($header);
+
+    /**
+     * Remove a specific header by case-insensitive name.
+     *
+     * @param string $header Case-insensitive header name.
+     */
+    public function removeHeader($header);
+
+    /**
+     * Appends a header value to any existing values associated with the
+     * given header name.
+     *
+     * @param string $header Header name to add
+     * @param string $value  Value of the header
+     */
+    public function addHeader($header, $value);
+
+    /**
+     * Merges in an associative array of headers.
+     *
+     * Each array key MUST be a string representing the case-insensitive name
+     * of a header. Each value MUST be either a string or an array of strings.
+     * For each value, the value is appended to any existing header of the same
+     * name, or, if a header does not already exist by the given name, then the
+     * header is added.
+     *
+     * @param array $headers Associative array of headers to add to the message
+     */
+    public function addHeaders(array $headers);
+
+    /**
+     * Sets a header, replacing any existing values of any headers with the
+     * same case-insensitive name.
+     *
+     * The header values MUST be a string or an array of strings.
+     *
+     * @param string       $header Header name
+     * @param string|array $value  Header value(s)
+     */
+    public function setHeader($header, $value);
+
+    /**
+     * Sets headers, replacing any headers that have already been set on the
+     * message.
+     *
+     * The array keys MUST be a string. The array values must be either a
+     * string or an array of strings.
+     *
+     * @param array $headers Headers to set.
+     */
+    public function setHeaders(array $headers);
+}

vendor/guzzlehttp/guzzle/src/Message/MessageParser.php

@@ -0,0 +1,171 @@
+<?php
+namespace GuzzleHttp\Message;
+
+/**
+ * Request and response parser used by Guzzle
+ */
+class MessageParser
+{
+    /**
+     * Parse an HTTP request message into an associative array of parts.
+     *
+     * @param string $message HTTP request to parse
+     *
+     * @return array|bool Returns false if the message is invalid
+     */
+    public function parseRequest($message)
+    {
+        if (!($parts = $this->parseMessage($message))) {
+            return false;
+        }
+
+        // Parse the protocol and protocol version
+        if (isset($parts['start_line'][2])) {
+            $startParts = explode('/', $parts['start_line'][2]);
+            $protocol = strtoupper($startParts[0]);
+            $version = isset($startParts[1]) ? $startParts[1] : '1.1';
+        } else {
+            $protocol = 'HTTP';
+            $version = '1.1';
+        }
+
+        $parsed = [
+            'method'   => strtoupper($parts['start_line'][0]),
+            'protocol' => $protocol,
+            'protocol_version' => $version,
+            'headers'  => $parts['headers'],
+            'body'     => $parts['body']
+        ];
+
+        $parsed['request_url'] = $this->getUrlPartsFromMessage(
+            (isset($parts['start_line'][1]) ? $parts['start_line'][1] : ''), $parsed);
+
+        return $parsed;
+    }
+
+    /**
+     * Parse an HTTP response message into an associative array of parts.
+     *
+     * @param string $message HTTP response to parse
+     *
+     * @return array|bool Returns false if the message is invalid
+     */
+    public function parseResponse($message)
+    {
+        if (!($parts = $this->parseMessage($message))) {
+            return false;
+        }
+
+        list($protocol, $version) = explode('/', trim($parts['start_line'][0]));
+
+        return [
+            'protocol'         => $protocol,
+            'protocol_version' => $version,
+            'code'             => $parts['start_line'][1],
+            'reason_phrase'    => isset($parts['start_line'][2]) ? $parts['start_line'][2] : '',
+            'headers'          => $parts['headers'],
+            'body'             => $parts['body']
+        ];
+    }
+
+    /**
+     * Parse a message into parts
+     *
+     * @param string $message Message to parse
+     *
+     * @return array|bool
+     */
+    private function parseMessage($message)
+    {
+        if (!$message) {
+            return false;
+        }
+
+        $startLine = null;
+        $headers = [];
+        $body = '';
+
+        // Iterate over each line in the message, accounting for line endings
+        $lines = preg_split('/(\\r?\\n)/', $message, -1, PREG_SPLIT_DELIM_CAPTURE);
+        for ($i = 0, $totalLines = count($lines); $i < $totalLines; $i += 2) {
+
+            $line = $lines[$i];
+
+            // If two line breaks were encountered, then this is the end of body
+            if (empty($line)) {
+                if ($i < $totalLines - 1) {
+                    $body = implode('', array_slice($lines, $i + 2));
+                }
+                break;
+            }
+
+            // Parse message headers
+            if (!$startLine) {
+                $startLine = explode(' ', $line, 3);
+            } elseif (strpos($line, ':')) {
+                $parts = explode(':', $line, 2);
+                $key = trim($parts[0]);
+                $value = isset($parts[1]) ? trim($parts[1]) : '';
+                if (!isset($headers[$key])) {
+                    $headers[$key] = $value;
+                } elseif (!is_array($headers[$key])) {
+                    $headers[$key] = [$headers[$key], $value];
+                } else {
+                    $headers[$key][] = $value;
+                }
+            }
+        }
+
+        return [
+            'start_line' => $startLine,
+            'headers'    => $headers,
+            'body'       => $body
+        ];
+    }
+
+    /**
+     * Create URL parts from HTTP message parts
+     *
+     * @param string $requestUrl Associated URL
+     * @param array  $parts      HTTP message parts
+     *
+     * @return array
+     */
+    private function getUrlPartsFromMessage($requestUrl, array $parts)
+    {
+        // Parse the URL information from the message
+        $urlParts = ['path' => $requestUrl, 'scheme' => 'http'];
+
+        // Check for the Host header
+        if (isset($parts['headers']['Host'])) {
+            $urlParts['host'] = $parts['headers']['Host'];
+        } elseif (isset($parts['headers']['host'])) {
+            $urlParts['host'] = $parts['headers']['host'];
+        } else {
+            $urlParts['host'] = null;
+        }
+
+        if (false === strpos($urlParts['host'], ':')) {
+            $urlParts['port'] = '';
+        } else {
+            $hostParts = explode(':', $urlParts['host']);
+            $urlParts['host'] = trim($hostParts[0]);
+            $urlParts['port'] = (int) trim($hostParts[1]);
+            if ($urlParts['port'] == 443) {
+                $urlParts['scheme'] = 'https';
+            }
+        }
+
+        // Check if a query is present
+        $path = $urlParts['path'];
+        $qpos = strpos($path, '?');
+        if ($qpos) {
+            $urlParts['query'] = substr($path, $qpos + 1);
+            $urlParts['path'] = substr($path, 0, $qpos);
+        } else {
+            $urlParts['query'] = '';
+        }
+
+        return $urlParts;
+    }
+}

vendor/guzzlehttp/guzzle/src/Message/Request.php

@@ -0,0 +1,195 @@
+<?php
+namespace GuzzleHttp\Message;
+
+use GuzzleHttp\Collection;
+use GuzzleHttp\Event\HasEmitterTrait;
+use GuzzleHttp\Subscriber\Prepare;
+use GuzzleHttp\Url;
+
+/**
+ * HTTP request class to send requests
+ */
+class Request extends AbstractMessage implements RequestInterface
+{
+    use HasEmitterTrait;
+
+    /** @var Url HTTP Url */
+    private $url;
+
+    /** @var string HTTP method */
+    private $method;
+
+    /** @var Collection Transfer options */
+    private $transferOptions;
+
+    /**
+     * @param string           $method  HTTP method
+     * @param string|Url       $url     HTTP URL to connect to. The URI scheme,
+     *   host header, and URI are parsed from the full URL. If query string
+     *   parameters are present they will be parsed as well.
+     * @param array|Collection $headers HTTP headers
+     * @param mixed            $body    Body to send with the request
+     * @param array            $options Array of options to use with the request
+     *     - emitter: Event emitter to use with the request
+     */
+    public function __construct(
+        $method,
+        $url,
+        $headers = [],
+        $body = null,
+        array $options = []
+    ) {
+        $this->setUrl($url);
+        $this->method = strtoupper($method);
+        $this->handleOptions($options);
+        $this->transferOptions = new Collection($options);
+        $this->addPrepareEvent();
+
+        if ($body !== null) {
+            $this->setBody($body);
+        }
+
+        if ($headers) {
+            foreach ($headers as $key => $value) {
+                $this->addHeader($key, $value);
+            }
+        }
+    }
+
+    public function __clone()
+    {
+        if ($this->emitter) {
+            $this->emitter = clone $this->emitter;
+        }
+        $this->transferOptions = clone $this->transferOptions;
+        $this->url = clone $this->url;
+    }
+
+    public function setUrl($url)
+    {
+        $this->url = $url instanceof Url ? $url : Url::fromString($url);
+        $this->updateHostHeaderFromUrl();
+    }
+
+    public function getUrl()
+    {
+        return (string) $this->url;
+    }
+
+    public function setQuery($query)
+    {
+        $this->url->setQuery($query);
+    }
+
+    public function getQuery()
+    {
+        return $this->url->getQuery();
+    }
+
+    public function setMethod($method)
+    {
+        $this->method = strtoupper($method);
+    }
+
+    public function getMethod()
+    {
+        return $this->method;
+    }
+
+    public function getScheme()
+    {
+        return $this->url->getScheme();
+    }
+
+    public function setScheme($scheme)
+    {
+        $this->url->setScheme($scheme);
+    }
+
+    public function getPort()
+    {
+        return $this->url->getPort();
+    }
+
+    public function setPort($port)
+    {
+        $this->url->setPort($port);
+        $this->updateHostHeaderFromUrl();
+    }
+
+    public function getHost()
+    {
+        return $this->url->getHost();
+    }
+
+    public function setHost($host)
+    {
+        $this->url->setHost($host);
+        $this->updateHostHeaderFromUrl();
+    }
+
+    public function getPath()
+    {
+        return '/' . ltrim($this->url->getPath(), '/');
+    }
+
+    public function setPath($path)
+    {
+        $this->url->setPath($path);
+    }
+
+    public function getResource()
+    {
+        $resource = $this->getPath();
+        if ($query = (string) $this->url->getQuery()) {
+            $resource .= '?' . $query;
+        }
+
+        return $resource;
+    }
+
+    public function getConfig()
+    {
+        return $this->transferOptions;
+    }
+
+    protected function handleOptions(array &$options)
+    {
+        parent::handleOptions($options);
+        // Use a custom emitter if one is specified, and remove it from
+        // options that are exposed through getConfig()
+        if (isset($options['emitter'])) {
+            $this->emitter = $options['emitter'];
+            unset($options['emitter']);
+        }
+    }
+
+    /**
+     * Adds a subscriber that ensures a request's body is prepared before
+     * sending.
+     */
+    private function addPrepareEvent()
+    {
+        static $subscriber;
+        if (!$subscriber) {
+            $subscriber = new Prepare();
+        }
+
+        $this->getEmitter()->attach($subscriber);
+    }
+
+    private function updateHostHeaderFromUrl()
+    {
+        $port = $this->url->getPort();
+        $scheme = $this->url->getScheme();
+        if ($host = $this->url->getHost()) {
+            if (($port == 80 && $scheme == 'http') ||
+                ($port == 443 && $scheme == 'https')
+            ) {
+                $this->setHeader('Host', $host);
+            } else {
+                $this->setHeader('Host', "{$host}:{$port}");
+            }
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Message/RequestInterface.php

@@ -0,0 +1,136 @@
+<?php
+namespace GuzzleHttp\Message;
+
+use GuzzleHttp\Event\HasEmitterInterface;
+use GuzzleHttp\Query;
+
+/**
+ * Generic HTTP request interface
+ */
+interface RequestInterface extends MessageInterface, HasEmitterInterface
+{
+    /**
+     * Sets the request URL.
+     *
+     * The URL MUST be a string, or an object that implements the
+     * `__toString()` method.
+     *
+     * @param string $url Request URL.
+     *
+     * @throws \InvalidArgumentException If the URL is invalid.
+     */
+    public function setUrl($url);
+
+    /**
+     * Gets the request URL as a string.
+     *
+     * @return string Returns the URL as a string.
+     */
+    public function getUrl();
+
+    /**
+     * Get the resource part of the the request, including the path, query
+     * string, and fragment.
+     *
+     * @return string
+     */
+    public function getResource();
+
+    /**
+     * Get the collection of key value pairs that will be used as the query
+     * string in the request.
+     *
+     * @return Query
+     */
+    public function getQuery();
+
+    /**
+     * Set the query string used by the request
+     *
+     * @param array|Query $query Query to set
+     */
+    public function setQuery($query);
+
+    /**
+     * Get the HTTP method of the request.
+     *
+     * @return string
+     */
+    public function getMethod();
+
+    /**
+     * Set the HTTP method of the request.
+     *
+     * @param string $method HTTP method
+     */
+    public function setMethod($method);
+
+    /**
+     * Get the URI scheme of the request (http, https, etc.).
+     *
+     * @return string
+     */
+    public function getScheme();
+
+    /**
+     * Set the URI scheme of the request (http, https, etc.).
+     *
+     * @param string $scheme Scheme to set
+     */
+    public function setScheme($scheme);
+
+    /**
+     * Get the port scheme of the request (e.g., 80, 443, etc.).
+     *
+     * @return int
+     */
+    public function getPort();
+
+    /**
+     * Set the port of the request.
+     *
+     * Setting a port modifies the Host header of a request as necessary.
+     *
+     * @param int $port Port to set
+     */
+    public function setPort($port);
+
+    /**
+     * Get the host of the request.
+     *
+     * @return string
+     */
+    public function getHost();
+
+    /**
+     * Set the host of the request including an optional port.
+     *
+     * Including a port in the host argument will explicitly change the port of
+     * the request. If no port is found, the default port of the current
+     * request scheme will be utilized.
+     *
+     * @param string $host Host to set (e.g. www.yahoo.com, www.yahoo.com:80)
+     */
+    public function setHost($host);
+
+    /**
+     * Get the path of the request (e.g. '/', '/index.html').
+     *
+     * @return string
+     */
+    public function getPath();
+
+    /**
+     * Set the path of the request (e.g. '/', '/index.html').
+     *
+     * @param string|array $path Path to set or array of segments to implode
+     */
+    public function setPath($path);
+
+    /**
+     * Get the request's configuration options.
+     *
+     * @return \GuzzleHttp\Collection
+     */
+    public function getConfig();
+}

vendor/guzzlehttp/guzzle/src/Message/Response.php

@@ -0,0 +1,208 @@
+<?php
+namespace GuzzleHttp\Message;
+
+use GuzzleHttp\Exception\ParseException;
+use GuzzleHttp\Exception\XmlParseException;
+use GuzzleHttp\Stream\StreamInterface;
+use GuzzleHttp\Utils;
+
+/**
+ * Guzzle HTTP response object
+ */
+class Response extends AbstractMessage implements ResponseInterface
+{
+    /** @var array Mapping of status codes to reason phrases */
+    private static $statusTexts = [
+        100 => 'Continue',
+        101 => 'Switching Protocols',
+        102 => 'Processing',
+        200 => 'OK',
+        201 => 'Created',
+        202 => 'Accepted',
+        203 => 'Non-Authoritative Information',
+        204 => 'No Content',
+        205 => 'Reset Content',
+        206 => 'Partial Content',
+        207 => 'Multi-Status',
+        208 => 'Already Reported',
+        226 => 'IM Used',
+        300 => 'Multiple Choices',
+        301 => 'Moved Permanently',
+        302 => 'Found',
+        303 => 'See Other',
+        304 => 'Not Modified',
+        305 => 'Use Proxy',
+        307 => 'Temporary Redirect',
+        308 => 'Permanent Redirect',
+        400 => 'Bad Request',
+        401 => 'Unauthorized',
+        402 => 'Payment Required',
+        403 => 'Forbidden',
+        404 => 'Not Found',
+        405 => 'Method Not Allowed',
+        406 => 'Not Acceptable',
+        407 => 'Proxy Authentication Required',
+        408 => 'Request Timeout',
+        409 => 'Conflict',
+        410 => 'Gone',
+        411 => 'Length Required',
+        412 => 'Precondition Failed',
+        413 => 'Request Entity Too Large',
+        414 => 'Request-URI Too Long',
+        415 => 'Unsupported Media Type',
+        416 => 'Requested Range Not Satisfiable',
+        417 => 'Expectation Failed',
+        422 => 'Unprocessable Entity',
+        423 => 'Locked',
+        424 => 'Failed Dependency',
+        425 => 'Reserved for WebDAV advanced collections expired proposal',
+        426 => 'Upgrade required',
+        428 => 'Precondition Required',
+        429 => 'Too Many Requests',
+        431 => 'Request Header Fields Too Large',
+        500 => 'Internal Server Error',
+        501 => 'Not Implemented',
+        502 => 'Bad Gateway',
+        503 => 'Service Unavailable',
+        504 => 'Gateway Timeout',
+        505 => 'HTTP Version Not Supported',
+        506 => 'Variant Also Negotiates (Experimental)',
+        507 => 'Insufficient Storage',
+        508 => 'Loop Detected',
+        510 => 'Not Extended',
+        511 => 'Network Authentication Required',
+    ];
+
+    /** @var string The reason phrase of the response (human readable code) */
+    private $reasonPhrase;
+
+    /** @var string The status code of the response */
+    private $statusCode;
+
+    /** @var string The effective URL that returned this response */
+    private $effectiveUrl;
+
+    /**
+     * @param int|string      $statusCode The response status code (e.g. 200)
+     * @param array           $headers    The response headers
+     * @param StreamInterface $body       The body of the response
+     * @param array           $options    Response message options
+     *     - reason_phrase: Set a custom reason phrase
+     *     - protocol_version: Set a custom protocol version
+     */
+    public function __construct(
+        $statusCode,
+        array $headers = [],
+        StreamInterface $body = null,
+        array $options = []
+    ) {
+        $this->statusCode = (int) $statusCode;
+        $this->handleOptions($options);
+
+        // Assume a reason phrase if one was not applied as an option
+        if (!$this->reasonPhrase &&
+            isset(self::$statusTexts[$this->statusCode])
+        ) {
+            $this->reasonPhrase = self::$statusTexts[$this->statusCode];
+        }
+
+        if ($headers) {
+            $this->setHeaders($headers);
+        }
+
+        if ($body) {
+            $this->setBody($body);
+        }
+    }
+
+    public function getStatusCode()
+    {
+        return $this->statusCode;
+    }
+
+    public function setStatusCode($code)
+    {
+        return $this->statusCode = (int) $code;
+    }
+
+    public function getReasonPhrase()
+    {
+        return $this->reasonPhrase;
+    }
+
+    public function setReasonPhrase($phrase)
+    {
+        return $this->reasonPhrase = $phrase;
+    }
+
+    public function json(array $config = [])
+    {
+        try {
+            return Utils::jsonDecode(
+                (string) $this->getBody(),
+                isset($config['object']) ? !$config['object'] : true,
+                512,
+                isset($config['big_int_strings']) ? JSON_BIGINT_AS_STRING : 0
+            );
+        } catch (\InvalidArgumentException $e) {
+            throw new ParseException(
+                $e->getMessage(),
+                $this
+            );
+        }
+    }
+
+    public function xml(array $config = [])
+    {
+        $disableEntities = libxml_disable_entity_loader(true);
+        $internalErrors = libxml_use_internal_errors(true);
+
+        try {
+            // Allow XML to be retrieved even if there is no response body
+            $xml = new \SimpleXMLElement(
+                (string) $this->getBody() ?: '<root />',
+                isset($config['libxml_options']) ? $config['libxml_options'] : LIBXML_NONET,
+                false,
+                isset($config['ns']) ? $config['ns'] : '',
+                isset($config['ns_is_prefix']) ? $config['ns_is_prefix'] : false
+            );
+            libxml_disable_entity_loader($disableEntities);
+            libxml_use_internal_errors($internalErrors);
+        } catch (\Exception $e) {
+            libxml_disable_entity_loader($disableEntities);
+            libxml_use_internal_errors($internalErrors);
+            throw new XmlParseException(
+                'Unable to parse response body into XML: ' . $e->getMessage(),
+                $this,
+                $e,
+                (libxml_get_last_error()) ?: null
+            );
+        }
+
+        return $xml;
+    }
+
+    public function getEffectiveUrl()
+    {
+        return $this->effectiveUrl;
+    }
+
+    public function setEffectiveUrl($url)
+    {
+        $this->effectiveUrl = $url;
+    }
+
+    /**
+     * Accepts and modifies the options provided to the response in the
+     * constructor.
+     *
+     * @param array $options Options array passed by reference.
+     */
+    protected function handleOptions(array &$options = [])
+    {
+        parent::handleOptions($options);
+        if (isset($options['reason_phrase'])) {
+            $this->reasonPhrase = $options['reason_phrase'];
+        }
+    }
+}

vendor/guzzlehttp/guzzle/src/Message/ResponseInterface.php

@@ -0,0 +1,111 @@
+<?php
+namespace GuzzleHttp\Message;
+
+/**
+ * Represents an HTTP response message.
+ */
+interface ResponseInterface extends MessageInterface
+{
+    /**
+     * Gets the response Status-Code.
+     *
+     * The Status-Code is a 3-digit integer result code of the server's attempt
+     * to understand and satisfy the request.
+     *
+     * @return int Status code.
+     */
+    public function getStatusCode();
+
+    /**
+     * Sets the status code of this response.
+     *
+     * @param int $code The 3-digit integer result code to set.
+     */
+    public function setStatusCode($code);
+
+    /**
+     * Gets the response Reason-Phrase, a short textual description of the
+     * Status-Code.
+     *
+     * Because a Reason-Phrase is not a required element in response
+     * Status-Line, the Reason-Phrase value MAY be null. Implementations MAY
+     * choose to return the default RFC 2616 recommended reason phrase for the
+     * response's Status-Code.
+     *
+     * @return string|null Reason phrase, or null if unknown.
+     */
+    public function getReasonPhrase();
+
+    /**
+     * Sets the Reason-Phrase of the response.
+     *
+     * If no Reason-Phrase is specified, implementations MAY choose to default
+     * to the RFC 2616 recommended reason phrase for the response's Status-Code.
+     *
+     * @param string $phrase The Reason-Phrase to set.
+     */
+    public function setReasonPhrase($phrase);
+
+    /**
+     * Get the effective URL that resulted in this response (e.g. the last
+     * redirect URL).
+     *
+     * @return string
+     */
+    public function getEffectiveUrl();
+
+    /**
+     * Set the effective URL that resulted in this response (e.g. the last
+     * redirect URL).
+     *
+     * @param string $url Effective URL
+     */
+    public function setEffectiveUrl($url);
+
+    /**
+     * Parse the JSON response body and return the JSON decoded data.
+     *
+     * @param array $config Associative array of configuration settings used
+     *     to control how the JSON data is parsed. Concrete implementations MAY
+     *     add further configuration settings as needed, but they MUST implement
+     *     functionality for the following options:
+     *
+     *     - object: Set to true to parse JSON objects as PHP objects rather
+     *       than associative arrays. Defaults to false.
+     *     - big_int_strings: When set to true, large integers are converted to
+     *       strings rather than floats. Defaults to false.
+     *
+     *     Implementations are free to add further configuration settings as
+     *     needed.
+     *
+     * @return mixed Returns the JSON decoded data based on the provided
+     *     parse settings.
+     * @throws \RuntimeException if the response body is not in JSON format
+     */
+    public function json(array $config = []);
+
+    /**
+     * Parse the XML response body and return a \SimpleXMLElement.
+     *
+     * In order to prevent XXE attacks, this method disables loading external
+     * entities. If you rely on external entities, then you must parse the
+     * XML response manually by accessing the response body directly.
+     *
+     * @param array $config Associative array of configuration settings used
+     *     to control how the XML is parsed. Concrete implementations MAY add
+     *     further configuration settings as needed, but they MUST implement
+     *     functionality for the following options:
+     *
+     *     - ns: Set to a string to represent the namespace prefix or URI
+     *     - ns_is_prefix: Set to true to specify that the NS is a prefix rather
+     *       than a URI (defaults to false).
+     *     - libxml_options: Bitwise OR of the libxml option constants
+     *       listed at http://php.net/manual/en/libxml.constants.php
+     *       (defaults to LIBXML_NONET)
+     *
+     * @return \SimpleXMLElement
+     * @throws \RuntimeException if the response body is not in XML format
+     * @link http://websec.io/2012/08/27/Preventing-XXE-in-PHP.html
+     */
+    public function xml(array $config = []);
+}

vendor/guzzlehttp/guzzle/src/Mimetypes.php

@@ -0,0 +1,963 @@
+<?php
+namespace GuzzleHttp;
+
+/**
+ * Provides mappings of file extensions to mimetypes
+ * @link http://svn.apache.org/repos/asf/httpd/httpd/branches/1.3.x/conf/mime.types
+ */
+class Mimetypes
+{
+    /** @var self */
+    protected static $instance;
+
+    /** @var array Mapping of extension to mimetype */
+    protected $mimetypes = array(
+        '3dml' => 'text/vnd.in3d.3dml',
+        '3g2' => 'video/3gpp2',
+        '3gp' => 'video/3gpp',
+        '7z' => 'application/x-7z-compressed',
+        'aab' => 'application/x-authorware-bin',
+        'aac' => 'audio/x-aac',
+        'aam' => 'application/x-authorware-map',
+        'aas' => 'application/x-authorware-seg',
+        'abw' => 'application/x-abiword',
+        'ac' => 'application/pkix-attr-cert',
+        'acc' => 'application/vnd.americandynamics.acc',
+        'ace' => 'application/x-ace-compressed',
+        'acu' => 'application/vnd.acucobol',
+        'acutc' => 'application/vnd.acucorp',
+        'adp' => 'audio/adpcm',
+        'aep' => 'application/vnd.audiograph',
+        'afm' => 'application/x-font-type1',
+        'afp' => 'application/vnd.ibm.modcap',
+        'ahead' => 'application/vnd.ahead.space',
+        'ai' => 'application/postscript',
+        'aif' => 'audio/x-aiff',
+        'aifc' => 'audio/x-aiff',
+        'aiff' => 'audio/x-aiff',
+        'air' => 'application/vnd.adobe.air-application-installer-package+zip',
+        'ait' => 'application/vnd.dvb.ait',
+        'ami' => 'application/vnd.amiga.ami',
+        'apk' => 'application/vnd.android.package-archive',
+        'application' => 'application/x-ms-application',
+        'apr' => 'application/vnd.lotus-approach',
+        'asa' => 'text/plain',
+        'asax' => 'application/octet-stream',
+        'asc' => 'application/pgp-signature',
+        'ascx' => 'text/plain',
+        'asf' => 'video/x-ms-asf',
+        'ashx' => 'text/plain',
+        'asm' => 'text/x-asm',
+        'asmx' => 'text/plain',
+        'aso' => 'application/vnd.accpac.simply.aso',
+        'asp' => 'text/plain',
+        'aspx' => 'text/plain',
+        'asx' => 'video/x-ms-asf',
+        'atc' => 'application/vnd.acucorp',
+        'atom' => 'application/atom+xml',
+        'atomcat' => 'application/atomcat+xml',
+        'atomsvc' => 'application/atomsvc+xml',
+        'atx' => 'application/vnd.antix.game-component',
+        'au' => 'audio/basic',
+        'avi' => 'video/x-msvideo',
+        'aw' => 'application/applixware',
+        'axd' => 'text/plain',
+        'azf' => 'application/vnd.airzip.filesecure.azf',
+        'azs' => 'application/vnd.airzip.filesecure.azs',
+        'azw' => 'application/vnd.amazon.ebook',
+        'bat' => 'application/x-msdownload',
+        'bcpio' => 'application/x-bcpio',
+        'bdf' => 'application/x-font-bdf',
+        'bdm' => 'application/vnd.syncml.dm+wbxml',
+        'bed' => 'application/vnd.realvnc.bed',
+        'bh2' => 'application/vnd.fujitsu.oasysprs',
+        'bin' => 'application/octet-stream',
+        'bmi' => 'application/vnd.bmi',
+        'bmp' => 'image/bmp',
+        'book' => 'application/vnd.framemaker',
+        'box' => 'application/vnd.previewsystems.box',
+        'boz' => 'application/x-bzip2',
+        'bpk' => 'application/octet-stream',
+        'btif' => 'image/prs.btif',
+        'bz' => 'application/x-bzip',
+        'bz2' => 'application/x-bzip2',
+        'c' => 'text/x-c',
+        'c11amc' => 'application/vnd.cluetrust.cartomobile-config',
+        'c11amz' => 'application/vnd.cluetrust.cartomobile-config-pkg',
+        'c4d' => 'application/vnd.clonk.c4group',
+        'c4f' => 'application/vnd.clonk.c4group',
+        'c4g' => 'application/vnd.clonk.c4group',
+        'c4p' => 'application/vnd.clonk.c4group',
+        'c4u' => 'application/vnd.clonk.c4group',
+        'cab' => 'application/vnd.ms-cab-compressed',
+        'car' => 'application/vnd.curl.car',
+        'cat' => 'application/vnd.ms-pki.seccat',
+        'cc' => 'text/x-c',
+        'cct' => 'application/x-director',
+        'ccxml' => 'application/ccxml+xml',
+        'cdbcmsg' => 'application/vnd.contact.cmsg',
+        'cdf' => 'application/x-netcdf',
+        'cdkey' => 'application/vnd.mediastation.cdkey',
+        'cdmia' => 'application/cdmi-capability',
+        'cdmic' => 'application/cdmi-container',
+        'cdmid' => 'application/cdmi-domain',
+        'cdmio' => 'application/cdmi-object',
+        'cdmiq' => 'application/cdmi-queue',
+        'cdx' => 'chemical/x-cdx',
+        'cdxml' => 'application/vnd.chemdraw+xml',
+        'cdy' => 'application/vnd.cinderella',
+        'cer' => 'application/pkix-cert',
+        'cfc' => 'application/x-coldfusion',
+        'cfm' => 'application/x-coldfusion',
+        'cgm' => 'image/cgm',
+        'chat' => 'application/x-chat',
+        'chm' => 'application/vnd.ms-htmlhelp',
+        'chrt' => 'application/vnd.kde.kchart',
+        'cif' => 'chemical/x-cif',
+        'cii' => 'application/vnd.anser-web-certificate-issue-initiation',
+        'cil' => 'application/vnd.ms-artgalry',
+        'cla' => 'application/vnd.claymore',
+        'class' => 'application/java-vm',
+        'clkk' => 'application/vnd.crick.clicker.keyboard',
+        'clkp' => 'application/vnd.crick.clicker.palette',
+        'clkt' => 'application/vnd.crick.clicker.template',
+        'clkw' => 'application/vnd.crick.clicker.wordbank',
+        'clkx' => 'application/vnd.crick.clicker',
+        'clp' => 'application/x-msclip',
+        'cmc' => 'application/vnd.cosmocaller',
+        'cmdf' => 'chemical/x-cmdf',
+        'cml' => 'chemical/x-cml',
+        'cmp' => 'application/vnd.yellowriver-custom-menu',
+        'cmx' => 'image/x-cmx',
+        'cod' => 'application/vnd.rim.cod',
+        'com' => 'application/x-msdownload',
+        'conf' => 'text/plain',
+        'cpio' => 'application/x-cpio',
+        'cpp' => 'text/x-c',
+        'cpt' => 'application/mac-compactpro',
+        'crd' => 'application/x-mscardfile',
+        'crl' => 'application/pkix-crl',
+        'crt' => 'application/x-x509-ca-cert',
+        'cryptonote' => 'application/vnd.rig.cryptonote',
+        'cs' => 'text/plain',
+        'csh' => 'application/x-csh',
+        'csml' => 'chemical/x-csml',
+        'csp' => 'application/vnd.commonspace',
+        'css' => 'text/css',
+        'cst' => 'application/x-director',
+        'csv' => 'text/csv',
+        'cu' => 'application/cu-seeme',
+        'curl' => 'text/vnd.curl',
+        'cww' => 'application/prs.cww',
+        'cxt' => 'application/x-director',
+        'cxx' => 'text/x-c',
+        'dae' => 'model/vnd.collada+xml',
+        'daf' => 'application/vnd.mobius.daf',
+        'dataless' => 'application/vnd.fdsn.seed',
+        'davmount' => 'application/davmount+xml',
+        'dcr' => 'application/x-director',
+        'dcurl' => 'text/vnd.curl.dcurl',
+        'dd2' => 'application/vnd.oma.dd2+xml',
+        'ddd' => 'application/vnd.fujixerox.ddd',
+        'deb' => 'application/x-debian-package',
+        'def' => 'text/plain',
+        'deploy' => 'application/octet-stream',
+        'der' => 'application/x-x509-ca-cert',
+        'dfac' => 'application/vnd.dreamfactory',
+        'dic' => 'text/x-c',
+        'dir' => 'application/x-director',
+        'dis' => 'application/vnd.mobius.dis',
+        'dist' => 'application/octet-stream',
+        'distz' => 'application/octet-stream',
+        'djv' => 'image/vnd.djvu',
+        'djvu' => 'image/vnd.djvu',
+        'dll' => 'application/x-msdownload',
+        'dmg' => 'application/octet-stream',
+        'dms' => 'application/octet-stream',
+        'dna' => 'application/vnd.dna',
+        'doc' => 'application/msword',
+        'docm' => 'application/vnd.ms-word.document.macroenabled.12',
+        'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'dot' => 'application/msword',
+        'dotm' => 'application/vnd.ms-word.template.macroenabled.12',
+        'dotx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+        'dp' => 'application/vnd.osgi.dp',
+        'dpg' => 'application/vnd.dpgraph',
+        'dra' => 'audio/vnd.dra',
+        'dsc' => 'text/prs.lines.tag',
+        'dssc' => 'application/dssc+der',
+        'dtb' => 'application/x-dtbook+xml',
+        'dtd' => 'application/xml-dtd',
+        'dts' => 'audio/vnd.dts',
+        'dtshd' => 'audio/vnd.dts.hd',
+        'dump' => 'application/octet-stream',
+        'dvi' => 'application/x-dvi',
+        'dwf' => 'model/vnd.dwf',
+        'dwg' => 'image/vnd.dwg',
+        'dxf' => 'image/vnd.dxf',
+        'dxp' => 'application/vnd.spotfire.dxp',
+        'dxr' => 'application/x-director',
+        'ecelp4800' => 'audio/vnd.nuera.ecelp4800',
+        'ecelp7470' => 'audio/vnd.nuera.ecelp7470',
+        'ecelp9600' => 'audio/vnd.nuera.ecelp9600',
+        'ecma' => 'application/ecmascript',
+        'edm' => 'application/vnd.novadigm.edm',
+        'edx' => 'application/vnd.novadigm.edx',
+        'efif' => 'application/vnd.picsel',
+        'ei6' => 'application/vnd.pg.osasli',
+        'elc' => 'application/octet-stream',
+        'eml' => 'message/rfc822',
+        'emma' => 'application/emma+xml',
+        'eol' => 'audio/vnd.digital-winds',
+        'eot' => 'application/vnd.ms-fontobject',
+        'eps' => 'application/postscript',
+        'epub' => 'application/epub+zip',
+        'es3' => 'application/vnd.eszigno3+xml',
+        'esf' => 'application/vnd.epson.esf',
+        'et3' => 'application/vnd.eszigno3+xml',
+        'etx' => 'text/x-setext',
+        'exe' => 'application/x-msdownload',
+        'exi' => 'application/exi',
+        'ext' => 'application/vnd.novadigm.ext',
+        'ez' => 'application/andrew-inset',
+        'ez2' => 'application/vnd.ezpix-album',
+        'ez3' => 'application/vnd.ezpix-package',
+        'f' => 'text/x-fortran',
+        'f4v' => 'video/x-f4v',
+        'f77' => 'text/x-fortran',
+        'f90' => 'text/x-fortran',
+        'fbs' => 'image/vnd.fastbidsheet',
+        'fcs' => 'application/vnd.isac.fcs',
+        'fdf' => 'application/vnd.fdf',
+        'fe_launch' => 'application/vnd.denovo.fcselayout-link',
+        'fg5' => 'application/vnd.fujitsu.oasysgp',
+        'fgd' => 'application/x-director',
+        'fh' => 'image/x-freehand',
+        'fh4' => 'image/x-freehand',
+        'fh5' => 'image/x-freehand',
+        'fh7' => 'image/x-freehand',
+        'fhc' => 'image/x-freehand',
+        'fig' => 'application/x-xfig',
+        'fli' => 'video/x-fli',
+        'flo' => 'application/vnd.micrografx.flo',
+        'flv' => 'video/x-flv',
+        'flw' => 'application/vnd.kde.kivio',
+        'flx' => 'text/vnd.fmi.flexstor',
+        'fly' => 'text/vnd.fly',
+        'fm' => 'application/vnd.framemaker',
+        'fnc' => 'application/vnd.frogans.fnc',
+        'for' => 'text/x-fortran',
+        'fpx' => 'image/vnd.fpx',
+        'frame' => 'application/vnd.framemaker',
+        'fsc' => 'application/vnd.fsc.weblaunch',
+        'fst' => 'image/vnd.fst',
+        'ftc' => 'application/vnd.fluxtime.clip',
+        'fti' => 'application/vnd.anser-web-funds-transfer-initiation',
+        'fvt' => 'video/vnd.fvt',
+        'fxp' => 'application/vnd.adobe.fxp',
+        'fxpl' => 'application/vnd.adobe.fxp',
+        'fzs' => 'application/vnd.fuzzysheet',
+        'g2w' => 'application/vnd.geoplan',
+        'g3' => 'image/g3fax',
+        'g3w' => 'application/vnd.geospace',
+        'gac' => 'application/vnd.groove-account',
+        'gdl' => 'model/vnd.gdl',
+        'geo' => 'application/vnd.dynageo',
+        'gex' => 'application/vnd.geometry-explorer',
+        'ggb' => 'application/vnd.geogebra.file',
+        'ggt' => 'application/vnd.geogebra.tool',
+        'ghf' => 'application/vnd.groove-help',
+        'gif' => 'image/gif',
+        'gim' => 'application/vnd.groove-identity-message',
+        'gmx' => 'application/vnd.gmx',
+        'gnumeric' => 'application/x-gnumeric',
+        'gph' => 'application/vnd.flographit',
+        'gqf' => 'application/vnd.grafeq',
+        'gqs' => 'application/vnd.grafeq',
+        'gram' => 'application/srgs',
+        'gre' => 'application/vnd.geometry-explorer',
+        'grv' => 'application/vnd.groove-injector',
+        'grxml' => 'application/srgs+xml',
+        'gsf' => 'application/x-font-ghostscript',
+        'gtar' => 'application/x-gtar',
+        'gtm' => 'application/vnd.groove-tool-message',
+        'gtw' => 'model/vnd.gtw',
+        'gv' => 'text/vnd.graphviz',
+        'gxt' => 'application/vnd.geonext',
+        'h' => 'text/x-c',
+        'h261' => 'video/h261',
+        'h263' => 'video/h263',
+        'h264' => 'video/h264',
+        'hal' => 'application/vnd.hal+xml',
+        'hbci' => 'application/vnd.hbci',
+        'hdf' => 'application/x-hdf',
+        'hh' => 'text/x-c',
+        'hlp' => 'application/winhlp',
+        'hpgl' => 'application/vnd.hp-hpgl',
+        'hpid' => 'application/vnd.hp-hpid',
+        'hps' => 'application/vnd.hp-hps',
+        'hqx' => 'application/mac-binhex40',
+        'hta' => 'application/octet-stream',
+        'htc' => 'text/html',
+        'htke' => 'application/vnd.kenameaapp',
+        'htm' => 'text/html',
+        'html' => 'text/html',
+        'hvd' => 'application/vnd.yamaha.hv-dic',
+        'hvp' => 'application/vnd.yamaha.hv-voice',
+        'hvs' => 'application/vnd.yamaha.hv-script',
+        'i2g' => 'application/vnd.intergeo',
+        'icc' => 'application/vnd.iccprofile',
+        'ice' => 'x-conference/x-cooltalk',
+        'icm' => 'application/vnd.iccprofile',
+        'ico' => 'image/x-icon',
+        'ics' => 'text/calendar',
+        'ief' => 'image/ief',
+        'ifb' => 'text/calendar',
+        'ifm' => 'application/vnd.shana.informed.formdata',
+        'iges' => 'model/iges',
+        'igl' => 'application/vnd.igloader',
+        'igm' => 'application/vnd.insors.igm',
+        'igs' => 'model/iges',
+        'igx' => 'application/vnd.micrografx.igx',
+        'iif' => 'application/vnd.shana.informed.interchange',
+        'imp' => 'application/vnd.accpac.simply.imp',
+        'ims' => 'application/vnd.ms-ims',
+        'in' => 'text/plain',
+        'ini' => 'text/plain',
+        'ipfix' => 'application/ipfix',
+        'ipk' => 'application/vnd.shana.informed.package',
+        'irm' => 'application/vnd.ibm.rights-management',
+        'irp' => 'application/vnd.irepository.package+xml',
+        'iso' => 'application/octet-stream',
+        'itp' => 'application/vnd.shana.informed.formtemplate',
+        'ivp' => 'application/vnd.immervision-ivp',
+        'ivu' => 'application/vnd.immervision-ivu',
+        'jad' => 'text/vnd.sun.j2me.app-descriptor',
+        'jam' => 'application/vnd.jam',
+        'jar' => 'application/java-archive',
+        'java' => 'text/x-java-source',
+        'jisp' => 'application/vnd.jisp',
+        'jlt' => 'application/vnd.hp-jlyt',
+        'jnlp' => 'application/x-java-jnlp-file',
+        'joda' => 'application/vnd.joost.joda-archive',
+        'jpe' => 'image/jpeg',
+        'jpeg' => 'image/jpeg',
+        'jpg' => 'image/jpeg',
+        'jpgm' => 'video/jpm',
+        'jpgv' => 'video/jpeg',
+        'jpm' => 'video/jpm',
+        'js' => 'text/javascript',
+        'json' => 'application/json',
+        'kar' => 'audio/midi',
+        'karbon' => 'application/vnd.kde.karbon',
+        'kfo' => 'application/vnd.kde.kformula',
+        'kia' => 'application/vnd.kidspiration',
+        'kml' => 'application/vnd.google-earth.kml+xml',
+        'kmz' => 'application/vnd.google-earth.kmz',
+        'kne' => 'application/vnd.kinar',
+        'knp' => 'application/vnd.kinar',
+        'kon' => 'application/vnd.kde.kontour',
+        'kpr' => 'application/vnd.kde.kpresenter',
+        'kpt' => 'application/vnd.kde.kpresenter',
+        'ksp' => 'application/vnd.kde.kspread',
+        'ktr' => 'application/vnd.kahootz',
+        'ktx' => 'image/ktx',
+        'ktz' => 'application/vnd.kahootz',
+        'kwd' => 'application/vnd.kde.kword',
+        'kwt' => 'application/vnd.kde.kword',
+        'lasxml' => 'application/vnd.las.las+xml',
+        'latex' => 'application/x-latex',
+        'lbd' => 'application/vnd.llamagraphics.life-balance.desktop',
+        'lbe' => 'application/vnd.llamagraphics.life-balance.exchange+xml',
+        'les' => 'application/vnd.hhe.lesson-player',
+        'lha' => 'application/octet-stream',
+        'link66' => 'application/vnd.route66.link66+xml',
+        'list' => 'text/plain',
+        'list3820' => 'application/vnd.ibm.modcap',
+        'listafp' => 'application/vnd.ibm.modcap',
+        'log' => 'text/plain',
+        'lostxml' => 'application/lost+xml',
+        'lrf' => 'application/octet-stream',
+        'lrm' => 'application/vnd.ms-lrm',
+        'ltf' => 'application/vnd.frogans.ltf',
+        'lvp' => 'audio/vnd.lucent.voice',
+        'lwp' => 'application/vnd.lotus-wordpro',
+        'lzh' => 'application/octet-stream',
+        'm13' => 'application/x-msmediaview',
+        'm14' => 'application/x-msmediaview',
+        'm1v' => 'video/mpeg',
+        'm21' => 'application/mp21',
+        'm2a' => 'audio/mpeg',
+        'm2v' => 'video/mpeg',
+        'm3a' => 'audio/mpeg',
+        'm3u' => 'audio/x-mpegurl',
+        'm3u8' => 'application/vnd.apple.mpegurl',
+        'm4a' => 'audio/mp4',
+        'm4u' => 'video/vnd.mpegurl',
+        'm4v' => 'video/mp4',
+        'ma' => 'application/mathematica',
+        'mads' => 'application/mads+xml',
+        'mag' => 'application/vnd.ecowin.chart',
+        'maker' => 'application/vnd.framemaker',
+        'man' => 'text/troff',
+        'mathml' => 'application/mathml+xml',
+        'mb' => 'application/mathematica',
+        'mbk' => 'application/vnd.mobius.mbk',
+        'mbox' => 'application/mbox',
+        'mc1' => 'application/vnd.medcalcdata',
+        'mcd' => 'application/vnd.mcd',
+        'mcurl' => 'text/vnd.curl.mcurl',
+        'mdb' => 'application/x-msaccess',
+        'mdi' => 'image/vnd.ms-modi',
+        'me' => 'text/troff',
+        'mesh' => 'model/mesh',
+        'meta4' => 'application/metalink4+xml',
+        'mets' => 'application/mets+xml',
+        'mfm' => 'application/vnd.mfmp',
+        'mgp' => 'application/vnd.osgeo.mapguide.package',
+        'mgz' => 'application/vnd.proteus.magazine',
+        'mid' => 'audio/midi',
+        'midi' => 'audio/midi',
+        'mif' => 'application/vnd.mif',
+        'mime' => 'message/rfc822',
+        'mj2' => 'video/mj2',
+        'mjp2' => 'video/mj2',
+        'mlp' => 'application/vnd.dolby.mlp',
+        'mmd' => 'application/vnd.chipnuts.karaoke-mmd',
+        'mmf' => 'application/vnd.smaf',
+        'mmr' => 'image/vnd.fujixerox.edmics-mmr',
+        'mny' => 'application/x-msmoney',
+        'mobi' => 'application/x-mobipocket-ebook',
+        'mods' => 'application/mods+xml',
+        'mov' => 'video/quicktime',
+        'movie' => 'video/x-sgi-movie',
+        'mp2' => 'audio/mpeg',
+        'mp21' => 'application/mp21',
+        'mp2a' => 'audio/mpeg',
+        'mp3' => 'audio/mpeg',
+        'mp4' => 'video/mp4',
+        'mp4a' => 'audio/mp4',
+        'mp4s' => 'application/mp4',
+        'mp4v' => 'video/mp4',
+        'mpc' => 'application/vnd.mophun.certificate',
+        'mpe' => 'video/mpeg',
+        'mpeg' => 'video/mpeg',
+        'mpg' => 'video/mpeg',
+        'mpg4' => 'video/mp4',
+        'mpga' => 'audio/mpeg',
+        'mpkg' => 'application/vnd.apple.installer+xml',
+        'mpm' => 'application/vnd.blueice.multipass',
+        'mpn' => 'application/vnd.mophun.application',
+        'mpp' => 'application/vnd.ms-project',
+        'mpt' => 'application/vnd.ms-project',
+        'mpy' => 'application/vnd.ibm.minipay',
+        'mqy' => 'application/vnd.mobius.mqy',
+        'mrc' => 'application/marc',
+        'mrcx' => 'application/marcxml+xml',
+        'ms' => 'text/troff',
+        'mscml' => 'application/mediaservercontrol+xml',
+        'mseed' => 'application/vnd.fdsn.mseed',
+        'mseq' => 'application/vnd.mseq',
+        'msf' => 'application/vnd.epson.msf',
+        'msh' => 'model/mesh',
+        'msi' => 'application/x-msdownload',
+        'msl' => 'application/vnd.mobius.msl',
+        'msty' => 'application/vnd.muvee.style',
+        'mts' => 'model/vnd.mts',
+        'mus' => 'application/vnd.musician',
+        'musicxml' => 'application/vnd.recordare.musicxml+xml',
+        'mvb' => 'application/x-msmediaview',
+        'mwf' => 'application/vnd.mfer',
+        'mxf' => 'application/mxf',
+        'mxl' => 'application/vnd.recordare.musicxml',
+        'mxml' => 'application/xv+xml',
+        'mxs' => 'application/vnd.triscape.mxs',
+        'mxu' => 'video/vnd.mpegurl',
+        'n-gage' => 'application/vnd.nokia.n-gage.symbian.install',
+        'n3' => 'text/n3',
+        'nb' => 'application/mathematica',
+        'nbp' => 'application/vnd.wolfram.player',
+        'nc' => 'application/x-netcdf',
+        'ncx' => 'application/x-dtbncx+xml',
+        'ngdat' => 'application/vnd.nokia.n-gage.data',
+        'nlu' => 'application/vnd.neurolanguage.nlu',
+        'nml' => 'application/vnd.enliven',
+        'nnd' => 'application/vnd.noblenet-directory',
+        'nns' => 'application/vnd.noblenet-sealer',
+        'nnw' => 'application/vnd.noblenet-web',
+        'npx' => 'image/vnd.net-fpx',
+        'nsf' => 'application/vnd.lotus-notes',
+        'oa2' => 'application/vnd.fujitsu.oasys2',
+        'oa3' => 'application/vnd.fujitsu.oasys3',
+        'oas' => 'application/vnd.fujitsu.oasys',
+        'obd' => 'application/x-msbinder',
+        'oda' => 'application/oda',
+        'odb' => 'application/vnd.oasis.opendocument.database',
+        'odc' => 'application/vnd.oasis.opendocument.chart',
+        'odf' => 'application/vnd.oasis.opendocument.formula',
+        'odft' => 'application/vnd.oasis.opendocument.formula-template',
+        'odg' => 'application/vnd.oasis.opendocument.graphics',
+        'odi' => 'application/vnd.oasis.opendocument.image',
+        'odm' => 'application/vnd.oasis.opendocument.text-master',
+        'odp' => 'application/vnd.oasis.opendocument.presentation',
+        'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
+        'odt' => 'application/vnd.oasis.opendocument.text',
+        'oga' => 'audio/ogg',
+        'ogg' => 'audio/ogg',
+        'ogv' => 'video/ogg',
+        'ogx' => 'application/ogg',
+        'onepkg' => 'application/onenote',
+        'onetmp' => 'application/onenote',
+        'onetoc' => 'application/onenote',
+        'onetoc2' => 'application/onenote',
+        'opf' => 'application/oebps-package+xml',
+        'oprc' => 'application/vnd.palm',
+        'org' => 'application/vnd.lotus-organizer',
+        'osf' => 'application/vnd.yamaha.openscoreformat',
+        'osfpvg' => 'application/vnd.yamaha.openscoreformat.osfpvg+xml',
+        'otc' => 'application/vnd.oasis.opendocument.chart-template',
+        'otf' => 'application/x-font-otf',
+        'otg' => 'application/vnd.oasis.opendocument.graphics-template',
+        'oth' => 'application/vnd.oasis.opendocument.text-web',
+        'oti' => 'application/vnd.oasis.opendocument.image-template',
+        'otp' => 'application/vnd.oasis.opendocument.presentation-template',
+        'ots' => 'application/vnd.oasis.opendocument.spreadsheet-template',
+        'ott' => 'application/vnd.oasis.opendocument.text-template',
+        'oxt' => 'application/vnd.openofficeorg.extension',
+        'p' => 'text/x-pascal',
+        'p10' => 'application/pkcs10',
+        'p12' => 'application/x-pkcs12',
+        'p7b' => 'application/x-pkcs7-certificates',
+        'p7c' => 'application/pkcs7-mime',
+        'p7m' => 'application/pkcs7-mime',
+        'p7r' => 'application/x-pkcs7-certreqresp',
+        'p7s' => 'application/pkcs7-signature',
+        'p8' => 'application/pkcs8',
+        'pas' => 'text/x-pascal',
+        'paw' => 'application/vnd.pawaafile',
+        'pbd' => 'application/vnd.powerbuilder6',
+        'pbm' => 'image/x-portable-bitmap',
+        'pcf' => 'application/x-font-pcf',
+        'pcl' => 'application/vnd.hp-pcl',
+        'pclxl' => 'application/vnd.hp-pclxl',
+        'pct' => 'image/x-pict',
+        'pcurl' => 'application/vnd.curl.pcurl',
+        'pcx' => 'image/x-pcx',
+        'pdb' => 'application/vnd.palm',
+        'pdf' => 'application/pdf',
+        'pfa' => 'application/x-font-type1',
+        'pfb' => 'application/x-font-type1',
+        'pfm' => 'application/x-font-type1',
+        'pfr' => 'application/font-tdpfr',
+        'pfx' => 'application/x-pkcs12',
+        'pgm' => 'image/x-portable-graymap',
+        'pgn' => 'application/x-chess-pgn',
+        'pgp' => 'application/pgp-encrypted',
+        'php' => 'text/x-php',
+        'phps' => 'application/x-httpd-phps',
+        'pic' => 'image/x-pict',
+        'pkg' => 'application/octet-stream',
+        'pki' => 'application/pkixcmp',
+        'pkipath' => 'application/pkix-pkipath',
+        'plb' => 'application/vnd.3gpp.pic-bw-large',
+        'plc' => 'application/vnd.mobius.plc',
+        'plf' => 'application/vnd.pocketlearn',
+        'pls' => 'application/pls+xml',
+        'pml' => 'application/vnd.ctc-posml',
+        'png' => 'image/png',
+        'pnm' => 'image/x-portable-anymap',
+        'portpkg' => 'application/vnd.macports.portpkg',
+        'pot' => 'application/vnd.ms-powerpoint',
+        'potm' => 'application/vnd.ms-powerpoint.template.macroenabled.12',
+        'potx' => 'application/vnd.openxmlformats-officedocument.presentationml.template',
+        'ppam' => 'application/vnd.ms-powerpoint.addin.macroenabled.12',
+        'ppd' => 'application/vnd.cups-ppd',
+        'ppm' => 'image/x-portable-pixmap',
+        'pps' => 'application/vnd.ms-powerpoint',
+        'ppsm' => 'application/vnd.ms-powerpoint.slideshow.macroenabled.12',
+        'ppsx' => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
+        'ppt' => 'application/vnd.ms-powerpoint',
+        'pptm' => 'application/vnd.ms-powerpoint.presentation.macroenabled.12',
+        'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        'pqa' => 'application/vnd.palm',
+        'prc' => 'application/x-mobipocket-ebook',
+        'pre' => 'application/vnd.lotus-freelance',
+        'prf' => 'application/pics-rules',
+        'ps' => 'application/postscript',
+        'psb' => 'application/vnd.3gpp.pic-bw-small',
+        'psd' => 'image/vnd.adobe.photoshop',
+        'psf' => 'application/x-font-linux-psf',
+        'pskcxml' => 'application/pskc+xml',
+        'ptid' => 'application/vnd.pvi.ptid1',
+        'pub' => 'application/x-mspublisher',
+        'pvb' => 'application/vnd.3gpp.pic-bw-var',
+        'pwn' => 'application/vnd.3m.post-it-notes',
+        'pya' => 'audio/vnd.ms-playready.media.pya',
+        'pyv' => 'video/vnd.ms-playready.media.pyv',
+        'qam' => 'application/vnd.epson.quickanime',
+        'qbo' => 'application/vnd.intu.qbo',
+        'qfx' => 'application/vnd.intu.qfx',
+        'qps' => 'application/vnd.publishare-delta-tree',
+        'qt' => 'video/quicktime',
+        'qwd' => 'application/vnd.quark.quarkxpress',
+        'qwt' => 'application/vnd.quark.quarkxpress',
+        'qxb' => 'application/vnd.quark.quarkxpress',
+        'qxd' => 'application/vnd.quark.quarkxpress',
+        'qxl' => 'application/vnd.quark.quarkxpress',
+        'qxt' => 'application/vnd.quark.quarkxpress',
+        'ra' => 'audio/x-pn-realaudio',
+        'ram' => 'audio/x-pn-realaudio',
+        'rar' => 'application/x-rar-compressed',
+        'ras' => 'image/x-cmu-raster',
+        'rb' => 'text/plain',
+        'rcprofile' => 'application/vnd.ipunplugged.rcprofile',
+        'rdf' => 'application/rdf+xml',
+        'rdz' => 'application/vnd.data-vision.rdz',
+        'rep' => 'application/vnd.businessobjects',
+        'res' => 'application/x-dtbresource+xml',
+        'resx' => 'text/xml',
+        'rgb' => 'image/x-rgb',
+        'rif' => 'application/reginfo+xml',
+        'rip' => 'audio/vnd.rip',
+        'rl' => 'application/resource-lists+xml',
+        'rlc' => 'image/vnd.fujixerox.edmics-rlc',
+        'rld' => 'application/resource-lists-diff+xml',
+        'rm' => 'application/vnd.rn-realmedia',
+        'rmi' => 'audio/midi',
+        'rmp' => 'audio/x-pn-realaudio-plugin',
+        'rms' => 'application/vnd.jcp.javame.midlet-rms',
+        'rnc' => 'application/relax-ng-compact-syntax',
+        'roff' => 'text/troff',
+        'rp9' => 'application/vnd.cloanto.rp9',
+        'rpss' => 'application/vnd.nokia.radio-presets',
+        'rpst' => 'application/vnd.nokia.radio-preset',
+        'rq' => 'application/sparql-query',
+        'rs' => 'application/rls-services+xml',
+        'rsd' => 'application/rsd+xml',
+        'rss' => 'application/rss+xml',
+        'rtf' => 'application/rtf',
+        'rtx' => 'text/richtext',
+        's' => 'text/x-asm',
+        'saf' => 'application/vnd.yamaha.smaf-audio',
+        'sbml' => 'application/sbml+xml',
+        'sc' => 'application/vnd.ibm.secure-container',
+        'scd' => 'application/x-msschedule',
+        'scm' => 'application/vnd.lotus-screencam',
+        'scq' => 'application/scvp-cv-request',
+        'scs' => 'application/scvp-cv-response',
+        'scurl' => 'text/vnd.curl.scurl',
+        'sda' => 'application/vnd.stardivision.draw',
+        'sdc' => 'application/vnd.stardivision.calc',
+        'sdd' => 'application/vnd.stardivision.impress',
+        'sdkd' => 'application/vnd.solent.sdkm+xml',
+        'sdkm' => 'application/vnd.solent.sdkm+xml',
+        'sdp' => 'application/sdp',
+        'sdw' => 'application/vnd.stardivision.writer',
+        'see' => 'application/vnd.seemail',
+        'seed' => 'application/vnd.fdsn.seed',
+        'sema' => 'application/vnd.sema',
+        'semd' => 'application/vnd.semd',
+        'semf' => 'application/vnd.semf',
+        'ser' => 'application/java-serialized-object',
+        'setpay' => 'application/set-payment-initiation',
+        'setreg' => 'application/set-registration-initiation',
+        'sfd-hdstx' => 'application/vnd.hydrostatix.sof-data',
+        'sfs' => 'application/vnd.spotfire.sfs',
+        'sgl' => 'application/vnd.stardivision.writer-global',
+        'sgm' => 'text/sgml',
+        'sgml' => 'text/sgml',
+        'sh' => 'application/x-sh',
+        'shar' => 'application/x-shar',
+        'shf' => 'application/shf+xml',
+        'sig' => 'application/pgp-signature',
+        'silo' => 'model/mesh',
+        'sis' => 'application/vnd.symbian.install',
+        'sisx' => 'application/vnd.symbian.install',
+        'sit' => 'application/x-stuffit',
+        'sitx' => 'application/x-stuffitx',
+        'skd' => 'application/vnd.koan',
+        'skm' => 'application/vnd.koan',
+        'skp' => 'application/vnd.koan',
+        'skt' => 'application/vnd.koan',
+        'sldm' => 'application/vnd.ms-powerpoint.slide.macroenabled.12',
+        'sldx' => 'application/vnd.openxmlformats-officedocument.presentationml.slide',
+        'slt' => 'application/vnd.epson.salt',
+        'sm' => 'application/vnd.stepmania.stepchart',
+        'smf' => 'application/vnd.stardivision.math',
+        'smi' => 'application/smil+xml',
+        'smil' => 'application/smil+xml',
+        'snd' => 'audio/basic',
+        'snf' => 'application/x-font-snf',
+        'so' => 'application/octet-stream',
+        'spc' => 'application/x-pkcs7-certificates',
+        'spf' => 'application/vnd.yamaha.smaf-phrase',
+        'spl' => 'application/x-futuresplash',
+        'spot' => 'text/vnd.in3d.spot',
+        'spp' => 'application/scvp-vp-response',
+        'spq' => 'application/scvp-vp-request',
+        'spx' => 'audio/ogg',
+        'src' => 'application/x-wais-source',
+        'sru' => 'application/sru+xml',
+        'srx' => 'application/sparql-results+xml',
+        'sse' => 'application/vnd.kodak-descriptor',
+        'ssf' => 'application/vnd.epson.ssf',
+        'ssml' => 'application/ssml+xml',
+        'st' => 'application/vnd.sailingtracker.track',
+        'stc' => 'application/vnd.sun.xml.calc.template',
+        'std' => 'application/vnd.sun.xml.draw.template',
+        'stf' => 'application/vnd.wt.stf',
+        'sti' => 'application/vnd.sun.xml.impress.template',
+        'stk' => 'application/hyperstudio',
+        'stl' => 'application/vnd.ms-pki.stl',
+        'str' => 'application/vnd.pg.format',
+        'stw' => 'application/vnd.sun.xml.writer.template',
+        'sub' => 'image/vnd.dvb.subtitle',
+        'sus' => 'application/vnd.sus-calendar',
+        'susp' => 'application/vnd.sus-calendar',
+        'sv4cpio' => 'application/x-sv4cpio',
+        'sv4crc' => 'application/x-sv4crc',
+        'svc' => 'application/vnd.dvb.service',
+        'svd' => 'application/vnd.svd',
+        'svg' => 'image/svg+xml',
+        'svgz' => 'image/svg+xml',
+        'swa' => 'application/x-director',
+        'swf' => 'application/x-shockwave-flash',
+        'swi' => 'application/vnd.aristanetworks.swi',
+        'sxc' => 'application/vnd.sun.xml.calc',
+        'sxd' => 'application/vnd.sun.xml.draw',
+        'sxg' => 'application/vnd.sun.xml.writer.global',
+        'sxi' => 'application/vnd.sun.xml.impress',
+        'sxm' => 'application/vnd.sun.xml.math',
+        'sxw' => 'application/vnd.sun.xml.writer',
+        't' => 'text/troff',
+        'tao' => 'application/vnd.tao.intent-module-archive',
+        'tar' => 'application/x-tar',
+        'tcap' => 'application/vnd.3gpp2.tcap',
+        'tcl' => 'application/x-tcl',
+        'teacher' => 'application/vnd.smart.teacher',
+        'tei' => 'application/tei+xml',
+        'teicorpus' => 'application/tei+xml',
+        'tex' => 'application/x-tex',
+        'texi' => 'application/x-texinfo',
+        'texinfo' => 'application/x-texinfo',
+        'text' => 'text/plain',
+        'tfi' => 'application/thraud+xml',
+        'tfm' => 'application/x-tex-tfm',
+        'thmx' => 'application/vnd.ms-officetheme',
+        'tif' => 'image/tiff',
+        'tiff' => 'image/tiff',
+        'tmo' => 'application/vnd.tmobile-livetv',
+        'torrent' => 'application/x-bittorrent',
+        'tpl' => 'application/vnd.groove-tool-template',
+        'tpt' => 'application/vnd.trid.tpt',
+        'tr' => 'text/troff',
+        'tra' => 'application/vnd.trueapp',
+        'trm' => 'application/x-msterminal',
+        'tsd' => 'application/timestamped-data',
+        'tsv' => 'text/tab-separated-values',
+        'ttc' => 'application/x-font-ttf',
+        'ttf' => 'application/x-font-ttf',
+        'ttl' => 'text/turtle',
+        'twd' => 'application/vnd.simtech-mindmapper',
+        'twds' => 'application/vnd.simtech-mindmapper',
+        'txd' => 'application/vnd.genomatix.tuxedo',
+        'txf' => 'application/vnd.mobius.txf',
+        'txt' => 'text/plain',
+        'u32' => 'application/x-authorware-bin',
+        'udeb' => 'application/x-debian-package',
+        'ufd' => 'application/vnd.ufdl',
+        'ufdl' => 'application/vnd.ufdl',
+        'umj' => 'application/vnd.umajin',
+        'unityweb' => 'application/vnd.unity',
+        'uoml' => 'application/vnd.uoml+xml',
+        'uri' => 'text/uri-list',
+        'uris' => 'text/uri-list',
+        'urls' => 'text/uri-list',
+        'ustar' => 'application/x-ustar',
+        'utz' => 'application/vnd.uiq.theme',
+        'uu' => 'text/x-uuencode',
+        'uva' => 'audio/vnd.dece.audio',
+        'uvd' => 'application/vnd.dece.data',
+        'uvf' => 'application/vnd.dece.data',
+        'uvg' => 'image/vnd.dece.graphic',
+        'uvh' => 'video/vnd.dece.hd',
+        'uvi' => 'image/vnd.dece.graphic',
+        'uvm' => 'video/vnd.dece.mobile',
+        'uvp' => 'video/vnd.dece.pd',
+        'uvs' => 'video/vnd.dece.sd',
+        'uvt' => 'application/vnd.dece.ttml+xml',
+        'uvu' => 'video/vnd.uvvu.mp4',
+        'uvv' => 'video/vnd.dece.video',
+        'uvva' => 'audio/vnd.dece.audio',
+        'uvvd' => 'application/vnd.dece.data',
+        'uvvf' => 'application/vnd.dece.data',
+        'uvvg' => 'image/vnd.dece.graphic',
+        'uvvh' => 'video/vnd.dece.hd',
+        'uvvi' => 'image/vnd.dece.graphic',
+        'uvvm' => 'video/vnd.dece.mobile',
+        'uvvp' => 'video/vnd.dece.pd',
+        'uvvs' => 'video/vnd.dece.sd',
+        'uvvt' => 'application/vnd.dece.ttml+xml',
+        'uvvu' => 'video/vnd.uvvu.mp4',
+        'uvvv' => 'video/vnd.dece.video',
+        'uvvx' => 'application/vnd.dece.unspecified',
+        'uvx' => 'application/vnd.dece.unspecified',
+        'vcd' => 'application/x-cdlink',
+        'vcf' => 'text/x-vcard',
+        'vcg' => 'application/vnd.groove-vcard',
+        'vcs' => 'text/x-vcalendar',
+        'vcx' => 'application/vnd.vcx',
+        'vis' => 'application/vnd.visionary',
+        'viv' => 'video/vnd.vivo',
+        'vor' => 'application/vnd.stardivision.writer',
+        'vox' => 'application/x-authorware-bin',
+        'vrml' => 'model/vrml',
+        'vsd' => 'application/vnd.visio',
+        'vsf' => 'application/vnd.vsf',
+        'vss' => 'application/vnd.visio',
+        'vst' => 'application/vnd.visio',
+        'vsw' => 'application/vnd.visio',
+        'vtu' => 'model/vnd.vtu',
+        'vxml' => 'application/voicexml+xml',
+        'w3d' => 'application/x-director',
+        'wad' => 'application/x-doom',
+        'wav' => 'audio/x-wav',
+        'wax' => 'audio/x-ms-wax',
+        'wbmp' => 'image/vnd.wap.wbmp',
+        'wbs' => 'application/vnd.criticaltools.wbs+xml',
+        'wbxml' => 'application/vnd.wap.wbxml',
+        'wcm' => 'application/vnd.ms-works',
+        'wdb' => 'application/vnd.ms-works',
+        'weba' => 'audio/webm',
+        'webm' => 'video/webm',
+        'webp' => 'image/webp',
+        'wg' => 'application/vnd.pmi.widget',
+        'wgt' => 'application/widget',
+        'wks' => 'application/vnd.ms-works',
+        'wm' => 'video/x-ms-wm',
+        'wma' => 'audio/x-ms-wma',
+        'wmd' => 'application/x-ms-wmd',
+        'wmf' => 'application/x-msmetafile',
+        'wml' => 'text/vnd.wap.wml',
+        'wmlc' => 'application/vnd.wap.wmlc',
+        'wmls' => 'text/vnd.wap.wmlscript',
+        'wmlsc' => 'application/vnd.wap.wmlscriptc',
+        'wmv' => 'video/x-ms-wmv',
+        'wmx' => 'video/x-ms-wmx',
+        'wmz' => 'application/x-ms-wmz',
+        'woff' => 'application/x-font-woff',
+        'wpd' => 'application/vnd.wordperfect',
+        'wpl' => 'application/vnd.ms-wpl',
+        'wps' => 'application/vnd.ms-works',
+        'wqd' => 'application/vnd.wqd',
+        'wri' => 'application/x-mswrite',
+        'wrl' => 'model/vrml',
+        'wsdl' => 'application/wsdl+xml',
+        'wspolicy' => 'application/wspolicy+xml',
+        'wtb' => 'application/vnd.webturbo',
+        'wvx' => 'video/x-ms-wvx',
+        'x32' => 'application/x-authorware-bin',
+        'x3d' => 'application/vnd.hzn-3d-crossword',
+        'xap' => 'application/x-silverlight-app',
+        'xar' => 'application/vnd.xara',
+        'xbap' => 'application/x-ms-xbap',
+        'xbd' => 'application/vnd.fujixerox.docuworks.binder',
+        'xbm' => 'image/x-xbitmap',
+        'xdf' => 'application/xcap-diff+xml',
+        'xdm' => 'application/vnd.syncml.dm+xml',
+        'xdp' => 'application/vnd.adobe.xdp+xml',
+        'xdssc' => 'application/dssc+xml',
+        'xdw' => 'application/vnd.fujixerox.docuworks',
+        'xenc' => 'application/xenc+xml',
+        'xer' => 'application/patch-ops-error+xml',
+        'xfdf' => 'application/vnd.adobe.xfdf',
+        'xfdl' => 'application/vnd.xfdl',
+        'xht' => 'application/xhtml+xml',
+        'xhtml' => 'application/xhtml+xml',
+        'xhvml' => 'application/xv+xml',
+        'xif' => 'image/vnd.xiff',
+        'xla' => 'application/vnd.ms-excel',
+        'xlam' => 'application/vnd.ms-excel.addin.macroenabled.12',
+        'xlc' => 'application/vnd.ms-excel',
+        'xlm' => 'application/vnd.ms-excel',
+        'xls' => 'application/vnd.ms-excel',
+        'xlsb' => 'application/vnd.ms-excel.sheet.binary.macroenabled.12',
+        'xlsm' => 'application/vnd.ms-excel.sheet.macroenabled.12',
+        'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'xlt' => 'application/vnd.ms-excel',
+        'xltm' => 'application/vnd.ms-excel.template.macroenabled.12',
+        'xltx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
+        'xlw' => 'application/vnd.ms-excel',
+        'xml' => 'application/xml',
+        'xo' => 'application/vnd.olpc-sugar',
+        'xop' => 'application/xop+xml',
+        'xpi' => 'application/x-xpinstall',
+        'xpm' => 'image/x-xpixmap',
+        'xpr' => 'application/vnd.is-xpr',
+        'xps' => 'application/vnd.ms-xpsdocument',
+        'xpw' => 'application/vnd.intercon.formnet',
+        'xpx' => 'application/vnd.intercon.formnet',
+        'xsl' => 'application/xml',
+        'xslt' => 'application/xslt+xml',
+        'xsm' => 'application/vnd.syncml+xml',
+        'xspf' => 'application/xspf+xml',
+        'xul' => 'application/vnd.mozilla.xul+xml',
+        'xvm' => 'application/xv+xml',
+        'xvml' => 'application/xv+xml',
+        'xwd' => 'image/x-xwindowdump',
+        'xyz' => 'chemical/x-xyz',
+        'yaml' => 'text/yaml',
+        'yang' => 'application/yang',
+        'yin' => 'application/yin+xml',
+        'yml' => 'text/yaml',
+        'zaz' => 'application/vnd.zzazz.deck+xml',
+        'zip' => 'application/zip',
+        'zir' => 'application/vnd.zul',
+        'zirz' => 'application/vnd.zul',
+        'zmm' => 'application/vnd.handheld-entertainment+xml'
+    );
+
+    /**
+     * Get a singleton instance of the class
+     *
+     * @return self
+     * @codeCoverageIgnore
+     */
+    public static function getInstance()
+    {
+        if (!self::$instance) {
+            self::$instance = new self();
+        }
+
+        return self::$instance;
+    }
+
+    /**
+     * Get a mimetype value from a file extension
+     *
+     * @param string $extension File extension
+     *
+     * @return string|null
+     *
+     */
+    public function fromExtension($extension)
+    {
+        $extension = strtolower($extension);
+
+        return isset($this->mimetypes[$extension])
+            ? $this->mimetypes[$extension]
+            : null;
+    }
+
+    /**
+     * Get a mimetype from a filename
+     *
+     * @param string $filename Filename to generate a mimetype from
+     *
+     * @return string|null
+     */
+    public function fromFilename($filename)
+    {
+        return $this->fromExtension(pathinfo($filename, PATHINFO_EXTENSION));
+    }
+}

vendor/guzzlehttp/guzzle/src/Pool.php

@@ -0,0 +1,333 @@
+<?php
+namespace GuzzleHttp;
+
+use GuzzleHttp\Event\BeforeEvent;
+use GuzzleHttp\Event\RequestEvents;
+use GuzzleHttp\Message\RequestInterface;
+use GuzzleHttp\Message\ResponseInterface;
+use GuzzleHttp\Ring\Core;
+use GuzzleHttp\Ring\Future\FutureInterface;
+use GuzzleHttp\Event\ListenerAttacherTrait;
+use GuzzleHttp\Event\EndEvent;
+use React\Promise\Deferred;
+use React\Promise\FulfilledPromise;
+use React\Promise\PromiseInterface;
+use React\Promise\RejectedPromise;
+
+/**
+ * Sends and iterator of requests concurrently using a capped pool size.
+ *
+ * The Pool object implements FutureInterface, meaning it can be used later
+ * when necessary, the requests provided to the pool can be cancelled, and
+ * you can check the state of the pool to know if it has been dereferenced
+ * (sent) or has been cancelled.
+ *
+ * When sending the pool, keep in mind that no results are returned: callers
+ * are expected to handle results asynchronously using Guzzle's event system.
+ * When requests complete, more are added to the pool to ensure that the
+ * requested pool size is always filled as much as possible.
+ *
+ * IMPORTANT: Do not provide a pool size greater that what the utilized
+ * underlying RingPHP handler can support. This will result is extremely poor
+ * performance.
+ */
+class Pool implements FutureInterface
+{
+    use ListenerAttacherTrait;
+
+    /** @var \GuzzleHttp\ClientInterface */
+    private $client;
+
+    /** @var \Iterator Yields requests */
+    private $iter;
+
+    /** @var Deferred */
+    private $deferred;
+
+    /** @var PromiseInterface */
+    private $promise;
+
+    private $waitQueue = [];
+    private $eventListeners = [];
+    private $poolSize;
+    private $isRealized = false;
+
+    /**
+     * The option values for 'before', 'complete', 'error' and 'end' can be a
+     * callable, an associative array containing event data, or an array of
+     * event data arrays. Event data arrays contain the following keys:
+     *
+     * - fn: callable to invoke that receives the event
+     * - priority: Optional event priority (defaults to 0)
+     * - once: Set to true so that the event is removed after it is triggered
+     *
+     * @param ClientInterface $client   Client used to send the requests.
+     * @param array|\Iterator $requests Requests to send in parallel
+     * @param array           $options  Associative array of options
+     *     - pool_size: (callable|int)   Maximum number of requests to send
+     *                                   concurrently, or a callback that receives
+     *                                   the current queue size and returns the
+     *                                   number of new requests to send
+     *     - before:    (callable|array) Receives a BeforeEvent
+     *     - complete:  (callable|array) Receives a CompleteEvent
+     *     - error:     (callable|array) Receives a ErrorEvent
+     *     - end:       (callable|array) Receives an EndEvent
+     */
+    public function __construct(
+        ClientInterface $client,
+        $requests,
+        array $options = []
+    ) {
+        $this->client = $client;
+        $this->iter = $this->coerceIterable($requests);
+        $this->deferred = new Deferred();
+        $this->promise = $this->deferred->promise();
+        $this->poolSize = isset($options['pool_size'])
+            ? $options['pool_size'] : 25;
+        $this->eventListeners = $this->prepareListeners(
+            $options,
+            ['before', 'complete', 'error', 'end']
+        );
+    }
+
+    /**
+     * Sends multiple requests in parallel and returns an array of responses
+     * and exceptions that uses the same ordering as the provided requests.
+     *
+     * IMPORTANT: This method keeps every request and response in memory, and
+     * as such, is NOT recommended when sending a large number or an
+     * indeterminate number of requests concurrently.
+     *
+     * @param ClientInterface $client   Client used to send the requests
+     * @param array|\Iterator $requests Requests to send in parallel
+     * @param array           $options  Passes through the options available in
+     *                                  {@see GuzzleHttp\Pool::__construct}
+     *
+     * @return BatchResults Returns a container for the results.
+     * @throws \InvalidArgumentException if the event format is incorrect.
+     */
+    public static function batch(
+        ClientInterface $client,
+        $requests,
+        array $options = []
+    ) {
+        $hash = new \SplObjectStorage();
+        foreach ($requests as $request) {
+            $hash->attach($request);
+        }
+
+        // In addition to the normally run events when requests complete, add
+        // and event to continuously track the results of transfers in the hash.
+        (new self($client, $requests, RequestEvents::convertEventArray(
+            $options,
+            ['end'],
+            [
+                'priority' => RequestEvents::LATE,
+                'fn'       => function (EndEvent $e) use ($hash) {
+                    $hash[$e->getRequest()] = $e->getException()
+                        ? $e->getException()
+                        : $e->getResponse();
+                }
+            ]
+        )))->wait();
+
+        return new BatchResults($hash);
+    }
+
+    /**
+     * Creates a Pool and immediately sends the requests.
+     *
+     * @param ClientInterface $client   Client used to send the requests
+     * @param array|\Iterator $requests Requests to send in parallel
+     * @param array           $options  Passes through the options available in
+     *                                  {@see GuzzleHttp\Pool::__construct}
+     */
+    public static function send(
+        ClientInterface $client,
+        $requests,
+        array $options = []
+    ) {
+        $pool = new self($client, $requests, $options);
+        $pool->wait();
+    }
+
+    private function getPoolSize()
+    {
+        return is_callable($this->poolSize)
+            ? call_user_func($this->poolSize, count($this->waitQueue))
+            : $this->poolSize;
+    }
+
+    /**
+     * Add as many requests as possible up to the current pool limit.
+     */
+    private function addNextRequests()
+    {
+        $limit = max($this->getPoolSize() - count($this->waitQueue), 0);
+        while ($limit--) {
+            if (!$this->addNextRequest()) {
+                break;
+            }
+        }
+    }
+
+    public function wait()
+    {
+        if ($this->isRealized) {
+            return false;
+        }
+
+        // Seed the pool with N number of requests.
+        $this->addNextRequests();
+
+        // Stop if the pool was cancelled while transferring requests.
+        if ($this->isRealized) {
+            return false;
+        }
+
+        // Wait on any outstanding FutureResponse objects.
+        while ($response = array_pop($this->waitQueue)) {
+            try {
+                $response->wait();
+            } catch (\Exception $e) {
+                // Eat exceptions because they should be handled asynchronously
+            }
+            $this->addNextRequests();
+        }
+
+        // Clean up no longer needed state.
+        $this->isRealized = true;
+        $this->waitQueue = $this->eventListeners = [];
+        $this->client = $this->iter = null;
+        $this->deferred->resolve(true);
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * Attempt to cancel all outstanding requests (requests that are queued for
+     * dereferencing). Returns true if all outstanding requests can be
+     * cancelled.
+     *
+     * @return bool
+     */
+    public function cancel()
+    {
+        if ($this->isRealized) {
+            return false;
+        }
+
+        $success = $this->isRealized = true;
+        foreach ($this->waitQueue as $response) {
+            if (!$response->cancel()) {
+                $success = false;
+            }
+        }
+
+        return $success;
+    }
+
+    /**
+     * Returns a promise that is invoked when the pool completed. There will be
+     * no passed value.
+     *
+     * {@inheritdoc}
+     */
+    public function then(
+        callable $onFulfilled = null,
+        callable $onRejected = null,
+        callable $onProgress = null
+    ) {
+        return $this->promise->then($onFulfilled, $onRejected, $onProgress);
+    }
+
+    public function promise()
+    {
+        return $this->promise;
+    }
+
+    private function coerceIterable($requests)
+    {
+        if ($requests instanceof \Iterator) {
+            return $requests;
+        } elseif (is_array($requests)) {
+            return new \ArrayIterator($requests);
+        }
+
+        throw new \InvalidArgumentException('Expected Iterator or array. '
+            . 'Found ' . Core::describeType($requests));
+    }
+
+    /**
+     * Adds the next request to pool and tracks what requests need to be
+     * dereferenced when completing the pool.
+     */
+    private function addNextRequest()
+    {
+        add_next:
+
+        if ($this->isRealized || !$this->iter || !$this->iter->valid()) {
+            return false;
+        }
+
+        $request = $this->iter->current();
+        $this->iter->next();
+
+        if (!($request instanceof RequestInterface)) {
+            throw new \InvalidArgumentException(sprintf(
+                'All requests in the provided iterator must implement '
+                . 'RequestInterface. Found %s',
+                Core::describeType($request)
+            ));
+        }
+
+        // Be sure to use "lazy" futures, meaning they do not send right away.
+        $request->getConfig()->set('future', 'lazy');
+        $hash = spl_object_hash($request);
+        $this->attachListeners($request, $this->eventListeners);
+        $request->getEmitter()->on('before', [$this, '_trackRetries'], RequestEvents::EARLY);
+        $response = $this->client->send($request);
+        $this->waitQueue[$hash] = $response;
+        $promise = $response->promise();
+
+        // Don't recursively call itself for completed or rejected responses.
+        if ($promise instanceof FulfilledPromise
+            || $promise instanceof RejectedPromise
+        ) {
+            try {
+                $this->finishResponse($request, $response->wait(), $hash);
+            } catch (\Exception $e) {
+                $this->finishResponse($request, $e, $hash);
+            }
+            goto add_next;
+        }
+
+        // Use this function for both resolution and rejection.
+        $thenFn = function ($value) use ($request, $hash) {
+            $this->finishResponse($request, $value, $hash);
+            if (!$request->getConfig()->get('_pool_retries')) {
+                $this->addNextRequests();
+            }
+        };
+
+        $promise->then($thenFn, $thenFn);
+
+        return true;
+    }
+
+    public function _trackRetries(BeforeEvent $e)
+    {
+        $e->getRequest()->getConfig()->set('_pool_retries', $e->getRetryCount());
+    }
+
+    private function finishResponse($request, $value, $hash)
+    {
+        unset($this->waitQueue[$hash]);
+        $result = $value instanceof ResponseInterface
+            ? ['request' => $request, 'response' => $value, 'error' => null]
+            : ['request' => $request, 'response' => null, 'error' => $value];
+        $this->deferred->notify($result);
+    }
+}