1 files changed, 276 insertions, 274 deletions
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;
+        });
+    }
+}