Include Vendor

vendor/laravel/framework/src/Illuminate/Support/AggregateServiceProvider.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Illuminate\Support;
+
+class AggregateServiceProvider extends ServiceProvider
+{
+    /**
+     * The provider class names.
+     *
+     * @var array
+     */
+    protected $providers = [];
+
+    /**
+     * An array of the service provider instances.
+     *
+     * @var array
+     */
+    protected $instances = [];
+
+    /**
+     * Register the service provider.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        $this->instances = [];
+
+        foreach ($this->providers as $provider) {
+            $this->instances[] = $this->app->register($provider);
+        }
+    }
+
+    /**
+     * Get the services provided by the provider.
+     *
+     * @return array
+     */
+    public function provides()
+    {
+        $provides = [];
+
+        foreach ($this->providers as $provider) {
+            $instance = $this->app->resolveProvider($provider);
+
+            $provides = array_merge($provides, $instance->provides());
+        }
+
+        return $provides;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Arr.php

@@ -0,0 +1,623 @@
+<?php
+
+namespace Illuminate\Support;
+
+use ArrayAccess;
+use InvalidArgumentException;
+use Illuminate\Support\Traits\Macroable;
+
+class Arr
+{
+    use Macroable;
+
+    /**
+     * Determine whether the given value is array accessible.
+     *
+     * @param  mixed  $value
+     * @return bool
+     */
+    public static function accessible($value)
+    {
+        return is_array($value) || $value instanceof ArrayAccess;
+    }
+
+    /**
+     * Add an element to an array using "dot" notation if it doesn't exist.
+     *
+     * @param  array   $array
+     * @param  string  $key
+     * @param  mixed   $value
+     * @return array
+     */
+    public static function add($array, $key, $value)
+    {
+        if (is_null(static::get($array, $key))) {
+            static::set($array, $key, $value);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Collapse an array of arrays into a single array.
+     *
+     * @param  array  $array
+     * @return array
+     */
+    public static function collapse($array)
+    {
+        $results = [];
+
+        foreach ($array as $values) {
+            if ($values instanceof Collection) {
+                $values = $values->all();
+            } elseif (! is_array($values)) {
+                continue;
+            }
+
+            $results = array_merge($results, $values);
+        }
+
+        return $results;
+    }
+
+    /**
+     * Cross join the given arrays, returning all possible permutations.
+     *
+     * @param  array  ...$arrays
+     * @return array
+     */
+    public static function crossJoin(...$arrays)
+    {
+        $results = [[]];
+
+        foreach ($arrays as $index => $array) {
+            $append = [];
+
+            foreach ($results as $product) {
+                foreach ($array as $item) {
+                    $product[$index] = $item;
+
+                    $append[] = $product;
+                }
+            }
+
+            $results = $append;
+        }
+
+        return $results;
+    }
+
+    /**
+     * Divide an array into two arrays. One with keys and the other with values.
+     *
+     * @param  array  $array
+     * @return array
+     */
+    public static function divide($array)
+    {
+        return [array_keys($array), array_values($array)];
+    }
+
+    /**
+     * Flatten a multi-dimensional associative array with dots.
+     *
+     * @param  array   $array
+     * @param  string  $prepend
+     * @return array
+     */
+    public static function dot($array, $prepend = '')
+    {
+        $results = [];
+
+        foreach ($array as $key => $value) {
+            if (is_array($value) && ! empty($value)) {
+                $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
+            } else {
+                $results[$prepend.$key] = $value;
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Get all of the given array except for a specified array of keys.
+     *
+     * @param  array  $array
+     * @param  array|string  $keys
+     * @return array
+     */
+    public static function except($array, $keys)
+    {
+        static::forget($array, $keys);
+
+        return $array;
+    }
+
+    /**
+     * Determine if the given key exists in the provided array.
+     *
+     * @param  \ArrayAccess|array  $array
+     * @param  string|int  $key
+     * @return bool
+     */
+    public static function exists($array, $key)
+    {
+        if ($array instanceof ArrayAccess) {
+            return $array->offsetExists($key);
+        }
+
+        return array_key_exists($key, $array);
+    }
+
+    /**
+     * Return the first element in an array passing a given truth test.
+     *
+     * @param  array  $array
+     * @param  callable|null  $callback
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public static function first($array, callable $callback = null, $default = null)
+    {
+        if (is_null($callback)) {
+            if (empty($array)) {
+                return value($default);
+            }
+
+            foreach ($array as $item) {
+                return $item;
+            }
+        }
+
+        foreach ($array as $key => $value) {
+            if (call_user_func($callback, $value, $key)) {
+                return $value;
+            }
+        }
+
+        return value($default);
+    }
+
+    /**
+     * Return the last element in an array passing a given truth test.
+     *
+     * @param  array  $array
+     * @param  callable|null  $callback
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public static function last($array, callable $callback = null, $default = null)
+    {
+        if (is_null($callback)) {
+            return empty($array) ? value($default) : end($array);
+        }
+
+        return static::first(array_reverse($array, true), $callback, $default);
+    }
+
+    /**
+     * Flatten a multi-dimensional array into a single level.
+     *
+     * @param  array  $array
+     * @param  int  $depth
+     * @return array
+     */
+    public static function flatten($array, $depth = INF)
+    {
+        $result = [];
+
+        foreach ($array as $item) {
+            $item = $item instanceof Collection ? $item->all() : $item;
+
+            if (! is_array($item)) {
+                $result[] = $item;
+            } elseif ($depth === 1) {
+                $result = array_merge($result, array_values($item));
+            } else {
+                $result = array_merge($result, static::flatten($item, $depth - 1));
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Remove one or many array items from a given array using "dot" notation.
+     *
+     * @param  array  $array
+     * @param  array|string  $keys
+     * @return void
+     */
+    public static function forget(&$array, $keys)
+    {
+        $original = &$array;
+
+        $keys = (array) $keys;
+
+        if (count($keys) === 0) {
+            return;
+        }
+
+        foreach ($keys as $key) {
+            // if the exact key exists in the top-level, remove it
+            if (static::exists($array, $key)) {
+                unset($array[$key]);
+
+                continue;
+            }
+
+            $parts = explode('.', $key);
+
+            // clean up before each pass
+            $array = &$original;
+
+            while (count($parts) > 1) {
+                $part = array_shift($parts);
+
+                if (isset($array[$part]) && is_array($array[$part])) {
+                    $array = &$array[$part];
+                } else {
+                    continue 2;
+                }
+            }
+
+            unset($array[array_shift($parts)]);
+        }
+    }
+
+    /**
+     * Get an item from an array using "dot" notation.
+     *
+     * @param  \ArrayAccess|array  $array
+     * @param  string  $key
+     * @param  mixed   $default
+     * @return mixed
+     */
+    public static function get($array, $key, $default = null)
+    {
+        if (! static::accessible($array)) {
+            return value($default);
+        }
+
+        if (is_null($key)) {
+            return $array;
+        }
+
+        if (static::exists($array, $key)) {
+            return $array[$key];
+        }
+
+        if (strpos($key, '.') === false) {
+            return $array[$key] ?? value($default);
+        }
+
+        foreach (explode('.', $key) as $segment) {
+            if (static::accessible($array) && static::exists($array, $segment)) {
+                $array = $array[$segment];
+            } else {
+                return value($default);
+            }
+        }
+
+        return $array;
+    }
+
+    /**
+     * Check if an item or items exist in an array using "dot" notation.
+     *
+     * @param  \ArrayAccess|array  $array
+     * @param  string|array  $keys
+     * @return bool
+     */
+    public static function has($array, $keys)
+    {
+        if (is_null($keys)) {
+            return false;
+        }
+
+        $keys = (array) $keys;
+
+        if (! $array) {
+            return false;
+        }
+
+        if ($keys === []) {
+            return false;
+        }
+
+        foreach ($keys as $key) {
+            $subKeyArray = $array;
+
+            if (static::exists($array, $key)) {
+                continue;
+            }
+
+            foreach (explode('.', $key) as $segment) {
+                if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
+                    $subKeyArray = $subKeyArray[$segment];
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Determines if an array is associative.
+     *
+     * An array is "associative" if it doesn't have sequential numerical keys beginning with zero.
+     *
+     * @param  array  $array
+     * @return bool
+     */
+    public static function isAssoc(array $array)
+    {
+        $keys = array_keys($array);
+
+        return array_keys($keys) !== $keys;
+    }
+
+    /**
+     * Get a subset of the items from the given array.
+     *
+     * @param  array  $array
+     * @param  array|string  $keys
+     * @return array
+     */
+    public static function only($array, $keys)
+    {
+        return array_intersect_key($array, array_flip((array) $keys));
+    }
+
+    /**
+     * Pluck an array of values from an array.
+     *
+     * @param  array  $array
+     * @param  string|array  $value
+     * @param  string|array|null  $key
+     * @return array
+     */
+    public static function pluck($array, $value, $key = null)
+    {
+        $results = [];
+
+        list($value, $key) = static::explodePluckParameters($value, $key);
+
+        foreach ($array as $item) {
+            $itemValue = data_get($item, $value);
+
+            // If the key is "null", we will just append the value to the array and keep
+            // looping. Otherwise we will key the array using the value of the key we
+            // received from the developer. Then we'll return the final array form.
+            if (is_null($key)) {
+                $results[] = $itemValue;
+            } else {
+                $itemKey = data_get($item, $key);
+
+                if (is_object($itemKey) && method_exists($itemKey, '__toString')) {
+                    $itemKey = (string) $itemKey;
+                }
+
+                $results[$itemKey] = $itemValue;
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Explode the "value" and "key" arguments passed to "pluck".
+     *
+     * @param  string|array  $value
+     * @param  string|array|null  $key
+     * @return array
+     */
+    protected static function explodePluckParameters($value, $key)
+    {
+        $value = is_string($value) ? explode('.', $value) : $value;
+
+        $key = is_null($key) || is_array($key) ? $key : explode('.', $key);
+
+        return [$value, $key];
+    }
+
+    /**
+     * Push an item onto the beginning of an array.
+     *
+     * @param  array  $array
+     * @param  mixed  $value
+     * @param  mixed  $key
+     * @return array
+     */
+    public static function prepend($array, $value, $key = null)
+    {
+        if (is_null($key)) {
+            array_unshift($array, $value);
+        } else {
+            $array = [$key => $value] + $array;
+        }
+
+        return $array;
+    }
+
+    /**
+     * Get a value from the array, and remove it.
+     *
+     * @param  array   $array
+     * @param  string  $key
+     * @param  mixed   $default
+     * @return mixed
+     */
+    public static function pull(&$array, $key, $default = null)
+    {
+        $value = static::get($array, $key, $default);
+
+        static::forget($array, $key);
+
+        return $value;
+    }
+
+    /**
+     * Get one or a specified number of random values from an array.
+     *
+     * @param  array  $array
+     * @param  int|null  $number
+     * @return mixed
+     *
+     * @throws \InvalidArgumentException
+     */
+    public static function random($array, $number = null)
+    {
+        $requested = is_null($number) ? 1 : $number;
+
+        $count = count($array);
+
+        if ($requested > $count) {
+            throw new InvalidArgumentException(
+                "You requested {$requested} items, but there are only {$count} items available."
+            );
+        }
+
+        if (is_null($number)) {
+            return $array[array_rand($array)];
+        }
+
+        if ((int) $number === 0) {
+            return [];
+        }
+
+        $keys = array_rand($array, $number);
+
+        $results = [];
+
+        foreach ((array) $keys as $key) {
+            $results[] = $array[$key];
+        }
+
+        return $results;
+    }
+
+    /**
+     * Set an array item to a given value using "dot" notation.
+     *
+     * If no key is given to the method, the entire array will be replaced.
+     *
+     * @param  array   $array
+     * @param  string  $key
+     * @param  mixed   $value
+     * @return array
+     */
+    public static function set(&$array, $key, $value)
+    {
+        if (is_null($key)) {
+            return $array = $value;
+        }
+
+        $keys = explode('.', $key);
+
+        while (count($keys) > 1) {
+            $key = array_shift($keys);
+
+            // If the key doesn't exist at this depth, we will just create an empty array
+            // to hold the next value, allowing us to create the arrays to hold final
+            // values at the correct depth. Then we'll keep digging into the array.
+            if (! isset($array[$key]) || ! is_array($array[$key])) {
+                $array[$key] = [];
+            }
+
+            $array = &$array[$key];
+        }
+
+        $array[array_shift($keys)] = $value;
+
+        return $array;
+    }
+
+    /**
+     * Shuffle the given array and return the result.
+     *
+     * @param  array  $array
+     * @param  int|null  $seed
+     * @return array
+     */
+    public static function shuffle($array, $seed = null)
+    {
+        if (is_null($seed)) {
+            shuffle($array);
+        } else {
+            srand($seed);
+
+            usort($array, function () {
+                return rand(-1, 1);
+            });
+        }
+
+        return $array;
+    }
+
+    /**
+     * Sort the array using the given callback or "dot" notation.
+     *
+     * @param  array  $array
+     * @param  callable|string|null  $callback
+     * @return array
+     */
+    public static function sort($array, $callback = null)
+    {
+        return Collection::make($array)->sortBy($callback)->all();
+    }
+
+    /**
+     * Recursively sort an array by keys and values.
+     *
+     * @param  array  $array
+     * @return array
+     */
+    public static function sortRecursive($array)
+    {
+        foreach ($array as &$value) {
+            if (is_array($value)) {
+                $value = static::sortRecursive($value);
+            }
+        }
+
+        if (static::isAssoc($array)) {
+            ksort($array);
+        } else {
+            sort($array);
+        }
+
+        return $array;
+    }
+
+    /**
+     * Filter the array using the given callback.
+     *
+     * @param  array  $array
+     * @param  callable  $callback
+     * @return array
+     */
+    public static function where($array, callable $callback)
+    {
+        return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
+    }
+
+    /**
+     * If the given value is not an array and not null, wrap it in one.
+     *
+     * @param  mixed  $value
+     * @return array
+     */
+    public static function wrap($value)
+    {
+        if (is_null($value)) {
+            return [];
+        }
+
+        return ! is_array($value) ? [$value] : $value;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Carbon.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Illuminate\Support;
+
+use JsonSerializable;
+use Carbon\Carbon as BaseCarbon;
+use Illuminate\Support\Traits\Macroable;
+
+class Carbon extends BaseCarbon implements JsonSerializable
+{
+    use Macroable;
+
+    /**
+     * The custom Carbon JSON serializer.
+     *
+     * @var callable|null
+     */
+    protected static $serializer;
+
+    /**
+     * Prepare the object for JSON serialization.
+     *
+     * @return array|string
+     */
+    public function jsonSerialize()
+    {
+        if (static::$serializer) {
+            return call_user_func(static::$serializer, $this);
+        }
+
+        $carbon = $this;
+
+        return call_user_func(function () use ($carbon) {
+            return get_object_vars($carbon);
+        });
+    }
+
+    /**
+     * JSON serialize all Carbon instances using the given callback.
+     *
+     * @param  callable  $callback
+     * @return void
+     */
+    public static function serializeUsing($callback)
+    {
+        static::$serializer = $callback;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Composer.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Illuminate\Filesystem\Filesystem;
+use Symfony\Component\Process\Process;
+use Symfony\Component\Process\PhpExecutableFinder;
+
+class Composer
+{
+    /**
+     * The filesystem instance.
+     *
+     * @var \Illuminate\Filesystem\Filesystem
+     */
+    protected $files;
+
+    /**
+     * The working path to regenerate from.
+     *
+     * @var string
+     */
+    protected $workingPath;
+
+    /**
+     * Create a new Composer manager instance.
+     *
+     * @param  \Illuminate\Filesystem\Filesystem  $files
+     * @param  string|null  $workingPath
+     * @return void
+     */
+    public function __construct(Filesystem $files, $workingPath = null)
+    {
+        $this->files = $files;
+        $this->workingPath = $workingPath;
+    }
+
+    /**
+     * Regenerate the Composer autoloader files.
+     *
+     * @param  string  $extra
+     * @return void
+     */
+    public function dumpAutoloads($extra = '')
+    {
+        $process = $this->getProcess();
+
+        $process->setCommandLine(trim($this->findComposer().' dump-autoload '.$extra));
+
+        $process->run();
+    }
+
+    /**
+     * Regenerate the optimized Composer autoloader files.
+     *
+     * @return void
+     */
+    public function dumpOptimized()
+    {
+        $this->dumpAutoloads('--optimize');
+    }
+
+    /**
+     * Get the composer command for the environment.
+     *
+     * @return string
+     */
+    protected function findComposer()
+    {
+        if ($this->files->exists($this->workingPath.'/composer.phar')) {
+            return ProcessUtils::escapeArgument((new PhpExecutableFinder)->find(false)).' composer.phar';
+        }
+
+        return 'composer';
+    }
+
+    /**
+     * Get a new Symfony process instance.
+     *
+     * @return \Symfony\Component\Process\Process
+     */
+    protected function getProcess()
+    {
+        return (new Process('', $this->workingPath))->setTimeout(null);
+    }
+
+    /**
+     * Set the working path used by the class.
+     *
+     * @param  string  $path
+     * @return $this
+     */
+    public function setWorkingPath($path)
+    {
+        $this->workingPath = realpath($path);
+
+        return $this;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Debug/Dumper.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Illuminate\Support\Debug;
+
+use Symfony\Component\VarDumper\Cloner\VarCloner;
+use Symfony\Component\VarDumper\Dumper\CliDumper;
+
+class Dumper
+{
+    /**
+     * Dump a value with elegance.
+     *
+     * @param  mixed  $value
+     * @return void
+     */
+    public function dump($value)
+    {
+        if (class_exists(CliDumper::class)) {
+            $dumper = in_array(PHP_SAPI, ['cli', 'phpdbg']) ? new CliDumper : new HtmlDumper;
+
+            $dumper->dump((new VarCloner)->cloneVar($value));
+        } else {
+            var_dump($value);
+        }
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Debug/HtmlDumper.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Illuminate\Support\Debug;
+
+use Symfony\Component\VarDumper\Dumper\HtmlDumper as SymfonyHtmlDumper;
+
+class HtmlDumper extends SymfonyHtmlDumper
+{
+    /**
+     * Colour definitions for output.
+     *
+     * @var array
+     */
+    protected $styles = [
+        'default' => 'background-color:#fff; color:#222; line-height:1.2em; font-weight:normal; font:12px Monaco, Consolas, monospace; word-wrap: break-word; white-space: pre-wrap; position:relative; z-index:100000',
+        'num' => 'color:#a71d5d',
+        'const' => 'color:#795da3',
+        'str' => 'color:#df5000',
+        'cchr' => 'color:#222',
+        'note' => 'color:#a71d5d',
+        'ref' => 'color:#a0a0a0',
+        'public' => 'color:#795da3',
+        'protected' => 'color:#795da3',
+        'private' => 'color:#795da3',
+        'meta' => 'color:#b729d9',
+        'key' => 'color:#df5000',
+        'index' => 'color:#a71d5d',
+    ];
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/App.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static string version()
+ * @method static string basePath()
+ * @method static string environment()
+ * @method static bool isDownForMaintenance()
+ * @method static void registerConfiguredProviders()
+ * @method static \Illuminate\Support\ServiceProvider register(\Illuminate\Support\ServiceProvider|string $provider, array $options = [], bool $force = false)
+ * @method static void registerDeferredProvider(string $provider, string $service = null)
+ * @method static void boot()
+ * @method static void booting(mixed $callback)
+ * @method static void booted(mixed $callback)
+ * @method static string getCachedServicesPath()
+ *
+ * @see \Illuminate\Foundation\Application
+ */
+class App extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'app';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Artisan.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Console\Kernel as ConsoleKernelContract;
+
+/**
+ * @method static int handle(\Symfony\Component\Console\Input\InputInterface $input, \Symfony\Component\Console\Output\OutputInterface $output = null)
+ * @method static int call(string $command, array $parameters = [], $outputBuffer = null)
+ * @method static int queue(string $command, array $parameters = [])
+ * @method static array all()
+ * @method static string output()
+ *
+ * @see \Illuminate\Contracts\Console\Kernel
+ */
+class Artisan extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return ConsoleKernelContract::class;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Auth.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static mixed guard(string|null $name = null)
+ * @method static void shouldUse(string $name);
+ * @method static bool check()
+ * @method static bool guest()
+ * @method static \Illuminate\Contracts\Auth\Authenticatable|null user()
+ * @method static int|null id()
+ * @method static bool validate(array $credentials = [])
+ * @method static void setUser(\Illuminate\Contracts\Auth\Authenticatable $user)
+ * @method static bool attempt(array $credentials = [], bool $remember = false)
+ * @method static bool once(array $credentials = [])
+ * @method static void login(\Illuminate\Contracts\Auth\Authenticatable $user, bool $remember = false)
+ * @method static \Illuminate\Contracts\Auth\Authenticatable loginUsingId(mixed $id, bool $remember = false)
+ * @method static bool onceUsingId(mixed $id)
+ * @method static bool viaRemember()
+ * @method static void logout()
+ * @method static \Symfony\Component\HttpFoundation\Response|null onceBasic(string $field = 'email',array $extraConditions = [])
+ * @method static null|bool logoutOtherDevices(string $password, string $attribute = 'password')
+ * @method static \Illuminate\Contracts\Auth\UserProvider|null createUserProvider(string $provider = null)
+ * @method static \Illuminate\Auth\AuthManager extend(string $driver, \Closure $callback)
+ * @method static \Illuminate\Auth\AuthManager provider(string $name, \Closure $callback)
+ *
+ * @see \Illuminate\Auth\AuthManager
+ * @see \Illuminate\Contracts\Auth\Factory
+ * @see \Illuminate\Contracts\Auth\Guard
+ * @see \Illuminate\Contracts\Auth\StatefulGuard
+ */
+class Auth extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'auth';
+    }
+
+    /**
+     * Register the typical authentication routes for an application.
+     *
+     * @return void
+     */
+    public static function routes()
+    {
+        static::$app->make('router')->auth();
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Blade.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static void compile($path = null)
+ * @method static string getPath()
+ * @method static void setPath($path)
+ * @method static string compileString($value)
+ * @method static string stripParentheses($expression)
+ * @method static void extend(callable $compiler)
+ * @method static array getExtensions()
+ * @method static void if($name, callable $callback)
+ * @method static bool check($name, ...$parameters)
+ * @method static void component($path, $alias = null)
+ * @method static void include($path, $alias = null)
+ * @method static void directive($name, callable $handler)
+ * @method static array getCustomDirectives()
+ * @method static void setEchoFormat($format)
+ * @method static void withDoubleEncoding()
+ * @method static void withoutDoubleEncoding()
+ *
+ * @see \Illuminate\View\Compilers\BladeCompiler
+ */
+class Blade extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return static::$app['view']->getEngineResolver()->resolve('blade')->getCompiler();
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Broadcast.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Broadcasting\Factory as BroadcastingFactoryContract;
+
+/**
+ * @method static void connection($name = null);
+ * @method static \Illuminate\Broadcasting\Broadcasters\Broadcaster channel(string $channel, callable|string  $callback)
+ * @method static mixed auth(\Illuminate\Http\Request $request)
+ *
+ * @see \Illuminate\Contracts\Broadcasting\Factory
+ */
+class Broadcast extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return BroadcastingFactoryContract::class;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Bus.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Support\Testing\Fakes\BusFake;
+use Illuminate\Contracts\Bus\Dispatcher as BusDispatcherContract;
+
+/**
+ * @method static mixed dispatch($command)
+ * @method static mixed dispatchNow($command, $handler = null)
+ * @method static bool hasCommandHandler($command)
+ * @method static bool|mixed getCommandHandler($command)
+ * @method static \Illuminate\Contracts\Bus\Dispatcher pipeThrough(array $pipes)
+ * @method static \Illuminate\Contracts\Bus\Dispatcher map(array $map)
+ *
+ * @see \Illuminate\Contracts\Bus\Dispatcher
+ */
+class Bus extends Facade
+{
+    /**
+     * Replace the bound instance with a fake.
+     *
+     * @return void
+     */
+    public static function fake()
+    {
+        static::swap(new BusFake);
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return BusDispatcherContract::class;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Cache.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Contracts\Cache\Repository  store(string|null $name = null)
+ * @method static bool has(string $key)
+ * @method static mixed get(string $key, mixed $default = null)
+ * @method static mixed pull(string $key, mixed $default = null)
+ * @method static void put(string $key, $value, \DateTimeInterface|\DateInterval|float|int $minutes)
+ * @method static bool add(string $key, $value, \DateTimeInterface|\DateInterval|float|int $minutes)
+ * @method static int|bool increment(string $key, $value = 1)
+ * @method static int|bool decrement(string $key, $value = 1)
+ * @method static void forever(string $key, $value)
+ * @method static mixed remember(string $key, \DateTimeInterface|\DateInterval|float|int $minutes, \Closure $callback)
+ * @method static mixed sear(string $key, \Closure $callback)
+ * @method static mixed rememberForever(string $key, \Closure $callback)
+ * @method static bool forget(string $key)
+ * @method static \Illuminate\Contracts\Cache\Store getStore()
+ *
+ * @see \Illuminate\Cache\CacheManager
+ * @see \Illuminate\Cache\Repository
+ */
+class Cache extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'cache';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Config.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static bool has($key)
+ * @method static mixed get($key, $default = null)
+ * @method static array all()
+ * @method static void set($key, $value = null)
+ * @method static void prepend($key, $value)
+ * @method static void push($key, $value)
+ *
+ * @see \Illuminate\Config\Repository
+ */
+class Config extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'config';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Cookie.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static void queue(...$parameters)
+ * @method static unqueue($name)
+ * @method static array getQueuedCookies()
+ *
+ * @see \Illuminate\Cookie\CookieJar
+ */
+class Cookie extends Facade
+{
+    /**
+     * Determine if a cookie exists on the request.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public static function has($key)
+    {
+        return ! is_null(static::$app['request']->cookie($key, null));
+    }
+
+    /**
+     * Retrieve a cookie from the request.
+     *
+     * @param  string  $key
+     * @param  mixed   $default
+     * @return string
+     */
+    public static function get($key = null, $default = null)
+    {
+        return static::$app['request']->cookie($key, $default);
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'cookie';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Crypt.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static string encrypt(string $value, bool $serialize = true)
+ * @method static string decrypt(string $payload, bool $unserialize = true)
+ *
+ * @see \Illuminate\Encryption\Encrypter
+ */
+class Crypt extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'encrypter';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/DB.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Database\ConnectionInterface connection(string $name = null)
+ * @method static string getDefaultConnection()
+ * @method static void setDefaultConnection(string $name)
+ * @method static \Illuminate\Database\Query\Builder table(string $table)
+ * @method static \Illuminate\Database\Query\Expression raw($value)
+ * @method static mixed selectOne(string $query, array $bindings = [])
+ * @method static array select(string $query, array $bindings = [])
+ * @method static bool insert(string $query, array $bindings = [])
+ * @method static int update(string $query, array $bindings = [])
+ * @method static int delete(string $query, array $bindings = [])
+ * @method static bool statement(string $query, array $bindings = [])
+ * @method static int affectingStatement(string $query, array $bindings = [])
+ * @method static bool unprepared(string $query)
+ * @method static array prepareBindings(array $bindings)
+ * @method static mixed transaction(\Closure $callback, int $attempts = 1)
+ * @method static void beginTransaction()
+ * @method static void commit()
+ * @method static void rollBack()
+ * @method static int transactionLevel()
+ * @method static array pretend(\Closure $callback)
+ *
+ * @see \Illuminate\Database\DatabaseManager
+ * @see \Illuminate\Database\Connection
+ */
+class DB extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'db';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Event.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Testing\Fakes\EventFake;
+
+/**
+ * @method static void listen(string | array $events, $listener)
+ * @method static bool hasListeners(string $eventName)
+ * @method static void subscribe(object | string $subscriber)
+ * @method static array|null until(string | object $event, $payload = [])
+ * @method static array|null dispatch(string | object $event, $payload = [], bool $halt = false)
+ * @method static void push(string $event, array $payload = [])
+ * @method static void flush(string $event)
+ * @method static void forget(string $event)
+ * @method static void forgetPushed()
+ *
+ * @see \Illuminate\Events\Dispatcher
+ */
+class Event extends Facade
+{
+    /**
+     * Replace the bound instance with a fake.
+     *
+     * @param  array|string  $eventsToFake
+     * @return void
+     */
+    public static function fake($eventsToFake = [])
+    {
+        static::swap($fake = new EventFake(static::getFacadeRoot(), $eventsToFake));
+
+        Model::setEventDispatcher($fake);
+    }
+
+    /**
+     * Replace the bound instance with a fake during the given callable's execution.
+     *
+     * @param  callable  $callable
+     * @param  array|string  $eventsToFake
+     * @return callable
+     */
+    public static function fakeFor(callable $callable, array $eventsToFake = [])
+    {
+        $originalDispatcher = static::getFacadeRoot();
+
+        static::fake($eventsToFake);
+
+        return tap($callable(), function () use ($originalDispatcher) {
+            static::swap($originalDispatcher);
+
+            Model::setEventDispatcher($originalDispatcher);
+        });
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'events';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Facade.php

@@ -0,0 +1,223 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Mockery;
+use RuntimeException;
+use Mockery\MockInterface;
+
+abstract class Facade
+{
+    /**
+     * The application instance being facaded.
+     *
+     * @var \Illuminate\Contracts\Foundation\Application
+     */
+    protected static $app;
+
+    /**
+     * The resolved object instances.
+     *
+     * @var array
+     */
+    protected static $resolvedInstance;
+
+    /**
+     * Convert the facade into a Mockery spy.
+     *
+     * @return void
+     */
+    public static function spy()
+    {
+        if (! static::isMock()) {
+            $class = static::getMockableClass();
+
+            static::swap($class ? Mockery::spy($class) : Mockery::spy());
+        }
+    }
+
+    /**
+     * Initiate a mock expectation on the facade.
+     *
+     * @return \Mockery\Expectation
+     */
+    public static function shouldReceive()
+    {
+        $name = static::getFacadeAccessor();
+
+        $mock = static::isMock()
+                    ? static::$resolvedInstance[$name]
+                    : static::createFreshMockInstance();
+
+        return $mock->shouldReceive(...func_get_args());
+    }
+
+    /**
+     * Create a fresh mock instance for the given class.
+     *
+     * @return \Mockery\Expectation
+     */
+    protected static function createFreshMockInstance()
+    {
+        return tap(static::createMock(), function ($mock) {
+            static::swap($mock);
+
+            $mock->shouldAllowMockingProtectedMethods();
+        });
+    }
+
+    /**
+     * Create a fresh mock instance for the given class.
+     *
+     * @return \Mockery\MockInterface
+     */
+    protected static function createMock()
+    {
+        $class = static::getMockableClass();
+
+        return $class ? Mockery::mock($class) : Mockery::mock();
+    }
+
+    /**
+     * Determines whether a mock is set as the instance of the facade.
+     *
+     * @return bool
+     */
+    protected static function isMock()
+    {
+        $name = static::getFacadeAccessor();
+
+        return isset(static::$resolvedInstance[$name]) &&
+               static::$resolvedInstance[$name] instanceof MockInterface;
+    }
+
+    /**
+     * Get the mockable class for the bound instance.
+     *
+     * @return string|null
+     */
+    protected static function getMockableClass()
+    {
+        if ($root = static::getFacadeRoot()) {
+            return get_class($root);
+        }
+    }
+
+    /**
+     * Hotswap the underlying instance behind the facade.
+     *
+     * @param  mixed  $instance
+     * @return void
+     */
+    public static function swap($instance)
+    {
+        static::$resolvedInstance[static::getFacadeAccessor()] = $instance;
+
+        if (isset(static::$app)) {
+            static::$app->instance(static::getFacadeAccessor(), $instance);
+        }
+    }
+
+    /**
+     * Get the root object behind the facade.
+     *
+     * @return mixed
+     */
+    public static function getFacadeRoot()
+    {
+        return static::resolveFacadeInstance(static::getFacadeAccessor());
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     *
+     * @throws \RuntimeException
+     */
+    protected static function getFacadeAccessor()
+    {
+        throw new RuntimeException('Facade does not implement getFacadeAccessor method.');
+    }
+
+    /**
+     * Resolve the facade root instance from the container.
+     *
+     * @param  string|object  $name
+     * @return mixed
+     */
+    protected static function resolveFacadeInstance($name)
+    {
+        if (is_object($name)) {
+            return $name;
+        }
+
+        if (isset(static::$resolvedInstance[$name])) {
+            return static::$resolvedInstance[$name];
+        }
+
+        return static::$resolvedInstance[$name] = static::$app[$name];
+    }
+
+    /**
+     * Clear a resolved facade instance.
+     *
+     * @param  string  $name
+     * @return void
+     */
+    public static function clearResolvedInstance($name)
+    {
+        unset(static::$resolvedInstance[$name]);
+    }
+
+    /**
+     * Clear all of the resolved instances.
+     *
+     * @return void
+     */
+    public static function clearResolvedInstances()
+    {
+        static::$resolvedInstance = [];
+    }
+
+    /**
+     * Get the application instance behind the facade.
+     *
+     * @return \Illuminate\Contracts\Foundation\Application
+     */
+    public static function getFacadeApplication()
+    {
+        return static::$app;
+    }
+
+    /**
+     * Set the application instance.
+     *
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
+     * @return void
+     */
+    public static function setFacadeApplication($app)
+    {
+        static::$app = $app;
+    }
+
+    /**
+     * Handle dynamic, static calls to the object.
+     *
+     * @param  string  $method
+     * @param  array   $args
+     * @return mixed
+     *
+     * @throws \RuntimeException
+     */
+    public static function __callStatic($method, $args)
+    {
+        $instance = static::getFacadeRoot();
+
+        if (! $instance) {
+            throw new RuntimeException('A facade root has not been set.');
+        }
+
+        return $instance->$method(...$args);
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/File.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static bool exists(string $path)
+ * @method static string get(string $path, bool $lock = false)
+ * @method static string sharedGet(string $path)
+ * @method static mixed getRequire(string $path)
+ * @method static mixed requireOnce(string $file)
+ * @method static string hash(string $path)
+ * @method static int put(string $path, string $contents, bool $lock = false)
+ * @method static int prepend(string $path, string $data)
+ * @method static int append(string $path, string $data)
+ * @method static mixed chmod(string $path, int $mode = null)
+ * @method static bool delete(string|array $paths)
+ * @method static bool move(string $path, string $target)
+ * @method static bool copy(string $path, string $target)
+ * @method static void link(string $target, string $link)
+ * @method static string name(string $path)
+ * @method static string basename(string $path)
+ * @method static string dirname(string $path)
+ * @method static string extension(string $path)
+ * @method static string type(string $path)
+ * @method static string|false mimeType(string $path)
+ * @method static int size(string $path)
+ * @method static int lastModified(string $path)
+ * @method static bool isDirectory(string $directory)
+ * @method static bool isReadable(string $path)
+ * @method static bool isWritable(string $path)
+ * @method static bool isFile(string $file)
+ * @method static array glob(string $pattern, int $flags = 0)
+ * @method static \Symfony\Component\Finder\SplFileInfo[] files(string $directory, bool $hidden = false)
+ * @method static \Symfony\Component\Finder\SplFileInfo[] allFiles(string $directory, bool $hidden = false)
+ * @method static array directories(string $directory)
+ * @method static bool makeDirectory(string $path, int $mode = 0755,  bool $recursive = false, bool $force = false)
+ * @method static bool moveDirectory(string $from, string $to, bool $overwrite = false)
+ * @method static bool copyDirectory(string $directory, string $destination, int $options = null)
+ * @method static bool deleteDirectory(string $directory, bool $preserve = false)
+ * @method static bool cleanDirectory(string $directory)
+ *
+ * @see \Illuminate\Filesystem\Filesystem
+ */
+class File extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'files';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Gate.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Auth\Access\Gate as GateContract;
+
+/**
+ * @method static bool has(string $ability)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate define(string $ability, callable | string $callback)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate policy(string $class, string $policy)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate before(callable $callback)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate after(callable $callback)
+ * @method static bool allows(string $ability, array | mixed $arguments = [])
+ * @method static bool denies(string $ability, array | mixed $arguments = [])
+ * @method static bool check(iterable | string $abilities, array | mixed $arguments = [])
+ * @method static bool any(iterable | string $abilities, array | mixed $arguments = [])
+ * @method static \Illuminate\Auth\Access\Response authorize(string $ability, array | mixed $arguments = [])
+ * @method static mixed getPolicyFor(object | string $class)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate forUser(\Illuminate\Contracts\Auth\Authenticatable | mixed $user)
+ * @method static array abilities()
+ *
+ * @see \Illuminate\Contracts\Auth\Access\Gate
+ */
+class Gate extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return GateContract::class;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Hash.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static array info(string $hashedValue)
+ * @method static string make(string $value, array $options = [])
+ * @method static bool check(string $value, string $hashedValue, array $options = [])
+ * @method static bool needsRehash(string $hashedValue, array $options = [])
+ *
+ * @see \Illuminate\Hashing\BcryptHasher
+ */
+class Hash extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'hash';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Input.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Http\Request instance()
+ * @method static string method()
+ * @method static string root()
+ * @method static string url()
+ * @method static string fullUrl()
+ * @method static string fullUrlWithQuery(array $query)
+ * @method static string path()
+ * @method static string decodedPath()
+ * @method static string|null segment(int $index, string|null $default = null)
+ * @method static array segments()
+ * @method static bool is(...$patterns)
+ * @method static bool routeIs(...$patterns)
+ * @method static bool fullUrlIs(...$patterns)
+ * @method static bool ajax()
+ * @method static bool pjax()
+ * @method static bool secure()
+ * @method static string ip()
+ * @method static array ips()
+ * @method static string userAgent()
+ * @method static \Illuminate\Http\Request merge(array $input)
+ * @method static \Illuminate\Http\Request replace(array $input)
+ * @method static \Symfony\Component\HttpFoundation\ParameterBag|mixed json(string $key = null, $default = null)
+ * @method static \Illuminate\Session\Store session()
+ * @method static \Illuminate\Session\Store|null getSession()
+ * @method static void setLaravelSession(\Illuminate\Contracts\Session\Session $session)
+ * @method static mixed user(string|null $guard = null)
+ * @method static \Illuminate\Routing\Route|object|string route(string|null $param = null)
+ * @method static string fingerprint()
+ * @method static \Illuminate\Http\Request setJson(\Symfony\Component\HttpFoundation\ParameterBag $json)
+ * @method static \Closure getUserResolver()
+ * @method static \Illuminate\Http\Request setUserResolver(\Closure $callback)
+ * @method static \Closure getRouteResolver()
+ * @method static \Illuminate\Http\Request setRouteResolver(\Closure $callback)
+ * @method static array toArray()
+ * @method static bool offsetExists(string $offset)
+ * @method static mixed offsetGet(string $offset)
+ * @method static void offsetSet(string $offset, $value)
+ * @method static void offsetUnset(string $offset)
+ *
+ * @see \Illuminate\Http\Request
+ */
+class Input extends Facade
+{
+    /**
+     * Get an item from the input data.
+     *
+     * This method is used for all request verbs (GET, POST, PUT, and DELETE)
+     *
+     * @param  string  $key
+     * @param  mixed   $default
+     * @return mixed
+     */
+    public static function get($key = null, $default = null)
+    {
+        return static::$app['request']->input($key, $default);
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'request';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Lang.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static mixed trans(string $key, array $replace = [], string $locale = null)
+ * @method static string transChoice(string $key, int | array | \Countable $number, array $replace = [], string $locale = null)
+ * @method static string getLocale()
+ * @method static void setLocale(string $locale)
+ * @method static string|array|null get(string $key, array $replace = [], string $locale = null, bool $fallback = true)
+ *
+ * @see \Illuminate\Translation\Translator
+ */
+class Lang extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'translator';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Log.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Psr\Log\LoggerInterface;
+
+/**
+ * @method static void emergency(string $message, array $context = [])
+ * @method static void alert(string $message, array $context = [])
+ * @method static void critical(string $message, array $context = [])
+ * @method static void error(string $message, array $context = [])
+ * @method static void warning(string $message, array $context = [])
+ * @method static void notice(string $message, array $context = [])
+ * @method static void info(string $message, array $context = [])
+ * @method static void debug(string $message, array $context = [])
+ * @method static void log($level, string $message, array $context = [])
+ * @method static mixed channel(string $channel = null)
+ * @method static \Psr\Log\LoggerInterface stack(array $channels, string $channel = null)
+ *
+ * @see \Illuminate\Log\Logger
+ */
+class Log extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return LoggerInterface::class;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Mail.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Support\Testing\Fakes\MailFake;
+
+/**
+ * @method static \Illuminate\Mail\PendingMail to($users)
+ * @method static \Illuminate\Mail\PendingMail bcc($users)
+ * @method static void raw(string $text, $callback)
+ * @method static void send(string|array|\Illuminate\Contracts\Mail\Mailable $view, array $data = [], \Closure|string $callback = null)
+ * @method static array failures()
+ * @method static mixed queue(string|array|\Illuminate\Contracts\Mail\Mailable $view, string $queue = null)
+ * @method static mixed later(\DateTimeInterface|\DateInterval|int $delay, string|array|\Illuminate\Contracts\Mail\Mailable $view, string $queue = null)
+ *
+ * @see \Illuminate\Mail\Mailer
+ */
+class Mail extends Facade
+{
+    /**
+     * Replace the bound instance with a fake.
+     *
+     * @return void
+     */
+    public static function fake()
+    {
+        static::swap(new MailFake);
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'mailer';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Notification.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Notifications\ChannelManager;
+use Illuminate\Notifications\AnonymousNotifiable;
+use Illuminate\Support\Testing\Fakes\NotificationFake;
+
+/**
+ * @method static void send(\Illuminate\Support\Collection|array|mixed $notifiables, $notification)
+ * @method static void sendNow(\Illuminate\Support\Collection|array|mixed $notifiables, $notification)
+ * @method static mixed channel(string|null $name = null)
+ *
+ * @see \Illuminate\Notifications\ChannelManager
+ */
+class Notification extends Facade
+{
+    /**
+     * Replace the bound instance with a fake.
+     *
+     * @return \Illuminate\Support\Testing\Fakes\NotificationFake
+     */
+    public static function fake()
+    {
+        static::swap($fake = new NotificationFake);
+
+        return $fake;
+    }
+
+    /**
+     * Begin sending a notification to an anonymous notifiable.
+     *
+     * @param  string  $channel
+     * @param  mixed  $route
+     * @return \Illuminate\Notifications\AnonymousNotifiable
+     */
+    public static function route($channel, $route)
+    {
+        return (new AnonymousNotifiable)->route($channel, $route);
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return ChannelManager::class;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Password.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static string sendResetLink(array $credentials)
+ * @method static mixed reset(array $credentials, \Closure $callback)
+ * @method static void validator(\Closure $callback)
+ * @method static bool validateNewPassword(array $credentials)
+ *
+ * @see \Illuminate\Auth\Passwords\PasswordBroker
+ */
+class Password extends Facade
+{
+    /**
+     * Constant representing a successfully sent reminder.
+     *
+     * @var string
+     */
+    const RESET_LINK_SENT = 'passwords.sent';
+
+    /**
+     * Constant representing a successfully reset password.
+     *
+     * @var string
+     */
+    const PASSWORD_RESET = 'passwords.reset';
+
+    /**
+     * Constant representing the user not found response.
+     *
+     * @var string
+     */
+    const INVALID_USER = 'passwords.user';
+
+    /**
+     * Constant representing an invalid password.
+     *
+     * @var string
+     */
+    const INVALID_PASSWORD = 'passwords.password';
+
+    /**
+     * Constant representing an invalid token.
+     *
+     * @var string
+     */
+    const INVALID_TOKEN = 'passwords.token';
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'auth.password';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Queue.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Support\Testing\Fakes\QueueFake;
+
+/**
+ * @method static int size(string $queue = null)
+ * @method static mixed push(string|object $job, string $data = '', $queue = null)
+ * @method static mixed pushOn(string $queue, string|object $job, $data = '')
+ * @method static mixed pushRaw(string $payload, string $queue = null, array $options = [])
+ * @method static mixed later(\DateTimeInterface|\DateInterval|int $delay, string|object $job, $data = '', string $queue = null)
+ * @method static mixed laterOn(string $queue, \DateTimeInterface|\DateInterval|int $delay, string|object $job, $data = '')
+ * @method static mixed bulk(array $jobs, $data = '', string $queue = null)
+ * @method static \Illuminate\Contracts\Queue\Job|null pop(string $queue = null)
+ * @method static string getConnectionName()
+ * @method static \Illuminate\Contracts\Queue\Queue setConnectionName(string $name)
+ *
+ * @see \Illuminate\Queue\QueueManager
+ * @see \Illuminate\Queue\Queue
+ */
+class Queue extends Facade
+{
+    /**
+     * Replace the bound instance with a fake.
+     *
+     * @return void
+     */
+    public static function fake()
+    {
+        static::swap(new QueueFake(static::getFacadeApplication()));
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'queue';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Redirect.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Http\RedirectResponse home(int $status = 302)
+ * @method static \Illuminate\Http\RedirectResponse back(int $status = 302, array $headers = [], $fallback = false)
+ * @method static \Illuminate\Http\RedirectResponse refresh(int $status = 302, array $headers = [])
+ * @method static \Illuminate\Http\RedirectResponse guest(string $path, int $status = 302, array $headers = [], bool $secure = null)
+ * @method static intended(string $default = '/', int $status = 302, array $headers = [], bool $secure = null)
+ * @method static \Illuminate\Http\RedirectResponse to(string $path, int $status = 302, array $headers = [], bool $secure = null)
+ * @method static \Illuminate\Http\RedirectResponse away(string $path, int $status = 302, array $headers = [])
+ * @method static \Illuminate\Http\RedirectResponse secure(string $path, int $status = 302, array $headers = [])
+ * @method static \Illuminate\Http\RedirectResponse route(string $route, array $parameters = [], int $status = 302, array $headers = [])
+ * @method static \Illuminate\Http\RedirectResponse action(string $action, array $parameters = [], int $status = 302, array $headers = [])
+ * @method static \Illuminate\Routing\UrlGenerator getUrlGenerator()
+ * @method static void setSession(\Illuminate\Session\Store $session)
+ *
+ * @see \Illuminate\Routing\Redirector
+ */
+class Redirect extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'redirect';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Redis.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Redis\Connections\Connection connection(string $name = null)
+ *
+ * @see \Illuminate\Redis\RedisManager
+ * @see \Illuminate\Contracts\Redis\Factory
+ */
+class Redis extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'redis';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Request.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Http\Request instance()
+ * @method static string method()
+ * @method static string root()
+ * @method static string url()
+ * @method static string fullUrl()
+ * @method static string fullUrlWithQuery(array $query)
+ * @method static string path()
+ * @method static string decodedPath()
+ * @method static string|null segment(int $index, string|null $default = null)
+ * @method static array segments()
+ * @method static bool is(...$patterns)
+ * @method static bool routeIs(...$patterns)
+ * @method static bool fullUrlIs(...$patterns)
+ * @method static bool ajax()
+ * @method static bool pjax()
+ * @method static bool secure()
+ * @method static string ip()
+ * @method static array ips()
+ * @method static string userAgent()
+ * @method static \Illuminate\Http\Request merge(array $input)
+ * @method static \Illuminate\Http\Request replace(array $input)
+ * @method static \Symfony\Component\HttpFoundation\ParameterBag|mixed json(string $key = null, $default = null)
+ * @method static \Illuminate\Session\Store session()
+ * @method static \Illuminate\Session\Store|null getSession()
+ * @method static void setLaravelSession(\Illuminate\Contracts\Session\Session $session)
+ * @method static mixed user(string|null $guard = null)
+ * @method static \Illuminate\Routing\Route|object|string route(string|null $param = null)
+ * @method static string fingerprint()
+ * @method static \Illuminate\Http\Request setJson(\Symfony\Component\HttpFoundation\ParameterBag $json)
+ * @method static \Closure getUserResolver()
+ * @method static \Illuminate\Http\Request setUserResolver(\Closure $callback)
+ * @method static \Closure getRouteResolver()
+ * @method static \Illuminate\Http\Request setRouteResolver(\Closure $callback)
+ * @method static array toArray()
+ * @method static bool offsetExists(string $offset)
+ * @method static mixed offsetGet(string $offset)
+ * @method static void offsetSet(string $offset, $value)
+ * @method static void offsetUnset(string $offset)
+ *
+ * @see \Illuminate\Http\Request
+ */
+class Request extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'request';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Response.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Routing\ResponseFactory as ResponseFactoryContract;
+
+/**
+ * @method static \Illuminate\Http\Response make(string $content = '', int $status = 200, array $headers = [])
+ * @method static \Illuminate\Http\Response view(string $view, array $data = [], int $status = 200, array $headers = [])
+ * @method static \Illuminate\Http\JsonResponse json(string | array $data = [], int $status = 200, array $headers = [], int $options = 0)
+ * @method static \Illuminate\Http\JsonResponse jsonp(string $callback, string | array $data = [], int $status = 200, array $headers = [], int $options = 0)
+ * @method static \Symfony\Component\HttpFoundation\StreamedResponse stream(\Closure $callback, int $status = 200, array $headers = [])
+ * @method static \Symfony\Component\HttpFoundation\StreamedResponse streamDownload(\Closure $callback, string | null $name = null, array $headers = [], string | null $disposition = 'attachment')
+ * @method static \Symfony\Component\HttpFoundation\BinaryFileResponse download(\SplFileInfo | string $file, string | null $name = null, array $headers = [], string | null $disposition = 'attachment')
+ * @method static \Illuminate\Http\RedirectResponse redirectTo(string $path, int $status = 302, array $headers = [], bool | null $secure = null)
+ * @method static \Illuminate\Http\RedirectResponse redirectToRoute(string $route, array $parameters = [], int $status = 302, array $headers = [])
+ * @method static \Illuminate\Http\RedirectResponse redirectToAction(string $action, array $parameters = [], int $status = 302, array $headers = [])
+ * @method static \Illuminate\Http\RedirectResponse redirectGuest(string $path, int $status = 302, array $headers = [], bool | null $secure = null)
+ * @method static \Illuminate\Http\RedirectResponse redirectToIntended(string $default = '/', int $status = 302, array $headers = [], bool | null $secure = null)
+ *
+ * @see \Illuminate\Contracts\Routing\ResponseFactory
+ */
+class Response extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return ResponseFactoryContract::class;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Route.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Routing\Route get(string $uri, \Closure|array|string|null $action = null)
+ * @method static \Illuminate\Routing\Route post(string $uri, \Closure|array|string|null $action = null)
+ * @method static \Illuminate\Routing\Route put(string $uri, \Closure|array|string|null $action = null)
+ * @method static \Illuminate\Routing\Route delete(string $uri, \Closure|array|string|null $action = null)
+ * @method static \Illuminate\Routing\Route patch(string $uri, \Closure|array|string|null $action = null)
+ * @method static \Illuminate\Routing\Route options(string $uri, \Closure|array|string|null $action = null)
+ * @method static \Illuminate\Routing\Route any(string $uri, \Closure|array|string|null $action = null)
+ * @method static \Illuminate\Routing\Route match(array|string $methods, string $uri, \Closure|array|string|null $action = null)
+ * @method static \Illuminate\Routing\RouteRegistrar prefix(string  $prefix)
+ * @method static \Illuminate\Routing\PendingResourceRegistration resource(string $name, string $controller, array $options = [])
+ * @method static \Illuminate\Routing\PendingResourceRegistration apiResource(string $name, string $controller, array $options = [])
+ * @method static void apiResources(array $resources)
+ * @method static \Illuminate\Routing\RouteRegistrar middleware(array|string|null $middleware)
+ * @method static \Illuminate\Routing\Route substituteBindings(\Illuminate\Support\Facades\Route $route)
+ * @method static void substituteImplicitBindings(\Illuminate\Support\Facades\Route $route)
+ * @method static \Illuminate\Routing\RouteRegistrar as(string $value)
+ * @method static \Illuminate\Routing\RouteRegistrar domain(string $value)
+ * @method static \Illuminate\Routing\RouteRegistrar name(string $value)
+ * @method static \Illuminate\Routing\RouteRegistrar namespace(string $value)
+ * @method static \Illuminate\Routing\Router|\Illuminate\Routing\RouteRegistrar group(array|\Closure|string $attributes, \Closure|string $routes)
+ * @method static \Illuminate\Routing\Route redirect(string $uri, string $destination, int $status = 301)
+ * @method static \Illuminate\Routing\Route view(string $uri, string $view, array $data = [])
+ * @method static void bind(string $key, string|callable $binder)
+ * @method static \Illuminate\Routing\Route current()
+ * @method static string|null currentRouteName()
+ * @method static string|null currentRouteAction()
+ *
+ * @see \Illuminate\Routing\Router
+ */
+class Route extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'router';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Schema.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Database\Schema\Builder create(string $table, \Closure $callback)
+ * @method static \Illuminate\Database\Schema\Builder drop(string $table)
+ * @method static \Illuminate\Database\Schema\Builder dropIfExists(string $table)
+ * @method static \Illuminate\Database\Schema\Builder table(string $table, \Closure $callback)
+ * @method static void defaultStringLength(int $length)
+ *
+ * @see \Illuminate\Database\Schema\Builder
+ */
+class Schema extends Facade
+{
+    /**
+     * Get a schema builder instance for a connection.
+     *
+     * @param  string  $name
+     * @return \Illuminate\Database\Schema\Builder
+     */
+    public static function connection($name)
+    {
+        return static::$app['db']->connection($name)->getSchemaBuilder();
+    }
+
+    /**
+     * Get a schema builder instance for the default connection.
+     *
+     * @return \Illuminate\Database\Schema\Builder
+     */
+    protected static function getFacadeAccessor()
+    {
+        return static::$app['db']->connection()->getSchemaBuilder();
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Session.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static string getName()
+ * @method static string getId()
+ * @method static void setId(string $id)
+ * @method static bool start()
+ * @method static bool save()
+ * @method static array all()
+ * @method static bool exists(string|array $key)
+ * @method static bool has(string|array $key)
+ * @method static mixed get(string $key, $default = null)
+ * @method static void put(string|array $key, $value = null)
+ * @method static string token()
+ * @method static mixed remove(string $key)
+ * @method static void forget(string|array $keys)
+ * @method static void flush()
+ * @method static bool migrate(bool $destroy = false)
+ * @method static bool isStarted()
+ * @method static string|null previousUrl()
+ * @method static void setPreviousUrl(string $url)
+ * @method static \SessionHandlerInterface getHandler()
+ * @method static bool handlerNeedsRequest()
+ * @method static void setRequestOnHandler(\Illuminate\Http\Request $request)
+ *
+ * @see \Illuminate\Session\SessionManager
+ * @see \Illuminate\Session\Store
+ */
+class Session extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'session';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Storage.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Filesystem\Filesystem;
+
+/**
+ * @method static \Illuminate\Contracts\Filesystem\Filesystem disk(string $name = null)
+ *
+ * @see \Illuminate\Filesystem\FilesystemManager
+ */
+class Storage extends Facade
+{
+    /**
+     * Replace the given disk with a local testing disk.
+     *
+     * @param  string|null  $disk
+     *
+     * @return void
+     */
+    public static function fake($disk = null)
+    {
+        $disk = $disk ?: self::$app['config']->get('filesystems.default');
+
+        (new Filesystem)->cleanDirectory(
+            $root = storage_path('framework/testing/disks/'.$disk)
+        );
+
+        static::set($disk, self::createLocalDriver(['root' => $root]));
+    }
+
+    /**
+     * Replace the given disk with a persistent local testing disk.
+     *
+     * @param  string|null  $disk
+     * @return void
+     */
+    public static function persistentFake($disk = null)
+    {
+        $disk = $disk ?: self::$app['config']->get('filesystems.default');
+
+        static::set($disk, self::createLocalDriver([
+            'root' => storage_path('framework/testing/disks/'.$disk),
+        ]));
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'filesystem';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/URL.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static string current()
+ * @method static string full()
+ * @method static string previous($fallback = false)
+ * @method static string to(string $path, $extra = [], bool $secure = null)
+ * @method static string secure(string $path, array $parameters = [])
+ * @method static string asset(string $path, bool $secure = null)
+ * @method static string route(string $name, $parameters = [], bool $absolute = true)
+ * @method static string action(string $action, $parameters = [], bool $absolute = true)
+ * @method static \Illuminate\Contracts\Routing\UrlGenerator setRootControllerNamespace(string $rootNamespace)
+ * @method static string signedRoute(string $name, array $parameters = [], \DateTimeInterface|int $expiration = null)
+ * @method static string temporarySignedRoute(string $name, \DateTimeInterface|int $expiration, array $parameters = [])
+ * @method static string hasValidSignature(\Illuminate\Http\Request $request)
+ * @method static void defaults(array $defaults)
+ *
+ * @see \Illuminate\Routing\UrlGenerator
+ */
+class URL extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'url';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/Validator.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Contracts\Validation\Validator make(array $data, array $rules, array $messages = [], array $customAttributes = [])
+ * @method static void extend(string $rule, \Closure | string $extension, string $message = null)
+ * @method static void extendImplicit(string $rule, \Closure | string $extension, string $message = null)
+ * @method static void replacer(string $rule, \Closure | string $replacer)
+ *
+ * @see \Illuminate\Validation\Factory
+ */
+class Validator extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'validator';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Facades/View.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static bool exists(string $view)
+ * @method static \Illuminate\Contracts\View\View file(string $path, array $data = [], array $mergeData = [])
+ * @method static \Illuminate\Contracts\View\View make(string $view, array $data = [], array $mergeData = [])
+ * @method static mixed share(array | string $key, $value = null)
+ * @method static array composer(array | string $views, \Closure | string $callback)
+ * @method static array creator(array | string $views, \Closure | string $callback)
+ * @method static \Illuminate\Contracts\View\Factory addNamespace(string $namespace, string | array $hints)
+ * @method static \Illuminate\Contracts\View\Factory replaceNamespace(string $namespace, string | array $hints)
+ *
+ * @see \Illuminate\View\Factory
+ */
+class View extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'view';
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Fluent.php

@@ -0,0 +1,192 @@
+<?php
+
+namespace Illuminate\Support;
+
+use ArrayAccess;
+use JsonSerializable;
+use Illuminate\Contracts\Support\Jsonable;
+use Illuminate\Contracts\Support\Arrayable;
+
+class Fluent implements ArrayAccess, Arrayable, Jsonable, JsonSerializable
+{
+    /**
+     * All of the attributes set on the container.
+     *
+     * @var array
+     */
+    protected $attributes = [];
+
+    /**
+     * Create a new fluent container instance.
+     *
+     * @param  array|object    $attributes
+     * @return void
+     */
+    public function __construct($attributes = [])
+    {
+        foreach ($attributes as $key => $value) {
+            $this->attributes[$key] = $value;
+        }
+    }
+
+    /**
+     * Get an attribute from the container.
+     *
+     * @param  string  $key
+     * @param  mixed   $default
+     * @return mixed
+     */
+    public function get($key, $default = null)
+    {
+        if (array_key_exists($key, $this->attributes)) {
+            return $this->attributes[$key];
+        }
+
+        return value($default);
+    }
+
+    /**
+     * Get the attributes from the container.
+     *
+     * @return array
+     */
+    public function getAttributes()
+    {
+        return $this->attributes;
+    }
+
+    /**
+     * Convert the Fluent instance to an array.
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->attributes;
+    }
+
+    /**
+     * Convert the object into something JSON serializable.
+     *
+     * @return array
+     */
+    public function jsonSerialize()
+    {
+        return $this->toArray();
+    }
+
+    /**
+     * Convert the Fluent instance to JSON.
+     *
+     * @param  int  $options
+     * @return string
+     */
+    public function toJson($options = 0)
+    {
+        return json_encode($this->jsonSerialize(), $options);
+    }
+
+    /**
+     * Determine if the given offset exists.
+     *
+     * @param  string  $offset
+     * @return bool
+     */
+    public function offsetExists($offset)
+    {
+        return isset($this->attributes[$offset]);
+    }
+
+    /**
+     * Get the value for a given offset.
+     *
+     * @param  string  $offset
+     * @return mixed
+     */
+    public function offsetGet($offset)
+    {
+        return $this->get($offset);
+    }
+
+    /**
+     * Set the value at the given offset.
+     *
+     * @param  string  $offset
+     * @param  mixed   $value
+     * @return void
+     */
+    public function offsetSet($offset, $value)
+    {
+        $this->attributes[$offset] = $value;
+    }
+
+    /**
+     * Unset the value at the given offset.
+     *
+     * @param  string  $offset
+     * @return void
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->attributes[$offset]);
+    }
+
+    /**
+     * Handle dynamic calls to the container to set attributes.
+     *
+     * @param  string  $method
+     * @param  array   $parameters
+     * @return $this
+     */
+    public function __call($method, $parameters)
+    {
+        $this->attributes[$method] = count($parameters) > 0 ? $parameters[0] : true;
+
+        return $this;
+    }
+
+    /**
+     * Dynamically retrieve the value of an attribute.
+     *
+     * @param  string  $key
+     * @return mixed
+     */
+    public function __get($key)
+    {
+        return $this->get($key);
+    }
+
+    /**
+     * Dynamically set the value of an attribute.
+     *
+     * @param  string  $key
+     * @param  mixed   $value
+     * @return void
+     */
+    public function __set($key, $value)
+    {
+        $this->offsetSet($key, $value);
+    }
+
+    /**
+     * Dynamically check if an attribute is set.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function __isset($key)
+    {
+        return $this->offsetExists($key);
+    }
+
+    /**
+     * Dynamically unset an attribute.
+     *
+     * @param  string  $key
+     * @return void
+     */
+    public function __unset($key)
+    {
+        $this->offsetUnset($key);
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/HigherOrderCollectionProxy.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Illuminate\Support;
+
+/**
+ * @mixin \Illuminate\Support\Collection
+ */
+class HigherOrderCollectionProxy
+{
+    /**
+     * The collection being operated on.
+     *
+     * @var \Illuminate\Support\Collection
+     */
+    protected $collection;
+
+    /**
+     * The method being proxied.
+     *
+     * @var string
+     */
+    protected $method;
+
+    /**
+     * Create a new proxy instance.
+     *
+     * @param  \Illuminate\Support\Collection  $collection
+     * @param  string  $method
+     * @return void
+     */
+    public function __construct(Collection $collection, $method)
+    {
+        $this->method = $method;
+        $this->collection = $collection;
+    }
+
+    /**
+     * Proxy accessing an attribute onto the collection items.
+     *
+     * @param  string  $key
+     * @return mixed
+     */
+    public function __get($key)
+    {
+        return $this->collection->{$this->method}(function ($value) use ($key) {
+            return is_array($value) ? $value[$key] : $value->{$key};
+        });
+    }
+
+    /**
+     * Proxy a method call onto the collection items.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->collection->{$this->method}(function ($value) use ($method, $parameters) {
+            return $value->{$method}(...$parameters);
+        });
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/HigherOrderTapProxy.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Illuminate\Support;
+
+class HigherOrderTapProxy
+{
+    /**
+     * The target being tapped.
+     *
+     * @var mixed
+     */
+    public $target;
+
+    /**
+     * Create a new tap proxy instance.
+     *
+     * @param  mixed  $target
+     * @return void
+     */
+    public function __construct($target)
+    {
+        $this->target = $target;
+    }
+
+    /**
+     * Dynamically pass method calls to the target.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        $this->target->{$method}(...$parameters);
+
+        return $this->target;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/HtmlString.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Illuminate\Contracts\Support\Htmlable;
+
+class HtmlString implements Htmlable
+{
+    /**
+     * The HTML string.
+     *
+     * @var string
+     */
+    protected $html;
+
+    /**
+     * Create a new HTML string instance.
+     *
+     * @param  string  $html
+     * @return void
+     */
+    public function __construct($html)
+    {
+        $this->html = $html;
+    }
+
+    /**
+     * Get the HTML string.
+     *
+     * @return string
+     */
+    public function toHtml()
+    {
+        return $this->html;
+    }
+
+    /**
+     * Get the HTML string.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->toHtml();
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/InteractsWithTime.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace Illuminate\Support;
+
+use DateInterval;
+use DateTimeInterface;
+
+trait InteractsWithTime
+{
+    /**
+     * Get the number of seconds until the given DateTime.
+     *
+     * @param  \DateTimeInterface|\DateInterval|int  $delay
+     * @return int
+     */
+    protected function secondsUntil($delay)
+    {
+        $delay = $this->parseDateInterval($delay);
+
+        return $delay instanceof DateTimeInterface
+                            ? max(0, $delay->getTimestamp() - $this->currentTime())
+                            : (int) $delay;
+    }
+
+    /**
+     * Get the "available at" UNIX timestamp.
+     *
+     * @param  \DateTimeInterface|\DateInterval|int  $delay
+     * @return int
+     */
+    protected function availableAt($delay = 0)
+    {
+        $delay = $this->parseDateInterval($delay);
+
+        return $delay instanceof DateTimeInterface
+                            ? $delay->getTimestamp()
+                            : Carbon::now()->addSeconds($delay)->getTimestamp();
+    }
+
+    /**
+     * If the given value is an interval, convert it to a DateTime instance.
+     *
+     * @param  \DateTimeInterface|\DateInterval|int  $delay
+     * @return \DateTimeInterface|int
+     */
+    protected function parseDateInterval($delay)
+    {
+        if ($delay instanceof DateInterval) {
+            $delay = Carbon::now()->add($delay);
+        }
+
+        return $delay;
+    }
+
+    /**
+     * Get the current system time as a UNIX timestamp.
+     *
+     * @return int
+     */
+    protected function currentTime()
+    {
+        return Carbon::now()->getTimestamp();
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Manager.php

@@ -0,0 +1,146 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Closure;
+use InvalidArgumentException;
+
+abstract class Manager
+{
+    /**
+     * The application instance.
+     *
+     * @var \Illuminate\Foundation\Application
+     */
+    protected $app;
+
+    /**
+     * The registered custom driver creators.
+     *
+     * @var array
+     */
+    protected $customCreators = [];
+
+    /**
+     * The array of created "drivers".
+     *
+     * @var array
+     */
+    protected $drivers = [];
+
+    /**
+     * Create a new manager instance.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return void
+     */
+    public function __construct($app)
+    {
+        $this->app = $app;
+    }
+
+    /**
+     * Get the default driver name.
+     *
+     * @return string
+     */
+    abstract public function getDefaultDriver();
+
+    /**
+     * Get a driver instance.
+     *
+     * @param  string  $driver
+     * @return mixed
+     */
+    public function driver($driver = null)
+    {
+        $driver = $driver ?: $this->getDefaultDriver();
+
+        if (is_null($driver)) {
+            throw new InvalidArgumentException(sprintf(
+                'Unable to resolve NULL driver for [%s].', static::class
+            ));
+        }
+
+        // If the given driver has not been created before, we will create the instances
+        // here and cache it so we can return it next time very quickly. If there is
+        // already a driver created by this name, we'll just return that instance.
+        if (! isset($this->drivers[$driver])) {
+            $this->drivers[$driver] = $this->createDriver($driver);
+        }
+
+        return $this->drivers[$driver];
+    }
+
+    /**
+     * Create a new driver instance.
+     *
+     * @param  string  $driver
+     * @return mixed
+     *
+     * @throws \InvalidArgumentException
+     */
+    protected function createDriver($driver)
+    {
+        // We'll check to see if a creator method exists for the given driver. If not we
+        // will check for a custom driver creator, which allows developers to create
+        // drivers using their own customized driver creator Closure to create it.
+        if (isset($this->customCreators[$driver])) {
+            return $this->callCustomCreator($driver);
+        } else {
+            $method = 'create'.Str::studly($driver).'Driver';
+
+            if (method_exists($this, $method)) {
+                return $this->$method();
+            }
+        }
+        throw new InvalidArgumentException("Driver [$driver] not supported.");
+    }
+
+    /**
+     * Call a custom driver creator.
+     *
+     * @param  string  $driver
+     * @return mixed
+     */
+    protected function callCustomCreator($driver)
+    {
+        return $this->customCreators[$driver]($this->app);
+    }
+
+    /**
+     * Register a custom driver creator Closure.
+     *
+     * @param  string    $driver
+     * @param  \Closure  $callback
+     * @return $this
+     */
+    public function extend($driver, Closure $callback)
+    {
+        $this->customCreators[$driver] = $callback;
+
+        return $this;
+    }
+
+    /**
+     * Get all of the created "drivers".
+     *
+     * @return array
+     */
+    public function getDrivers()
+    {
+        return $this->drivers;
+    }
+
+    /**
+     * Dynamically call the default driver instance.
+     *
+     * @param  string  $method
+     * @param  array   $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->driver()->$method(...$parameters);
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/MessageBag.php

@@ -0,0 +1,395 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Countable;
+use JsonSerializable;
+use Illuminate\Contracts\Support\Jsonable;
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Contracts\Support\MessageProvider;
+use Illuminate\Contracts\Support\MessageBag as MessageBagContract;
+
+class MessageBag implements Arrayable, Countable, Jsonable, JsonSerializable, MessageBagContract, MessageProvider
+{
+    /**
+     * All of the registered messages.
+     *
+     * @var array
+     */
+    protected $messages = [];
+
+    /**
+     * Default format for message output.
+     *
+     * @var string
+     */
+    protected $format = ':message';
+
+    /**
+     * Create a new message bag instance.
+     *
+     * @param  array  $messages
+     * @return void
+     */
+    public function __construct(array $messages = [])
+    {
+        foreach ($messages as $key => $value) {
+            $this->messages[$key] = $value instanceof Arrayable
+                    ? $value->toArray() : (array) $value;
+        }
+    }
+
+    /**
+     * Get the keys present in the message bag.
+     *
+     * @return array
+     */
+    public function keys()
+    {
+        return array_keys($this->messages);
+    }
+
+    /**
+     * Add a message to the bag.
+     *
+     * @param  string  $key
+     * @param  string  $message
+     * @return $this
+     */
+    public function add($key, $message)
+    {
+        if ($this->isUnique($key, $message)) {
+            $this->messages[$key][] = $message;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Determine if a key and message combination already exists.
+     *
+     * @param  string  $key
+     * @param  string  $message
+     * @return bool
+     */
+    protected function isUnique($key, $message)
+    {
+        $messages = (array) $this->messages;
+
+        return ! isset($messages[$key]) || ! in_array($message, $messages[$key]);
+    }
+
+    /**
+     * Merge a new array of messages into the bag.
+     *
+     * @param  \Illuminate\Contracts\Support\MessageProvider|array  $messages
+     * @return $this
+     */
+    public function merge($messages)
+    {
+        if ($messages instanceof MessageProvider) {
+            $messages = $messages->getMessageBag()->getMessages();
+        }
+
+        $this->messages = array_merge_recursive($this->messages, $messages);
+
+        return $this;
+    }
+
+    /**
+     * Determine if messages exist for all of the given keys.
+     *
+     * @param  array|string  $key
+     * @return bool
+     */
+    public function has($key)
+    {
+        if (is_null($key)) {
+            return $this->any();
+        }
+
+        $keys = is_array($key) ? $key : func_get_args();
+
+        foreach ($keys as $key) {
+            if ($this->first($key) === '') {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Determine if messages exist for any of the given keys.
+     *
+     * @param  array|string  $keys
+     * @return bool
+     */
+    public function hasAny($keys = [])
+    {
+        $keys = is_array($keys) ? $keys : func_get_args();
+
+        foreach ($keys as $key) {
+            if ($this->has($key)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Get the first message from the bag for a given key.
+     *
+     * @param  string  $key
+     * @param  string  $format
+     * @return string
+     */
+    public function first($key = null, $format = null)
+    {
+        $messages = is_null($key) ? $this->all($format) : $this->get($key, $format);
+
+        $firstMessage = Arr::first($messages, null, '');
+
+        return is_array($firstMessage) ? Arr::first($firstMessage) : $firstMessage;
+    }
+
+    /**
+     * Get all of the messages from the bag for a given key.
+     *
+     * @param  string  $key
+     * @param  string  $format
+     * @return array
+     */
+    public function get($key, $format = null)
+    {
+        // If the message exists in the container, we will transform it and return
+        // the message. Otherwise, we'll check if the key is implicit & collect
+        // all the messages that match a given key and output it as an array.
+        if (array_key_exists($key, $this->messages)) {
+            return $this->transform(
+                $this->messages[$key], $this->checkFormat($format), $key
+            );
+        }
+
+        if (Str::contains($key, '*')) {
+            return $this->getMessagesForWildcardKey($key, $format);
+        }
+
+        return [];
+    }
+
+    /**
+     * Get the messages for a wildcard key.
+     *
+     * @param  string  $key
+     * @param  string|null  $format
+     * @return array
+     */
+    protected function getMessagesForWildcardKey($key, $format)
+    {
+        return collect($this->messages)
+                ->filter(function ($messages, $messageKey) use ($key) {
+                    return Str::is($key, $messageKey);
+                })
+                ->map(function ($messages, $messageKey) use ($format) {
+                    return $this->transform(
+                        $messages, $this->checkFormat($format), $messageKey
+                    );
+                })->all();
+    }
+
+    /**
+     * Get all of the messages for every key in the bag.
+     *
+     * @param  string  $format
+     * @return array
+     */
+    public function all($format = null)
+    {
+        $format = $this->checkFormat($format);
+
+        $all = [];
+
+        foreach ($this->messages as $key => $messages) {
+            $all = array_merge($all, $this->transform($messages, $format, $key));
+        }
+
+        return $all;
+    }
+
+    /**
+     * Get all of the unique messages for every key in the bag.
+     *
+     * @param  string  $format
+     * @return array
+     */
+    public function unique($format = null)
+    {
+        return array_unique($this->all($format));
+    }
+
+    /**
+     * Format an array of messages.
+     *
+     * @param  array   $messages
+     * @param  string  $format
+     * @param  string  $messageKey
+     * @return array
+     */
+    protected function transform($messages, $format, $messageKey)
+    {
+        return collect((array) $messages)
+            ->map(function ($message) use ($format, $messageKey) {
+                // We will simply spin through the given messages and transform each one
+                // replacing the :message place holder with the real message allowing
+                // the messages to be easily formatted to each developer's desires.
+                return str_replace([':message', ':key'], [$message, $messageKey], $format);
+            })->all();
+    }
+
+    /**
+     * Get the appropriate format based on the given format.
+     *
+     * @param  string  $format
+     * @return string
+     */
+    protected function checkFormat($format)
+    {
+        return $format ?: $this->format;
+    }
+
+    /**
+     * Get the raw messages in the container.
+     *
+     * @return array
+     */
+    public function messages()
+    {
+        return $this->messages;
+    }
+
+    /**
+     * Get the raw messages in the container.
+     *
+     * @return array
+     */
+    public function getMessages()
+    {
+        return $this->messages();
+    }
+
+    /**
+     * Get the messages for the instance.
+     *
+     * @return \Illuminate\Support\MessageBag
+     */
+    public function getMessageBag()
+    {
+        return $this;
+    }
+
+    /**
+     * Get the default message format.
+     *
+     * @return string
+     */
+    public function getFormat()
+    {
+        return $this->format;
+    }
+
+    /**
+     * Set the default message format.
+     *
+     * @param  string  $format
+     * @return \Illuminate\Support\MessageBag
+     */
+    public function setFormat($format = ':message')
+    {
+        $this->format = $format;
+
+        return $this;
+    }
+
+    /**
+     * Determine if the message bag has any messages.
+     *
+     * @return bool
+     */
+    public function isEmpty()
+    {
+        return ! $this->any();
+    }
+
+    /**
+     * Determine if the message bag has any messages.
+     *
+     * @return bool
+     */
+    public function isNotEmpty()
+    {
+        return $this->any();
+    }
+
+    /**
+     * Determine if the message bag has any messages.
+     *
+     * @return bool
+     */
+    public function any()
+    {
+        return $this->count() > 0;
+    }
+
+    /**
+     * Get the number of messages in the container.
+     *
+     * @return int
+     */
+    public function count()
+    {
+        return count($this->messages, COUNT_RECURSIVE) - count($this->messages);
+    }
+
+    /**
+     * Get the instance as an array.
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->getMessages();
+    }
+
+    /**
+     * Convert the object into something JSON serializable.
+     *
+     * @return array
+     */
+    public function jsonSerialize()
+    {
+        return $this->toArray();
+    }
+
+    /**
+     * Convert the object to its JSON representation.
+     *
+     * @param  int  $options
+     * @return string
+     */
+    public function toJson($options = 0)
+    {
+        return json_encode($this->jsonSerialize(), $options);
+    }
+
+    /**
+     * Convert the message bag to its string representation.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->toJson();
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/NamespacedItemResolver.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Illuminate\Support;
+
+class NamespacedItemResolver
+{
+    /**
+     * A cache of the parsed items.
+     *
+     * @var array
+     */
+    protected $parsed = [];
+
+    /**
+     * Parse a key into namespace, group, and item.
+     *
+     * @param  string  $key
+     * @return array
+     */
+    public function parseKey($key)
+    {
+        // If we've already parsed the given key, we'll return the cached version we
+        // already have, as this will save us some processing. We cache off every
+        // key we parse so we can quickly return it on all subsequent requests.
+        if (isset($this->parsed[$key])) {
+            return $this->parsed[$key];
+        }
+
+        // If the key does not contain a double colon, it means the key is not in a
+        // namespace, and is just a regular configuration item. Namespaces are a
+        // tool for organizing configuration items for things such as modules.
+        if (strpos($key, '::') === false) {
+            $segments = explode('.', $key);
+
+            $parsed = $this->parseBasicSegments($segments);
+        } else {
+            $parsed = $this->parseNamespacedSegments($key);
+        }
+
+        // Once we have the parsed array of this key's elements, such as its groups
+        // and namespace, we will cache each array inside a simple list that has
+        // the key and the parsed array for quick look-ups for later requests.
+        return $this->parsed[$key] = $parsed;
+    }
+
+    /**
+     * Parse an array of basic segments.
+     *
+     * @param  array  $segments
+     * @return array
+     */
+    protected function parseBasicSegments(array $segments)
+    {
+        // The first segment in a basic array will always be the group, so we can go
+        // ahead and grab that segment. If there is only one total segment we are
+        // just pulling an entire group out of the array and not a single item.
+        $group = $segments[0];
+
+        // If there is more than one segment in this group, it means we are pulling
+        // a specific item out of a group and will need to return this item name
+        // as well as the group so we know which item to pull from the arrays.
+        $item = count($segments) === 1
+                    ? null
+                    : implode('.', array_slice($segments, 1));
+
+        return [null, $group, $item];
+    }
+
+    /**
+     * Parse an array of namespaced segments.
+     *
+     * @param  string  $key
+     * @return array
+     */
+    protected function parseNamespacedSegments($key)
+    {
+        list($namespace, $item) = explode('::', $key);
+
+        // First we'll just explode the first segment to get the namespace and group
+        // since the item should be in the remaining segments. Once we have these
+        // two pieces of data we can proceed with parsing out the item's value.
+        $itemSegments = explode('.', $item);
+
+        $groupAndItem = array_slice(
+            $this->parseBasicSegments($itemSegments), 1
+        );
+
+        return array_merge([$namespace], $groupAndItem);
+    }
+
+    /**
+     * Set the parsed value of a key.
+     *
+     * @param  string  $key
+     * @param  array   $parsed
+     * @return void
+     */
+    public function setParsedKey($key, $parsed)
+    {
+        $this->parsed[$key] = $parsed;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Optional.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace Illuminate\Support;
+
+use ArrayAccess;
+
+class Optional implements ArrayAccess
+{
+    use Traits\Macroable {
+        __call as macroCall;
+    }
+
+    /**
+     * The underlying object.
+     *
+     * @var mixed
+     */
+    protected $value;
+
+    /**
+     * Create a new optional instance.
+     *
+     * @param  mixed  $value
+     * @return void
+     */
+    public function __construct($value)
+    {
+        $this->value = $value;
+    }
+
+    /**
+     * Dynamically access a property on the underlying object.
+     *
+     * @param  string  $key
+     * @return mixed
+     */
+    public function __get($key)
+    {
+        if (is_object($this->value)) {
+            return $this->value->{$key} ?? null;
+        }
+    }
+
+    /**
+     * Dynamically check a property exists on the underlying object.
+     *
+     * @param $name
+     * @return bool
+     */
+    public function __isset($name)
+    {
+        if (is_object($this->value)) {
+            return isset($this->value->{$name});
+        }
+
+        if (is_array($this->value) || $this->value instanceof \ArrayObject) {
+            return isset($this->value[$name]);
+        }
+
+        return false;
+    }
+
+    /**
+     * Determine if an item exists at an offset.
+     *
+     * @param  mixed  $key
+     * @return bool
+     */
+    public function offsetExists($key)
+    {
+        return Arr::accessible($this->value) && Arr::exists($this->value, $key);
+    }
+
+    /**
+     * Get an item at a given offset.
+     *
+     * @param  mixed  $key
+     * @return mixed
+     */
+    public function offsetGet($key)
+    {
+        return Arr::get($this->value, $key);
+    }
+
+    /**
+     * Set the item at a given offset.
+     *
+     * @param  mixed  $key
+     * @param  mixed  $value
+     * @return void
+     */
+    public function offsetSet($key, $value)
+    {
+        if (Arr::accessible($this->value)) {
+            $this->value[$key] = $value;
+        }
+    }
+
+    /**
+     * Unset the item at a given offset.
+     *
+     * @param  string  $key
+     * @return void
+     */
+    public function offsetUnset($key)
+    {
+        if (Arr::accessible($this->value)) {
+            unset($this->value[$key]);
+        }
+    }
+
+    /**
+     * Dynamically pass a method to the underlying object.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        if (static::hasMacro($method)) {
+            return $this->macroCall($method, $parameters);
+        }
+
+        if (is_object($this->value)) {
+            return $this->value->{$method}(...$parameters);
+        }
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Pluralizer.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Doctrine\Common\Inflector\Inflector;
+
+class Pluralizer
+{
+    /**
+     * Uncountable word forms.
+     *
+     * @var array
+     */
+    public static $uncountable = [
+        'audio',
+        'bison',
+        'cattle',
+        'chassis',
+        'compensation',
+        'coreopsis',
+        'data',
+        'deer',
+        'education',
+        'emoji',
+        'equipment',
+        'evidence',
+        'feedback',
+        'firmware',
+        'fish',
+        'furniture',
+        'gold',
+        'hardware',
+        'information',
+        'jedi',
+        'kin',
+        'knowledge',
+        'love',
+        'metadata',
+        'money',
+        'moose',
+        'news',
+        'nutrition',
+        'offspring',
+        'plankton',
+        'pokemon',
+        'police',
+        'rain',
+        'rice',
+        'series',
+        'sheep',
+        'software',
+        'species',
+        'swine',
+        'traffic',
+        'wheat',
+    ];
+
+    /**
+     * Get the plural form of an English word.
+     *
+     * @param  string  $value
+     * @param  int     $count
+     * @return string
+     */
+    public static function plural($value, $count = 2)
+    {
+        if ((int) $count === 1 || static::uncountable($value)) {
+            return $value;
+        }
+
+        $plural = Inflector::pluralize($value);
+
+        return static::matchCase($plural, $value);
+    }
+
+    /**
+     * Get the singular form of an English word.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public static function singular($value)
+    {
+        $singular = Inflector::singularize($value);
+
+        return static::matchCase($singular, $value);
+    }
+
+    /**
+     * Determine if the given value is uncountable.
+     *
+     * @param  string  $value
+     * @return bool
+     */
+    protected static function uncountable($value)
+    {
+        return in_array(strtolower($value), static::$uncountable);
+    }
+
+    /**
+     * Attempt to match the case on two strings.
+     *
+     * @param  string  $value
+     * @param  string  $comparison
+     * @return string
+     */
+    protected static function matchCase($value, $comparison)
+    {
+        $functions = ['mb_strtolower', 'mb_strtoupper', 'ucfirst', 'ucwords'];
+
+        foreach ($functions as $function) {
+            if (call_user_func($function, $comparison) === $comparison) {
+                return call_user_func($function, $value);
+            }
+        }
+
+        return $value;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/ProcessUtils.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Illuminate\Support;
+
+/**
+ * ProcessUtils is a bunch of utility methods.
+ *
+ * This class was originally copied from Symfony 3.
+ */
+class ProcessUtils
+{
+    /**
+     * Escapes a string to be used as a shell argument.
+     *
+     * @param  string  $argument
+     * @return string
+     */
+    public static function escapeArgument($argument)
+    {
+        // Fix for PHP bug #43784 escapeshellarg removes % from given string
+        // Fix for PHP bug #49446 escapeshellarg doesn't work on Windows
+        // @see https://bugs.php.net/bug.php?id=43784
+        // @see https://bugs.php.net/bug.php?id=49446
+        if ('\\' === DIRECTORY_SEPARATOR) {
+            if ('' === $argument) {
+                return '""';
+            }
+
+            $escapedArgument = '';
+            $quote = false;
+
+            foreach (preg_split('/(")/', $argument, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE) as $part) {
+                if ('"' === $part) {
+                    $escapedArgument .= '\\"';
+                } elseif (self::isSurroundedBy($part, '%')) {
+                    // Avoid environment variable expansion
+                    $escapedArgument .= '^%"'.substr($part, 1, -1).'"^%';
+                } else {
+                    // escape trailing backslash
+                    if ('\\' === substr($part, -1)) {
+                        $part .= '\\';
+                    }
+                    $quote = true;
+                    $escapedArgument .= $part;
+                }
+            }
+
+            if ($quote) {
+                $escapedArgument = '"'.$escapedArgument.'"';
+            }
+
+            return $escapedArgument;
+        }
+
+        return "'".str_replace("'", "'\\''", $argument)."'";
+    }
+
+    /**
+     * Is the given string surrounded by the given character?
+     *
+     * @param  string  $arg
+     * @param  string  $char
+     * @return bool
+     */
+    protected static function isSurroundedBy($arg, $char)
+    {
+        return 2 < strlen($arg) && $char === $arg[0] && $char === $arg[strlen($arg) - 1];
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/ServiceProvider.php

@@ -0,0 +1,300 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Illuminate\Console\Application as Artisan;
+
+abstract class ServiceProvider
+{
+    /**
+     * The application instance.
+     *
+     * @var \Illuminate\Contracts\Foundation\Application
+     */
+    protected $app;
+
+    /**
+     * Indicates if loading of the provider is deferred.
+     *
+     * @var bool
+     */
+    protected $defer = false;
+
+    /**
+     * The paths that should be published.
+     *
+     * @var array
+     */
+    public static $publishes = [];
+
+    /**
+     * The paths that should be published by group.
+     *
+     * @var array
+     */
+    public static $publishGroups = [];
+
+    /**
+     * Create a new service provider instance.
+     *
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
+     * @return void
+     */
+    public function __construct($app)
+    {
+        $this->app = $app;
+    }
+
+    /**
+     * Merge the given configuration with the existing configuration.
+     *
+     * @param  string  $path
+     * @param  string  $key
+     * @return void
+     */
+    protected function mergeConfigFrom($path, $key)
+    {
+        $config = $this->app['config']->get($key, []);
+
+        $this->app['config']->set($key, array_merge(require $path, $config));
+    }
+
+    /**
+     * Load the given routes file if routes are not already cached.
+     *
+     * @param  string  $path
+     * @return void
+     */
+    protected function loadRoutesFrom($path)
+    {
+        if (! $this->app->routesAreCached()) {
+            require $path;
+        }
+    }
+
+    /**
+     * Register a view file namespace.
+     *
+     * @param  string  $path
+     * @param  string  $namespace
+     * @return void
+     */
+    protected function loadViewsFrom($path, $namespace)
+    {
+        if (is_array($this->app->config['view']['paths'])) {
+            foreach ($this->app->config['view']['paths'] as $viewPath) {
+                if (is_dir($appPath = $viewPath.'/vendor/'.$namespace)) {
+                    $this->app['view']->addNamespace($namespace, $appPath);
+                }
+            }
+        }
+
+        $this->app['view']->addNamespace($namespace, $path);
+    }
+
+    /**
+     * Register a translation file namespace.
+     *
+     * @param  string  $path
+     * @param  string  $namespace
+     * @return void
+     */
+    protected function loadTranslationsFrom($path, $namespace)
+    {
+        $this->app['translator']->addNamespace($namespace, $path);
+    }
+
+    /**
+     * Register a JSON translation file path.
+     *
+     * @param  string  $path
+     * @return void
+     */
+    protected function loadJsonTranslationsFrom($path)
+    {
+        $this->app['translator']->addJsonPath($path);
+    }
+
+    /**
+     * Register a database migration path.
+     *
+     * @param  array|string  $paths
+     * @return void
+     */
+    protected function loadMigrationsFrom($paths)
+    {
+        $this->app->afterResolving('migrator', function ($migrator) use ($paths) {
+            foreach ((array) $paths as $path) {
+                $migrator->path($path);
+            }
+        });
+    }
+
+    /**
+     * Register paths to be published by the publish command.
+     *
+     * @param  array  $paths
+     * @param  string  $group
+     * @return void
+     */
+    protected function publishes(array $paths, $group = null)
+    {
+        $this->ensurePublishArrayInitialized($class = static::class);
+
+        static::$publishes[$class] = array_merge(static::$publishes[$class], $paths);
+
+        if ($group) {
+            $this->addPublishGroup($group, $paths);
+        }
+    }
+
+    /**
+     * Ensure the publish array for the service provider is initialized.
+     *
+     * @param  string  $class
+     * @return void
+     */
+    protected function ensurePublishArrayInitialized($class)
+    {
+        if (! array_key_exists($class, static::$publishes)) {
+            static::$publishes[$class] = [];
+        }
+    }
+
+    /**
+     * Add a publish group / tag to the service provider.
+     *
+     * @param  string  $group
+     * @param  array  $paths
+     * @return void
+     */
+    protected function addPublishGroup($group, $paths)
+    {
+        if (! array_key_exists($group, static::$publishGroups)) {
+            static::$publishGroups[$group] = [];
+        }
+
+        static::$publishGroups[$group] = array_merge(
+            static::$publishGroups[$group], $paths
+        );
+    }
+
+    /**
+     * Get the paths to publish.
+     *
+     * @param  string  $provider
+     * @param  string  $group
+     * @return array
+     */
+    public static function pathsToPublish($provider = null, $group = null)
+    {
+        if (! is_null($paths = static::pathsForProviderOrGroup($provider, $group))) {
+            return $paths;
+        }
+
+        return collect(static::$publishes)->reduce(function ($paths, $p) {
+            return array_merge($paths, $p);
+        }, []);
+    }
+
+    /**
+     * Get the paths for the provider or group (or both).
+     *
+     * @param  string|null  $provider
+     * @param  string|null  $group
+     * @return array
+     */
+    protected static function pathsForProviderOrGroup($provider, $group)
+    {
+        if ($provider && $group) {
+            return static::pathsForProviderAndGroup($provider, $group);
+        } elseif ($group && array_key_exists($group, static::$publishGroups)) {
+            return static::$publishGroups[$group];
+        } elseif ($provider && array_key_exists($provider, static::$publishes)) {
+            return static::$publishes[$provider];
+        } elseif ($group || $provider) {
+            return [];
+        }
+    }
+
+    /**
+     * Get the paths for the provider and group.
+     *
+     * @param  string  $provider
+     * @param  string  $group
+     * @return array
+     */
+    protected static function pathsForProviderAndGroup($provider, $group)
+    {
+        if (! empty(static::$publishes[$provider]) && ! empty(static::$publishGroups[$group])) {
+            return array_intersect_key(static::$publishes[$provider], static::$publishGroups[$group]);
+        }
+
+        return [];
+    }
+
+    /**
+     * Get the service providers available for publishing.
+     *
+     * @return array
+     */
+    public static function publishableProviders()
+    {
+        return array_keys(static::$publishes);
+    }
+
+    /**
+     * Get the groups available for publishing.
+     *
+     * @return array
+     */
+    public static function publishableGroups()
+    {
+        return array_keys(static::$publishGroups);
+    }
+
+    /**
+     * Register the package's custom Artisan commands.
+     *
+     * @param  array|mixed  $commands
+     * @return void
+     */
+    public function commands($commands)
+    {
+        $commands = is_array($commands) ? $commands : func_get_args();
+
+        Artisan::starting(function ($artisan) use ($commands) {
+            $artisan->resolveCommands($commands);
+        });
+    }
+
+    /**
+     * Get the services provided by the provider.
+     *
+     * @return array
+     */
+    public function provides()
+    {
+        return [];
+    }
+
+    /**
+     * Get the events that trigger this service provider to register.
+     *
+     * @return array
+     */
+    public function when()
+    {
+        return [];
+    }
+
+    /**
+     * Determine if the provider is deferred.
+     *
+     * @return bool
+     */
+    public function isDeferred()
+    {
+        return $this->defer;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Str.php

@@ -0,0 +1,718 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Ramsey\Uuid\Uuid;
+use Ramsey\Uuid\UuidFactory;
+use Illuminate\Support\Traits\Macroable;
+use Ramsey\Uuid\Generator\CombGenerator;
+use Ramsey\Uuid\Codec\TimestampFirstCombCodec;
+
+class Str
+{
+    use Macroable;
+
+    /**
+     * The cache of snake-cased words.
+     *
+     * @var array
+     */
+    protected static $snakeCache = [];
+
+    /**
+     * The cache of camel-cased words.
+     *
+     * @var array
+     */
+    protected static $camelCache = [];
+
+    /**
+     * The cache of studly-cased words.
+     *
+     * @var array
+     */
+    protected static $studlyCache = [];
+
+    /**
+     * Return the remainder of a string after a given value.
+     *
+     * @param  string  $subject
+     * @param  string  $search
+     * @return string
+     */
+    public static function after($subject, $search)
+    {
+        return $search === '' ? $subject : array_reverse(explode($search, $subject, 2))[0];
+    }
+
+    /**
+     * Transliterate a UTF-8 value to ASCII.
+     *
+     * @param  string  $value
+     * @param  string  $language
+     * @return string
+     */
+    public static function ascii($value, $language = 'en')
+    {
+        $languageSpecific = static::languageSpecificCharsArray($language);
+
+        if (! is_null($languageSpecific)) {
+            $value = str_replace($languageSpecific[0], $languageSpecific[1], $value);
+        }
+
+        foreach (static::charsArray() as $key => $val) {
+            $value = str_replace($val, $key, $value);
+        }
+
+        return preg_replace('/[^\x20-\x7E]/u', '', $value);
+    }
+
+    /**
+     * Get the portion of a string before a given value.
+     *
+     * @param  string  $subject
+     * @param  string  $search
+     * @return string
+     */
+    public static function before($subject, $search)
+    {
+        return $search === '' ? $subject : explode($search, $subject)[0];
+    }
+
+    /**
+     * Convert a value to camel case.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public static function camel($value)
+    {
+        if (isset(static::$camelCache[$value])) {
+            return static::$camelCache[$value];
+        }
+
+        return static::$camelCache[$value] = lcfirst(static::studly($value));
+    }
+
+    /**
+     * Determine if a given string contains a given substring.
+     *
+     * @param  string  $haystack
+     * @param  string|array  $needles
+     * @return bool
+     */
+    public static function contains($haystack, $needles)
+    {
+        foreach ((array) $needles as $needle) {
+            if ($needle !== '' && mb_strpos($haystack, $needle) !== false) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Determine if a given string ends with a given substring.
+     *
+     * @param  string  $haystack
+     * @param  string|array  $needles
+     * @return bool
+     */
+    public static function endsWith($haystack, $needles)
+    {
+        foreach ((array) $needles as $needle) {
+            if (substr($haystack, -strlen($needle)) === (string) $needle) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Cap a string with a single instance of a given value.
+     *
+     * @param  string  $value
+     * @param  string  $cap
+     * @return string
+     */
+    public static function finish($value, $cap)
+    {
+        $quoted = preg_quote($cap, '/');
+
+        return preg_replace('/(?:'.$quoted.')+$/u', '', $value).$cap;
+    }
+
+    /**
+     * Determine if a given string matches a given pattern.
+     *
+     * @param  string|array  $pattern
+     * @param  string  $value
+     * @return bool
+     */
+    public static function is($pattern, $value)
+    {
+        $patterns = Arr::wrap($pattern);
+
+        if (empty($patterns)) {
+            return false;
+        }
+
+        foreach ($patterns as $pattern) {
+            // If the given value is an exact match we can of course return true right
+            // from the beginning. Otherwise, we will translate asterisks and do an
+            // actual pattern match against the two strings to see if they match.
+            if ($pattern == $value) {
+                return true;
+            }
+
+            $pattern = preg_quote($pattern, '#');
+
+            // Asterisks are translated into zero-or-more regular expression wildcards
+            // to make it convenient to check if the strings starts with the given
+            // pattern such as "library/*", making any string check convenient.
+            $pattern = str_replace('\*', '.*', $pattern);
+
+            if (preg_match('#^'.$pattern.'\z#u', $value) === 1) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Convert a string to kebab case.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public static function kebab($value)
+    {
+        return static::snake($value, '-');
+    }
+
+    /**
+     * Return the length of the given string.
+     *
+     * @param  string  $value
+     * @param  string  $encoding
+     * @return int
+     */
+    public static function length($value, $encoding = null)
+    {
+        if ($encoding) {
+            return mb_strlen($value, $encoding);
+        }
+
+        return mb_strlen($value);
+    }
+
+    /**
+     * Limit the number of characters in a string.
+     *
+     * @param  string  $value
+     * @param  int     $limit
+     * @param  string  $end
+     * @return string
+     */
+    public static function limit($value, $limit = 100, $end = '...')
+    {
+        if (mb_strwidth($value, 'UTF-8') <= $limit) {
+            return $value;
+        }
+
+        return rtrim(mb_strimwidth($value, 0, $limit, '', 'UTF-8')).$end;
+    }
+
+    /**
+     * Convert the given string to lower-case.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public static function lower($value)
+    {
+        return mb_strtolower($value, 'UTF-8');
+    }
+
+    /**
+     * Limit the number of words in a string.
+     *
+     * @param  string  $value
+     * @param  int     $words
+     * @param  string  $end
+     * @return string
+     */
+    public static function words($value, $words = 100, $end = '...')
+    {
+        preg_match('/^\s*+(?:\S++\s*+){1,'.$words.'}/u', $value, $matches);
+
+        if (! isset($matches[0]) || static::length($value) === static::length($matches[0])) {
+            return $value;
+        }
+
+        return rtrim($matches[0]).$end;
+    }
+
+    /**
+     * Parse a Class@method style callback into class and method.
+     *
+     * @param  string  $callback
+     * @param  string|null  $default
+     * @return array
+     */
+    public static function parseCallback($callback, $default = null)
+    {
+        return static::contains($callback, '@') ? explode('@', $callback, 2) : [$callback, $default];
+    }
+
+    /**
+     * Get the plural form of an English word.
+     *
+     * @param  string  $value
+     * @param  int     $count
+     * @return string
+     */
+    public static function plural($value, $count = 2)
+    {
+        return Pluralizer::plural($value, $count);
+    }
+
+    /**
+     * Generate a more truly "random" alpha-numeric string.
+     *
+     * @param  int  $length
+     * @return string
+     */
+    public static function random($length = 16)
+    {
+        $string = '';
+
+        while (($len = strlen($string)) < $length) {
+            $size = $length - $len;
+
+            $bytes = random_bytes($size);
+
+            $string .= substr(str_replace(['/', '+', '='], '', base64_encode($bytes)), 0, $size);
+        }
+
+        return $string;
+    }
+
+    /**
+     * Replace a given value in the string sequentially with an array.
+     *
+     * @param  string  $search
+     * @param  array   $replace
+     * @param  string  $subject
+     * @return string
+     */
+    public static function replaceArray($search, array $replace, $subject)
+    {
+        foreach ($replace as $value) {
+            $subject = static::replaceFirst($search, $value, $subject);
+        }
+
+        return $subject;
+    }
+
+    /**
+     * Replace the first occurrence of a given value in the string.
+     *
+     * @param  string  $search
+     * @param  string  $replace
+     * @param  string  $subject
+     * @return string
+     */
+    public static function replaceFirst($search, $replace, $subject)
+    {
+        if ($search == '') {
+            return $subject;
+        }
+
+        $position = strpos($subject, $search);
+
+        if ($position !== false) {
+            return substr_replace($subject, $replace, $position, strlen($search));
+        }
+
+        return $subject;
+    }
+
+    /**
+     * Replace the last occurrence of a given value in the string.
+     *
+     * @param  string  $search
+     * @param  string  $replace
+     * @param  string  $subject
+     * @return string
+     */
+    public static function replaceLast($search, $replace, $subject)
+    {
+        $position = strrpos($subject, $search);
+
+        if ($position !== false) {
+            return substr_replace($subject, $replace, $position, strlen($search));
+        }
+
+        return $subject;
+    }
+
+    /**
+     * Begin a string with a single instance of a given value.
+     *
+     * @param  string  $value
+     * @param  string  $prefix
+     * @return string
+     */
+    public static function start($value, $prefix)
+    {
+        $quoted = preg_quote($prefix, '/');
+
+        return $prefix.preg_replace('/^(?:'.$quoted.')+/u', '', $value);
+    }
+
+    /**
+     * Convert the given string to upper-case.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public static function upper($value)
+    {
+        return mb_strtoupper($value, 'UTF-8');
+    }
+
+    /**
+     * Convert the given string to title case.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public static function title($value)
+    {
+        return mb_convert_case($value, MB_CASE_TITLE, 'UTF-8');
+    }
+
+    /**
+     * Get the singular form of an English word.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public static function singular($value)
+    {
+        return Pluralizer::singular($value);
+    }
+
+    /**
+     * Generate a URL friendly "slug" from a given string.
+     *
+     * @param  string  $title
+     * @param  string  $separator
+     * @param  string  $language
+     * @return string
+     */
+    public static function slug($title, $separator = '-', $language = 'en')
+    {
+        $title = static::ascii($title, $language);
+
+        // Convert all dashes/underscores into separator
+        $flip = $separator == '-' ? '_' : '-';
+
+        $title = preg_replace('!['.preg_quote($flip).']+!u', $separator, $title);
+
+        // Replace @ with the word 'at'
+        $title = str_replace('@', $separator.'at'.$separator, $title);
+
+        // Remove all characters that are not the separator, letters, numbers, or whitespace.
+        $title = preg_replace('![^'.preg_quote($separator).'\pL\pN\s]+!u', '', mb_strtolower($title));
+
+        // Replace all separator characters and whitespace by a single separator
+        $title = preg_replace('!['.preg_quote($separator).'\s]+!u', $separator, $title);
+
+        return trim($title, $separator);
+    }
+
+    /**
+     * Convert a string to snake case.
+     *
+     * @param  string  $value
+     * @param  string  $delimiter
+     * @return string
+     */
+    public static function snake($value, $delimiter = '_')
+    {
+        $key = $value;
+
+        if (isset(static::$snakeCache[$key][$delimiter])) {
+            return static::$snakeCache[$key][$delimiter];
+        }
+
+        if (! ctype_lower($value)) {
+            $value = preg_replace('/\s+/u', '', ucwords($value));
+
+            $value = static::lower(preg_replace('/(.)(?=[A-Z])/u', '$1'.$delimiter, $value));
+        }
+
+        return static::$snakeCache[$key][$delimiter] = $value;
+    }
+
+    /**
+     * Determine if a given string starts with a given substring.
+     *
+     * @param  string  $haystack
+     * @param  string|array  $needles
+     * @return bool
+     */
+    public static function startsWith($haystack, $needles)
+    {
+        foreach ((array) $needles as $needle) {
+            if ($needle !== '' && substr($haystack, 0, strlen($needle)) === (string) $needle) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Convert a value to studly caps case.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public static function studly($value)
+    {
+        $key = $value;
+
+        if (isset(static::$studlyCache[$key])) {
+            return static::$studlyCache[$key];
+        }
+
+        $value = ucwords(str_replace(['-', '_'], ' ', $value));
+
+        return static::$studlyCache[$key] = str_replace(' ', '', $value);
+    }
+
+    /**
+     * Returns the portion of string specified by the start and length parameters.
+     *
+     * @param  string  $string
+     * @param  int  $start
+     * @param  int|null  $length
+     * @return string
+     */
+    public static function substr($string, $start, $length = null)
+    {
+        return mb_substr($string, $start, $length, 'UTF-8');
+    }
+
+    /**
+     * Make a string's first character uppercase.
+     *
+     * @param  string  $string
+     * @return string
+     */
+    public static function ucfirst($string)
+    {
+        return static::upper(static::substr($string, 0, 1)).static::substr($string, 1);
+    }
+
+    /**
+     * Generate a UUID (version 4).
+     *
+     * @return \Ramsey\Uuid\UuidInterface
+     */
+    public static function uuid()
+    {
+        return Uuid::uuid4();
+    }
+
+    /**
+     * Generate a time-ordered UUID (version 4).
+     *
+     * @return \Ramsey\Uuid\UuidInterface
+     */
+    public static function orderedUuid()
+    {
+        $factory = new UuidFactory;
+
+        $factory->setRandomGenerator(new CombGenerator(
+            $factory->getRandomGenerator(),
+            $factory->getNumberConverter()
+        ));
+
+        $factory->setCodec(new TimestampFirstCombCodec(
+            $factory->getUuidBuilder()
+        ));
+
+        return $factory->uuid4();
+    }
+
+    /**
+     * Returns the replacements for the ascii method.
+     *
+     * Note: Adapted from Stringy\Stringy.
+     *
+     * @see https://github.com/danielstjules/Stringy/blob/3.1.0/LICENSE.txt
+     *
+     * @return array
+     */
+    protected static function charsArray()
+    {
+        static $charsArray;
+
+        if (isset($charsArray)) {
+            return $charsArray;
+        }
+
+        return $charsArray = [
+            '0'    => ['°', '₀', '۰', '０'],
+            '1'    => ['¹', '₁', '۱', '１'],
+            '2'    => ['²', '₂', '۲', '２'],
+            '3'    => ['³', '₃', '۳', '３'],
+            '4'    => ['⁴', '₄', '۴', '٤', '４'],
+            '5'    => ['⁵', '₅', '۵', '٥', '５'],
+            '6'    => ['⁶', '₆', '۶', '٦', '６'],
+            '7'    => ['⁷', '₇', '۷', '７'],
+            '8'    => ['⁸', '₈', '۸', '８'],
+            '9'    => ['⁹', '₉', '۹', '９'],
+            'a'    => ['à', 'á', 'ả', 'ã', 'ạ', 'ă', 'ắ', 'ằ', 'ẳ', 'ẵ', 'ặ', 'â', 'ấ', 'ầ', 'ẩ', 'ẫ', 'ậ', 'ā', 'ą', 'å', 'α', 'ά', 'ἀ', 'ἁ', 'ἂ', 'ἃ', 'ἄ', 'ἅ', 'ἆ', 'ἇ', 'ᾀ', 'ᾁ', 'ᾂ', 'ᾃ', 'ᾄ', 'ᾅ', 'ᾆ', 'ᾇ', 'ὰ', 'ά', 'ᾰ', 'ᾱ', 'ᾲ', 'ᾳ', 'ᾴ', 'ᾶ', 'ᾷ', 'а', 'أ', 'အ', 'ာ', 'ါ', 'ǻ', 'ǎ', 'ª', 'ა', 'अ', 'ا', 'ａ', 'ä'],
+            'b'    => ['б', 'β', 'ب', 'ဗ', 'ბ', 'ｂ'],
+            'c'    => ['ç', 'ć', 'č', 'ĉ', 'ċ', 'ｃ'],
+            'd'    => ['ď', 'ð', 'đ', 'ƌ', 'ȡ', 'ɖ', 'ɗ', 'ᵭ', 'ᶁ', 'ᶑ', 'д', 'δ', 'د', 'ض', 'ဍ', 'ဒ', 'დ', 'ｄ'],
+            'e'    => ['é', 'è', 'ẻ', 'ẽ', 'ẹ', 'ê', 'ế', 'ề', 'ể', 'ễ', 'ệ', 'ë', 'ē', 'ę', 'ě', 'ĕ', 'ė', 'ε', 'έ', 'ἐ', 'ἑ', 'ἒ', 'ἓ', 'ἔ', 'ἕ', 'ὲ', 'έ', 'е', 'ё', 'э', 'є', 'ə', 'ဧ', 'ေ', 'ဲ', 'ე', 'ए', 'إ', 'ئ', 'ｅ'],
+            'f'    => ['ф', 'φ', 'ف', 'ƒ', 'ფ', 'ｆ'],
+            'g'    => ['ĝ', 'ğ', 'ġ', 'ģ', 'г', 'ґ', 'γ', 'ဂ', 'გ', 'گ', 'ｇ'],
+            'h'    => ['ĥ', 'ħ', 'η', 'ή', 'ح', 'ه', 'ဟ', 'ှ', 'ჰ', 'ｈ'],
+            'i'    => ['í', 'ì', 'ỉ', 'ĩ', 'ị', 'î', 'ï', 'ī', 'ĭ', 'į', 'ı', 'ι', 'ί', 'ϊ', 'ΐ', 'ἰ', 'ἱ', 'ἲ', 'ἳ', 'ἴ', 'ἵ', 'ἶ', 'ἷ', 'ὶ', 'ί', 'ῐ', 'ῑ', 'ῒ', 'ΐ', 'ῖ', 'ῗ', 'і', 'ї', 'и', 'ဣ', 'ိ', 'ီ', 'ည်', 'ǐ', 'ი', 'इ', 'ی', 'ｉ'],
+            'j'    => ['ĵ', 'ј', 'Ј', 'ჯ', 'ج', 'ｊ'],
+            'k'    => ['ķ', 'ĸ', 'к', 'κ', 'Ķ', 'ق', 'ك', 'က', 'კ', 'ქ', 'ک', 'ｋ'],
+            'l'    => ['ł', 'ľ', 'ĺ', 'ļ', 'ŀ', 'л', 'λ', 'ل', 'လ', 'ლ', 'ｌ'],
+            'm'    => ['м', 'μ', 'م', 'မ', 'მ', 'ｍ'],
+            'n'    => ['ñ', 'ń', 'ň', 'ņ', 'ʼn', 'ŋ', 'ν', 'н', 'ن', 'န', 'ნ', 'ｎ'],
+            'o'    => ['ó', 'ò', 'ỏ', 'õ', 'ọ', 'ô', 'ố', 'ồ', 'ổ', 'ỗ', 'ộ', 'ơ', 'ớ', 'ờ', 'ở', 'ỡ', 'ợ', 'ø', 'ō', 'ő', 'ŏ', 'ο', 'ὀ', 'ὁ', 'ὂ', 'ὃ', 'ὄ', 'ὅ', 'ὸ', 'ό', 'о', 'و', 'θ', 'ို', 'ǒ', 'ǿ', 'º', 'ო', 'ओ', 'ｏ', 'ö'],
+            'p'    => ['п', 'π', 'ပ', 'პ', 'پ', 'ｐ'],
+            'q'    => ['ყ', 'ｑ'],
+            'r'    => ['ŕ', 'ř', 'ŗ', 'р', 'ρ', 'ر', 'რ', 'ｒ'],
+            's'    => ['ś', 'š', 'ş', 'с', 'σ', 'ș', 'ς', 'س', 'ص', 'စ', 'ſ', 'ს', 'ｓ'],
+            't'    => ['ť', 'ţ', 'т', 'τ', 'ț', 'ت', 'ط', 'ဋ', 'တ', 'ŧ', 'თ', 'ტ', 'ｔ'],
+            'u'    => ['ú', 'ù', 'ủ', 'ũ', 'ụ', 'ư', 'ứ', 'ừ', 'ử', 'ữ', 'ự', 'û', 'ū', 'ů', 'ű', 'ŭ', 'ų', 'µ', 'у', 'ဉ', 'ု', 'ူ', 'ǔ', 'ǖ', 'ǘ', 'ǚ', 'ǜ', 'უ', 'उ', 'ｕ', 'ў', 'ü'],
+            'v'    => ['в', 'ვ', 'ϐ', 'ｖ'],
+            'w'    => ['ŵ', 'ω', 'ώ', 'ဝ', 'ွ', 'ｗ'],
+            'x'    => ['χ', 'ξ', 'ｘ'],
+            'y'    => ['ý', 'ỳ', 'ỷ', 'ỹ', 'ỵ', 'ÿ', 'ŷ', 'й', 'ы', 'υ', 'ϋ', 'ύ', 'ΰ', 'ي', 'ယ', 'ｙ'],
+            'z'    => ['ź', 'ž', 'ż', 'з', 'ζ', 'ز', 'ဇ', 'ზ', 'ｚ'],
+            'aa'   => ['ع', 'आ', 'آ'],
+            'ae'   => ['æ', 'ǽ'],
+            'ai'   => ['ऐ'],
+            'ch'   => ['ч', 'ჩ', 'ჭ', 'چ'],
+            'dj'   => ['ђ', 'đ'],
+            'dz'   => ['џ', 'ძ'],
+            'ei'   => ['ऍ'],
+            'gh'   => ['غ', 'ღ'],
+            'ii'   => ['ई'],
+            'ij'   => ['ij'],
+            'kh'   => ['х', 'خ', 'ხ'],
+            'lj'   => ['љ'],
+            'nj'   => ['њ'],
+            'oe'   => ['ö', 'œ', 'ؤ'],
+            'oi'   => ['ऑ'],
+            'oii'  => ['ऒ'],
+            'ps'   => ['ψ'],
+            'sh'   => ['ш', 'შ', 'ش'],
+            'shch' => ['щ'],
+            'ss'   => ['ß'],
+            'sx'   => ['ŝ'],
+            'th'   => ['þ', 'ϑ', 'ث', 'ذ', 'ظ'],
+            'ts'   => ['ц', 'ც', 'წ'],
+            'ue'   => ['ü'],
+            'uu'   => ['ऊ'],
+            'ya'   => ['я'],
+            'yu'   => ['ю'],
+            'zh'   => ['ж', 'ჟ', 'ژ'],
+            '(c)'  => ['©'],
+            'A'    => ['Á', 'À', 'Ả', 'Ã', 'Ạ', 'Ă', 'Ắ', 'Ằ', 'Ẳ', 'Ẵ', 'Ặ', 'Â', 'Ấ', 'Ầ', 'Ẩ', 'Ẫ', 'Ậ', 'Å', 'Ā', 'Ą', 'Α', 'Ά', 'Ἀ', 'Ἁ', 'Ἂ', 'Ἃ', 'Ἄ', 'Ἅ', 'Ἆ', 'Ἇ', 'ᾈ', 'ᾉ', 'ᾊ', 'ᾋ', 'ᾌ', 'ᾍ', 'ᾎ', 'ᾏ', 'Ᾰ', 'Ᾱ', 'Ὰ', 'Ά', 'ᾼ', 'А', 'Ǻ', 'Ǎ', 'Ａ', 'Ä'],
+            'B'    => ['Б', 'Β', 'ब', 'Ｂ'],
+            'C'    => ['Ç', 'Ć', 'Č', 'Ĉ', 'Ċ', 'Ｃ'],
+            'D'    => ['Ď', 'Ð', 'Đ', 'Ɖ', 'Ɗ', 'Ƌ', 'ᴅ', 'ᴆ', 'Д', 'Δ', 'Ｄ'],
+            'E'    => ['É', 'È', 'Ẻ', 'Ẽ', 'Ẹ', 'Ê', 'Ế', 'Ề', 'Ể', 'Ễ', 'Ệ', 'Ë', 'Ē', 'Ę', 'Ě', 'Ĕ', 'Ė', 'Ε', 'Έ', 'Ἐ', 'Ἑ', 'Ἒ', 'Ἓ', 'Ἔ', 'Ἕ', 'Έ', 'Ὲ', 'Е', 'Ё', 'Э', 'Є', 'Ə', 'Ｅ'],
+            'F'    => ['Ф', 'Φ', 'Ｆ'],
+            'G'    => ['Ğ', 'Ġ', 'Ģ', 'Г', 'Ґ', 'Γ', 'Ｇ'],
+            'H'    => ['Η', 'Ή', 'Ħ', 'Ｈ'],
+            'I'    => ['Í', 'Ì', 'Ỉ', 'Ĩ', 'Ị', 'Î', 'Ï', 'Ī', 'Ĭ', 'Į', 'İ', 'Ι', 'Ί', 'Ϊ', 'Ἰ', 'Ἱ', 'Ἳ', 'Ἴ', 'Ἵ', 'Ἶ', 'Ἷ', 'Ῐ', 'Ῑ', 'Ὶ', 'Ί', 'И', 'І', 'Ї', 'Ǐ', 'ϒ', 'Ｉ'],
+            'J'    => ['Ｊ'],
+            'K'    => ['К', 'Κ', 'Ｋ'],
+            'L'    => ['Ĺ', 'Ł', 'Л', 'Λ', 'Ļ', 'Ľ', 'Ŀ', 'ल', 'Ｌ'],
+            'M'    => ['М', 'Μ', 'Ｍ'],
+            'N'    => ['Ń', 'Ñ', 'Ň', 'Ņ', 'Ŋ', 'Н', 'Ν', 'Ｎ'],
+            'O'    => ['Ó', 'Ò', 'Ỏ', 'Õ', 'Ọ', 'Ô', 'Ố', 'Ồ', 'Ổ', 'Ỗ', 'Ộ', 'Ơ', 'Ớ', 'Ờ', 'Ở', 'Ỡ', 'Ợ', 'Ø', 'Ō', 'Ő', 'Ŏ', 'Ο', 'Ό', 'Ὀ', 'Ὁ', 'Ὂ', 'Ὃ', 'Ὄ', 'Ὅ', 'Ὸ', 'Ό', 'О', 'Θ', 'Ө', 'Ǒ', 'Ǿ', 'Ｏ', 'Ö'],
+            'P'    => ['П', 'Π', 'Ｐ'],
+            'Q'    => ['Ｑ'],
+            'R'    => ['Ř', 'Ŕ', 'Р', 'Ρ', 'Ŗ', 'Ｒ'],
+            'S'    => ['Ş', 'Ŝ', 'Ș', 'Š', 'Ś', 'С', 'Σ', 'Ｓ'],
+            'T'    => ['Ť', 'Ţ', 'Ŧ', 'Ț', 'Т', 'Τ', 'Ｔ'],
+            'U'    => ['Ú', 'Ù', 'Ủ', 'Ũ', 'Ụ', 'Ư', 'Ứ', 'Ừ', 'Ử', 'Ữ', 'Ự', 'Û', 'Ū', 'Ů', 'Ű', 'Ŭ', 'Ų', 'У', 'Ǔ', 'Ǖ', 'Ǘ', 'Ǚ', 'Ǜ', 'Ｕ', 'Ў', 'Ü'],
+            'V'    => ['В', 'Ｖ'],
+            'W'    => ['Ω', 'Ώ', 'Ŵ', 'Ｗ'],
+            'X'    => ['Χ', 'Ξ', 'Ｘ'],
+            'Y'    => ['Ý', 'Ỳ', 'Ỷ', 'Ỹ', 'Ỵ', 'Ÿ', 'Ῠ', 'Ῡ', 'Ὺ', 'Ύ', 'Ы', 'Й', 'Υ', 'Ϋ', 'Ŷ', 'Ｙ'],
+            'Z'    => ['Ź', 'Ž', 'Ż', 'З', 'Ζ', 'Ｚ'],
+            'AE'   => ['Æ', 'Ǽ'],
+            'Ch'   => ['Ч'],
+            'Dj'   => ['Ђ'],
+            'Dz'   => ['Џ'],
+            'Gx'   => ['Ĝ'],
+            'Hx'   => ['Ĥ'],
+            'Ij'   => ['IJ'],
+            'Jx'   => ['Ĵ'],
+            'Kh'   => ['Х'],
+            'Lj'   => ['Љ'],
+            'Nj'   => ['Њ'],
+            'Oe'   => ['Œ'],
+            'Ps'   => ['Ψ'],
+            'Sh'   => ['Ш'],
+            'Shch' => ['Щ'],
+            'Ss'   => ['ẞ'],
+            'Th'   => ['Þ'],
+            'Ts'   => ['Ц'],
+            'Ya'   => ['Я'],
+            'Yu'   => ['Ю'],
+            'Zh'   => ['Ж'],
+            ' '    => ["\xC2\xA0", "\xE2\x80\x80", "\xE2\x80\x81", "\xE2\x80\x82", "\xE2\x80\x83", "\xE2\x80\x84", "\xE2\x80\x85", "\xE2\x80\x86", "\xE2\x80\x87", "\xE2\x80\x88", "\xE2\x80\x89", "\xE2\x80\x8A", "\xE2\x80\xAF", "\xE2\x81\x9F", "\xE3\x80\x80", "\xEF\xBE\xA0"],
+        ];
+    }
+
+    /**
+     * Returns the language specific replacements for the ascii method.
+     *
+     * Note: Adapted from Stringy\Stringy.
+     *
+     * @see https://github.com/danielstjules/Stringy/blob/3.1.0/LICENSE.txt
+     *
+     * @param  string  $language
+     * @return array|null
+     */
+    protected static function languageSpecificCharsArray($language)
+    {
+        static $languageSpecific;
+
+        if (! isset($languageSpecific)) {
+            $languageSpecific = [
+                'bg' => [
+                    ['х', 'Х', 'щ', 'Щ', 'ъ', 'Ъ', 'ь', 'Ь'],
+                    ['h', 'H', 'sht', 'SHT', 'a', 'А', 'y', 'Y'],
+                ],
+                'de' => [
+                    ['ä',  'ö',  'ü',  'Ä',  'Ö',  'Ü'],
+                    ['ae', 'oe', 'ue', 'AE', 'OE', 'UE'],
+                ],
+            ];
+        }
+
+        return $languageSpecific[$language] ?? null;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Testing/Fakes/BusFake.php

@@ -0,0 +1,165 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Illuminate\Contracts\Bus\Dispatcher;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class BusFake implements Dispatcher
+{
+    /**
+     * The commands that have been dispatched.
+     *
+     * @var array
+     */
+    protected $commands = [];
+
+    /**
+     * Assert if a job was dispatched based on a truth-test callback.
+     *
+     * @param  string  $command
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertDispatched($command, $callback = null)
+    {
+        if (is_numeric($callback)) {
+            return $this->assertDispatchedTimes($command, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->dispatched($command, $callback)->count() > 0,
+            "The expected [{$command}] job was not dispatched."
+        );
+    }
+
+    /**
+     * Assert if a job was pushed a number of times.
+     *
+     * @param  string  $command
+     * @param  int  $times
+     * @return void
+     */
+    protected function assertDispatchedTimes($command, $times = 1)
+    {
+        PHPUnit::assertTrue(
+            ($count = $this->dispatched($command)->count()) === $times,
+            "The expected [{$command}] job was pushed {$count} times instead of {$times} times."
+        );
+    }
+
+    /**
+     * Determine if a job was dispatched based on a truth-test callback.
+     *
+     * @param  string  $command
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotDispatched($command, $callback = null)
+    {
+        PHPUnit::assertTrue(
+            $this->dispatched($command, $callback)->count() === 0,
+            "The unexpected [{$command}] job was dispatched."
+        );
+    }
+
+    /**
+     * Get all of the jobs matching a truth-test callback.
+     *
+     * @param  string  $command
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function dispatched($command, $callback = null)
+    {
+        if (! $this->hasDispatched($command)) {
+            return collect();
+        }
+
+        $callback = $callback ?: function () {
+            return true;
+        };
+
+        return collect($this->commands[$command])->filter(function ($command) use ($callback) {
+            return $callback($command);
+        });
+    }
+
+    /**
+     * Determine if there are any stored commands for a given class.
+     *
+     * @param  string  $command
+     * @return bool
+     */
+    public function hasDispatched($command)
+    {
+        return isset($this->commands[$command]) && ! empty($this->commands[$command]);
+    }
+
+    /**
+     * Dispatch a command to its appropriate handler.
+     *
+     * @param  mixed  $command
+     * @return mixed
+     */
+    public function dispatch($command)
+    {
+        return $this->dispatchNow($command);
+    }
+
+    /**
+     * Dispatch a command to its appropriate handler in the current process.
+     *
+     * @param  mixed  $command
+     * @param  mixed  $handler
+     * @return mixed
+     */
+    public function dispatchNow($command, $handler = null)
+    {
+        $this->commands[get_class($command)][] = $command;
+    }
+
+    /**
+     * Set the pipes commands should be piped through before dispatching.
+     *
+     * @param  array  $pipes
+     * @return $this
+     */
+    public function pipeThrough(array $pipes)
+    {
+        //
+    }
+
+    /**
+     * Determine if the given command has a handler.
+     *
+     * @param  mixed  $command
+     * @return bool
+     */
+    public function hasCommandHandler($command)
+    {
+        return false;
+    }
+
+    /**
+     * Retrieve the handler for a command.
+     *
+     * @param  mixed  $command
+     * @return mixed
+     */
+    public function getCommandHandler($command)
+    {
+        return false;
+    }
+
+    /**
+     * Map a command to a handler.
+     *
+     * @param  array  $map
+     * @return $this
+     */
+    public function map(array $map)
+    {
+        return $this;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Testing/Fakes/EventFake.php

@@ -0,0 +1,260 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Illuminate\Support\Arr;
+use PHPUnit\Framework\Assert as PHPUnit;
+use Illuminate\Contracts\Events\Dispatcher;
+
+class EventFake implements Dispatcher
+{
+    /**
+     * The original event dispatcher.
+     *
+     * @var \Illuminate\Contracts\Events\Dispatcher
+     */
+    protected $dispatcher;
+
+    /**
+     * The event types that should be intercepted instead of dispatched.
+     *
+     * @var array
+     */
+    protected $eventsToFake;
+
+    /**
+     * All of the events that have been intercepted keyed by type.
+     *
+     * @var array
+     */
+    protected $events = [];
+
+    /**
+     * Create a new event fake instance.
+     *
+     * @param  \Illuminate\Contracts\Events\Dispatcher  $dispatcher
+     * @param  array|string  $eventsToFake
+     * @return void
+     */
+    public function __construct(Dispatcher $dispatcher, $eventsToFake = [])
+    {
+        $this->dispatcher = $dispatcher;
+
+        $this->eventsToFake = Arr::wrap($eventsToFake);
+    }
+
+    /**
+     * Assert if an event was dispatched based on a truth-test callback.
+     *
+     * @param  string  $event
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertDispatched($event, $callback = null)
+    {
+        if (is_int($callback)) {
+            return $this->assertDispatchedTimes($event, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->dispatched($event, $callback)->count() > 0,
+            "The expected [{$event}] event was not dispatched."
+        );
+    }
+
+    /**
+     * Assert if a event was dispatched a number of times.
+     *
+     * @param  string  $event
+     * @param  int  $times
+     * @return void
+     */
+    public function assertDispatchedTimes($event, $times = 1)
+    {
+        PHPUnit::assertTrue(
+            ($count = $this->dispatched($event)->count()) === $times,
+            "The expected [{$event}] event was dispatched {$count} times instead of {$times} times."
+        );
+    }
+
+    /**
+     * Determine if an event was dispatched based on a truth-test callback.
+     *
+     * @param  string  $event
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotDispatched($event, $callback = null)
+    {
+        PHPUnit::assertTrue(
+            $this->dispatched($event, $callback)->count() === 0,
+            "The unexpected [{$event}] event was dispatched."
+        );
+    }
+
+    /**
+     * Get all of the events matching a truth-test callback.
+     *
+     * @param  string  $event
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function dispatched($event, $callback = null)
+    {
+        if (! $this->hasDispatched($event)) {
+            return collect();
+        }
+
+        $callback = $callback ?: function () {
+            return true;
+        };
+
+        return collect($this->events[$event])->filter(function ($arguments) use ($callback) {
+            return $callback(...$arguments);
+        });
+    }
+
+    /**
+     * Determine if the given event has been dispatched.
+     *
+     * @param  string  $event
+     * @return bool
+     */
+    public function hasDispatched($event)
+    {
+        return isset($this->events[$event]) && ! empty($this->events[$event]);
+    }
+
+    /**
+     * Register an event listener with the dispatcher.
+     *
+     * @param  string|array  $events
+     * @param  mixed  $listener
+     * @return void
+     */
+    public function listen($events, $listener)
+    {
+        //
+    }
+
+    /**
+     * Determine if a given event has listeners.
+     *
+     * @param  string  $eventName
+     * @return bool
+     */
+    public function hasListeners($eventName)
+    {
+        //
+    }
+
+    /**
+     * Register an event and payload to be dispatched later.
+     *
+     * @param  string  $event
+     * @param  array  $payload
+     * @return void
+     */
+    public function push($event, $payload = [])
+    {
+        //
+    }
+
+    /**
+     * Register an event subscriber with the dispatcher.
+     *
+     * @param  object|string  $subscriber
+     * @return void
+     */
+    public function subscribe($subscriber)
+    {
+        //
+    }
+
+    /**
+     * Flush a set of pushed events.
+     *
+     * @param  string  $event
+     * @return void
+     */
+    public function flush($event)
+    {
+        //
+    }
+
+    /**
+     * Fire an event and call the listeners.
+     *
+     * @param  string|object  $event
+     * @param  mixed  $payload
+     * @param  bool  $halt
+     * @return array|null
+     */
+    public function fire($event, $payload = [], $halt = false)
+    {
+        return $this->dispatch($event, $payload, $halt);
+    }
+
+    /**
+     * Fire an event and call the listeners.
+     *
+     * @param  string|object  $event
+     * @param  mixed  $payload
+     * @param  bool  $halt
+     * @return array|null
+     */
+    public function dispatch($event, $payload = [], $halt = false)
+    {
+        $name = is_object($event) ? get_class($event) : (string) $event;
+
+        if ($this->shouldFakeEvent($name)) {
+            $this->events[$name][] = func_get_args();
+        } else {
+            $this->dispatcher->dispatch($event, $payload, $halt);
+        }
+    }
+
+    /**
+     * Determine if an event should be faked or actually dispatched.
+     *
+     * @param  string  $eventName
+     * @return bool
+     */
+    protected function shouldFakeEvent($eventName)
+    {
+        return empty($this->eventsToFake) || in_array($eventName, $this->eventsToFake);
+    }
+
+    /**
+     * Remove a set of listeners from the dispatcher.
+     *
+     * @param  string  $event
+     * @return void
+     */
+    public function forget($event)
+    {
+        //
+    }
+
+    /**
+     * Forget all of the queued listeners.
+     *
+     * @return void
+     */
+    public function forgetPushed()
+    {
+        //
+    }
+
+    /**
+     * Dispatch an event and call the listeners.
+     *
+     * @param  string|object $event
+     * @param  mixed $payload
+     * @return void
+     */
+    public function until($event, $payload = [])
+    {
+        return $this->dispatch($event, $payload, true);
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Testing/Fakes/MailFake.php

@@ -0,0 +1,316 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Illuminate\Contracts\Mail\Mailer;
+use Illuminate\Contracts\Mail\Mailable;
+use PHPUnit\Framework\Assert as PHPUnit;
+use Illuminate\Contracts\Queue\ShouldQueue;
+
+class MailFake implements Mailer
+{
+    /**
+     * All of the mailables that have been sent.
+     *
+     * @var array
+     */
+    protected $mailables = [];
+
+    /**
+     * All of the mailables that have been queued.
+     *
+     * @var array
+     */
+    protected $queuedMailables = [];
+
+    /**
+     * Assert if a mailable was sent based on a truth-test callback.
+     *
+     * @param  string  $mailable
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertSent($mailable, $callback = null)
+    {
+        if (is_numeric($callback)) {
+            return $this->assertSentTimes($mailable, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->sent($mailable, $callback)->count() > 0,
+            "The expected [{$mailable}] mailable was not sent."
+        );
+    }
+
+    /**
+     * Assert if a mailable was sent a number of times.
+     *
+     * @param  string  $mailable
+     * @param  int  $times
+     * @return void
+     */
+    protected function assertSentTimes($mailable, $times = 1)
+    {
+        PHPUnit::assertTrue(
+            ($count = $this->sent($mailable)->count()) === $times,
+            "The expected [{$mailable}] mailable was sent {$count} times instead of {$times} times."
+        );
+    }
+
+    /**
+     * Determine if a mailable was not sent based on a truth-test callback.
+     *
+     * @param  string  $mailable
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotSent($mailable, $callback = null)
+    {
+        PHPUnit::assertTrue(
+            $this->sent($mailable, $callback)->count() === 0,
+            "The unexpected [{$mailable}] mailable was sent."
+        );
+    }
+
+    /**
+     * Assert that no mailables were sent.
+     *
+     * @return void
+     */
+    public function assertNothingSent()
+    {
+        PHPUnit::assertEmpty($this->mailables, 'Mailables were sent unexpectedly.');
+    }
+
+    /**
+     * Assert if a mailable was queued based on a truth-test callback.
+     *
+     * @param  string  $mailable
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertQueued($mailable, $callback = null)
+    {
+        if (is_numeric($callback)) {
+            return $this->assertQueuedTimes($mailable, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->queued($mailable, $callback)->count() > 0,
+            "The expected [{$mailable}] mailable was not queued."
+        );
+    }
+
+    /**
+     * Assert if a mailable was queued a number of times.
+     *
+     * @param  string  $mailable
+     * @param  int  $times
+     * @return void
+     */
+    protected function assertQueuedTimes($mailable, $times = 1)
+    {
+        PHPUnit::assertTrue(
+            ($count = $this->queued($mailable)->count()) === $times,
+            "The expected [{$mailable}] mailable was queued {$count} times instead of {$times} times."
+        );
+    }
+
+    /**
+     * Determine if a mailable was not queued based on a truth-test callback.
+     *
+     * @param  string  $mailable
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotQueued($mailable, $callback = null)
+    {
+        PHPUnit::assertTrue(
+            $this->queued($mailable, $callback)->count() === 0,
+            "The unexpected [{$mailable}] mailable was queued."
+        );
+    }
+
+    /**
+     * Assert that no mailables were queued.
+     *
+     * @return void
+     */
+    public function assertNothingQueued()
+    {
+        PHPUnit::assertEmpty($this->queuedMailables, 'Mailables were queued unexpectedly.');
+    }
+
+    /**
+     * Get all of the mailables matching a truth-test callback.
+     *
+     * @param  string  $mailable
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function sent($mailable, $callback = null)
+    {
+        if (! $this->hasSent($mailable)) {
+            return collect();
+        }
+
+        $callback = $callback ?: function () {
+            return true;
+        };
+
+        return $this->mailablesOf($mailable)->filter(function ($mailable) use ($callback) {
+            return $callback($mailable);
+        });
+    }
+
+    /**
+     * Determine if the given mailable has been sent.
+     *
+     * @param  string  $mailable
+     * @return bool
+     */
+    public function hasSent($mailable)
+    {
+        return $this->mailablesOf($mailable)->count() > 0;
+    }
+
+    /**
+     * Get all of the queued mailables matching a truth-test callback.
+     *
+     * @param  string  $mailable
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function queued($mailable, $callback = null)
+    {
+        if (! $this->hasQueued($mailable)) {
+            return collect();
+        }
+
+        $callback = $callback ?: function () {
+            return true;
+        };
+
+        return $this->queuedMailablesOf($mailable)->filter(function ($mailable) use ($callback) {
+            return $callback($mailable);
+        });
+    }
+
+    /**
+     * Determine if the given mailable has been queued.
+     *
+     * @param  string  $mailable
+     * @return bool
+     */
+    public function hasQueued($mailable)
+    {
+        return $this->queuedMailablesOf($mailable)->count() > 0;
+    }
+
+    /**
+     * Get all of the mailed mailables for a given type.
+     *
+     * @param  string  $type
+     * @return \Illuminate\Support\Collection
+     */
+    protected function mailablesOf($type)
+    {
+        return collect($this->mailables)->filter(function ($mailable) use ($type) {
+            return $mailable instanceof $type;
+        });
+    }
+
+    /**
+     * Get all of the mailed mailables for a given type.
+     *
+     * @param  string  $type
+     * @return \Illuminate\Support\Collection
+     */
+    protected function queuedMailablesOf($type)
+    {
+        return collect($this->queuedMailables)->filter(function ($mailable) use ($type) {
+            return $mailable instanceof $type;
+        });
+    }
+
+    /**
+     * Begin the process of mailing a mailable class instance.
+     *
+     * @param  mixed  $users
+     * @return \Illuminate\Mail\PendingMail
+     */
+    public function to($users)
+    {
+        return (new PendingMailFake($this))->to($users);
+    }
+
+    /**
+     * Begin the process of mailing a mailable class instance.
+     *
+     * @param  mixed  $users
+     * @return \Illuminate\Mail\PendingMail
+     */
+    public function bcc($users)
+    {
+        return (new PendingMailFake($this))->bcc($users);
+    }
+
+    /**
+     * Send a new message when only a raw text part.
+     *
+     * @param  string  $text
+     * @param  \Closure|string  $callback
+     * @return int
+     */
+    public function raw($text, $callback)
+    {
+        //
+    }
+
+    /**
+     * Send a new message using a view.
+     *
+     * @param  string|array  $view
+     * @param  array  $data
+     * @param  \Closure|string  $callback
+     * @return void
+     */
+    public function send($view, array $data = [], $callback = null)
+    {
+        if (! $view instanceof Mailable) {
+            return;
+        }
+
+        if ($view instanceof ShouldQueue) {
+            return $this->queue($view, $data);
+        }
+
+        $this->mailables[] = $view;
+    }
+
+    /**
+     * Queue a new e-mail message for sending.
+     *
+     * @param  string|array  $view
+     * @param  string|null  $queue
+     * @return mixed
+     */
+    public function queue($view, $queue = null)
+    {
+        if (! $view instanceof Mailable) {
+            return;
+        }
+
+        $this->queuedMailables[] = $view;
+    }
+
+    /**
+     * Get the array of failed recipients.
+     *
+     * @return array
+     */
+    public function failures()
+    {
+        //
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Testing/Fakes/NotificationFake.php

@@ -0,0 +1,220 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Illuminate\Support\Str;
+use Illuminate\Support\Collection;
+use PHPUnit\Framework\Assert as PHPUnit;
+use Illuminate\Contracts\Notifications\Factory as NotificationFactory;
+use Illuminate\Contracts\Notifications\Dispatcher as NotificationDispatcher;
+
+class NotificationFake implements NotificationFactory, NotificationDispatcher
+{
+    /**
+     * All of the notifications that have been sent.
+     *
+     * @var array
+     */
+    protected $notifications = [];
+
+    /**
+     * Assert if a notification was sent based on a truth-test callback.
+     *
+     * @param  mixed  $notifiable
+     * @param  string  $notification
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertSentTo($notifiable, $notification, $callback = null)
+    {
+        if (is_array($notifiable) || $notifiable instanceof Collection) {
+            foreach ($notifiable as $singleNotifiable) {
+                $this->assertSentTo($singleNotifiable, $notification, $callback);
+            }
+
+            return;
+        }
+
+        if (is_numeric($callback)) {
+            return $this->assertSentToTimes($notifiable, $notification, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->sent($notifiable, $notification, $callback)->count() > 0,
+            "The expected [{$notification}] notification was not sent."
+        );
+    }
+
+    /**
+     * Assert if a notification was sent a number of times.
+     *
+     * @param  mixed  $notifiable
+     * @param  string  $notification
+     * @param  int  $times
+     * @return void
+     */
+    public function assertSentToTimes($notifiable, $notification, $times = 1)
+    {
+        PHPUnit::assertTrue(
+            ($count = $this->sent($notifiable, $notification)->count()) === $times,
+            "Expected [{$notification}] to be sent {$count} times, but was sent {$times} times."
+        );
+    }
+
+    /**
+     * Determine if a notification was sent based on a truth-test callback.
+     *
+     * @param  mixed  $notifiable
+     * @param  string  $notification
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotSentTo($notifiable, $notification, $callback = null)
+    {
+        if (is_array($notifiable) || $notifiable instanceof Collection) {
+            foreach ($notifiable as $singleNotifiable) {
+                $this->assertNotSentTo($singleNotifiable, $notification, $callback);
+            }
+
+            return;
+        }
+
+        PHPUnit::assertTrue(
+            $this->sent($notifiable, $notification, $callback)->count() === 0,
+            "The unexpected [{$notification}] notification was sent."
+        );
+    }
+
+    /**
+     * Assert that no notifications were sent.
+     *
+     * @return void
+     */
+    public function assertNothingSent()
+    {
+        PHPUnit::assertEmpty($this->notifications, 'Notifications were sent unexpectedly.');
+    }
+
+    /**
+     * Assert the total amount of times a notification was sent.
+     *
+     * @param  int  $expectedCount
+     * @param  string  $notification
+     * @return void
+     */
+    public function assertTimesSent($expectedCount, $notification)
+    {
+        $actualCount = collect($this->notifications)
+            ->flatten(1)
+            ->reduce(function ($count, $sent) use ($notification) {
+                return $count + count($sent[$notification] ?? []);
+            }, 0);
+
+        PHPUnit::assertSame(
+            $expectedCount, $actualCount,
+            "Expected [{$notification}] to be sent {$expectedCount} times, but was sent {$actualCount} times."
+        );
+    }
+
+    /**
+     * Get all of the notifications matching a truth-test callback.
+     *
+     * @param  mixed  $notifiable
+     * @param  string  $notification
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function sent($notifiable, $notification, $callback = null)
+    {
+        if (! $this->hasSent($notifiable, $notification)) {
+            return collect();
+        }
+
+        $callback = $callback ?: function () {
+            return true;
+        };
+
+        $notifications = collect($this->notificationsFor($notifiable, $notification));
+
+        return $notifications->filter(function ($arguments) use ($callback) {
+            return $callback(...array_values($arguments));
+        })->pluck('notification');
+    }
+
+    /**
+     * Determine if there are more notifications left to inspect.
+     *
+     * @param  mixed  $notifiable
+     * @param  string  $notification
+     * @return bool
+     */
+    public function hasSent($notifiable, $notification)
+    {
+        return ! empty($this->notificationsFor($notifiable, $notification));
+    }
+
+    /**
+     * Get all of the notifications for a notifiable entity by type.
+     *
+     * @param  mixed  $notifiable
+     * @param  string  $notification
+     * @return array
+     */
+    protected function notificationsFor($notifiable, $notification)
+    {
+        if (isset($this->notifications[get_class($notifiable)][$notifiable->getKey()][$notification])) {
+            return $this->notifications[get_class($notifiable)][$notifiable->getKey()][$notification];
+        }
+
+        return [];
+    }
+
+    /**
+     * Send the given notification to the given notifiable entities.
+     *
+     * @param  \Illuminate\Support\Collection|array|mixed  $notifiables
+     * @param  mixed  $notification
+     * @return void
+     */
+    public function send($notifiables, $notification)
+    {
+        return $this->sendNow($notifiables, $notification);
+    }
+
+    /**
+     * Send the given notification immediately.
+     *
+     * @param  \Illuminate\Support\Collection|array|mixed  $notifiables
+     * @param  mixed  $notification
+     * @return void
+     */
+    public function sendNow($notifiables, $notification)
+    {
+        if (! $notifiables instanceof Collection && ! is_array($notifiables)) {
+            $notifiables = [$notifiables];
+        }
+
+        foreach ($notifiables as $notifiable) {
+            if (! $notification->id) {
+                $notification->id = Str::uuid()->toString();
+            }
+
+            $this->notifications[get_class($notifiable)][$notifiable->getKey()][get_class($notification)][] = [
+                'notification' => $notification,
+                'channels' => $notification->via($notifiable),
+                'notifiable' => $notifiable,
+            ];
+        }
+    }
+
+    /**
+     * Get a channel instance by name.
+     *
+     * @param  string|null  $name
+     * @return mixed
+     */
+    public function channel($name = null)
+    {
+        //
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Testing/Fakes/PendingMailFake.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Illuminate\Mail\Mailable;
+use Illuminate\Mail\PendingMail;
+
+class PendingMailFake extends PendingMail
+{
+    /**
+     * Create a new instance.
+     *
+     * @param  \Illuminate\Support\Testing\Fakes\MailFake  $mailer
+     * @return void
+     */
+    public function __construct($mailer)
+    {
+        $this->mailer = $mailer;
+    }
+
+    /**
+     * Send a new mailable message instance.
+     *
+     * @param  \Illuminate\Mail\Mailable $mailable
+     * @return mixed
+     */
+    public function send(Mailable $mailable)
+    {
+        return $this->sendNow($mailable);
+    }
+
+    /**
+     * Send a mailable message immediately.
+     *
+     * @param  \Illuminate\Mail\Mailable $mailable
+     * @return mixed
+     */
+    public function sendNow(Mailable $mailable)
+    {
+        $this->mailer->send($this->fill($mailable));
+    }
+
+    /**
+     * Push the given mailable onto the queue.
+     *
+     * @param  \Illuminate\Mail\Mailable $mailable
+     * @return mixed
+     */
+    public function queue(Mailable $mailable)
+    {
+        return $this->mailer->queue($this->fill($mailable));
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Testing/Fakes/QueueFake.php

@@ -0,0 +1,351 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Illuminate\Queue\QueueManager;
+use Illuminate\Contracts\Queue\Queue;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class QueueFake extends QueueManager implements Queue
+{
+    /**
+     * All of the jobs that have been pushed.
+     *
+     * @var array
+     */
+    protected $jobs = [];
+
+    /**
+     * Assert if a job was pushed based on a truth-test callback.
+     *
+     * @param  string  $job
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertPushed($job, $callback = null)
+    {
+        if (is_numeric($callback)) {
+            return $this->assertPushedTimes($job, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->pushed($job, $callback)->count() > 0,
+            "The expected [{$job}] job was not pushed."
+        );
+    }
+
+    /**
+     * Assert if a job was pushed a number of times.
+     *
+     * @param  string  $job
+     * @param  int  $times
+     * @return void
+     */
+    protected function assertPushedTimes($job, $times = 1)
+    {
+        PHPUnit::assertTrue(
+            ($count = $this->pushed($job)->count()) === $times,
+            "The expected [{$job}] job was pushed {$count} times instead of {$times} times."
+        );
+    }
+
+    /**
+     * Assert if a job was pushed based on a truth-test callback.
+     *
+     * @param  string  $queue
+     * @param  string  $job
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertPushedOn($queue, $job, $callback = null)
+    {
+        return $this->assertPushed($job, function ($job, $pushedQueue) use ($callback, $queue) {
+            if ($pushedQueue !== $queue) {
+                return false;
+            }
+
+            return $callback ? $callback(...func_get_args()) : true;
+        });
+    }
+
+    /**
+     * Assert if a job was pushed with chained jobs based on a truth-test callback.
+     *
+     * @param  string $job
+     * @param  array $expectedChain
+     * @param  callable|null $callback
+     * @return void
+     */
+    public function assertPushedWithChain($job, $expectedChain = [], $callback = null)
+    {
+        PHPUnit::assertTrue(
+            $this->pushed($job, $callback)->isNotEmpty(),
+            "The expected [{$job}] job was not pushed."
+        );
+
+        PHPUnit::assertTrue(
+            collect($expectedChain)->isNotEmpty(),
+            'The expected chain can not be empty.'
+        );
+
+        $this->isChainOfObjects($expectedChain)
+                ? $this->assertPushedWithChainOfObjects($job, $expectedChain, $callback)
+                : $this->assertPushedWithChainOfClasses($job, $expectedChain, $callback);
+    }
+
+    /**
+     * Assert if a job was pushed with chained jobs based on a truth-test callback.
+     *
+     * @param  string $job
+     * @param  array $expectedChain
+     * @param  callable|null $callback
+     * @return void
+     */
+    protected function assertPushedWithChainOfObjects($job, $expectedChain, $callback)
+    {
+        $chain = collect($expectedChain)->map(function ($job) {
+            return serialize($job);
+        })->all();
+
+        PHPUnit::assertTrue(
+            $this->pushed($job, $callback)->filter(function ($job) use ($chain) {
+                return $job->chained == $chain;
+            })->isNotEmpty(),
+            'The expected chain was not pushed.'
+        );
+    }
+
+    /**
+     * Assert if a job was pushed with chained jobs based on a truth-test callback.
+     *
+     * @param  string $job
+     * @param  array $expectedChain
+     * @param  callable|null $callback
+     * @return void
+     */
+    protected function assertPushedWithChainOfClasses($job, $expectedChain, $callback)
+    {
+        $matching = $this->pushed($job, $callback)->map->chained->map(function ($chain) {
+            return collect($chain)->map(function ($job) {
+                return get_class(unserialize($job));
+            });
+        })->filter(function ($chain) use ($expectedChain) {
+            return $chain->all() === $expectedChain;
+        });
+
+        PHPUnit::assertTrue(
+            $matching->isNotEmpty(), 'The expected chain was not pushed.'
+        );
+    }
+
+    /**
+     * Determine if the given chain is entirely composed of objects.
+     *
+     * @param  array  $chain
+     * @return bool
+     */
+    protected function isChainOfObjects($chain)
+    {
+        return collect($chain)->count() == collect($chain)
+                    ->filter(function ($job) {
+                        return is_object($job);
+                    })->count();
+    }
+
+    /**
+     * Determine if a job was pushed based on a truth-test callback.
+     *
+     * @param  string  $job
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotPushed($job, $callback = null)
+    {
+        PHPUnit::assertTrue(
+            $this->pushed($job, $callback)->count() === 0,
+            "The unexpected [{$job}] job was pushed."
+        );
+    }
+
+    /**
+     * Assert that no jobs were pushed.
+     *
+     * @return void
+     */
+    public function assertNothingPushed()
+    {
+        PHPUnit::assertEmpty($this->jobs, 'Jobs were pushed unexpectedly.');
+    }
+
+    /**
+     * Get all of the jobs matching a truth-test callback.
+     *
+     * @param  string  $job
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function pushed($job, $callback = null)
+    {
+        if (! $this->hasPushed($job)) {
+            return collect();
+        }
+
+        $callback = $callback ?: function () {
+            return true;
+        };
+
+        return collect($this->jobs[$job])->filter(function ($data) use ($callback) {
+            return $callback($data['job'], $data['queue']);
+        })->pluck('job');
+    }
+
+    /**
+     * Determine if there are any stored jobs for a given class.
+     *
+     * @param  string  $job
+     * @return bool
+     */
+    public function hasPushed($job)
+    {
+        return isset($this->jobs[$job]) && ! empty($this->jobs[$job]);
+    }
+
+    /**
+     * Resolve a queue connection instance.
+     *
+     * @param  mixed  $value
+     * @return \Illuminate\Contracts\Queue\Queue
+     */
+    public function connection($value = null)
+    {
+        return $this;
+    }
+
+    /**
+     * Get the size of the queue.
+     *
+     * @param  string  $queue
+     * @return int
+     */
+    public function size($queue = null)
+    {
+        return count($this->jobs);
+    }
+
+    /**
+     * Push a new job onto the queue.
+     *
+     * @param  string  $job
+     * @param  mixed   $data
+     * @param  string  $queue
+     * @return mixed
+     */
+    public function push($job, $data = '', $queue = null)
+    {
+        $this->jobs[is_object($job) ? get_class($job) : $job][] = [
+            'job' => $job,
+            'queue' => $queue,
+        ];
+    }
+
+    /**
+     * Push a raw payload onto the queue.
+     *
+     * @param  string  $payload
+     * @param  string  $queue
+     * @param  array   $options
+     * @return mixed
+     */
+    public function pushRaw($payload, $queue = null, array $options = [])
+    {
+        //
+    }
+
+    /**
+     * Push a new job onto the queue after a delay.
+     *
+     * @param  \DateTime|int  $delay
+     * @param  string  $job
+     * @param  mixed   $data
+     * @param  string  $queue
+     * @return mixed
+     */
+    public function later($delay, $job, $data = '', $queue = null)
+    {
+        return $this->push($job, $data, $queue);
+    }
+
+    /**
+     * Push a new job onto the queue.
+     *
+     * @param  string  $queue
+     * @param  string  $job
+     * @param  mixed   $data
+     * @return mixed
+     */
+    public function pushOn($queue, $job, $data = '')
+    {
+        return $this->push($job, $data, $queue);
+    }
+
+    /**
+     * Push a new job onto the queue after a delay.
+     *
+     * @param  string  $queue
+     * @param  \DateTime|int  $delay
+     * @param  string  $job
+     * @param  mixed   $data
+     * @return mixed
+     */
+    public function laterOn($queue, $delay, $job, $data = '')
+    {
+        return $this->push($job, $data, $queue);
+    }
+
+    /**
+     * Pop the next job off of the queue.
+     *
+     * @param  string  $queue
+     * @return \Illuminate\Contracts\Queue\Job|null
+     */
+    public function pop($queue = null)
+    {
+        //
+    }
+
+    /**
+     * Push an array of jobs onto the queue.
+     *
+     * @param  array $jobs
+     * @param  mixed $data
+     * @param  string $queue
+     * @return mixed
+     */
+    public function bulk($jobs, $data = '', $queue = null)
+    {
+        foreach ($jobs as $job) {
+            $this->push($job, $data, $queue);
+        }
+    }
+
+    /**
+     * Get the connection name for the queue.
+     *
+     * @return string
+     */
+    public function getConnectionName()
+    {
+        //
+    }
+
+    /**
+     * Set the connection name for the queue.
+     *
+     * @param  string $name
+     * @return $this
+     */
+    public function setConnectionName($name)
+    {
+        return $this;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Traits/CapsuleManagerTrait.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Illuminate\Support\Traits;
+
+use Illuminate\Support\Fluent;
+use Illuminate\Contracts\Container\Container;
+
+trait CapsuleManagerTrait
+{
+    /**
+     * The current globally used instance.
+     *
+     * @var object
+     */
+    protected static $instance;
+
+    /**
+     * The container instance.
+     *
+     * @var \Illuminate\Contracts\Container\Container
+     */
+    protected $container;
+
+    /**
+     * Setup the IoC container instance.
+     *
+     * @param  \Illuminate\Contracts\Container\Container  $container
+     * @return void
+     */
+    protected function setupContainer(Container $container)
+    {
+        $this->container = $container;
+
+        if (! $this->container->bound('config')) {
+            $this->container->instance('config', new Fluent);
+        }
+    }
+
+    /**
+     * Make this capsule instance available globally.
+     *
+     * @return void
+     */
+    public function setAsGlobal()
+    {
+        static::$instance = $this;
+    }
+
+    /**
+     * Get the IoC container instance.
+     *
+     * @return \Illuminate\Contracts\Container\Container
+     */
+    public function getContainer()
+    {
+        return $this->container;
+    }
+
+    /**
+     * Set the IoC container instance.
+     *
+     * @param  \Illuminate\Contracts\Container\Container  $container
+     * @return void
+     */
+    public function setContainer(Container $container)
+    {
+        $this->container = $container;
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Traits/Localizable.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Illuminate\Support\Traits;
+
+trait Localizable
+{
+    /**
+     * Run the callback with the given locale.
+     *
+     * @param  string  $locale
+     * @param  \Illuminate\Contracts\Translation\Translator  $translator
+     * @param  \Closure  $callback
+     * @return bool
+     */
+    public function withLocale($locale, $translator, $callback)
+    {
+        if (! $locale || ! $translator) {
+            return $callback();
+        }
+
+        $original = $translator->getLocale();
+
+        try {
+            $translator->setLocale($locale);
+
+            return $callback();
+        } finally {
+            $translator->setLocale($original);
+        }
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/Traits/Macroable.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Illuminate\Support\Traits;
+
+use Closure;
+use ReflectionClass;
+use ReflectionMethod;
+use BadMethodCallException;
+
+trait Macroable
+{
+    /**
+     * The registered string macros.
+     *
+     * @var array
+     */
+    protected static $macros = [];
+
+    /**
+     * Register a custom macro.
+     *
+     * @param  string $name
+     * @param  object|callable  $macro
+     *
+     * @return void
+     */
+    public static function macro($name, $macro)
+    {
+        static::$macros[$name] = $macro;
+    }
+
+    /**
+     * Mix another object into the class.
+     *
+     * @param  object  $mixin
+     * @return void
+     * @throws \ReflectionException
+     */
+    public static function mixin($mixin)
+    {
+        $methods = (new ReflectionClass($mixin))->getMethods(
+            ReflectionMethod::IS_PUBLIC | ReflectionMethod::IS_PROTECTED
+        );
+
+        foreach ($methods as $method) {
+            $method->setAccessible(true);
+
+            static::macro($method->name, $method->invoke($mixin));
+        }
+    }
+
+    /**
+     * Checks if macro is registered.
+     *
+     * @param  string  $name
+     * @return bool
+     */
+    public static function hasMacro($name)
+    {
+        return isset(static::$macros[$name]);
+    }
+
+    /**
+     * Dynamically handle calls to the class.
+     *
+     * @param  string  $method
+     * @param  array   $parameters
+     * @return mixed
+     *
+     * @throws \BadMethodCallException
+     */
+    public static function __callStatic($method, $parameters)
+    {
+        if (! static::hasMacro($method)) {
+            throw new BadMethodCallException(sprintf(
+                'Method %s::%s does not exist.', static::class, $method
+            ));
+        }
+
+        if (static::$macros[$method] instanceof Closure) {
+            return call_user_func_array(Closure::bind(static::$macros[$method], null, static::class), $parameters);
+        }
+
+        return call_user_func_array(static::$macros[$method], $parameters);
+    }
+
+    /**
+     * Dynamically handle calls to the class.
+     *
+     * @param  string  $method
+     * @param  array   $parameters
+     * @return mixed
+     *
+     * @throws \BadMethodCallException
+     */
+    public function __call($method, $parameters)
+    {
+        if (! static::hasMacro($method)) {
+            throw new BadMethodCallException(sprintf(
+                'Method %s::%s does not exist.', static::class, $method
+            ));
+        }
+
+        $macro = static::$macros[$method];
+
+        if ($macro instanceof Closure) {
+            return call_user_func_array($macro->bindTo($this, static::class), $parameters);
+        }
+
+        return call_user_func_array($macro, $parameters);
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/ViewErrorBag.php

@@ -0,0 +1,130 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Countable;
+use Illuminate\Contracts\Support\MessageBag as MessageBagContract;
+
+/**
+ * @mixin \Illuminate\Contracts\Support\MessageBag
+ */
+class ViewErrorBag implements Countable
+{
+    /**
+     * The array of the view error bags.
+     *
+     * @var array
+     */
+    protected $bags = [];
+
+    /**
+     * Checks if a named MessageBag exists in the bags.
+     *
+     * @param  string  $key
+     * @return bool
+     */
+    public function hasBag($key = 'default')
+    {
+        return isset($this->bags[$key]);
+    }
+
+    /**
+     * Get a MessageBag instance from the bags.
+     *
+     * @param  string  $key
+     * @return \Illuminate\Contracts\Support\MessageBag
+     */
+    public function getBag($key)
+    {
+        return Arr::get($this->bags, $key) ?: new MessageBag;
+    }
+
+    /**
+     * Get all the bags.
+     *
+     * @return array
+     */
+    public function getBags()
+    {
+        return $this->bags;
+    }
+
+    /**
+     * Add a new MessageBag instance to the bags.
+     *
+     * @param  string  $key
+     * @param  \Illuminate\Contracts\Support\MessageBag  $bag
+     * @return $this
+     */
+    public function put($key, MessageBagContract $bag)
+    {
+        $this->bags[$key] = $bag;
+
+        return $this;
+    }
+
+    /**
+     * Determine if the default message bag has any messages.
+     *
+     * @return bool
+     */
+    public function any()
+    {
+        return $this->count() > 0;
+    }
+
+    /**
+     * Get the number of messages in the default bag.
+     *
+     * @return int
+     */
+    public function count()
+    {
+        return $this->getBag('default')->count();
+    }
+
+    /**
+     * Dynamically call methods on the default bag.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->getBag('default')->$method(...$parameters);
+    }
+
+    /**
+     * Dynamically access a view error bag.
+     *
+     * @param  string  $key
+     * @return \Illuminate\Contracts\Support\MessageBag
+     */
+    public function __get($key)
+    {
+        return $this->getBag($key);
+    }
+
+    /**
+     * Dynamically set a view error bag.
+     *
+     * @param  string  $key
+     * @param  \Illuminate\Contracts\Support\MessageBag  $value
+     * @return void
+     */
+    public function __set($key, $value)
+    {
+        $this->put($key, $value);
+    }
+
+    /**
+     * Convert the default bag to its string representation.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return (string) $this->getBag('default');
+    }
+}

vendor/laravel/framework/src/Illuminate/Support/composer.json

@@ -0,0 +1,49 @@
+{
+    "name": "illuminate/support",
+    "description": "The Illuminate Support package.",
+    "license": "MIT",
+    "homepage": "https://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylor@laravel.com"
+        }
+    ],
+    "require": {
+        "php": "^7.1.3",
+        "ext-mbstring": "*",
+        "doctrine/inflector": "~1.1",
+        "illuminate/contracts": "5.6.*",
+        "nesbot/carbon": "^1.24.1"
+    },
+    "conflict": {
+        "tightenco/collect": "<5.5.33"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Support\\": ""
+        },
+        "files": [
+            "helpers.php"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "5.6-dev"
+        }
+    },
+    "suggest": {
+        "illuminate/filesystem": "Required to use the composer class (5.6.*).",
+        "ramsey/uuid": "Required to use Str::uuid() (^3.7).",
+        "symfony/process": "Required to use the composer class (~4.0).",
+        "symfony/var-dumper": "Required to use the dd function (~4.0)."
+    },
+    "config": {
+        "sort-packages": true
+    },
+    "minimum-stability": "dev"
+}