22 files changed, 2407 insertions, 2347 deletions

diff --git a/vendor/guzzlehttp/promises/CHANGELOG.md b/vendor/guzzlehttp/promises/CHANGELOG.md
index 7c46ff6..f808174 100644
--- a/vendor/guzzlehttp/promises/CHANGELOG.md
+++ b/vendor/guzzlehttp/promises/CHANGELOG.md
@@ -1,7 +1,39 @@
 # CHANGELOG

 

+## 1.5.3 - 2023-05-21

+

+### Changed

+

+- Removed remaining usage of deprecated functions

+

+## 1.5.2 - 2022-08-07

+

+### Changed

+

+- Officially support PHP 8.2

+

+## 1.5.1 - 2021-10-22

+

+### Fixed

+

+- Revert "Call handler when waiting on fulfilled/rejected Promise"

+- Fix pool memory leak when empty array of promises provided

+

+## 1.5.0 - 2021-10-07

+

+### Changed

+

+- Call handler when waiting on fulfilled/rejected Promise

+- Officially support PHP 8.1

+

+### Fixed

+

+- Fix manually settle promises generated with `Utils::task`

+

 ## 1.4.1 - 2021-02-18

 

+### Fixed

+

 - Fixed `each_limit` skipping promises and failing

 

 ## 1.4.0 - 2020-09-30

diff --git a/vendor/guzzlehttp/promises/LICENSE b/vendor/guzzlehttp/promises/LICENSE
index 67f91a1..9f0f943 100644
--- a/vendor/guzzlehttp/promises/LICENSE
+++ b/vendor/guzzlehttp/promises/LICENSE
@@ -1,4 +1,9 @@
-Copyright (c) 2015-2016 Michael Dowling, https://github.com/mtdowling <mtdowling@gmail.com>
+The MIT License (MIT)
+
+Copyright (c) 2015 Michael Dowling <mtdowling@gmail.com>
+Copyright (c) 2015 Graham Campbell <hello@gjcampbell.co.uk>
+Copyright (c) 2017 Tobias Schultze <webmaster@tubo-world.de>
+Copyright (c) 2020 Tobias Nyholm <tobias.nyholm@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
diff --git a/vendor/guzzlehttp/promises/README.md b/vendor/guzzlehttp/promises/README.md
index a95c605..0879086 100644
--- a/vendor/guzzlehttp/promises/README.md
+++ b/vendor/guzzlehttp/promises/README.md
@@ -1,532 +1,546 @@
-# Guzzle Promises
-
-[Promises/A+](https://promisesaplus.com/) implementation that handles promise
-chaining and resolution iteratively, allowing for "infinite" promise chaining
-while keeping the stack size constant. Read [this blog post](https://blog.domenic.me/youre-missing-the-point-of-promises/)
-for a general introduction to promises.
-
-- [Features](#features)
-- [Quick start](#quick-start)
-- [Synchronous wait](#synchronous-wait)
-- [Cancellation](#cancellation)
-- [API](#api)
-  - [Promise](#promise)
-  - [FulfilledPromise](#fulfilledpromise)
-  - [RejectedPromise](#rejectedpromise)
-- [Promise interop](#promise-interop)
-- [Implementation notes](#implementation-notes)
-
-
-# Features
-
-- [Promises/A+](https://promisesaplus.com/) implementation.
-- Promise resolution and chaining is handled iteratively, allowing for
-  "infinite" promise chaining.
-- Promises have a synchronous `wait` method.
-- Promises can be cancelled.
-- Works with any object that has a `then` function.
-- C# style async/await coroutine promises using
-  `GuzzleHttp\Promise\Coroutine::of()`.
-
-
-# Quick start
-
-A *promise* represents the eventual result of an asynchronous operation. The
-primary way of interacting with a promise is through its `then` method, which
-registers callbacks to receive either a promise's eventual value or the reason
-why the promise cannot be fulfilled.
-
-
-## Callbacks
-
-Callbacks are registered with the `then` method by providing an optional 
-`$onFulfilled` followed by an optional `$onRejected` function.
-
-
-```php
-use GuzzleHttp\Promise\Promise;
-
-$promise = new Promise();
-$promise->then(
-    // $onFulfilled
-    function ($value) {
-        echo 'The promise was fulfilled.';
-    },
-    // $onRejected
-    function ($reason) {
-        echo 'The promise was rejected.';
-    }
-);
-```
-
-*Resolving* a promise means that you either fulfill a promise with a *value* or
-reject a promise with a *reason*. Resolving a promises triggers callbacks
-registered with the promises's `then` method. These callbacks are triggered
-only once and in the order in which they were added.
-
-
-## Resolving a promise
-
-Promises are fulfilled using the `resolve($value)` method. Resolving a promise
-with any value other than a `GuzzleHttp\Promise\RejectedPromise` will trigger
-all of the onFulfilled callbacks (resolving a promise with a rejected promise
-will reject the promise and trigger the `$onRejected` callbacks).
-
-```php
-use GuzzleHttp\Promise\Promise;
-
-$promise = new Promise();
-$promise
-    ->then(function ($value) {
-        // Return a value and don't break the chain
-        return "Hello, " . $value;
-    })
-    // This then is executed after the first then and receives the value
-    // returned from the first then.
-    ->then(function ($value) {
-        echo $value;
-    });
-
-// Resolving the promise triggers the $onFulfilled callbacks and outputs
-// "Hello, reader."
-$promise->resolve('reader.');
-```
-
-
-## Promise forwarding
-
-Promises can be chained one after the other. Each then in the chain is a new
-promise. The return value of a promise is what's forwarded to the next
-promise in the chain. Returning a promise in a `then` callback will cause the
-subsequent promises in the chain to only be fulfilled when the returned promise
-has been fulfilled. The next promise in the chain will be invoked with the
-resolved value of the promise.
-
-```php
-use GuzzleHttp\Promise\Promise;
-
-$promise = new Promise();
-$nextPromise = new Promise();
-
-$promise
-    ->then(function ($value) use ($nextPromise) {
-        echo $value;
-        return $nextPromise;
-    })
-    ->then(function ($value) {
-        echo $value;
-    });
-
-// Triggers the first callback and outputs "A"
-$promise->resolve('A');
-// Triggers the second callback and outputs "B"
-$nextPromise->resolve('B');
-```
-
-## Promise rejection
-
-When a promise is rejected, the `$onRejected` callbacks are invoked with the
-rejection reason.
-
-```php
-use GuzzleHttp\Promise\Promise;
-
-$promise = new Promise();
-$promise->then(null, function ($reason) {
-    echo $reason;
-});
-
-$promise->reject('Error!');
-// Outputs "Error!"
-```
-
-## Rejection forwarding
-
-If an exception is thrown in an `$onRejected` callback, subsequent
-`$onRejected` callbacks are invoked with the thrown exception as the reason.
-
-```php
-use GuzzleHttp\Promise\Promise;
-
-$promise = new Promise();
-$promise->then(null, function ($reason) {
-    throw new Exception($reason);
-})->then(null, function ($reason) {
-    assert($reason->getMessage() === 'Error!');
-});
-
-$promise->reject('Error!');
-```
-
-You can also forward a rejection down the promise chain by returning a
-`GuzzleHttp\Promise\RejectedPromise` in either an `$onFulfilled` or
-`$onRejected` callback.
-
-```php
-use GuzzleHttp\Promise\Promise;
-use GuzzleHttp\Promise\RejectedPromise;
-
-$promise = new Promise();
-$promise->then(null, function ($reason) {
-    return new RejectedPromise($reason);
-})->then(null, function ($reason) {
-    assert($reason === 'Error!');
-});
-
-$promise->reject('Error!');
-```
-
-If an exception is not thrown in a `$onRejected` callback and the callback
-does not return a rejected promise, downstream `$onFulfilled` callbacks are
-invoked using the value returned from the `$onRejected` callback.
-
-```php
-use GuzzleHttp\Promise\Promise;
-
-$promise = new Promise();
-$promise
-    ->then(null, function ($reason) {
-        return "It's ok";
-    })
-    ->then(function ($value) {
-        assert($value === "It's ok");
-    });
-
-$promise->reject('Error!');
-```
-
-# Synchronous wait
-
-You can synchronously force promises to complete using a promise's `wait`
-method. When creating a promise, you can provide a wait function that is used
-to synchronously force a promise to complete. When a wait function is invoked
-it is expected to deliver a value to the promise or reject the promise. If the
-wait function does not deliver a value, then an exception is thrown. The wait
-function provided to a promise constructor is invoked when the `wait` function
-of the promise is called.
-
-```php
-$promise = new Promise(function () use (&$promise) {
-    $promise->resolve('foo');
-});
-
-// Calling wait will return the value of the promise.
-echo $promise->wait(); // outputs "foo"
-```
-
-If an exception is encountered while invoking the wait function of a promise,
-the promise is rejected with the exception and the exception is thrown.
-
-```php
-$promise = new Promise(function () use (&$promise) {
-    throw new Exception('foo');
-});
-
-$promise->wait(); // throws the exception.
-```
-
-Calling `wait` on a promise that has been fulfilled will not trigger the wait
-function. It will simply return the previously resolved value.
-
-```php
-$promise = new Promise(function () { die('this is not called!'); });
-$promise->resolve('foo');
-echo $promise->wait(); // outputs "foo"
-```
-
-Calling `wait` on a promise that has been rejected will throw an exception. If
-the rejection reason is an instance of `\Exception` the reason is thrown.
-Otherwise, a `GuzzleHttp\Promise\RejectionException` is thrown and the reason
-can be obtained by calling the `getReason` method of the exception.
-
-```php
-$promise = new Promise();
-$promise->reject('foo');
-$promise->wait();
-```
-
-> PHP Fatal error:  Uncaught exception 'GuzzleHttp\Promise\RejectionException' with message 'The promise was rejected with value: foo'
-
-
-## Unwrapping a promise
-
-When synchronously waiting on a promise, you are joining the state of the
-promise into the current state of execution (i.e., return the value of the
-promise if it was fulfilled or throw an exception if it was rejected). This is
-called "unwrapping" the promise. Waiting on a promise will by default unwrap
-the promise state.
-
-You can force a promise to resolve and *not* unwrap the state of the promise
-by passing `false` to the first argument of the `wait` function:
-
-```php
-$promise = new Promise();
-$promise->reject('foo');
-// This will not throw an exception. It simply ensures the promise has
-// been resolved.
-$promise->wait(false);
-```
-
-When unwrapping a promise, the resolved value of the promise will be waited
-upon until the unwrapped value is not a promise. This means that if you resolve
-promise A with a promise B and unwrap promise A, the value returned by the
-wait function will be the value delivered to promise B.
-
-**Note**: when you do not unwrap the promise, no value is returned.
-
-
-# Cancellation
-
-You can cancel a promise that has not yet been fulfilled using the `cancel()`
-method of a promise. When creating a promise you can provide an optional
-cancel function that when invoked cancels the action of computing a resolution
-of the promise.
-
-
-# API
-
-
-## Promise
-
-When creating a promise object, you can provide an optional `$waitFn` and
-`$cancelFn`. `$waitFn` is a function that is invoked with no arguments and is
-expected to resolve the promise. `$cancelFn` is a function with no arguments
-that is expected to cancel the computation of a promise. It is invoked when the
-`cancel()` method of a promise is called.
-
-```php
-use GuzzleHttp\Promise\Promise;
-
-$promise = new Promise(
-    function () use (&$promise) {
-        $promise->resolve('waited');
-    },
-    function () {
-        // do something that will cancel the promise computation (e.g., close
-        // a socket, cancel a database query, etc...)
-    }
-);
-
-assert('waited' === $promise->wait());
-```
-
-A promise has the following methods:
-
-- `then(callable $onFulfilled, callable $onRejected) : PromiseInterface`
-  
-  Appends fulfillment and rejection handlers to the promise, and returns a new promise resolving to the return value of the called handler.
-
-- `otherwise(callable $onRejected) : PromiseInterface`
-  
-  Appends a rejection handler callback to the promise, and returns a new promise resolving to the return value of the callback if it is called, or to its original fulfillment value if the promise is instead fulfilled.
-
-- `wait($unwrap = true) : mixed`
-
-  Synchronously waits on the promise to complete.
-  
-  `$unwrap` controls whether or not the value of the promise is returned for a
-  fulfilled promise or if an exception is thrown if the promise is rejected.
-  This is set to `true` by default.
-
-- `cancel()`
-
-  Attempts to cancel the promise if possible. The promise being cancelled and
-  the parent most ancestor that has not yet been resolved will also be
-  cancelled. Any promises waiting on the cancelled promise to resolve will also
-  be cancelled.
-
-- `getState() : string`
-
-  Returns the state of the promise. One of `pending`, `fulfilled`, or
-  `rejected`.
-
-- `resolve($value)`
-
-  Fulfills the promise with the given `$value`.
-
-- `reject($reason)`
-
-  Rejects the promise with the given `$reason`.
-
-
-## FulfilledPromise
-
-A fulfilled promise can be created to represent a promise that has been
-fulfilled.
-
-```php
-use GuzzleHttp\Promise\FulfilledPromise;
-
-$promise = new FulfilledPromise('value');
-
-// Fulfilled callbacks are immediately invoked.
-$promise->then(function ($value) {
-    echo $value;
-});
-```
-
-
-## RejectedPromise
-
-A rejected promise can be created to represent a promise that has been
-rejected.
-
-```php
-use GuzzleHttp\Promise\RejectedPromise;
-
-$promise = new RejectedPromise('Error');
-
-// Rejected callbacks are immediately invoked.
-$promise->then(null, function ($reason) {
-    echo $reason;
-});
-```
-
-
-# Promise interop
-
-This library works with foreign promises that have a `then` method. This means
-you can use Guzzle promises with [React promises](https://github.com/reactphp/promise)
-for example. When a foreign promise is returned inside of a then method
-callback, promise resolution will occur recursively.
-
-```php
-// Create a React promise
-$deferred = new React\Promise\Deferred();
-$reactPromise = $deferred->promise();
-
-// Create a Guzzle promise that is fulfilled with a React promise.
-$guzzlePromise = new GuzzleHttp\Promise\Promise();
-$guzzlePromise->then(function ($value) use ($reactPromise) {
-    // Do something something with the value...
-    // Return the React promise
-    return $reactPromise;
-});
-```
-
-Please note that wait and cancel chaining is no longer possible when forwarding
-a foreign promise. You will need to wrap a third-party promise with a Guzzle
-promise in order to utilize wait and cancel functions with foreign promises.
-
-
-## Event Loop Integration
-
-In order to keep the stack size constant, Guzzle promises are resolved
-asynchronously using a task queue. When waiting on promises synchronously, the
-task queue will be automatically run to ensure that the blocking promise and
-any forwarded promises are resolved. When using promises asynchronously in an
-event loop, you will need to run the task queue on each tick of the loop. If
-you do not run the task queue, then promises will not be resolved.
-
-You can run the task queue using the `run()` method of the global task queue
-instance.
-
-```php
-// Get the global task queue
-$queue = GuzzleHttp\Promise\Utils::queue();
-$queue->run();
-```
-
-For example, you could use Guzzle promises with React using a periodic timer:
-
-```php
-$loop = React\EventLoop\Factory::create();
-$loop->addPeriodicTimer(0, [$queue, 'run']);
-```
-
-*TODO*: Perhaps adding a `futureTick()` on each tick would be faster?
-
-
-# Implementation notes
-
-
-## Promise resolution and chaining is handled iteratively
-
-By shuffling pending handlers from one owner to another, promises are
-resolved iteratively, allowing for "infinite" then chaining.
-
-```php
-<?php
-require 'vendor/autoload.php';
-
-use GuzzleHttp\Promise\Promise;
-
-$parent = new Promise();
-$p = $parent;
-
-for ($i = 0; $i < 1000; $i++) {
-    $p = $p->then(function ($v) {
-        // The stack size remains constant (a good thing)
-        echo xdebug_get_stack_depth() . ', ';
-        return $v + 1;
-    });
-}
-
-$parent->resolve(0);
-var_dump($p->wait()); // int(1000)
-
-```
-
-When a promise is fulfilled or rejected with a non-promise value, the promise
-then takes ownership of the handlers of each child promise and delivers values
-down the chain without using recursion.
-
-When a promise is resolved with another promise, the original promise transfers
-all of its pending handlers to the new promise. When the new promise is
-eventually resolved, all of the pending handlers are delivered the forwarded
-value.
-
-
-## A promise is the deferred.
-
-Some promise libraries implement promises using a deferred object to represent
-a computation and a promise object to represent the delivery of the result of
-the computation. This is a nice separation of computation and delivery because
-consumers of the promise cannot modify the value that will be eventually
-delivered.
-
-One side effect of being able to implement promise resolution and chaining
-iteratively is that you need to be able for one promise to reach into the state
-of another promise to shuffle around ownership of handlers. In order to achieve
-this without making the handlers of a promise publicly mutable, a promise is
-also the deferred value, allowing promises of the same parent class to reach
-into and modify the private properties of promises of the same type. While this
-does allow consumers of the value to modify the resolution or rejection of the
-deferred, it is a small price to pay for keeping the stack size constant.
-
-```php
-$promise = new Promise();
-$promise->then(function ($value) { echo $value; });
-// The promise is the deferred value, so you can deliver a value to it.
-$promise->resolve('foo');
-// prints "foo"
-```
-
-
-## Upgrading from Function API
-
-A static API was first introduced in 1.4.0, in order to mitigate problems with functions conflicting between global and local copies of the package. The function API will be removed in 2.0.0. A migration table has been provided here for your convenience:
-
-| Original Function | Replacement Method |
-|----------------|----------------|
-| `queue` | `Utils::queue` |
-| `task` | `Utils::task` |
-| `promise_for` | `Create::promiseFor` |
-| `rejection_for` | `Create::rejectionFor` |
-| `exception_for` | `Create::exceptionFor` |
-| `iter_for` | `Create::iterFor` |
-| `inspect` | `Utils::inspect` |
-| `inspect_all` | `Utils::inspectAll` |
-| `unwrap` | `Utils::unwrap` |
-| `all` | `Utils::all` |
-| `some` | `Utils::some` |
-| `any` | `Utils::any` |
-| `settle` | `Utils::settle` |
-| `each` | `Each::of` |
-| `each_limit` | `Each::ofLimit` |
-| `each_limit_all` | `Each::ofLimitAll` |
-| `!is_fulfilled` | `Is::pending` |
-| `is_fulfilled` | `Is::fulfilled` |
-| `is_rejected` | `Is::rejected` |
-| `is_settled` | `Is::settled` |
-| `coroutine` | `Coroutine::of` |
+# Guzzle Promises

+

+[Promises/A+](https://promisesaplus.com/) implementation that handles promise

+chaining and resolution iteratively, allowing for "infinite" promise chaining

+while keeping the stack size constant. Read [this blog post](https://blog.domenic.me/youre-missing-the-point-of-promises/)

+for a general introduction to promises.

+

+- [Features](#features)

+- [Quick start](#quick-start)

+- [Synchronous wait](#synchronous-wait)

+- [Cancellation](#cancellation)

+- [API](#api)

+  - [Promise](#promise)

+  - [FulfilledPromise](#fulfilledpromise)

+  - [RejectedPromise](#rejectedpromise)

+- [Promise interop](#promise-interop)

+- [Implementation notes](#implementation-notes)

+

+

+## Features

+

+- [Promises/A+](https://promisesaplus.com/) implementation.

+- Promise resolution and chaining is handled iteratively, allowing for

+  "infinite" promise chaining.

+- Promises have a synchronous `wait` method.

+- Promises can be cancelled.

+- Works with any object that has a `then` function.

+- C# style async/await coroutine promises using

+  `GuzzleHttp\Promise\Coroutine::of()`.

+

+

+## Quick Start

+

+A *promise* represents the eventual result of an asynchronous operation. The

+primary way of interacting with a promise is through its `then` method, which

+registers callbacks to receive either a promise's eventual value or the reason

+why the promise cannot be fulfilled.

+

+### Callbacks

+

+Callbacks are registered with the `then` method by providing an optional 

+`$onFulfilled` followed by an optional `$onRejected` function.

+

+

+```php

+use GuzzleHttp\Promise\Promise;

+

+$promise = new Promise();

+$promise->then(

+    // $onFulfilled

+    function ($value) {

+        echo 'The promise was fulfilled.';

+    },

+    // $onRejected

+    function ($reason) {

+        echo 'The promise was rejected.';

+    }

+);

+```

+

+*Resolving* a promise means that you either fulfill a promise with a *value* or

+reject a promise with a *reason*. Resolving a promise triggers callbacks

+registered with the promise's `then` method. These callbacks are triggered

+only once and in the order in which they were added.

+

+### Resolving a Promise

+

+Promises are fulfilled using the `resolve($value)` method. Resolving a promise

+with any value other than a `GuzzleHttp\Promise\RejectedPromise` will trigger

+all of the onFulfilled callbacks (resolving a promise with a rejected promise

+will reject the promise and trigger the `$onRejected` callbacks).

+

+```php

+use GuzzleHttp\Promise\Promise;

+

+$promise = new Promise();

+$promise

+    ->then(function ($value) {

+        // Return a value and don't break the chain

+        return "Hello, " . $value;

+    })

+    // This then is executed after the first then and receives the value

+    // returned from the first then.

+    ->then(function ($value) {

+        echo $value;

+    });

+

+// Resolving the promise triggers the $onFulfilled callbacks and outputs

+// "Hello, reader."

+$promise->resolve('reader.');

+```

+

+### Promise Forwarding

+

+Promises can be chained one after the other. Each then in the chain is a new

+promise. The return value of a promise is what's forwarded to the next

+promise in the chain. Returning a promise in a `then` callback will cause the

+subsequent promises in the chain to only be fulfilled when the returned promise

+has been fulfilled. The next promise in the chain will be invoked with the

+resolved value of the promise.

+

+```php

+use GuzzleHttp\Promise\Promise;

+

+$promise = new Promise();

+$nextPromise = new Promise();

+

+$promise

+    ->then(function ($value) use ($nextPromise) {

+        echo $value;

+        return $nextPromise;

+    })

+    ->then(function ($value) {

+        echo $value;

+    });

+

+// Triggers the first callback and outputs "A"

+$promise->resolve('A');

+// Triggers the second callback and outputs "B"

+$nextPromise->resolve('B');

+```

+

+### Promise Rejection

+

+When a promise is rejected, the `$onRejected` callbacks are invoked with the

+rejection reason.

+

+```php

+use GuzzleHttp\Promise\Promise;

+

+$promise = new Promise();

+$promise->then(null, function ($reason) {

+    echo $reason;

+});

+

+$promise->reject('Error!');

+// Outputs "Error!"

+```

+

+### Rejection Forwarding

+

+If an exception is thrown in an `$onRejected` callback, subsequent

+`$onRejected` callbacks are invoked with the thrown exception as the reason.

+

+```php

+use GuzzleHttp\Promise\Promise;

+

+$promise = new Promise();

+$promise->then(null, function ($reason) {

+    throw new Exception($reason);

+})->then(null, function ($reason) {

+    assert($reason->getMessage() === 'Error!');

+});

+

+$promise->reject('Error!');

+```

+

+You can also forward a rejection down the promise chain by returning a

+`GuzzleHttp\Promise\RejectedPromise` in either an `$onFulfilled` or

+`$onRejected` callback.

+

+```php

+use GuzzleHttp\Promise\Promise;

+use GuzzleHttp\Promise\RejectedPromise;

+

+$promise = new Promise();

+$promise->then(null, function ($reason) {

+    return new RejectedPromise($reason);

+})->then(null, function ($reason) {

+    assert($reason === 'Error!');

+});

+

+$promise->reject('Error!');

+```

+

+If an exception is not thrown in a `$onRejected` callback and the callback

+does not return a rejected promise, downstream `$onFulfilled` callbacks are

+invoked using the value returned from the `$onRejected` callback.

+

+```php

+use GuzzleHttp\Promise\Promise;

+

+$promise = new Promise();

+$promise

+    ->then(null, function ($reason) {

+        return "It's ok";

+    })

+    ->then(function ($value) {

+        assert($value === "It's ok");

+    });

+

+$promise->reject('Error!');

+```

+

+

+## Synchronous Wait

+

+You can synchronously force promises to complete using a promise's `wait`

+method. When creating a promise, you can provide a wait function that is used

+to synchronously force a promise to complete. When a wait function is invoked

+it is expected to deliver a value to the promise or reject the promise. If the

+wait function does not deliver a value, then an exception is thrown. The wait

+function provided to a promise constructor is invoked when the `wait` function

+of the promise is called.

+

+```php

+$promise = new Promise(function () use (&$promise) {

+    $promise->resolve('foo');

+});

+

+// Calling wait will return the value of the promise.

+echo $promise->wait(); // outputs "foo"

+```

+

+If an exception is encountered while invoking the wait function of a promise,

+the promise is rejected with the exception and the exception is thrown.

+

+```php

+$promise = new Promise(function () use (&$promise) {

+    throw new Exception('foo');

+});

+

+$promise->wait(); // throws the exception.

+```

+

+Calling `wait` on a promise that has been fulfilled will not trigger the wait

+function. It will simply return the previously resolved value.

+

+```php

+$promise = new Promise(function () { die('this is not called!'); });

+$promise->resolve('foo');

+echo $promise->wait(); // outputs "foo"

+```

+

+Calling `wait` on a promise that has been rejected will throw an exception. If

+the rejection reason is an instance of `\Exception` the reason is thrown.

+Otherwise, a `GuzzleHttp\Promise\RejectionException` is thrown and the reason

+can be obtained by calling the `getReason` method of the exception.

+

+```php

+$promise = new Promise();

+$promise->reject('foo');

+$promise->wait();

+```

+

+> PHP Fatal error:  Uncaught exception 'GuzzleHttp\Promise\RejectionException' with message 'The promise was rejected with value: foo'

+

+### Unwrapping a Promise

+

+When synchronously waiting on a promise, you are joining the state of the

+promise into the current state of execution (i.e., return the value of the

+promise if it was fulfilled or throw an exception if it was rejected). This is

+called "unwrapping" the promise. Waiting on a promise will by default unwrap

+the promise state.

+

+You can force a promise to resolve and *not* unwrap the state of the promise

+by passing `false` to the first argument of the `wait` function:

+

+```php

+$promise = new Promise();

+$promise->reject('foo');

+// This will not throw an exception. It simply ensures the promise has

+// been resolved.

+$promise->wait(false);

+```

+

+When unwrapping a promise, the resolved value of the promise will be waited

+upon until the unwrapped value is not a promise. This means that if you resolve

+promise A with a promise B and unwrap promise A, the value returned by the

+wait function will be the value delivered to promise B.

+

+**Note**: when you do not unwrap the promise, no value is returned.

+

+

+## Cancellation

+

+You can cancel a promise that has not yet been fulfilled using the `cancel()`

+method of a promise. When creating a promise you can provide an optional

+cancel function that when invoked cancels the action of computing a resolution

+of the promise.

+

+

+## API

+

+### Promise

+

+When creating a promise object, you can provide an optional `$waitFn` and

+`$cancelFn`. `$waitFn` is a function that is invoked with no arguments and is

+expected to resolve the promise. `$cancelFn` is a function with no arguments

+that is expected to cancel the computation of a promise. It is invoked when the

+`cancel()` method of a promise is called.

+

+```php

+use GuzzleHttp\Promise\Promise;

+

+$promise = new Promise(

+    function () use (&$promise) {

+        $promise->resolve('waited');

+    },

+    function () {

+        // do something that will cancel the promise computation (e.g., close

+        // a socket, cancel a database query, etc...)

+    }

+);

+

+assert('waited' === $promise->wait());

+```

+

+A promise has the following methods:

+

+- `then(callable $onFulfilled, callable $onRejected) : PromiseInterface`

+  

+  Appends fulfillment and rejection handlers to the promise, and returns a new promise resolving to the return value of the called handler.

+

+- `otherwise(callable $onRejected) : PromiseInterface`

+  

+  Appends a rejection handler callback to the promise, and returns a new promise resolving to the return value of the callback if it is called, or to its original fulfillment value if the promise is instead fulfilled.

+

+- `wait($unwrap = true) : mixed`

+

+  Synchronously waits on the promise to complete.

+  

+  `$unwrap` controls whether or not the value of the promise is returned for a

+  fulfilled promise or if an exception is thrown if the promise is rejected.

+  This is set to `true` by default.

+

+- `cancel()`

+

+  Attempts to cancel the promise if possible. The promise being cancelled and

+  the parent most ancestor that has not yet been resolved will also be

+  cancelled. Any promises waiting on the cancelled promise to resolve will also

+  be cancelled.

+

+- `getState() : string`

+

+  Returns the state of the promise. One of `pending`, `fulfilled`, or

+  `rejected`.

+

+- `resolve($value)`

+

+  Fulfills the promise with the given `$value`.

+

+- `reject($reason)`

+

+  Rejects the promise with the given `$reason`.

+

+

+### FulfilledPromise

+

+A fulfilled promise can be created to represent a promise that has been

+fulfilled.

+

+```php

+use GuzzleHttp\Promise\FulfilledPromise;

+

+$promise = new FulfilledPromise('value');

+

+// Fulfilled callbacks are immediately invoked.

+$promise->then(function ($value) {

+    echo $value;

+});

+```

+

+

+### RejectedPromise

+

+A rejected promise can be created to represent a promise that has been

+rejected.

+

+```php

+use GuzzleHttp\Promise\RejectedPromise;

+

+$promise = new RejectedPromise('Error');

+

+// Rejected callbacks are immediately invoked.

+$promise->then(null, function ($reason) {

+    echo $reason;

+});

+```

+

+

+## Promise Interoperability

+

+This library works with foreign promises that have a `then` method. This means

+you can use Guzzle promises with [React promises](https://github.com/reactphp/promise)

+for example. When a foreign promise is returned inside of a then method

+callback, promise resolution will occur recursively.

+

+```php

+// Create a React promise

+$deferred = new React\Promise\Deferred();

+$reactPromise = $deferred->promise();

+

+// Create a Guzzle promise that is fulfilled with a React promise.

+$guzzlePromise = new GuzzleHttp\Promise\Promise();

+$guzzlePromise->then(function ($value) use ($reactPromise) {

+    // Do something something with the value...

+    // Return the React promise

+    return $reactPromise;

+});

+```

+

+Please note that wait and cancel chaining is no longer possible when forwarding

+a foreign promise. You will need to wrap a third-party promise with a Guzzle

+promise in order to utilize wait and cancel functions with foreign promises.

+

+

+### Event Loop Integration

+

+In order to keep the stack size constant, Guzzle promises are resolved

+asynchronously using a task queue. When waiting on promises synchronously, the

+task queue will be automatically run to ensure that the blocking promise and

+any forwarded promises are resolved. When using promises asynchronously in an

+event loop, you will need to run the task queue on each tick of the loop. If

+you do not run the task queue, then promises will not be resolved.

+

+You can run the task queue using the `run()` method of the global task queue

+instance.

+

+```php

+// Get the global task queue

+$queue = GuzzleHttp\Promise\Utils::queue();

+$queue->run();

+```

+

+For example, you could use Guzzle promises with React using a periodic timer:

+

+```php

+$loop = React\EventLoop\Factory::create();

+$loop->addPeriodicTimer(0, [$queue, 'run']);

+```

+

+*TODO*: Perhaps adding a `futureTick()` on each tick would be faster?

+

+

+## Implementation Notes

+

+### Promise Resolution and Chaining is Handled Iteratively

+

+By shuffling pending handlers from one owner to another, promises are

+resolved iteratively, allowing for "infinite" then chaining.

+

+```php

+<?php

+require 'vendor/autoload.php';

+

+use GuzzleHttp\Promise\Promise;

+

+$parent = new Promise();

+$p = $parent;

+

+for ($i = 0; $i < 1000; $i++) {

+    $p = $p->then(function ($v) {

+        // The stack size remains constant (a good thing)

+        echo xdebug_get_stack_depth() . ', ';

+        return $v + 1;

+    });

+}

+

+$parent->resolve(0);

+var_dump($p->wait()); // int(1000)

+

+```

+

+When a promise is fulfilled or rejected with a non-promise value, the promise

+then takes ownership of the handlers of each child promise and delivers values

+down the chain without using recursion.

+

+When a promise is resolved with another promise, the original promise transfers

+all of its pending handlers to the new promise. When the new promise is

+eventually resolved, all of the pending handlers are delivered the forwarded

+value.

+

+### A Promise is the Deferred

+

+Some promise libraries implement promises using a deferred object to represent

+a computation and a promise object to represent the delivery of the result of

+the computation. This is a nice separation of computation and delivery because

+consumers of the promise cannot modify the value that will be eventually

+delivered.

+

+One side effect of being able to implement promise resolution and chaining

+iteratively is that you need to be able for one promise to reach into the state

+of another promise to shuffle around ownership of handlers. In order to achieve

+this without making the handlers of a promise publicly mutable, a promise is

+also the deferred value, allowing promises of the same parent class to reach

+into and modify the private properties of promises of the same type. While this

+does allow consumers of the value to modify the resolution or rejection of the

+deferred, it is a small price to pay for keeping the stack size constant.

+

+```php

+$promise = new Promise();

+$promise->then(function ($value) { echo $value; });

+// The promise is the deferred value, so you can deliver a value to it.

+$promise->resolve('foo');

+// prints "foo"

+```

+

+

+## Upgrading from Function API

+

+A static API was first introduced in 1.4.0, in order to mitigate problems with

+functions conflicting between global and local copies of the package. The

+function API will be removed in 2.0.0. A migration table has been provided here

+for your convenience:

+

+| Original Function | Replacement Method |

+|----------------|----------------|

+| `queue` | `Utils::queue` |

+| `task` | `Utils::task` |

+| `promise_for` | `Create::promiseFor` |

+| `rejection_for` | `Create::rejectionFor` |

+| `exception_for` | `Create::exceptionFor` |

+| `iter_for` | `Create::iterFor` |

+| `inspect` | `Utils::inspect` |

+| `inspect_all` | `Utils::inspectAll` |

+| `unwrap` | `Utils::unwrap` |

+| `all` | `Utils::all` |

+| `some` | `Utils::some` |

+| `any` | `Utils::any` |

+| `settle` | `Utils::settle` |

+| `each` | `Each::of` |

+| `each_limit` | `Each::ofLimit` |

+| `each_limit_all` | `Each::ofLimitAll` |

+| `!is_fulfilled` | `Is::pending` |

+| `is_fulfilled` | `Is::fulfilled` |

+| `is_rejected` | `Is::rejected` |

+| `is_settled` | `Is::settled` |

+| `coroutine` | `Coroutine::of` |

+

+

+## Security

+

+If you discover a security vulnerability within this package, please send an email to security@tidelift.com. All security vulnerabilities will be promptly addressed. Please do not disclose security-related issues publicly until a fix has been announced. Please see [Security Policy](https://github.com/guzzle/promises/security/policy) for more information.

+

+

+## License

+

+Guzzle is made available under the MIT License (MIT). Please see [License File](LICENSE) for more information.

+

+

+## For Enterprise

+

+Available as part of the Tidelift Subscription

+

+The maintainers of Guzzle and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/packagist-guzzlehttp-promises?utm_source=packagist-guzzlehttp-promises&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

diff --git a/vendor/guzzlehttp/promises/composer.json b/vendor/guzzlehttp/promises/composer.json
index db44d9e..cc66168 100644
--- a/vendor/guzzlehttp/promises/composer.json
+++ b/vendor/guzzlehttp/promises/composer.json
@@ -1,39 +1,53 @@
-{
-    "name": "guzzlehttp/promises",
-    "description": "Guzzle promises library",
-    "keywords": ["promise"],
-    "license": "MIT",
-    "authors": [
-        {
-            "name": "Michael Dowling",
-            "email": "mtdowling@gmail.com",
-            "homepage": "https://github.com/mtdowling"
-        }
-    ],
-    "require": {
-        "php": ">=5.5"
-    },
-    "require-dev": {
-        "symfony/phpunit-bridge": "^4.4 || ^5.1"
-    },
-    "autoload": {
-        "psr-4": {
-            "GuzzleHttp\\Promise\\": "src/"
-        },
-        "files": ["src/functions_include.php"]
-    },
-    "autoload-dev": {
-        "psr-4": {
-            "GuzzleHttp\\Promise\\Tests\\": "tests/"
-        }
-    },
-    "scripts": {
-        "test": "vendor/bin/simple-phpunit",
-        "test-ci": "vendor/bin/simple-phpunit --coverage-text"
-    },
-    "extra": {
-        "branch-alias": {
-            "dev-master": "1.4-dev"
-        }
-    }
-}
+{

+    "name": "guzzlehttp/promises",

+    "description": "Guzzle promises library",

+    "keywords": ["promise"],

+    "license": "MIT",

+    "authors": [

+        {

+            "name": "Graham Campbell",

+            "email": "hello@gjcampbell.co.uk",

+            "homepage": "https://github.com/GrahamCampbell"

+        },

+        {

+            "name": "Michael Dowling",

+            "email": "mtdowling@gmail.com",

+            "homepage": "https://github.com/mtdowling"

+        },

+        {

+            "name": "Tobias Nyholm",

+            "email": "tobias.nyholm@gmail.com",

+            "homepage": "https://github.com/Nyholm"

+        },

+        {

+            "name": "Tobias Schultze",

+            "email": "webmaster@tubo-world.de",

+            "homepage": "https://github.com/Tobion"

+        }

+    ],

+    "require": {

+        "php": ">=5.5"

+    },

+    "require-dev": {

+        "symfony/phpunit-bridge": "^4.4 || ^5.1"

+    },

+    "autoload": {

+        "psr-4": {

+            "GuzzleHttp\\Promise\\": "src/"

+        },

+        "files": ["src/functions_include.php"]

+    },

+    "autoload-dev": {

+        "psr-4": {

+            "GuzzleHttp\\Promise\\Tests\\": "tests/"

+        }

+    },

+    "scripts": {

+        "test": "vendor/bin/simple-phpunit",

+        "test-ci": "vendor/bin/simple-phpunit --coverage-text"

+    },

+    "config": {

+        "preferred-install": "dist",

+        "sort-packages": true

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/AggregateException.php b/vendor/guzzlehttp/promises/src/AggregateException.php
index d2b5712..4fbc9e8 100644
--- a/vendor/guzzlehttp/promises/src/AggregateException.php
+++ b/vendor/guzzlehttp/promises/src/AggregateException.php
@@ -1,17 +1,17 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * Exception thrown when too many errors occur in the some() or any() methods.
- */
-class AggregateException extends RejectionException
-{
-    public function __construct($msg, array $reasons)
-    {
-        parent::__construct(
-            $reasons,
-            sprintf('%s; %d rejected promises', $msg, count($reasons))
-        );
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * Exception thrown when too many errors occur in the some() or any() methods.

+ */

+class AggregateException extends RejectionException

+{

+    public function __construct($msg, array $reasons)

+    {

+        parent::__construct(

+            $reasons,

+            sprintf('%s; %d rejected promises', $msg, count($reasons))

+        );

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/CancellationException.php b/vendor/guzzlehttp/promises/src/CancellationException.php
index 56a1ed6..358aaba 100644
--- a/vendor/guzzlehttp/promises/src/CancellationException.php
+++ b/vendor/guzzlehttp/promises/src/CancellationException.php
@@ -1,10 +1,10 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * Exception that is set as the reason for a promise that has been cancelled.
- */
-class CancellationException extends RejectionException
-{
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * Exception that is set as the reason for a promise that has been cancelled.

+ */

+class CancellationException extends RejectionException

+{

+}

diff --git a/vendor/guzzlehttp/promises/src/Coroutine.php b/vendor/guzzlehttp/promises/src/Coroutine.php
index 670da47..ac36081 100644
--- a/vendor/guzzlehttp/promises/src/Coroutine.php
+++ b/vendor/guzzlehttp/promises/src/Coroutine.php
@@ -1,169 +1,169 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-use Exception;
-use Generator;
-use Throwable;
-
-/**
- * Creates a promise that is resolved using a generator that yields values or
- * promises (somewhat similar to C#'s async keyword).
- *
- * When called, the Coroutine::of method will start an instance of the generator
- * and returns a promise that is fulfilled with its final yielded value.
- *
- * Control is returned back to the generator when the yielded promise settles.
- * This can lead to less verbose code when doing lots of sequential async calls
- * with minimal processing in between.
- *
- *     use GuzzleHttp\Promise;
- *
- *     function createPromise($value) {
- *         return new Promise\FulfilledPromise($value);
- *     }
- *
- *     $promise = Promise\Coroutine::of(function () {
- *         $value = (yield createPromise('a'));
- *         try {
- *             $value = (yield createPromise($value . 'b'));
- *         } catch (\Exception $e) {
- *             // The promise was rejected.
- *         }
- *         yield $value . 'c';
- *     });
- *
- *     // Outputs "abc"
- *     $promise->then(function ($v) { echo $v; });
- *
- * @param callable $generatorFn Generator function to wrap into a promise.
- *
- * @return Promise
- *
- * @link https://github.com/petkaantonov/bluebird/blob/master/API.md#generators inspiration
- */
-final class Coroutine implements PromiseInterface
-{
-    /**
-     * @var PromiseInterface|null
-     */
-    private $currentPromise;
-
-    /**
-     * @var Generator
-     */
-    private $generator;
-
-    /**
-     * @var Promise
-     */
-    private $result;
-
-    public function __construct(callable $generatorFn)
-    {
-        $this->generator = $generatorFn();
-        $this->result = new Promise(function () {
-            while (isset($this->currentPromise)) {
-                $this->currentPromise->wait();
-            }
-        });
-        try {
-            $this->nextCoroutine($this->generator->current());
-        } catch (\Exception $exception) {
-            $this->result->reject($exception);
-        } catch (Throwable $throwable) {
-            $this->result->reject($throwable);
-        }
-    }
-
-    /**
-     * Create a new coroutine.
-     *
-     * @return self
-     */
-    public static function of(callable $generatorFn)
-    {
-        return new self($generatorFn);
-    }
-
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ) {
-        return $this->result->then($onFulfilled, $onRejected);
-    }
-
-    public function otherwise(callable $onRejected)
-    {
-        return $this->result->otherwise($onRejected);
-    }
-
-    public function wait($unwrap = true)
-    {
-        return $this->result->wait($unwrap);
-    }
-
-    public function getState()
-    {
-        return $this->result->getState();
-    }
-
-    public function resolve($value)
-    {
-        $this->result->resolve($value);
-    }
-
-    public function reject($reason)
-    {
-        $this->result->reject($reason);
-    }
-
-    public function cancel()
-    {
-        $this->currentPromise->cancel();
-        $this->result->cancel();
-    }
-
-    private function nextCoroutine($yielded)
-    {
-        $this->currentPromise = Create::promiseFor($yielded)
-            ->then([$this, '_handleSuccess'], [$this, '_handleFailure']);
-    }
-
-    /**
-     * @internal
-     */
-    public function _handleSuccess($value)
-    {
-        unset($this->currentPromise);
-        try {
-            $next = $this->generator->send($value);
-            if ($this->generator->valid()) {
-                $this->nextCoroutine($next);
-            } else {
-                $this->result->resolve($value);
-            }
-        } catch (Exception $exception) {
-            $this->result->reject($exception);
-        } catch (Throwable $throwable) {
-            $this->result->reject($throwable);
-        }
-    }
-
-    /**
-     * @internal
-     */
-    public function _handleFailure($reason)
-    {
-        unset($this->currentPromise);
-        try {
-            $nextYield = $this->generator->throw(Create::exceptionFor($reason));
-            // The throw was caught, so keep iterating on the coroutine
-            $this->nextCoroutine($nextYield);
-        } catch (Exception $exception) {
-            $this->result->reject($exception);
-        } catch (Throwable $throwable) {
-            $this->result->reject($throwable);
-        }
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+use Exception;

+use Generator;

+use Throwable;

+

+/**

+ * Creates a promise that is resolved using a generator that yields values or

+ * promises (somewhat similar to C#'s async keyword).

+ *

+ * When called, the Coroutine::of method will start an instance of the generator

+ * and returns a promise that is fulfilled with its final yielded value.

+ *

+ * Control is returned back to the generator when the yielded promise settles.

+ * This can lead to less verbose code when doing lots of sequential async calls

+ * with minimal processing in between.

+ *

+ *     use GuzzleHttp\Promise;

+ *

+ *     function createPromise($value) {

+ *         return new Promise\FulfilledPromise($value);

+ *     }

+ *

+ *     $promise = Promise\Coroutine::of(function () {

+ *         $value = (yield createPromise('a'));

+ *         try {

+ *             $value = (yield createPromise($value . 'b'));

+ *         } catch (\Exception $e) {

+ *             // The promise was rejected.

+ *         }

+ *         yield $value . 'c';

+ *     });

+ *

+ *     // Outputs "abc"

+ *     $promise->then(function ($v) { echo $v; });

+ *

+ * @param callable $generatorFn Generator function to wrap into a promise.

+ *

+ * @return Promise

+ *

+ * @link https://github.com/petkaantonov/bluebird/blob/master/API.md#generators inspiration

+ */

+final class Coroutine implements PromiseInterface

+{

+    /**

+     * @var PromiseInterface|null

+     */

+    private $currentPromise;

+

+    /**

+     * @var Generator

+     */

+    private $generator;

+

+    /**

+     * @var Promise

+     */

+    private $result;

+

+    public function __construct(callable $generatorFn)

+    {

+        $this->generator = $generatorFn();

+        $this->result = new Promise(function () {

+            while (isset($this->currentPromise)) {

+                $this->currentPromise->wait();

+            }

+        });

+        try {

+            $this->nextCoroutine($this->generator->current());

+        } catch (\Exception $exception) {

+            $this->result->reject($exception);

+        } catch (Throwable $throwable) {

+            $this->result->reject($throwable);

+        }

+    }

+

+    /**

+     * Create a new coroutine.

+     *

+     * @return self

+     */

+    public static function of(callable $generatorFn)

+    {

+        return new self($generatorFn);

+    }

+

+    public function then(

+        callable $onFulfilled = null,

+        callable $onRejected = null

+    ) {

+        return $this->result->then($onFulfilled, $onRejected);

+    }

+

+    public function otherwise(callable $onRejected)

+    {

+        return $this->result->otherwise($onRejected);

+    }

+

+    public function wait($unwrap = true)

+    {

+        return $this->result->wait($unwrap);

+    }

+

+    public function getState()

+    {

+        return $this->result->getState();

+    }

+

+    public function resolve($value)

+    {

+        $this->result->resolve($value);

+    }

+

+    public function reject($reason)

+    {

+        $this->result->reject($reason);

+    }

+

+    public function cancel()

+    {

+        $this->currentPromise->cancel();

+        $this->result->cancel();

+    }

+

+    private function nextCoroutine($yielded)

+    {

+        $this->currentPromise = Create::promiseFor($yielded)

+            ->then([$this, '_handleSuccess'], [$this, '_handleFailure']);

+    }

+

+    /**

+     * @internal

+     */

+    public function _handleSuccess($value)

+    {

+        unset($this->currentPromise);

+        try {

+            $next = $this->generator->send($value);

+            if ($this->generator->valid()) {

+                $this->nextCoroutine($next);

+            } else {

+                $this->result->resolve($value);

+            }

+        } catch (Exception $exception) {

+            $this->result->reject($exception);

+        } catch (Throwable $throwable) {

+            $this->result->reject($throwable);

+        }

+    }

+

+    /**

+     * @internal

+     */

+    public function _handleFailure($reason)

+    {

+        unset($this->currentPromise);

+        try {

+            $nextYield = $this->generator->throw(Create::exceptionFor($reason));

+            // The throw was caught, so keep iterating on the coroutine

+            $this->nextCoroutine($nextYield);

+        } catch (Exception $exception) {

+            $this->result->reject($exception);

+        } catch (Throwable $throwable) {

+            $this->result->reject($throwable);

+        }

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/Create.php b/vendor/guzzlehttp/promises/src/Create.php
index 8d038e9..c2307d4 100644
--- a/vendor/guzzlehttp/promises/src/Create.php
+++ b/vendor/guzzlehttp/promises/src/Create.php
@@ -1,84 +1,84 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-final class Create
-{
-    /**
-     * Creates a promise for a value if the value is not a promise.
-     *
-     * @param mixed $value Promise or value.
-     *
-     * @return PromiseInterface
-     */
-    public static function promiseFor($value)
-    {
-        if ($value instanceof PromiseInterface) {
-            return $value;
-        }
-
-        // Return a Guzzle promise that shadows the given promise.
-        if (is_object($value) && method_exists($value, 'then')) {
-            $wfn = method_exists($value, 'wait') ? [$value, 'wait'] : null;
-            $cfn = method_exists($value, 'cancel') ? [$value, 'cancel'] : null;
-            $promise = new Promise($wfn, $cfn);
-            $value->then([$promise, 'resolve'], [$promise, 'reject']);
-            return $promise;
-        }
-
-        return new FulfilledPromise($value);
-    }
-
-    /**
-     * Creates a rejected promise for a reason if the reason is not a promise.
-     * If the provided reason is a promise, then it is returned as-is.
-     *
-     * @param mixed $reason Promise or reason.
-     *
-     * @return PromiseInterface
-     */
-    public static function rejectionFor($reason)
-    {
-        if ($reason instanceof PromiseInterface) {
-            return $reason;
-        }
-
-        return new RejectedPromise($reason);
-    }
-
-    /**
-     * Create an exception for a rejected promise value.
-     *
-     * @param mixed $reason
-     *
-     * @return \Exception|\Throwable
-     */
-    public static function exceptionFor($reason)
-    {
-        if ($reason instanceof \Exception || $reason instanceof \Throwable) {
-            return $reason;
-        }
-
-        return new RejectionException($reason);
-    }
-
-    /**
-     * Returns an iterator for the given value.
-     *
-     * @param mixed $value
-     *
-     * @return \Iterator
-     */
-    public static function iterFor($value)
-    {
-        if ($value instanceof \Iterator) {
-            return $value;
-        }
-
-        if (is_array($value)) {
-            return new \ArrayIterator($value);
-        }
-
-        return new \ArrayIterator([$value]);
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+final class Create

+{

+    /**

+     * Creates a promise for a value if the value is not a promise.

+     *

+     * @param mixed $value Promise or value.

+     *

+     * @return PromiseInterface

+     */

+    public static function promiseFor($value)

+    {

+        if ($value instanceof PromiseInterface) {

+            return $value;

+        }

+

+        // Return a Guzzle promise that shadows the given promise.

+        if (is_object($value) && method_exists($value, 'then')) {

+            $wfn = method_exists($value, 'wait') ? [$value, 'wait'] : null;

+            $cfn = method_exists($value, 'cancel') ? [$value, 'cancel'] : null;

+            $promise = new Promise($wfn, $cfn);

+            $value->then([$promise, 'resolve'], [$promise, 'reject']);

+            return $promise;

+        }

+

+        return new FulfilledPromise($value);

+    }

+

+    /**

+     * Creates a rejected promise for a reason if the reason is not a promise.

+     * If the provided reason is a promise, then it is returned as-is.

+     *

+     * @param mixed $reason Promise or reason.

+     *

+     * @return PromiseInterface

+     */

+    public static function rejectionFor($reason)

+    {

+        if ($reason instanceof PromiseInterface) {

+            return $reason;

+        }

+

+        return new RejectedPromise($reason);

+    }

+

+    /**

+     * Create an exception for a rejected promise value.

+     *

+     * @param mixed $reason

+     *

+     * @return \Exception|\Throwable

+     */

+    public static function exceptionFor($reason)

+    {

+        if ($reason instanceof \Exception || $reason instanceof \Throwable) {

+            return $reason;

+        }

+

+        return new RejectionException($reason);

+    }

+

+    /**

+     * Returns an iterator for the given value.

+     *

+     * @param mixed $value

+     *

+     * @return \Iterator

+     */

+    public static function iterFor($value)

+    {

+        if ($value instanceof \Iterator) {

+            return $value;

+        }

+

+        if (is_array($value)) {

+            return new \ArrayIterator($value);

+        }

+

+        return new \ArrayIterator([$value]);

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/Each.php b/vendor/guzzlehttp/promises/src/Each.php
index 1dda354..8934e60 100644
--- a/vendor/guzzlehttp/promises/src/Each.php
+++ b/vendor/guzzlehttp/promises/src/Each.php
@@ -1,90 +1,90 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-final class Each
-{
-    /**
-     * Given an iterator that yields promises or values, returns a promise that
-     * is fulfilled with a null value when the iterator has been consumed or
-     * the aggregate promise has been fulfilled or rejected.
-     *
-     * $onFulfilled is a function that accepts the fulfilled value, iterator
-     * index, and the aggregate promise. The callback can invoke any necessary
-     * side effects and choose to resolve or reject the aggregate if needed.
-     *
-     * $onRejected is a function that accepts the rejection reason, iterator
-     * index, and the aggregate promise. The callback can invoke any necessary
-     * side effects and choose to resolve or reject the aggregate if needed.
-     *
-     * @param mixed    $iterable    Iterator or array to iterate over.
-     * @param callable $onFulfilled
-     * @param callable $onRejected
-     *
-     * @return PromiseInterface
-     */
-    public static function of(
-        $iterable,
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ) {
-        return (new EachPromise($iterable, [
-            'fulfilled' => $onFulfilled,
-            'rejected'  => $onRejected
-        ]))->promise();
-    }
-
-    /**
-     * Like of, but only allows a certain number of outstanding promises at any
-     * given time.
-     *
-     * $concurrency may be an integer or a function that accepts the number of
-     * pending promises and returns a numeric concurrency limit value to allow
-     * for dynamic a concurrency size.
-     *
-     * @param mixed        $iterable
-     * @param int|callable $concurrency
-     * @param callable     $onFulfilled
-     * @param callable     $onRejected
-     *
-     * @return PromiseInterface
-     */
-    public static function ofLimit(
-        $iterable,
-        $concurrency,
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ) {
-        return (new EachPromise($iterable, [
-            'fulfilled'   => $onFulfilled,
-            'rejected'    => $onRejected,
-            'concurrency' => $concurrency
-        ]))->promise();
-    }
-
-    /**
-     * Like limit, but ensures that no promise in the given $iterable argument
-     * is rejected. If any promise is rejected, then the aggregate promise is
-     * rejected with the encountered rejection.
-     *
-     * @param mixed        $iterable
-     * @param int|callable $concurrency
-     * @param callable     $onFulfilled
-     *
-     * @return PromiseInterface
-     */
-    public static function ofLimitAll(
-        $iterable,
-        $concurrency,
-        callable $onFulfilled = null
-    ) {
-        return each_limit(
-            $iterable,
-            $concurrency,
-            $onFulfilled,
-            function ($reason, $idx, PromiseInterface $aggregate) {
-                $aggregate->reject($reason);
-            }
-        );
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+final class Each

+{

+    /**

+     * Given an iterator that yields promises or values, returns a promise that

+     * is fulfilled with a null value when the iterator has been consumed or

+     * the aggregate promise has been fulfilled or rejected.

+     *

+     * $onFulfilled is a function that accepts the fulfilled value, iterator

+     * index, and the aggregate promise. The callback can invoke any necessary

+     * side effects and choose to resolve or reject the aggregate if needed.

+     *

+     * $onRejected is a function that accepts the rejection reason, iterator

+     * index, and the aggregate promise. The callback can invoke any necessary

+     * side effects and choose to resolve or reject the aggregate if needed.

+     *

+     * @param mixed    $iterable    Iterator or array to iterate over.

+     * @param callable $onFulfilled

+     * @param callable $onRejected

+     *

+     * @return PromiseInterface

+     */

+    public static function of(

+        $iterable,

+        callable $onFulfilled = null,

+        callable $onRejected = null

+    ) {

+        return (new EachPromise($iterable, [

+            'fulfilled' => $onFulfilled,

+            'rejected'  => $onRejected

+        ]))->promise();

+    }

+

+    /**

+     * Like of, but only allows a certain number of outstanding promises at any

+     * given time.

+     *

+     * $concurrency may be an integer or a function that accepts the number of

+     * pending promises and returns a numeric concurrency limit value to allow

+     * for dynamic a concurrency size.

+     *

+     * @param mixed        $iterable

+     * @param int|callable $concurrency

+     * @param callable     $onFulfilled

+     * @param callable     $onRejected

+     *

+     * @return PromiseInterface

+     */

+    public static function ofLimit(

+        $iterable,

+        $concurrency,

+        callable $onFulfilled = null,

+        callable $onRejected = null

+    ) {

+        return (new EachPromise($iterable, [

+            'fulfilled'   => $onFulfilled,

+            'rejected'    => $onRejected,

+            'concurrency' => $concurrency

+        ]))->promise();

+    }

+

+    /**

+     * Like limit, but ensures that no promise in the given $iterable argument

+     * is rejected. If any promise is rejected, then the aggregate promise is

+     * rejected with the encountered rejection.

+     *

+     * @param mixed        $iterable

+     * @param int|callable $concurrency

+     * @param callable     $onFulfilled

+     *

+     * @return PromiseInterface

+     */

+    public static function ofLimitAll(

+        $iterable,

+        $concurrency,

+        callable $onFulfilled = null

+    ) {

+        return self::ofLimit(

+            $iterable,

+            $concurrency,

+            $onFulfilled,

+            function ($reason, $idx, PromiseInterface $aggregate) {

+                $aggregate->reject($reason);

+            }

+        );

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/EachPromise.php b/vendor/guzzlehttp/promises/src/EachPromise.php
index b5cb103..bce6f0f 100644
--- a/vendor/guzzlehttp/promises/src/EachPromise.php
+++ b/vendor/guzzlehttp/promises/src/EachPromise.php
@@ -79,20 +79,10 @@ class EachPromise implements PromisorInterface
             $this->createPromise();

             /** @psalm-assert Promise $this->aggregate */

             $this->iterable->rewind();

-            if (!$this->checkIfFinished()) {

-                $this->refillPending();

-            }

+            $this->refillPending();

         } catch (\Throwable $e) {

-            /**

-             * @psalm-suppress NullReference

-             * @phpstan-ignore-next-line

-             */

             $this->aggregate->reject($e);

         } catch (\Exception $e) {

-            /**

-             * @psalm-suppress NullReference

-             * @phpstan-ignore-next-line

-             */

             $this->aggregate->reject($e);

         }

 

@@ -107,6 +97,9 @@ class EachPromise implements PromisorInterface
     {

         $this->mutex = false;

         $this->aggregate = new Promise(function () {

+            if ($this->checkIfFinished()) {

+                return;

+            }

             reset($this->pending);

             // Consume a potentially fluctuating list of promises while

             // ensuring that indexes are maintained (precluding array_shift).

diff --git a/vendor/guzzlehttp/promises/src/FulfilledPromise.php b/vendor/guzzlehttp/promises/src/FulfilledPromise.php
index 98f72a6..ed36912 100644
--- a/vendor/guzzlehttp/promises/src/FulfilledPromise.php
+++ b/vendor/guzzlehttp/promises/src/FulfilledPromise.php
@@ -1,84 +1,84 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * A promise that has been fulfilled.
- *
- * Thenning off of this promise will invoke the onFulfilled callback
- * immediately and ignore other callbacks.
- */
-class FulfilledPromise implements PromiseInterface
-{
-    private $value;
-
-    public function __construct($value)
-    {
-        if (is_object($value) && method_exists($value, 'then')) {
-            throw new \InvalidArgumentException(
-                'You cannot create a FulfilledPromise with a promise.'
-            );
-        }
-
-        $this->value = $value;
-    }
-
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ) {
-        // Return itself if there is no onFulfilled function.
-        if (!$onFulfilled) {
-            return $this;
-        }
-
-        $queue = Utils::queue();
-        $p = new Promise([$queue, 'run']);
-        $value = $this->value;
-        $queue->add(static function () use ($p, $value, $onFulfilled) {
-            if (Is::pending($p)) {
-                try {
-                    $p->resolve($onFulfilled($value));
-                } catch (\Throwable $e) {
-                    $p->reject($e);
-                } catch (\Exception $e) {
-                    $p->reject($e);
-                }
-            }
-        });
-
-        return $p;
-    }
-
-    public function otherwise(callable $onRejected)
-    {
-        return $this->then(null, $onRejected);
-    }
-
-    public function wait($unwrap = true, $defaultDelivery = null)
-    {
-        return $unwrap ? $this->value : null;
-    }
-
-    public function getState()
-    {
-        return self::FULFILLED;
-    }
-
-    public function resolve($value)
-    {
-        if ($value !== $this->value) {
-            throw new \LogicException("Cannot resolve a fulfilled promise");
-        }
-    }
-
-    public function reject($reason)
-    {
-        throw new \LogicException("Cannot reject a fulfilled promise");
-    }
-
-    public function cancel()
-    {
-        // pass
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * A promise that has been fulfilled.

+ *

+ * Thenning off of this promise will invoke the onFulfilled callback

+ * immediately and ignore other callbacks.

+ */

+class FulfilledPromise implements PromiseInterface

+{

+    private $value;

+

+    public function __construct($value)

+    {

+        if (is_object($value) && method_exists($value, 'then')) {

+            throw new \InvalidArgumentException(

+                'You cannot create a FulfilledPromise with a promise.'

+            );

+        }

+

+        $this->value = $value;

+    }

+

+    public function then(

+        callable $onFulfilled = null,

+        callable $onRejected = null

+    ) {

+        // Return itself if there is no onFulfilled function.

+        if (!$onFulfilled) {

+            return $this;

+        }

+

+        $queue = Utils::queue();

+        $p = new Promise([$queue, 'run']);

+        $value = $this->value;

+        $queue->add(static function () use ($p, $value, $onFulfilled) {

+            if (Is::pending($p)) {

+                try {

+                    $p->resolve($onFulfilled($value));

+                } catch (\Throwable $e) {

+                    $p->reject($e);

+                } catch (\Exception $e) {

+                    $p->reject($e);

+                }

+            }

+        });

+

+        return $p;

+    }

+

+    public function otherwise(callable $onRejected)

+    {

+        return $this->then(null, $onRejected);

+    }

+

+    public function wait($unwrap = true, $defaultDelivery = null)

+    {

+        return $unwrap ? $this->value : null;

+    }

+

+    public function getState()

+    {

+        return self::FULFILLED;

+    }

+

+    public function resolve($value)

+    {

+        if ($value !== $this->value) {

+            throw new \LogicException("Cannot resolve a fulfilled promise");

+        }

+    }

+

+    public function reject($reason)

+    {

+        throw new \LogicException("Cannot reject a fulfilled promise");

+    }

+

+    public function cancel()

+    {

+        // pass

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/Is.php b/vendor/guzzlehttp/promises/src/Is.php
index c3ed8d0..ab2a0ad 100644
--- a/vendor/guzzlehttp/promises/src/Is.php
+++ b/vendor/guzzlehttp/promises/src/Is.php
@@ -1,46 +1,46 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-final class Is
-{
-    /**
-     * Returns true if a promise is pending.
-     *
-     * @return bool
-     */
-    public static function pending(PromiseInterface $promise)
-    {
-        return $promise->getState() === PromiseInterface::PENDING;
-    }
-
-    /**
-     * Returns true if a promise is fulfilled or rejected.
-     *
-     * @return bool
-     */
-    public static function settled(PromiseInterface $promise)
-    {
-        return $promise->getState() !== PromiseInterface::PENDING;
-    }
-
-    /**
-     * Returns true if a promise is fulfilled.
-     *
-     * @return bool
-     */
-    public static function fulfilled(PromiseInterface $promise)
-    {
-        return $promise->getState() === PromiseInterface::FULFILLED;
-    }
-
-    /**
-     * Returns true if a promise is rejected.
-     *
-     * @return bool
-     */
-    public static function rejected(PromiseInterface $promise)
-    {
-        return $promise->getState() === PromiseInterface::REJECTED;
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+final class Is

+{

+    /**

+     * Returns true if a promise is pending.

+     *

+     * @return bool

+     */

+    public static function pending(PromiseInterface $promise)

+    {

+        return $promise->getState() === PromiseInterface::PENDING;

+    }

+

+    /**

+     * Returns true if a promise is fulfilled or rejected.

+     *

+     * @return bool

+     */

+    public static function settled(PromiseInterface $promise)

+    {

+        return $promise->getState() !== PromiseInterface::PENDING;

+    }

+

+    /**

+     * Returns true if a promise is fulfilled.

+     *

+     * @return bool

+     */

+    public static function fulfilled(PromiseInterface $promise)

+    {

+        return $promise->getState() === PromiseInterface::FULFILLED;

+    }

+

+    /**

+     * Returns true if a promise is rejected.

+     *

+     * @return bool

+     */

+    public static function rejected(PromiseInterface $promise)

+    {

+        return $promise->getState() === PromiseInterface::REJECTED;

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/Promise.php b/vendor/guzzlehttp/promises/src/Promise.php
index 7593905..3d118c7 100644
--- a/vendor/guzzlehttp/promises/src/Promise.php
+++ b/vendor/guzzlehttp/promises/src/Promise.php
@@ -1,278 +1,278 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * Promises/A+ implementation that avoids recursion when possible.
- *
- * @link https://promisesaplus.com/
- */
-class Promise implements PromiseInterface
-{
-    private $state = self::PENDING;
-    private $result;
-    private $cancelFn;
-    private $waitFn;
-    private $waitList;
-    private $handlers = [];
-
-    /**
-     * @param callable $waitFn   Fn that when invoked resolves the promise.
-     * @param callable $cancelFn Fn that when invoked cancels the promise.
-     */
-    public function __construct(
-        callable $waitFn = null,
-        callable $cancelFn = null
-    ) {
-        $this->waitFn = $waitFn;
-        $this->cancelFn = $cancelFn;
-    }
-
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ) {
-        if ($this->state === self::PENDING) {
-            $p = new Promise(null, [$this, 'cancel']);
-            $this->handlers[] = [$p, $onFulfilled, $onRejected];
-            $p->waitList = $this->waitList;
-            $p->waitList[] = $this;
-            return $p;
-        }
-
-        // Return a fulfilled promise and immediately invoke any callbacks.
-        if ($this->state === self::FULFILLED) {
-            $promise = Create::promiseFor($this->result);
-            return $onFulfilled ? $promise->then($onFulfilled) : $promise;
-        }
-
-        // It's either cancelled or rejected, so return a rejected promise
-        // and immediately invoke any callbacks.
-        $rejection = Create::rejectionFor($this->result);
-        return $onRejected ? $rejection->then(null, $onRejected) : $rejection;
-    }
-
-    public function otherwise(callable $onRejected)
-    {
-        return $this->then(null, $onRejected);
-    }
-
-    public function wait($unwrap = true)
-    {
-        $this->waitIfPending();
-
-        if ($this->result instanceof PromiseInterface) {
-            return $this->result->wait($unwrap);
-        }
-        if ($unwrap) {
-            if ($this->state === self::FULFILLED) {
-                return $this->result;
-            }
-            // It's rejected so "unwrap" and throw an exception.
-            throw Create::exceptionFor($this->result);
-        }
-    }
-
-    public function getState()
-    {
-        return $this->state;
-    }
-
-    public function cancel()
-    {
-        if ($this->state !== self::PENDING) {
-            return;
-        }
-
-        $this->waitFn = $this->waitList = null;
-
-        if ($this->cancelFn) {
-            $fn = $this->cancelFn;
-            $this->cancelFn = null;
-            try {
-                $fn();
-            } catch (\Throwable $e) {
-                $this->reject($e);
-            } catch (\Exception $e) {
-                $this->reject($e);
-            }
-        }
-
-        // Reject the promise only if it wasn't rejected in a then callback.
-        /** @psalm-suppress RedundantCondition */
-        if ($this->state === self::PENDING) {
-            $this->reject(new CancellationException('Promise has been cancelled'));
-        }
-    }
-
-    public function resolve($value)
-    {
-        $this->settle(self::FULFILLED, $value);
-    }
-
-    public function reject($reason)
-    {
-        $this->settle(self::REJECTED, $reason);
-    }
-
-    private function settle($state, $value)
-    {
-        if ($this->state !== self::PENDING) {
-            // Ignore calls with the same resolution.
-            if ($state === $this->state && $value === $this->result) {
-                return;
-            }
-            throw $this->state === $state
-                ? new \LogicException("The promise is already {$state}.")
-                : new \LogicException("Cannot change a {$this->state} promise to {$state}");
-        }
-
-        if ($value === $this) {
-            throw new \LogicException('Cannot fulfill or reject a promise with itself');
-        }
-
-        // Clear out the state of the promise but stash the handlers.
-        $this->state = $state;
-        $this->result = $value;
-        $handlers = $this->handlers;
-        $this->handlers = null;
-        $this->waitList = $this->waitFn = null;
-        $this->cancelFn = null;
-
-        if (!$handlers) {
-            return;
-        }
-
-        // If the value was not a settled promise or a thenable, then resolve
-        // it in the task queue using the correct ID.
-        if (!is_object($value) || !method_exists($value, 'then')) {
-            $id = $state === self::FULFILLED ? 1 : 2;
-            // It's a success, so resolve the handlers in the queue.
-            Utils::queue()->add(static function () use ($id, $value, $handlers) {
-                foreach ($handlers as $handler) {
-                    self::callHandler($id, $value, $handler);
-                }
-            });
-        } elseif ($value instanceof Promise && Is::pending($value)) {
-            // We can just merge our handlers onto the next promise.
-            $value->handlers = array_merge($value->handlers, $handlers);
-        } else {
-            // Resolve the handlers when the forwarded promise is resolved.
-            $value->then(
-                static function ($value) use ($handlers) {
-                    foreach ($handlers as $handler) {
-                        self::callHandler(1, $value, $handler);
-                    }
-                },
-                static function ($reason) use ($handlers) {
-                    foreach ($handlers as $handler) {
-                        self::callHandler(2, $reason, $handler);
-                    }
-                }
-            );
-        }
-    }
-
-    /**
-     * Call a stack of handlers using a specific callback index and value.
-     *
-     * @param int   $index   1 (resolve) or 2 (reject).
-     * @param mixed $value   Value to pass to the callback.
-     * @param array $handler Array of handler data (promise and callbacks).
-     */
-    private static function callHandler($index, $value, array $handler)
-    {
-        /** @var PromiseInterface $promise */
-        $promise = $handler[0];
-
-        // The promise may have been cancelled or resolved before placing
-        // this thunk in the queue.
-        if (Is::settled($promise)) {
-            return;
-        }
-
-        try {
-            if (isset($handler[$index])) {
-                /*
-                 * If $f throws an exception, then $handler will be in the exception
-                 * stack trace. Since $handler contains a reference to the callable
-                 * itself we get a circular reference. We clear the $handler
-                 * here to avoid that memory leak.
-                 */
-                $f = $handler[$index];
-                unset($handler);
-                $promise->resolve($f($value));
-            } elseif ($index === 1) {
-                // Forward resolution values as-is.
-                $promise->resolve($value);
-            } else {
-                // Forward rejections down the chain.
-                $promise->reject($value);
-            }
-        } catch (\Throwable $reason) {
-            $promise->reject($reason);
-        } catch (\Exception $reason) {
-            $promise->reject($reason);
-        }
-    }
-
-    private function waitIfPending()
-    {
-        if ($this->state !== self::PENDING) {
-            return;
-        } elseif ($this->waitFn) {
-            $this->invokeWaitFn();
-        } elseif ($this->waitList) {
-            $this->invokeWaitList();
-        } else {
-            // If there's no wait function, then reject the promise.
-            $this->reject('Cannot wait on a promise that has '
-                . 'no internal wait function. You must provide a wait '
-                . 'function when constructing the promise to be able to '
-                . 'wait on a promise.');
-        }
-
-        Utils::queue()->run();
-
-        /** @psalm-suppress RedundantCondition */
-        if ($this->state === self::PENDING) {
-            $this->reject('Invoking the wait callback did not resolve the promise');
-        }
-    }
-
-    private function invokeWaitFn()
-    {
-        try {
-            $wfn = $this->waitFn;
-            $this->waitFn = null;
-            $wfn(true);
-        } catch (\Exception $reason) {
-            if ($this->state === self::PENDING) {
-                // The promise has not been resolved yet, so reject the promise
-                // with the exception.
-                $this->reject($reason);
-            } else {
-                // The promise was already resolved, so there's a problem in
-                // the application.
-                throw $reason;
-            }
-        }
-    }
-
-    private function invokeWaitList()
-    {
-        $waitList = $this->waitList;
-        $this->waitList = null;
-
-        foreach ($waitList as $result) {
-            do {
-                $result->waitIfPending();
-                $result = $result->result;
-            } while ($result instanceof Promise);
-
-            if ($result instanceof PromiseInterface) {
-                $result->wait(false);
-            }
-        }
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * Promises/A+ implementation that avoids recursion when possible.

+ *

+ * @link https://promisesaplus.com/

+ */

+class Promise implements PromiseInterface

+{

+    private $state = self::PENDING;

+    private $result;

+    private $cancelFn;

+    private $waitFn;

+    private $waitList;

+    private $handlers = [];

+

+    /**

+     * @param callable $waitFn   Fn that when invoked resolves the promise.

+     * @param callable $cancelFn Fn that when invoked cancels the promise.

+     */

+    public function __construct(

+        callable $waitFn = null,

+        callable $cancelFn = null

+    ) {

+        $this->waitFn = $waitFn;

+        $this->cancelFn = $cancelFn;

+    }

+

+    public function then(

+        callable $onFulfilled = null,

+        callable $onRejected = null

+    ) {

+        if ($this->state === self::PENDING) {

+            $p = new Promise(null, [$this, 'cancel']);

+            $this->handlers[] = [$p, $onFulfilled, $onRejected];

+            $p->waitList = $this->waitList;

+            $p->waitList[] = $this;

+            return $p;

+        }

+

+        // Return a fulfilled promise and immediately invoke any callbacks.

+        if ($this->state === self::FULFILLED) {

+            $promise = Create::promiseFor($this->result);

+            return $onFulfilled ? $promise->then($onFulfilled) : $promise;

+        }

+

+        // It's either cancelled or rejected, so return a rejected promise

+        // and immediately invoke any callbacks.

+        $rejection = Create::rejectionFor($this->result);

+        return $onRejected ? $rejection->then(null, $onRejected) : $rejection;

+    }

+

+    public function otherwise(callable $onRejected)

+    {

+        return $this->then(null, $onRejected);

+    }

+

+    public function wait($unwrap = true)

+    {

+        $this->waitIfPending();

+

+        if ($this->result instanceof PromiseInterface) {

+            return $this->result->wait($unwrap);

+        }

+        if ($unwrap) {

+            if ($this->state === self::FULFILLED) {

+                return $this->result;

+            }

+            // It's rejected so "unwrap" and throw an exception.

+            throw Create::exceptionFor($this->result);

+        }

+    }

+

+    public function getState()

+    {

+        return $this->state;

+    }

+

+    public function cancel()

+    {

+        if ($this->state !== self::PENDING) {

+            return;

+        }

+

+        $this->waitFn = $this->waitList = null;

+

+        if ($this->cancelFn) {

+            $fn = $this->cancelFn;

+            $this->cancelFn = null;

+            try {

+                $fn();

+            } catch (\Throwable $e) {

+                $this->reject($e);

+            } catch (\Exception $e) {

+                $this->reject($e);

+            }

+        }

+

+        // Reject the promise only if it wasn't rejected in a then callback.

+        /** @psalm-suppress RedundantCondition */

+        if ($this->state === self::PENDING) {

+            $this->reject(new CancellationException('Promise has been cancelled'));

+        }

+    }

+

+    public function resolve($value)

+    {

+        $this->settle(self::FULFILLED, $value);

+    }

+

+    public function reject($reason)

+    {

+        $this->settle(self::REJECTED, $reason);

+    }

+

+    private function settle($state, $value)

+    {

+        if ($this->state !== self::PENDING) {

+            // Ignore calls with the same resolution.

+            if ($state === $this->state && $value === $this->result) {

+                return;

+            }

+            throw $this->state === $state

+                ? new \LogicException("The promise is already {$state}.")

+                : new \LogicException("Cannot change a {$this->state} promise to {$state}");

+        }

+

+        if ($value === $this) {

+            throw new \LogicException('Cannot fulfill or reject a promise with itself');

+        }

+

+        // Clear out the state of the promise but stash the handlers.

+        $this->state = $state;

+        $this->result = $value;

+        $handlers = $this->handlers;

+        $this->handlers = null;

+        $this->waitList = $this->waitFn = null;

+        $this->cancelFn = null;

+

+        if (!$handlers) {

+            return;

+        }

+

+        // If the value was not a settled promise or a thenable, then resolve

+        // it in the task queue using the correct ID.

+        if (!is_object($value) || !method_exists($value, 'then')) {

+            $id = $state === self::FULFILLED ? 1 : 2;

+            // It's a success, so resolve the handlers in the queue.

+            Utils::queue()->add(static function () use ($id, $value, $handlers) {

+                foreach ($handlers as $handler) {

+                    self::callHandler($id, $value, $handler);

+                }

+            });

+        } elseif ($value instanceof Promise && Is::pending($value)) {

+            // We can just merge our handlers onto the next promise.

+            $value->handlers = array_merge($value->handlers, $handlers);

+        } else {

+            // Resolve the handlers when the forwarded promise is resolved.

+            $value->then(

+                static function ($value) use ($handlers) {

+                    foreach ($handlers as $handler) {

+                        self::callHandler(1, $value, $handler);

+                    }

+                },

+                static function ($reason) use ($handlers) {

+                    foreach ($handlers as $handler) {

+                        self::callHandler(2, $reason, $handler);

+                    }

+                }

+            );

+        }

+    }

+

+    /**

+     * Call a stack of handlers using a specific callback index and value.

+     *

+     * @param int   $index   1 (resolve) or 2 (reject).

+     * @param mixed $value   Value to pass to the callback.

+     * @param array $handler Array of handler data (promise and callbacks).

+     */

+    private static function callHandler($index, $value, array $handler)

+    {

+        /** @var PromiseInterface $promise */

+        $promise = $handler[0];

+

+        // The promise may have been cancelled or resolved before placing

+        // this thunk in the queue.

+        if (Is::settled($promise)) {

+            return;

+        }

+

+        try {

+            if (isset($handler[$index])) {

+                /*

+                 * If $f throws an exception, then $handler will be in the exception

+                 * stack trace. Since $handler contains a reference to the callable

+                 * itself we get a circular reference. We clear the $handler

+                 * here to avoid that memory leak.

+                 */

+                $f = $handler[$index];

+                unset($handler);

+                $promise->resolve($f($value));

+            } elseif ($index === 1) {

+                // Forward resolution values as-is.

+                $promise->resolve($value);

+            } else {

+                // Forward rejections down the chain.

+                $promise->reject($value);

+            }

+        } catch (\Throwable $reason) {

+            $promise->reject($reason);

+        } catch (\Exception $reason) {

+            $promise->reject($reason);

+        }

+    }

+

+    private function waitIfPending()

+    {

+        if ($this->state !== self::PENDING) {

+            return;

+        } elseif ($this->waitFn) {

+            $this->invokeWaitFn();

+        } elseif ($this->waitList) {

+            $this->invokeWaitList();

+        } else {

+            // If there's no wait function, then reject the promise.

+            $this->reject('Cannot wait on a promise that has '

+                . 'no internal wait function. You must provide a wait '

+                . 'function when constructing the promise to be able to '

+                . 'wait on a promise.');

+        }

+

+        Utils::queue()->run();

+

+        /** @psalm-suppress RedundantCondition */

+        if ($this->state === self::PENDING) {

+            $this->reject('Invoking the wait callback did not resolve the promise');

+        }

+    }

+

+    private function invokeWaitFn()

+    {

+        try {

+            $wfn = $this->waitFn;

+            $this->waitFn = null;

+            $wfn(true);

+        } catch (\Exception $reason) {

+            if ($this->state === self::PENDING) {

+                // The promise has not been resolved yet, so reject the promise

+                // with the exception.

+                $this->reject($reason);

+            } else {

+                // The promise was already resolved, so there's a problem in

+                // the application.

+                throw $reason;

+            }

+        }

+    }

+

+    private function invokeWaitList()

+    {

+        $waitList = $this->waitList;

+        $this->waitList = null;

+

+        foreach ($waitList as $result) {

+            do {

+                $result->waitIfPending();

+                $result = $result->result;

+            } while ($result instanceof Promise);

+

+            if ($result instanceof PromiseInterface) {

+                $result->wait(false);

+            }

+        }

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/PromiseInterface.php b/vendor/guzzlehttp/promises/src/PromiseInterface.php
index e598331..653ac44 100644
--- a/vendor/guzzlehttp/promises/src/PromiseInterface.php
+++ b/vendor/guzzlehttp/promises/src/PromiseInterface.php
@@ -1,97 +1,97 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * A promise represents the eventual result of an asynchronous operation.
- *
- * The primary way of interacting with a promise is through its then method,
- * which registers callbacks to receive either a promise’s eventual value or
- * the reason why the promise cannot be fulfilled.
- *
- * @link https://promisesaplus.com/
- */
-interface PromiseInterface
-{
-    const PENDING = 'pending';
-    const FULFILLED = 'fulfilled';
-    const REJECTED = 'rejected';
-
-    /**
-     * Appends fulfillment and rejection handlers to the promise, and returns
-     * a new promise resolving to the return value of the called handler.
-     *
-     * @param callable $onFulfilled Invoked when the promise fulfills.
-     * @param callable $onRejected  Invoked when the promise is rejected.
-     *
-     * @return PromiseInterface
-     */
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    );
-
-    /**
-     * Appends a rejection handler callback to the promise, and returns a new
-     * promise resolving to the return value of the callback if it is called,
-     * or to its original fulfillment value if the promise is instead
-     * fulfilled.
-     *
-     * @param callable $onRejected Invoked when the promise is rejected.
-     *
-     * @return PromiseInterface
-     */
-    public function otherwise(callable $onRejected);
-
-    /**
-     * Get the state of the promise ("pending", "rejected", or "fulfilled").
-     *
-     * The three states can be checked against the constants defined on
-     * PromiseInterface: PENDING, FULFILLED, and REJECTED.
-     *
-     * @return string
-     */
-    public function getState();
-
-    /**
-     * Resolve the promise with the given value.
-     *
-     * @param mixed $value
-     *
-     * @throws \RuntimeException if the promise is already resolved.
-     */
-    public function resolve($value);
-
-    /**
-     * Reject the promise with the given reason.
-     *
-     * @param mixed $reason
-     *
-     * @throws \RuntimeException if the promise is already resolved.
-     */
-    public function reject($reason);
-
-    /**
-     * Cancels the promise if possible.
-     *
-     * @link https://github.com/promises-aplus/cancellation-spec/issues/7
-     */
-    public function cancel();
-
-    /**
-     * Waits until the promise completes if possible.
-     *
-     * Pass $unwrap as true to unwrap the result of the promise, either
-     * returning the resolved value or throwing the rejected exception.
-     *
-     * If the promise cannot be waited on, then the promise will be rejected.
-     *
-     * @param bool $unwrap
-     *
-     * @return mixed
-     *
-     * @throws \LogicException if the promise has no wait function or if the
-     *                         promise does not settle after waiting.
-     */
-    public function wait($unwrap = true);
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * A promise represents the eventual result of an asynchronous operation.

+ *

+ * The primary way of interacting with a promise is through its then method,

+ * which registers callbacks to receive either a promise’s eventual value or

+ * the reason why the promise cannot be fulfilled.

+ *

+ * @link https://promisesaplus.com/

+ */

+interface PromiseInterface

+{

+    const PENDING = 'pending';

+    const FULFILLED = 'fulfilled';

+    const REJECTED = 'rejected';

+

+    /**

+     * Appends fulfillment and rejection handlers to the promise, and returns

+     * a new promise resolving to the return value of the called handler.

+     *

+     * @param callable $onFulfilled Invoked when the promise fulfills.

+     * @param callable $onRejected  Invoked when the promise is rejected.

+     *

+     * @return PromiseInterface

+     */

+    public function then(

+        callable $onFulfilled = null,

+        callable $onRejected = null

+    );

+

+    /**

+     * Appends a rejection handler callback to the promise, and returns a new

+     * promise resolving to the return value of the callback if it is called,

+     * or to its original fulfillment value if the promise is instead

+     * fulfilled.

+     *

+     * @param callable $onRejected Invoked when the promise is rejected.

+     *

+     * @return PromiseInterface

+     */

+    public function otherwise(callable $onRejected);

+

+    /**

+     * Get the state of the promise ("pending", "rejected", or "fulfilled").

+     *

+     * The three states can be checked against the constants defined on

+     * PromiseInterface: PENDING, FULFILLED, and REJECTED.

+     *

+     * @return string

+     */

+    public function getState();

+

+    /**

+     * Resolve the promise with the given value.

+     *

+     * @param mixed $value

+     *

+     * @throws \RuntimeException if the promise is already resolved.

+     */

+    public function resolve($value);

+

+    /**

+     * Reject the promise with the given reason.

+     *

+     * @param mixed $reason

+     *

+     * @throws \RuntimeException if the promise is already resolved.

+     */

+    public function reject($reason);

+

+    /**

+     * Cancels the promise if possible.

+     *

+     * @link https://github.com/promises-aplus/cancellation-spec/issues/7

+     */

+    public function cancel();

+

+    /**

+     * Waits until the promise completes if possible.

+     *

+     * Pass $unwrap as true to unwrap the result of the promise, either

+     * returning the resolved value or throwing the rejected exception.

+     *

+     * If the promise cannot be waited on, then the promise will be rejected.

+     *

+     * @param bool $unwrap

+     *

+     * @return mixed

+     *

+     * @throws \LogicException if the promise has no wait function or if the

+     *                         promise does not settle after waiting.

+     */

+    public function wait($unwrap = true);

+}

diff --git a/vendor/guzzlehttp/promises/src/PromisorInterface.php b/vendor/guzzlehttp/promises/src/PromisorInterface.php
index 2d2e342..e1cb043 100644
--- a/vendor/guzzlehttp/promises/src/PromisorInterface.php
+++ b/vendor/guzzlehttp/promises/src/PromisorInterface.php
@@ -1,16 +1,16 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * Interface used with classes that return a promise.
- */
-interface PromisorInterface
-{
-    /**
-     * Returns a promise.
-     *
-     * @return PromiseInterface
-     */
-    public function promise();
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * Interface used with classes that return a promise.

+ */

+interface PromisorInterface

+{

+    /**

+     * Returns a promise.

+     *

+     * @return PromiseInterface

+     */

+    public function promise();

+}

diff --git a/vendor/guzzlehttp/promises/src/RejectedPromise.php b/vendor/guzzlehttp/promises/src/RejectedPromise.php
index d291846..44a3ecf 100644
--- a/vendor/guzzlehttp/promises/src/RejectedPromise.php
+++ b/vendor/guzzlehttp/promises/src/RejectedPromise.php
@@ -1,91 +1,91 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * A promise that has been rejected.
- *
- * Thenning off of this promise will invoke the onRejected callback
- * immediately and ignore other callbacks.
- */
-class RejectedPromise implements PromiseInterface
-{
-    private $reason;
-
-    public function __construct($reason)
-    {
-        if (is_object($reason) && method_exists($reason, 'then')) {
-            throw new \InvalidArgumentException(
-                'You cannot create a RejectedPromise with a promise.'
-            );
-        }
-
-        $this->reason = $reason;
-    }
-
-    public function then(
-        callable $onFulfilled = null,
-        callable $onRejected = null
-    ) {
-        // If there's no onRejected callback then just return self.
-        if (!$onRejected) {
-            return $this;
-        }
-
-        $queue = Utils::queue();
-        $reason = $this->reason;
-        $p = new Promise([$queue, 'run']);
-        $queue->add(static function () use ($p, $reason, $onRejected) {
-            if (Is::pending($p)) {
-                try {
-                    // Return a resolved promise if onRejected does not throw.
-                    $p->resolve($onRejected($reason));
-                } catch (\Throwable $e) {
-                    // onRejected threw, so return a rejected promise.
-                    $p->reject($e);
-                } catch (\Exception $e) {
-                    // onRejected threw, so return a rejected promise.
-                    $p->reject($e);
-                }
-            }
-        });
-
-        return $p;
-    }
-
-    public function otherwise(callable $onRejected)
-    {
-        return $this->then(null, $onRejected);
-    }
-
-    public function wait($unwrap = true, $defaultDelivery = null)
-    {
-        if ($unwrap) {
-            throw Create::exceptionFor($this->reason);
-        }
-
-        return null;
-    }
-
-    public function getState()
-    {
-        return self::REJECTED;
-    }
-
-    public function resolve($value)
-    {
-        throw new \LogicException("Cannot resolve a rejected promise");
-    }
-
-    public function reject($reason)
-    {
-        if ($reason !== $this->reason) {
-            throw new \LogicException("Cannot reject a rejected promise");
-        }
-    }
-
-    public function cancel()
-    {
-        // pass
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * A promise that has been rejected.

+ *

+ * Thenning off of this promise will invoke the onRejected callback

+ * immediately and ignore other callbacks.

+ */

+class RejectedPromise implements PromiseInterface

+{

+    private $reason;

+

+    public function __construct($reason)

+    {

+        if (is_object($reason) && method_exists($reason, 'then')) {

+            throw new \InvalidArgumentException(

+                'You cannot create a RejectedPromise with a promise.'

+            );

+        }

+

+        $this->reason = $reason;

+    }

+

+    public function then(

+        callable $onFulfilled = null,

+        callable $onRejected = null

+    ) {

+        // If there's no onRejected callback then just return self.

+        if (!$onRejected) {

+            return $this;

+        }

+

+        $queue = Utils::queue();

+        $reason = $this->reason;

+        $p = new Promise([$queue, 'run']);

+        $queue->add(static function () use ($p, $reason, $onRejected) {

+            if (Is::pending($p)) {

+                try {

+                    // Return a resolved promise if onRejected does not throw.

+                    $p->resolve($onRejected($reason));

+                } catch (\Throwable $e) {

+                    // onRejected threw, so return a rejected promise.

+                    $p->reject($e);

+                } catch (\Exception $e) {

+                    // onRejected threw, so return a rejected promise.

+                    $p->reject($e);

+                }

+            }

+        });

+

+        return $p;

+    }

+

+    public function otherwise(callable $onRejected)

+    {

+        return $this->then(null, $onRejected);

+    }

+

+    public function wait($unwrap = true, $defaultDelivery = null)

+    {

+        if ($unwrap) {

+            throw Create::exceptionFor($this->reason);

+        }

+

+        return null;

+    }

+

+    public function getState()

+    {

+        return self::REJECTED;

+    }

+

+    public function resolve($value)

+    {

+        throw new \LogicException("Cannot resolve a rejected promise");

+    }

+

+    public function reject($reason)

+    {

+        if ($reason !== $this->reason) {

+            throw new \LogicException("Cannot reject a rejected promise");

+        }

+    }

+

+    public function cancel()

+    {

+        // pass

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/RejectionException.php b/vendor/guzzlehttp/promises/src/RejectionException.php
index e2f1377..8cf915d 100644
--- a/vendor/guzzlehttp/promises/src/RejectionException.php
+++ b/vendor/guzzlehttp/promises/src/RejectionException.php
@@ -1,48 +1,48 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * A special exception that is thrown when waiting on a rejected promise.
- *
- * The reason value is available via the getReason() method.
- */
-class RejectionException extends \RuntimeException
-{
-    /** @var mixed Rejection reason. */
-    private $reason;
-
-    /**
-     * @param mixed  $reason      Rejection reason.
-     * @param string $description Optional description
-     */
-    public function __construct($reason, $description = null)
-    {
-        $this->reason = $reason;
-
-        $message = 'The promise was rejected';
-
-        if ($description) {
-            $message .= ' with reason: ' . $description;
-        } elseif (is_string($reason)
-            || (is_object($reason) && method_exists($reason, '__toString'))
-        ) {
-            $message .= ' with reason: ' . $this->reason;
-        } elseif ($reason instanceof \JsonSerializable) {
-            $message .= ' with reason: '
-                . json_encode($this->reason, JSON_PRETTY_PRINT);
-        }
-
-        parent::__construct($message);
-    }
-
-    /**
-     * Returns the rejection reason.
-     *
-     * @return mixed
-     */
-    public function getReason()
-    {
-        return $this->reason;
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * A special exception that is thrown when waiting on a rejected promise.

+ *

+ * The reason value is available via the getReason() method.

+ */

+class RejectionException extends \RuntimeException

+{

+    /** @var mixed Rejection reason. */

+    private $reason;

+

+    /**

+     * @param mixed  $reason      Rejection reason.

+     * @param string $description Optional description

+     */

+    public function __construct($reason, $description = null)

+    {

+        $this->reason = $reason;

+

+        $message = 'The promise was rejected';

+

+        if ($description) {

+            $message .= ' with reason: ' . $description;

+        } elseif (is_string($reason)

+            || (is_object($reason) && method_exists($reason, '__toString'))

+        ) {

+            $message .= ' with reason: ' . $this->reason;

+        } elseif ($reason instanceof \JsonSerializable) {

+            $message .= ' with reason: '

+                . json_encode($this->reason, JSON_PRETTY_PRINT);

+        }

+

+        parent::__construct($message);

+    }

+

+    /**

+     * Returns the rejection reason.

+     *

+     * @return mixed

+     */

+    public function getReason()

+    {

+        return $this->reason;

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/TaskQueue.php b/vendor/guzzlehttp/promises/src/TaskQueue.php
index f0fba2c..75b8bc2 100644
--- a/vendor/guzzlehttp/promises/src/TaskQueue.php
+++ b/vendor/guzzlehttp/promises/src/TaskQueue.php
@@ -1,67 +1,67 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * A task queue that executes tasks in a FIFO order.
- *
- * This task queue class is used to settle promises asynchronously and
- * maintains a constant stack size. You can use the task queue asynchronously
- * by calling the `run()` function of the global task queue in an event loop.
- *
- *     GuzzleHttp\Promise\Utils::queue()->run();
- */
-class TaskQueue implements TaskQueueInterface
-{
-    private $enableShutdown = true;
-    private $queue = [];
-
-    public function __construct($withShutdown = true)
-    {
-        if ($withShutdown) {
-            register_shutdown_function(function () {
-                if ($this->enableShutdown) {
-                    // Only run the tasks if an E_ERROR didn't occur.
-                    $err = error_get_last();
-                    if (!$err || ($err['type'] ^ E_ERROR)) {
-                        $this->run();
-                    }
-                }
-            });
-        }
-    }
-
-    public function isEmpty()
-    {
-        return !$this->queue;
-    }
-
-    public function add(callable $task)
-    {
-        $this->queue[] = $task;
-    }
-
-    public function run()
-    {
-        while ($task = array_shift($this->queue)) {
-            /** @var callable $task */
-            $task();
-        }
-    }
-
-    /**
-     * The task queue will be run and exhausted by default when the process
-     * exits IFF the exit is not the result of a PHP E_ERROR error.
-     *
-     * You can disable running the automatic shutdown of the queue by calling
-     * this function. If you disable the task queue shutdown process, then you
-     * MUST either run the task queue (as a result of running your event loop
-     * or manually using the run() method) or wait on each outstanding promise.
-     *
-     * Note: This shutdown will occur before any destructors are triggered.
-     */
-    public function disableShutdown()
-    {
-        $this->enableShutdown = false;
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * A task queue that executes tasks in a FIFO order.

+ *

+ * This task queue class is used to settle promises asynchronously and

+ * maintains a constant stack size. You can use the task queue asynchronously

+ * by calling the `run()` function of the global task queue in an event loop.

+ *

+ *     GuzzleHttp\Promise\Utils::queue()->run();

+ */

+class TaskQueue implements TaskQueueInterface

+{

+    private $enableShutdown = true;

+    private $queue = [];

+

+    public function __construct($withShutdown = true)

+    {

+        if ($withShutdown) {

+            register_shutdown_function(function () {

+                if ($this->enableShutdown) {

+                    // Only run the tasks if an E_ERROR didn't occur.

+                    $err = error_get_last();

+                    if (!$err || ($err['type'] ^ E_ERROR)) {

+                        $this->run();

+                    }

+                }

+            });

+        }

+    }

+

+    public function isEmpty()

+    {

+        return !$this->queue;

+    }

+

+    public function add(callable $task)

+    {

+        $this->queue[] = $task;

+    }

+

+    public function run()

+    {

+        while ($task = array_shift($this->queue)) {

+            /** @var callable $task */

+            $task();

+        }

+    }

+

+    /**

+     * The task queue will be run and exhausted by default when the process

+     * exits IFF the exit is not the result of a PHP E_ERROR error.

+     *

+     * You can disable running the automatic shutdown of the queue by calling

+     * this function. If you disable the task queue shutdown process, then you

+     * MUST either run the task queue (as a result of running your event loop

+     * or manually using the run() method) or wait on each outstanding promise.

+     *

+     * Note: This shutdown will occur before any destructors are triggered.

+     */

+    public function disableShutdown()

+    {

+        $this->enableShutdown = false;

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/TaskQueueInterface.php b/vendor/guzzlehttp/promises/src/TaskQueueInterface.php
index 723d4d5..332f550 100644
--- a/vendor/guzzlehttp/promises/src/TaskQueueInterface.php
+++ b/vendor/guzzlehttp/promises/src/TaskQueueInterface.php
@@ -1,24 +1,24 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-interface TaskQueueInterface
-{
-    /**
-     * Returns true if the queue is empty.
-     *
-     * @return bool
-     */
-    public function isEmpty();
-
-    /**
-     * Adds a task to the queue that will be executed the next time run is
-     * called.
-     */
-    public function add(callable $task);
-
-    /**
-     * Execute all of the pending task in the queue.
-     */
-    public function run();
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+interface TaskQueueInterface

+{

+    /**

+     * Returns true if the queue is empty.

+     *

+     * @return bool

+     */

+    public function isEmpty();

+

+    /**

+     * Adds a task to the queue that will be executed the next time run is

+     * called.

+     */

+    public function add(callable $task);

+

+    /**

+     * Execute all of the pending task in the queue.

+     */

+    public function run();

+}

diff --git a/vendor/guzzlehttp/promises/src/Utils.php b/vendor/guzzlehttp/promises/src/Utils.php
index 1cee862..6368a0a 100644
--- a/vendor/guzzlehttp/promises/src/Utils.php
+++ b/vendor/guzzlehttp/promises/src/Utils.php
@@ -1,274 +1,276 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-final class Utils
-{
-    /**
-     * Get the global task queue used for promise resolution.
-     *
-     * This task queue MUST be run in an event loop in order for promises to be
-     * settled asynchronously. It will be automatically run when synchronously
-     * waiting on a promise.
-     *
-     * <code>
-     * while ($eventLoop->isRunning()) {
-     *     GuzzleHttp\Promise\Utils::queue()->run();
-     * }
-     * </code>
-     *
-     * @param TaskQueueInterface $assign Optionally specify a new queue instance.
-     *
-     * @return TaskQueueInterface
-     */
-    public static function queue(TaskQueueInterface $assign = null)
-    {
-        static $queue;
-
-        if ($assign) {
-            $queue = $assign;
-        } elseif (!$queue) {
-            $queue = new TaskQueue();
-        }
-
-        return $queue;
-    }
-
-    /**
-     * Adds a function to run in the task queue when it is next `run()` and
-     * returns a promise that is fulfilled or rejected with the result.
-     *
-     * @param callable $task Task function to run.
-     *
-     * @return PromiseInterface
-     */
-    public static function task(callable $task)
-    {
-        $queue = self::queue();
-        $promise = new Promise([$queue, 'run']);
-        $queue->add(function () use ($task, $promise) {
-            try {
-                $promise->resolve($task());
-            } catch (\Throwable $e) {
-                $promise->reject($e);
-            } catch (\Exception $e) {
-                $promise->reject($e);
-            }
-        });
-
-        return $promise;
-    }
-
-    /**
-     * Synchronously waits on a promise to resolve and returns an inspection
-     * state array.
-     *
-     * Returns a state associative array containing a "state" key mapping to a
-     * valid promise state. If the state of the promise is "fulfilled", the
-     * array will contain a "value" key mapping to the fulfilled value of the
-     * promise. If the promise is rejected, the array will contain a "reason"
-     * key mapping to the rejection reason of the promise.
-     *
-     * @param PromiseInterface $promise Promise or value.
-     *
-     * @return array
-     */
-    public static function inspect(PromiseInterface $promise)
-    {
-        try {
-            return [
-                'state' => PromiseInterface::FULFILLED,
-                'value' => $promise->wait()
-            ];
-        } catch (RejectionException $e) {
-            return ['state' => PromiseInterface::REJECTED, 'reason' => $e->getReason()];
-        } catch (\Throwable $e) {
-            return ['state' => PromiseInterface::REJECTED, 'reason' => $e];
-        } catch (\Exception $e) {
-            return ['state' => PromiseInterface::REJECTED, 'reason' => $e];
-        }
-    }
-
-    /**
-     * Waits on all of the provided promises, but does not unwrap rejected
-     * promises as thrown exception.
-     *
-     * Returns an array of inspection state arrays.
-     *
-     * @see inspect for the inspection state array format.
-     *
-     * @param PromiseInterface[] $promises Traversable of promises to wait upon.
-     *
-     * @return array
-     */
-    public static function inspectAll($promises)
-    {
-        $results = [];
-        foreach ($promises as $key => $promise) {
-            $results[$key] = inspect($promise);
-        }
-
-        return $results;
-    }
-
-    /**
-     * Waits on all of the provided promises and returns the fulfilled values.
-     *
-     * Returns an array that contains the value of each promise (in the same
-     * order the promises were provided). An exception is thrown if any of the
-     * promises are rejected.
-     *
-     * @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.
-     *
-     * @return array
-     *
-     * @throws \Exception on error
-     * @throws \Throwable on error in PHP >=7
-     */
-    public static function unwrap($promises)
-    {
-        $results = [];
-        foreach ($promises as $key => $promise) {
-            $results[$key] = $promise->wait();
-        }
-
-        return $results;
-    }
-
-    /**
-     * Given an array of promises, return a promise that is fulfilled when all
-     * the items in the array are fulfilled.
-     *
-     * The promise's fulfillment value is an array with fulfillment values at
-     * respective positions to the original array. If any promise in the array
-     * rejects, the returned promise is rejected with the rejection reason.
-     *
-     * @param mixed $promises  Promises or values.
-     * @param bool  $recursive If true, resolves new promises that might have been added to the stack during its own resolution.
-     *
-     * @return PromiseInterface
-     */
-    public static function all($promises, $recursive = false)
-    {
-        $results = [];
-        $promise = Each::of(
-            $promises,
-            function ($value, $idx) use (&$results) {
-                $results[$idx] = $value;
-            },
-            function ($reason, $idx, Promise $aggregate) {
-                $aggregate->reject($reason);
-            }
-        )->then(function () use (&$results) {
-            ksort($results);
-            return $results;
-        });
-
-        if (true === $recursive) {
-            $promise = $promise->then(function ($results) use ($recursive, &$promises) {
-                foreach ($promises as $promise) {
-                    if (Is::pending($promise)) {
-                        return self::all($promises, $recursive);
-                    }
-                }
-                return $results;
-            });
-        }
-
-        return $promise;
-    }
-
-    /**
-     * Initiate a competitive race between multiple promises or values (values
-     * will become immediately fulfilled promises).
-     *
-     * When count amount of promises have been fulfilled, the returned promise
-     * is fulfilled with an array that contains the fulfillment values of the
-     * winners in order of resolution.
-     *
-     * This promise is rejected with a {@see AggregateException} if the number
-     * of fulfilled promises is less than the desired $count.
-     *
-     * @param int   $count    Total number of promises.
-     * @param mixed $promises Promises or values.
-     *
-     * @return PromiseInterface
-     */
-    public static function some($count, $promises)
-    {
-        $results = [];
-        $rejections = [];
-
-        return Each::of(
-            $promises,
-            function ($value, $idx, PromiseInterface $p) use (&$results, $count) {
-                if (Is::settled($p)) {
-                    return;
-                }
-                $results[$idx] = $value;
-                if (count($results) >= $count) {
-                    $p->resolve(null);
-                }
-            },
-            function ($reason) use (&$rejections) {
-                $rejections[] = $reason;
-            }
-        )->then(
-            function () use (&$results, &$rejections, $count) {
-                if (count($results) !== $count) {
-                    throw new AggregateException(
-                        'Not enough promises to fulfill count',
-                        $rejections
-                    );
-                }
-                ksort($results);
-                return array_values($results);
-            }
-        );
-    }
-
-    /**
-     * Like some(), with 1 as count. However, if the promise fulfills, the
-     * fulfillment value is not an array of 1 but the value directly.
-     *
-     * @param mixed $promises Promises or values.
-     *
-     * @return PromiseInterface
-     */
-    public static function any($promises)
-    {
-        return self::some(1, $promises)->then(function ($values) {
-            return $values[0];
-        });
-    }
-
-    /**
-     * Returns a promise that is fulfilled when all of the provided promises have
-     * been fulfilled or rejected.
-     *
-     * The returned promise is fulfilled with an array of inspection state arrays.
-     *
-     * @see inspect for the inspection state array format.
-     *
-     * @param mixed $promises Promises or values.
-     *
-     * @return PromiseInterface
-     */
-    public static function settle($promises)
-    {
-        $results = [];
-
-        return Each::of(
-            $promises,
-            function ($value, $idx) use (&$results) {
-                $results[$idx] = ['state' => PromiseInterface::FULFILLED, 'value' => $value];
-            },
-            function ($reason, $idx) use (&$results) {
-                $results[$idx] = ['state' => PromiseInterface::REJECTED, 'reason' => $reason];
-            }
-        )->then(function () use (&$results) {
-            ksort($results);
-            return $results;
-        });
-    }
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+final class Utils

+{

+    /**

+     * Get the global task queue used for promise resolution.

+     *

+     * This task queue MUST be run in an event loop in order for promises to be

+     * settled asynchronously. It will be automatically run when synchronously

+     * waiting on a promise.

+     *

+     * <code>

+     * while ($eventLoop->isRunning()) {

+     *     GuzzleHttp\Promise\Utils::queue()->run();

+     * }

+     * </code>

+     *

+     * @param TaskQueueInterface $assign Optionally specify a new queue instance.

+     *

+     * @return TaskQueueInterface

+     */

+    public static function queue(TaskQueueInterface $assign = null)

+    {

+        static $queue;

+

+        if ($assign) {

+            $queue = $assign;

+        } elseif (!$queue) {

+            $queue = new TaskQueue();

+        }

+

+        return $queue;

+    }

+

+    /**

+     * Adds a function to run in the task queue when it is next `run()` and

+     * returns a promise that is fulfilled or rejected with the result.

+     *

+     * @param callable $task Task function to run.

+     *

+     * @return PromiseInterface

+     */

+    public static function task(callable $task)

+    {

+        $queue = self::queue();

+        $promise = new Promise([$queue, 'run']);

+        $queue->add(function () use ($task, $promise) {

+            try {

+                if (Is::pending($promise)) {

+                    $promise->resolve($task());

+                }

+            } catch (\Throwable $e) {

+                $promise->reject($e);

+            } catch (\Exception $e) {

+                $promise->reject($e);

+            }

+        });

+

+        return $promise;

+    }

+

+    /**

+     * Synchronously waits on a promise to resolve and returns an inspection

+     * state array.

+     *

+     * Returns a state associative array containing a "state" key mapping to a

+     * valid promise state. If the state of the promise is "fulfilled", the

+     * array will contain a "value" key mapping to the fulfilled value of the

+     * promise. If the promise is rejected, the array will contain a "reason"

+     * key mapping to the rejection reason of the promise.

+     *

+     * @param PromiseInterface $promise Promise or value.

+     *

+     * @return array

+     */

+    public static function inspect(PromiseInterface $promise)

+    {

+        try {

+            return [

+                'state' => PromiseInterface::FULFILLED,

+                'value' => $promise->wait()

+            ];

+        } catch (RejectionException $e) {

+            return ['state' => PromiseInterface::REJECTED, 'reason' => $e->getReason()];

+        } catch (\Throwable $e) {

+            return ['state' => PromiseInterface::REJECTED, 'reason' => $e];

+        } catch (\Exception $e) {

+            return ['state' => PromiseInterface::REJECTED, 'reason' => $e];

+        }

+    }

+

+    /**

+     * Waits on all of the provided promises, but does not unwrap rejected

+     * promises as thrown exception.

+     *

+     * Returns an array of inspection state arrays.

+     *

+     * @see inspect for the inspection state array format.

+     *

+     * @param PromiseInterface[] $promises Traversable of promises to wait upon.

+     *

+     * @return array

+     */

+    public static function inspectAll($promises)

+    {

+        $results = [];

+        foreach ($promises as $key => $promise) {

+            $results[$key] = self::inspect($promise);

+        }

+

+        return $results;

+    }

+

+    /**

+     * Waits on all of the provided promises and returns the fulfilled values.

+     *

+     * Returns an array that contains the value of each promise (in the same

+     * order the promises were provided). An exception is thrown if any of the

+     * promises are rejected.

+     *

+     * @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.

+     *

+     * @return array

+     *

+     * @throws \Exception on error

+     * @throws \Throwable on error in PHP >=7

+     */

+    public static function unwrap($promises)

+    {

+        $results = [];

+        foreach ($promises as $key => $promise) {

+            $results[$key] = $promise->wait();

+        }

+

+        return $results;

+    }

+

+    /**

+     * Given an array of promises, return a promise that is fulfilled when all

+     * the items in the array are fulfilled.

+     *

+     * The promise's fulfillment value is an array with fulfillment values at

+     * respective positions to the original array. If any promise in the array

+     * rejects, the returned promise is rejected with the rejection reason.

+     *

+     * @param mixed $promises  Promises or values.

+     * @param bool  $recursive If true, resolves new promises that might have been added to the stack during its own resolution.

+     *

+     * @return PromiseInterface

+     */

+    public static function all($promises, $recursive = false)

+    {

+        $results = [];

+        $promise = Each::of(

+            $promises,

+            function ($value, $idx) use (&$results) {

+                $results[$idx] = $value;

+            },

+            function ($reason, $idx, Promise $aggregate) {

+                $aggregate->reject($reason);

+            }

+        )->then(function () use (&$results) {

+            ksort($results);

+            return $results;

+        });

+

+        if (true === $recursive) {

+            $promise = $promise->then(function ($results) use ($recursive, &$promises) {

+                foreach ($promises as $promise) {

+                    if (Is::pending($promise)) {

+                        return self::all($promises, $recursive);

+                    }

+                }

+                return $results;

+            });

+        }

+

+        return $promise;

+    }

+

+    /**

+     * Initiate a competitive race between multiple promises or values (values

+     * will become immediately fulfilled promises).

+     *

+     * When count amount of promises have been fulfilled, the returned promise

+     * is fulfilled with an array that contains the fulfillment values of the

+     * winners in order of resolution.

+     *

+     * This promise is rejected with a {@see AggregateException} if the number

+     * of fulfilled promises is less than the desired $count.

+     *

+     * @param int   $count    Total number of promises.

+     * @param mixed $promises Promises or values.

+     *

+     * @return PromiseInterface

+     */

+    public static function some($count, $promises)

+    {

+        $results = [];

+        $rejections = [];

+

+        return Each::of(

+            $promises,

+            function ($value, $idx, PromiseInterface $p) use (&$results, $count) {

+                if (Is::settled($p)) {

+                    return;

+                }

+                $results[$idx] = $value;

+                if (count($results) >= $count) {

+                    $p->resolve(null);

+                }

+            },

+            function ($reason) use (&$rejections) {

+                $rejections[] = $reason;

+            }

+        )->then(

+            function () use (&$results, &$rejections, $count) {

+                if (count($results) !== $count) {

+                    throw new AggregateException(

+                        'Not enough promises to fulfill count',

+                        $rejections

+                    );

+                }

+                ksort($results);

+                return array_values($results);

+            }

+        );

+    }

+

+    /**

+     * Like some(), with 1 as count. However, if the promise fulfills, the

+     * fulfillment value is not an array of 1 but the value directly.

+     *

+     * @param mixed $promises Promises or values.

+     *

+     * @return PromiseInterface

+     */

+    public static function any($promises)

+    {

+        return self::some(1, $promises)->then(function ($values) {

+            return $values[0];

+        });

+    }

+

+    /**

+     * Returns a promise that is fulfilled when all of the provided promises have

+     * been fulfilled or rejected.

+     *

+     * The returned promise is fulfilled with an array of inspection state arrays.

+     *

+     * @see inspect for the inspection state array format.

+     *

+     * @param mixed $promises Promises or values.

+     *

+     * @return PromiseInterface

+     */

+    public static function settle($promises)

+    {

+        $results = [];

+

+        return Each::of(

+            $promises,

+            function ($value, $idx) use (&$results) {

+                $results[$idx] = ['state' => PromiseInterface::FULFILLED, 'value' => $value];

+            },

+            function ($reason, $idx) use (&$results) {

+                $results[$idx] = ['state' => PromiseInterface::REJECTED, 'reason' => $reason];

+            }

+        )->then(function () use (&$results) {

+            ksort($results);

+            return $results;

+        });

+    }

+}

diff --git a/vendor/guzzlehttp/promises/src/functions.php b/vendor/guzzlehttp/promises/src/functions.php
index c03d39d..75aab22 100644
--- a/vendor/guzzlehttp/promises/src/functions.php
+++ b/vendor/guzzlehttp/promises/src/functions.php
@@ -1,363 +1,363 @@
-<?php
-
-namespace GuzzleHttp\Promise;
-
-/**
- * Get the global task queue used for promise resolution.
- *
- * This task queue MUST be run in an event loop in order for promises to be
- * settled asynchronously. It will be automatically run when synchronously
- * waiting on a promise.
- *
- * <code>
- * while ($eventLoop->isRunning()) {
- *     GuzzleHttp\Promise\queue()->run();
- * }
- * </code>
- *
- * @param TaskQueueInterface $assign Optionally specify a new queue instance.
- *
- * @return TaskQueueInterface
- *
- * @deprecated queue will be removed in guzzlehttp/promises:2.0. Use Utils::queue instead.
- */
-function queue(TaskQueueInterface $assign = null)
-{
-    return Utils::queue($assign);
-}
-
-/**
- * Adds a function to run in the task queue when it is next `run()` and returns
- * a promise that is fulfilled or rejected with the result.
- *
- * @param callable $task Task function to run.
- *
- * @return PromiseInterface
- *
- * @deprecated task will be removed in guzzlehttp/promises:2.0. Use Utils::task instead.
- */
-function task(callable $task)
-{
-    return Utils::task($task);
-}
-
-/**
- * Creates a promise for a value if the value is not a promise.
- *
- * @param mixed $value Promise or value.
- *
- * @return PromiseInterface
- *
- * @deprecated promise_for will be removed in guzzlehttp/promises:2.0. Use Create::promiseFor instead.
- */
-function promise_for($value)
-{
-    return Create::promiseFor($value);
-}
-
-/**
- * Creates a rejected promise for a reason if the reason is not a promise. If
- * the provided reason is a promise, then it is returned as-is.
- *
- * @param mixed $reason Promise or reason.
- *
- * @return PromiseInterface
- *
- * @deprecated rejection_for will be removed in guzzlehttp/promises:2.0. Use Create::rejectionFor instead.
- */
-function rejection_for($reason)
-{
-    return Create::rejectionFor($reason);
-}
-
-/**
- * Create an exception for a rejected promise value.
- *
- * @param mixed $reason
- *
- * @return \Exception|\Throwable
- *
- * @deprecated exception_for will be removed in guzzlehttp/promises:2.0. Use Create::exceptionFor instead.
- */
-function exception_for($reason)
-{
-    return Create::exceptionFor($reason);
-}
-
-/**
- * Returns an iterator for the given value.
- *
- * @param mixed $value
- *
- * @return \Iterator
- *
- * @deprecated iter_for will be removed in guzzlehttp/promises:2.0. Use Create::iterFor instead.
- */
-function iter_for($value)
-{
-    return Create::iterFor($value);
-}
-
-/**
- * Synchronously waits on a promise to resolve and returns an inspection state
- * array.
- *
- * Returns a state associative array containing a "state" key mapping to a
- * valid promise state. If the state of the promise is "fulfilled", the array
- * will contain a "value" key mapping to the fulfilled value of the promise. If
- * the promise is rejected, the array will contain a "reason" key mapping to
- * the rejection reason of the promise.
- *
- * @param PromiseInterface $promise Promise or value.
- *
- * @return array
- *
- * @deprecated inspect will be removed in guzzlehttp/promises:2.0. Use Utils::inspect instead.
- */
-function inspect(PromiseInterface $promise)
-{
-    return Utils::inspect($promise);
-}
-
-/**
- * Waits on all of the provided promises, but does not unwrap rejected promises
- * as thrown exception.
- *
- * Returns an array of inspection state arrays.
- *
- * @see inspect for the inspection state array format.
- *
- * @param PromiseInterface[] $promises Traversable of promises to wait upon.
- *
- * @return array
- *
- * @deprecated inspect will be removed in guzzlehttp/promises:2.0. Use Utils::inspectAll instead.
- */
-function inspect_all($promises)
-{
-    return Utils::inspectAll($promises);
-}
-
-/**
- * Waits on all of the provided promises and returns the fulfilled values.
- *
- * Returns an array that contains the value of each promise (in the same order
- * the promises were provided). An exception is thrown if any of the promises
- * are rejected.
- *
- * @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.
- *
- * @return array
- *
- * @throws \Exception on error
- * @throws \Throwable on error in PHP >=7
- *
- * @deprecated unwrap will be removed in guzzlehttp/promises:2.0. Use Utils::unwrap instead.
- */
-function unwrap($promises)
-{
-    return Utils::unwrap($promises);
-}
-
-/**
- * Given an array of promises, return a promise that is fulfilled when all the
- * items in the array are fulfilled.
- *
- * The promise's fulfillment value is an array with fulfillment values at
- * respective positions to the original array. If any promise in the array
- * rejects, the returned promise is rejected with the rejection reason.
- *
- * @param mixed $promises  Promises or values.
- * @param bool  $recursive If true, resolves new promises that might have been added to the stack during its own resolution.
- *
- * @return PromiseInterface
- *
- * @deprecated all will be removed in guzzlehttp/promises:2.0. Use Utils::all instead.
- */
-function all($promises, $recursive = false)
-{
-    return Utils::all($promises, $recursive);
-}
-
-/**
- * Initiate a competitive race between multiple promises or values (values will
- * become immediately fulfilled promises).
- *
- * When count amount of promises have been fulfilled, the returned promise is
- * fulfilled with an array that contains the fulfillment values of the winners
- * in order of resolution.
- *
- * This promise is rejected with a {@see AggregateException} if the number of
- * fulfilled promises is less than the desired $count.
- *
- * @param int   $count    Total number of promises.
- * @param mixed $promises Promises or values.
- *
- * @return PromiseInterface
- *
- * @deprecated some will be removed in guzzlehttp/promises:2.0. Use Utils::some instead.
- */
-function some($count, $promises)
-{
-    return Utils::some($count, $promises);
-}
-
-/**
- * Like some(), with 1 as count. However, if the promise fulfills, the
- * fulfillment value is not an array of 1 but the value directly.
- *
- * @param mixed $promises Promises or values.
- *
- * @return PromiseInterface
- *
- * @deprecated any will be removed in guzzlehttp/promises:2.0. Use Utils::any instead.
- */
-function any($promises)
-{
-    return Utils::any($promises);
-}
-
-/**
- * Returns a promise that is fulfilled when all of the provided promises have
- * been fulfilled or rejected.
- *
- * The returned promise is fulfilled with an array of inspection state arrays.
- *
- * @see inspect for the inspection state array format.
- *
- * @param mixed $promises Promises or values.
- *
- * @return PromiseInterface
- *
- * @deprecated settle will be removed in guzzlehttp/promises:2.0. Use Utils::settle instead.
- */
-function settle($promises)
-{
-    return Utils::settle($promises);
-}
-
-/**
- * Given an iterator that yields promises or values, returns a promise that is
- * fulfilled with a null value when the iterator has been consumed or the
- * aggregate promise has been fulfilled or rejected.
- *
- * $onFulfilled is a function that accepts the fulfilled value, iterator index,
- * and the aggregate promise. The callback can invoke any necessary side
- * effects and choose to resolve or reject the aggregate if needed.
- *
- * $onRejected is a function that accepts the rejection reason, iterator index,
- * and the aggregate promise. The callback can invoke any necessary side
- * effects and choose to resolve or reject the aggregate if needed.
- *
- * @param mixed    $iterable    Iterator or array to iterate over.
- * @param callable $onFulfilled
- * @param callable $onRejected
- *
- * @return PromiseInterface
- *
- * @deprecated each will be removed in guzzlehttp/promises:2.0. Use Each::of instead.
- */
-function each(
-    $iterable,
-    callable $onFulfilled = null,
-    callable $onRejected = null
-) {
-    return Each::of($iterable, $onFulfilled, $onRejected);
-}
-
-/**
- * Like each, but only allows a certain number of outstanding promises at any
- * given time.
- *
- * $concurrency may be an integer or a function that accepts the number of
- * pending promises and returns a numeric concurrency limit value to allow for
- * dynamic a concurrency size.
- *
- * @param mixed        $iterable
- * @param int|callable $concurrency
- * @param callable     $onFulfilled
- * @param callable     $onRejected
- *
- * @return PromiseInterface
- *
- * @deprecated each_limit will be removed in guzzlehttp/promises:2.0. Use Each::ofLimit instead.
- */
-function each_limit(
-    $iterable,
-    $concurrency,
-    callable $onFulfilled = null,
-    callable $onRejected = null
-) {
-    return Each::ofLimit($iterable, $concurrency, $onFulfilled, $onRejected);
-}
-
-/**
- * Like each_limit, but ensures that no promise in the given $iterable argument
- * is rejected. If any promise is rejected, then the aggregate promise is
- * rejected with the encountered rejection.
- *
- * @param mixed        $iterable
- * @param int|callable $concurrency
- * @param callable     $onFulfilled
- *
- * @return PromiseInterface
- *
- * @deprecated each_limit_all will be removed in guzzlehttp/promises:2.0. Use Each::ofLimitAll instead.
- */
-function each_limit_all(
-    $iterable,
-    $concurrency,
-    callable $onFulfilled = null
-) {
-    return Each::ofLimitAll($iterable, $concurrency, $onFulfilled);
-}
-
-/**
- * Returns true if a promise is fulfilled.
- *
- * @return bool
- *
- * @deprecated is_fulfilled will be removed in guzzlehttp/promises:2.0. Use Is::fulfilled instead.
- */
-function is_fulfilled(PromiseInterface $promise)
-{
-    return Is::fulfilled($promise);
-}
-
-/**
- * Returns true if a promise is rejected.
- *
- * @return bool
- *
- * @deprecated is_rejected will be removed in guzzlehttp/promises:2.0. Use Is::rejected instead.
- */
-function is_rejected(PromiseInterface $promise)
-{
-    return Is::rejected($promise);
-}
-
-/**
- * Returns true if a promise is fulfilled or rejected.
- *
- * @return bool
- *
- * @deprecated is_settled will be removed in guzzlehttp/promises:2.0. Use Is::settled instead.
- */
-function is_settled(PromiseInterface $promise)
-{
-    return Is::settled($promise);
-}
-
-/**
- * Create a new coroutine.
- *
- * @see Coroutine
- *
- * @return PromiseInterface
- *
- * @deprecated coroutine will be removed in guzzlehttp/promises:2.0. Use Coroutine::of instead.
- */
-function coroutine(callable $generatorFn)
-{
-    return Coroutine::of($generatorFn);
-}
+<?php

+

+namespace GuzzleHttp\Promise;

+

+/**

+ * Get the global task queue used for promise resolution.

+ *

+ * This task queue MUST be run in an event loop in order for promises to be

+ * settled asynchronously. It will be automatically run when synchronously

+ * waiting on a promise.

+ *

+ * <code>

+ * while ($eventLoop->isRunning()) {

+ *     GuzzleHttp\Promise\queue()->run();

+ * }

+ * </code>

+ *

+ * @param TaskQueueInterface $assign Optionally specify a new queue instance.

+ *

+ * @return TaskQueueInterface

+ *

+ * @deprecated queue will be removed in guzzlehttp/promises:2.0. Use Utils::queue instead.

+ */

+function queue(TaskQueueInterface $assign = null)

+{

+    return Utils::queue($assign);

+}

+

+/**

+ * Adds a function to run in the task queue when it is next `run()` and returns

+ * a promise that is fulfilled or rejected with the result.

+ *

+ * @param callable $task Task function to run.

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated task will be removed in guzzlehttp/promises:2.0. Use Utils::task instead.

+ */

+function task(callable $task)

+{

+    return Utils::task($task);

+}

+

+/**

+ * Creates a promise for a value if the value is not a promise.

+ *

+ * @param mixed $value Promise or value.

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated promise_for will be removed in guzzlehttp/promises:2.0. Use Create::promiseFor instead.

+ */

+function promise_for($value)

+{

+    return Create::promiseFor($value);

+}

+

+/**

+ * Creates a rejected promise for a reason if the reason is not a promise. If

+ * the provided reason is a promise, then it is returned as-is.

+ *

+ * @param mixed $reason Promise or reason.

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated rejection_for will be removed in guzzlehttp/promises:2.0. Use Create::rejectionFor instead.

+ */

+function rejection_for($reason)

+{

+    return Create::rejectionFor($reason);

+}

+

+/**

+ * Create an exception for a rejected promise value.

+ *

+ * @param mixed $reason

+ *

+ * @return \Exception|\Throwable

+ *

+ * @deprecated exception_for will be removed in guzzlehttp/promises:2.0. Use Create::exceptionFor instead.

+ */

+function exception_for($reason)

+{

+    return Create::exceptionFor($reason);

+}

+

+/**

+ * Returns an iterator for the given value.

+ *

+ * @param mixed $value

+ *

+ * @return \Iterator

+ *

+ * @deprecated iter_for will be removed in guzzlehttp/promises:2.0. Use Create::iterFor instead.

+ */

+function iter_for($value)

+{

+    return Create::iterFor($value);

+}

+

+/**

+ * Synchronously waits on a promise to resolve and returns an inspection state

+ * array.

+ *

+ * Returns a state associative array containing a "state" key mapping to a

+ * valid promise state. If the state of the promise is "fulfilled", the array

+ * will contain a "value" key mapping to the fulfilled value of the promise. If

+ * the promise is rejected, the array will contain a "reason" key mapping to

+ * the rejection reason of the promise.

+ *

+ * @param PromiseInterface $promise Promise or value.

+ *

+ * @return array

+ *

+ * @deprecated inspect will be removed in guzzlehttp/promises:2.0. Use Utils::inspect instead.

+ */

+function inspect(PromiseInterface $promise)

+{

+    return Utils::inspect($promise);

+}

+

+/**

+ * Waits on all of the provided promises, but does not unwrap rejected promises

+ * as thrown exception.

+ *

+ * Returns an array of inspection state arrays.

+ *

+ * @see inspect for the inspection state array format.

+ *

+ * @param PromiseInterface[] $promises Traversable of promises to wait upon.

+ *

+ * @return array

+ *

+ * @deprecated inspect will be removed in guzzlehttp/promises:2.0. Use Utils::inspectAll instead.

+ */

+function inspect_all($promises)

+{

+    return Utils::inspectAll($promises);

+}

+

+/**

+ * Waits on all of the provided promises and returns the fulfilled values.

+ *

+ * Returns an array that contains the value of each promise (in the same order

+ * the promises were provided). An exception is thrown if any of the promises

+ * are rejected.

+ *

+ * @param iterable<PromiseInterface> $promises Iterable of PromiseInterface objects to wait on.

+ *

+ * @return array

+ *

+ * @throws \Exception on error

+ * @throws \Throwable on error in PHP >=7

+ *

+ * @deprecated unwrap will be removed in guzzlehttp/promises:2.0. Use Utils::unwrap instead.

+ */

+function unwrap($promises)

+{

+    return Utils::unwrap($promises);

+}

+

+/**

+ * Given an array of promises, return a promise that is fulfilled when all the

+ * items in the array are fulfilled.

+ *

+ * The promise's fulfillment value is an array with fulfillment values at

+ * respective positions to the original array. If any promise in the array

+ * rejects, the returned promise is rejected with the rejection reason.

+ *

+ * @param mixed $promises  Promises or values.

+ * @param bool  $recursive If true, resolves new promises that might have been added to the stack during its own resolution.

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated all will be removed in guzzlehttp/promises:2.0. Use Utils::all instead.

+ */

+function all($promises, $recursive = false)

+{

+    return Utils::all($promises, $recursive);

+}

+

+/**

+ * Initiate a competitive race between multiple promises or values (values will

+ * become immediately fulfilled promises).

+ *

+ * When count amount of promises have been fulfilled, the returned promise is

+ * fulfilled with an array that contains the fulfillment values of the winners

+ * in order of resolution.

+ *

+ * This promise is rejected with a {@see AggregateException} if the number of

+ * fulfilled promises is less than the desired $count.

+ *

+ * @param int   $count    Total number of promises.

+ * @param mixed $promises Promises or values.

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated some will be removed in guzzlehttp/promises:2.0. Use Utils::some instead.

+ */

+function some($count, $promises)

+{

+    return Utils::some($count, $promises);

+}

+

+/**

+ * Like some(), with 1 as count. However, if the promise fulfills, the

+ * fulfillment value is not an array of 1 but the value directly.

+ *

+ * @param mixed $promises Promises or values.

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated any will be removed in guzzlehttp/promises:2.0. Use Utils::any instead.

+ */

+function any($promises)

+{

+    return Utils::any($promises);

+}

+

+/**

+ * Returns a promise that is fulfilled when all of the provided promises have

+ * been fulfilled or rejected.

+ *

+ * The returned promise is fulfilled with an array of inspection state arrays.

+ *

+ * @see inspect for the inspection state array format.

+ *

+ * @param mixed $promises Promises or values.

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated settle will be removed in guzzlehttp/promises:2.0. Use Utils::settle instead.

+ */

+function settle($promises)

+{

+    return Utils::settle($promises);

+}

+

+/**

+ * Given an iterator that yields promises or values, returns a promise that is

+ * fulfilled with a null value when the iterator has been consumed or the

+ * aggregate promise has been fulfilled or rejected.

+ *

+ * $onFulfilled is a function that accepts the fulfilled value, iterator index,

+ * and the aggregate promise. The callback can invoke any necessary side

+ * effects and choose to resolve or reject the aggregate if needed.

+ *

+ * $onRejected is a function that accepts the rejection reason, iterator index,

+ * and the aggregate promise. The callback can invoke any necessary side

+ * effects and choose to resolve or reject the aggregate if needed.

+ *

+ * @param mixed    $iterable    Iterator or array to iterate over.

+ * @param callable $onFulfilled

+ * @param callable $onRejected

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated each will be removed in guzzlehttp/promises:2.0. Use Each::of instead.

+ */

+function each(

+    $iterable,

+    callable $onFulfilled = null,

+    callable $onRejected = null

+) {

+    return Each::of($iterable, $onFulfilled, $onRejected);

+}

+

+/**

+ * Like each, but only allows a certain number of outstanding promises at any

+ * given time.

+ *

+ * $concurrency may be an integer or a function that accepts the number of

+ * pending promises and returns a numeric concurrency limit value to allow for

+ * dynamic a concurrency size.

+ *

+ * @param mixed        $iterable

+ * @param int|callable $concurrency

+ * @param callable     $onFulfilled

+ * @param callable     $onRejected

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated each_limit will be removed in guzzlehttp/promises:2.0. Use Each::ofLimit instead.

+ */

+function each_limit(

+    $iterable,

+    $concurrency,

+    callable $onFulfilled = null,

+    callable $onRejected = null

+) {

+    return Each::ofLimit($iterable, $concurrency, $onFulfilled, $onRejected);

+}

+

+/**

+ * Like each_limit, but ensures that no promise in the given $iterable argument

+ * is rejected. If any promise is rejected, then the aggregate promise is

+ * rejected with the encountered rejection.

+ *

+ * @param mixed        $iterable

+ * @param int|callable $concurrency

+ * @param callable     $onFulfilled

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated each_limit_all will be removed in guzzlehttp/promises:2.0. Use Each::ofLimitAll instead.

+ */

+function each_limit_all(

+    $iterable,

+    $concurrency,

+    callable $onFulfilled = null

+) {

+    return Each::ofLimitAll($iterable, $concurrency, $onFulfilled);

+}

+

+/**

+ * Returns true if a promise is fulfilled.

+ *

+ * @return bool

+ *

+ * @deprecated is_fulfilled will be removed in guzzlehttp/promises:2.0. Use Is::fulfilled instead.

+ */

+function is_fulfilled(PromiseInterface $promise)

+{

+    return Is::fulfilled($promise);

+}

+

+/**

+ * Returns true if a promise is rejected.

+ *

+ * @return bool

+ *

+ * @deprecated is_rejected will be removed in guzzlehttp/promises:2.0. Use Is::rejected instead.

+ */

+function is_rejected(PromiseInterface $promise)

+{

+    return Is::rejected($promise);

+}

+

+/**

+ * Returns true if a promise is fulfilled or rejected.

+ *

+ * @return bool

+ *

+ * @deprecated is_settled will be removed in guzzlehttp/promises:2.0. Use Is::settled instead.

+ */

+function is_settled(PromiseInterface $promise)

+{

+    return Is::settled($promise);

+}

+

+/**

+ * Create a new coroutine.

+ *

+ * @see Coroutine

+ *

+ * @return PromiseInterface

+ *

+ * @deprecated coroutine will be removed in guzzlehttp/promises:2.0. Use Coroutine::of instead.

+ */

+function coroutine(callable $generatorFn)

+{

+    return Coroutine::of($generatorFn);

+}

diff --git a/vendor/guzzlehttp/promises/src/functions_include.php b/vendor/guzzlehttp/promises/src/functions_include.php
index 34cd171..47e007c 100644
--- a/vendor/guzzlehttp/promises/src/functions_include.php
+++ b/vendor/guzzlehttp/promises/src/functions_include.php
@@ -1,6 +1,6 @@
-<?php
-
-// Don't redefine the functions if included multiple times.
-if (!function_exists('GuzzleHttp\Promise\promise_for')) {
-    require __DIR__ . '/functions.php';
-}
+<?php

+

+// Don't redefine the functions if included multiple times.

+if (!function_exists('GuzzleHttp\Promise\promise_for')) {

+    require __DIR__ . '/functions.php';

+}