20220717

vendor/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/illuminate/support/Carbon.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Carbon\Carbon as BaseCarbon;
+use Carbon\CarbonImmutable as BaseCarbonImmutable;
+use Illuminate\Support\Traits\Conditionable;
+
+class Carbon extends BaseCarbon
+{
+    use Conditionable;
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function setTestNow($testNow = null)
+    {
+        BaseCarbon::setTestNow($testNow);
+        BaseCarbonImmutable::setTestNow($testNow);
+    }
+}

vendor/illuminate/support/Composer.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Illuminate\Filesystem\Filesystem;
+use Symfony\Component\Process\PhpExecutableFinder;
+use Symfony\Component\Process\Process;
+
+class Composer
+{
+    /**
+     * The filesystem instance.
+     *
+     * @var \Illuminate\Filesystem\Filesystem
+     */
+    protected $files;
+
+    /**
+     * The working path to regenerate from.
+     *
+     * @var string|null
+     */
+    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|array  $extra
+     * @return int
+     */
+    public function dumpAutoloads($extra = '')
+    {
+        $extra = $extra ? (array) $extra : [];
+
+        $command = array_merge($this->findComposer(), ['dump-autoload'], $extra);
+
+        return $this->getProcess($command)->run();
+    }
+
+    /**
+     * Regenerate the optimized Composer autoloader files.
+     *
+     * @return int
+     */
+    public function dumpOptimized()
+    {
+        return $this->dumpAutoloads('--optimize');
+    }
+
+    /**
+     * Get the composer command for the environment.
+     *
+     * @return array
+     */
+    protected function findComposer()
+    {
+        if ($this->files->exists($this->workingPath.'/composer.phar')) {
+            return [$this->phpBinary(), 'composer.phar'];
+        }
+
+        return ['composer'];
+    }
+
+    /**
+     * Get the PHP binary.
+     *
+     * @return string
+     */
+    protected function phpBinary()
+    {
+        return ProcessUtils::escapeArgument((new PhpExecutableFinder)->find(false));
+    }
+
+    /**
+     * Get a new Symfony process instance.
+     *
+     * @param  array  $command
+     * @return \Symfony\Component\Process\Process
+     */
+    protected function getProcess(array $command)
+    {
+        return (new Process($command, $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/illuminate/support/ConfigurationUrlParser.php

@@ -0,0 +1,191 @@
+<?php
+
+namespace Illuminate\Support;
+
+use InvalidArgumentException;
+
+class ConfigurationUrlParser
+{
+    /**
+     * The drivers aliases map.
+     *
+     * @var array
+     */
+    protected static $driverAliases = [
+        'mssql' => 'sqlsrv',
+        'mysql2' => 'mysql', // RDS
+        'postgres' => 'pgsql',
+        'postgresql' => 'pgsql',
+        'sqlite3' => 'sqlite',
+        'redis' => 'tcp',
+        'rediss' => 'tls',
+    ];
+
+    /**
+     * Parse the database configuration, hydrating options using a database configuration URL if possible.
+     *
+     * @param  array|string  $config
+     * @return array
+     */
+    public function parseConfiguration($config)
+    {
+        if (is_string($config)) {
+            $config = ['url' => $config];
+        }
+
+        $url = Arr::pull($config, 'url');
+
+        if (! $url) {
+            return $config;
+        }
+
+        $rawComponents = $this->parseUrl($url);
+
+        $decodedComponents = $this->parseStringsToNativeTypes(
+            array_map('rawurldecode', $rawComponents)
+        );
+
+        return array_merge(
+            $config,
+            $this->getPrimaryOptions($decodedComponents),
+            $this->getQueryOptions($rawComponents)
+        );
+    }
+
+    /**
+     * Get the primary database connection options.
+     *
+     * @param  array  $url
+     * @return array
+     */
+    protected function getPrimaryOptions($url)
+    {
+        return array_filter([
+            'driver' => $this->getDriver($url),
+            'database' => $this->getDatabase($url),
+            'host' => $url['host'] ?? null,
+            'port' => $url['port'] ?? null,
+            'username' => $url['user'] ?? null,
+            'password' => $url['pass'] ?? null,
+        ], fn ($value) => ! is_null($value));
+    }
+
+    /**
+     * Get the database driver from the URL.
+     *
+     * @param  array  $url
+     * @return string|null
+     */
+    protected function getDriver($url)
+    {
+        $alias = $url['scheme'] ?? null;
+
+        if (! $alias) {
+            return;
+        }
+
+        return static::$driverAliases[$alias] ?? $alias;
+    }
+
+    /**
+     * Get the database name from the URL.
+     *
+     * @param  array  $url
+     * @return string|null
+     */
+    protected function getDatabase($url)
+    {
+        $path = $url['path'] ?? null;
+
+        return $path && $path !== '/' ? substr($path, 1) : null;
+    }
+
+    /**
+     * Get all of the additional database options from the query string.
+     *
+     * @param  array  $url
+     * @return array
+     */
+    protected function getQueryOptions($url)
+    {
+        $queryString = $url['query'] ?? null;
+
+        if (! $queryString) {
+            return [];
+        }
+
+        $query = [];
+
+        parse_str($queryString, $query);
+
+        return $this->parseStringsToNativeTypes($query);
+    }
+
+    /**
+     * Parse the string URL to an array of components.
+     *
+     * @param  string  $url
+     * @return array
+     *
+     * @throws \InvalidArgumentException
+     */
+    protected function parseUrl($url)
+    {
+        $url = preg_replace('#^(sqlite3?):///#', '$1://null/', $url);
+
+        $parsedUrl = parse_url($url);
+
+        if ($parsedUrl === false) {
+            throw new InvalidArgumentException('The database configuration URL is malformed.');
+        }
+
+        return $parsedUrl;
+    }
+
+    /**
+     * Convert string casted values to their native types.
+     *
+     * @param  mixed  $value
+     * @return mixed
+     */
+    protected function parseStringsToNativeTypes($value)
+    {
+        if (is_array($value)) {
+            return array_map([$this, 'parseStringsToNativeTypes'], $value);
+        }
+
+        if (! is_string($value)) {
+            return $value;
+        }
+
+        $parsedValue = json_decode($value, true);
+
+        if (json_last_error() === JSON_ERROR_NONE) {
+            return $parsedValue;
+        }
+
+        return $value;
+    }
+
+    /**
+     * Get all of the current drivers' aliases.
+     *
+     * @return array
+     */
+    public static function getDriverAliases()
+    {
+        return static::$driverAliases;
+    }
+
+    /**
+     * Add the given driver alias to the driver aliases array.
+     *
+     * @param  string  $alias
+     * @param  string  $driver
+     * @return void
+     */
+    public static function addDriverAlias($alias, $driver)
+    {
+        static::$driverAliases[$alias] = $driver;
+    }
+}

vendor/illuminate/support/DateFactory.php

@@ -0,0 +1,231 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Carbon\Factory;
+use InvalidArgumentException;
+
+/**
+ * @see https://carbon.nesbot.com/docs/
+ * @see https://github.com/briannesbitt/Carbon/blob/master/src/Carbon/Factory.php
+ *
+ * @method static Carbon create($year = 0, $month = 1, $day = 1, $hour = 0, $minute = 0, $second = 0, $tz = null)
+ * @method static Carbon createFromDate($year = null, $month = null, $day = null, $tz = null)
+ * @method static Carbon|false createFromFormat($format, $time, $tz = null)
+ * @method static Carbon createFromTime($hour = 0, $minute = 0, $second = 0, $tz = null)
+ * @method static Carbon createFromTimeString($time, $tz = null)
+ * @method static Carbon createFromTimestamp($timestamp, $tz = null)
+ * @method static Carbon createFromTimestampMs($timestamp, $tz = null)
+ * @method static Carbon createFromTimestampUTC($timestamp)
+ * @method static Carbon createMidnightDate($year = null, $month = null, $day = null, $tz = null)
+ * @method static Carbon|false createSafe($year = null, $month = null, $day = null, $hour = null, $minute = null, $second = null, $tz = null)
+ * @method static Carbon disableHumanDiffOption($humanDiffOption)
+ * @method static Carbon enableHumanDiffOption($humanDiffOption)
+ * @method static mixed executeWithLocale($locale, $func)
+ * @method static Carbon fromSerialized($value)
+ * @method static array getAvailableLocales()
+ * @method static array getDays()
+ * @method static int getHumanDiffOptions()
+ * @method static array getIsoUnits()
+ * @method static Carbon getLastErrors()
+ * @method static string getLocale()
+ * @method static int getMidDayAt()
+ * @method static Carbon getTestNow()
+ * @method static \Symfony\Component\Translation\TranslatorInterface getTranslator()
+ * @method static int getWeekEndsAt()
+ * @method static int getWeekStartsAt()
+ * @method static array getWeekendDays()
+ * @method static bool hasFormat($date, $format)
+ * @method static bool hasMacro($name)
+ * @method static bool hasRelativeKeywords($time)
+ * @method static bool hasTestNow()
+ * @method static Carbon instance($date)
+ * @method static bool isImmutable()
+ * @method static bool isModifiableUnit($unit)
+ * @method static Carbon isMutable()
+ * @method static bool isStrictModeEnabled()
+ * @method static bool localeHasDiffOneDayWords($locale)
+ * @method static bool localeHasDiffSyntax($locale)
+ * @method static bool localeHasDiffTwoDayWords($locale)
+ * @method static bool localeHasPeriodSyntax($locale)
+ * @method static bool localeHasShortUnits($locale)
+ * @method static void macro($name, $macro)
+ * @method static Carbon|null make($var)
+ * @method static Carbon maxValue()
+ * @method static Carbon minValue()
+ * @method static void mixin($mixin)
+ * @method static Carbon now($tz = null)
+ * @method static Carbon parse($time = null, $tz = null)
+ * @method static string pluralUnit(string $unit)
+ * @method static void resetMonthsOverflow()
+ * @method static void resetToStringFormat()
+ * @method static void resetYearsOverflow()
+ * @method static void serializeUsing($callback)
+ * @method static Carbon setHumanDiffOptions($humanDiffOptions)
+ * @method static bool setLocale($locale)
+ * @method static void setMidDayAt($hour)
+ * @method static void setTestNow($testNow = null)
+ * @method static void setToStringFormat($format)
+ * @method static void setTranslator(\Symfony\Component\Translation\TranslatorInterface $translator)
+ * @method static Carbon setUtf8($utf8)
+ * @method static void setWeekEndsAt($day)
+ * @method static void setWeekStartsAt($day)
+ * @method static void setWeekendDays($days)
+ * @method static bool shouldOverflowMonths()
+ * @method static bool shouldOverflowYears()
+ * @method static string singularUnit(string $unit)
+ * @method static Carbon today($tz = null)
+ * @method static Carbon tomorrow($tz = null)
+ * @method static void useMonthsOverflow($monthsOverflow = true)
+ * @method static Carbon useStrictMode($strictModeEnabled = true)
+ * @method static void useYearsOverflow($yearsOverflow = true)
+ * @method static Carbon yesterday($tz = null)
+ */
+class DateFactory
+{
+    /**
+     * The default class that will be used for all created dates.
+     *
+     * @var string
+     */
+    const DEFAULT_CLASS_NAME = Carbon::class;
+
+    /**
+     * The type (class) of dates that should be created.
+     *
+     * @var string
+     */
+    protected static $dateClass;
+
+    /**
+     * This callable may be used to intercept date creation.
+     *
+     * @var callable
+     */
+    protected static $callable;
+
+    /**
+     * The Carbon factory that should be used when creating dates.
+     *
+     * @var object
+     */
+    protected static $factory;
+
+    /**
+     * Use the given handler when generating dates (class name, callable, or factory).
+     *
+     * @param  mixed  $handler
+     * @return mixed
+     *
+     * @throws \InvalidArgumentException
+     */
+    public static function use($handler)
+    {
+        if (is_callable($handler) && is_object($handler)) {
+            return static::useCallable($handler);
+        } elseif (is_string($handler)) {
+            return static::useClass($handler);
+        } elseif ($handler instanceof Factory) {
+            return static::useFactory($handler);
+        }
+
+        throw new InvalidArgumentException('Invalid date creation handler. Please provide a class name, callable, or Carbon factory.');
+    }
+
+    /**
+     * Use the default date class when generating dates.
+     *
+     * @return void
+     */
+    public static function useDefault()
+    {
+        static::$dateClass = null;
+        static::$callable = null;
+        static::$factory = null;
+    }
+
+    /**
+     * Execute the given callable on each date creation.
+     *
+     * @param  callable  $callable
+     * @return void
+     */
+    public static function useCallable(callable $callable)
+    {
+        static::$callable = $callable;
+
+        static::$dateClass = null;
+        static::$factory = null;
+    }
+
+    /**
+     * Use the given date type (class) when generating dates.
+     *
+     * @param  string  $dateClass
+     * @return void
+     */
+    public static function useClass($dateClass)
+    {
+        static::$dateClass = $dateClass;
+
+        static::$factory = null;
+        static::$callable = null;
+    }
+
+    /**
+     * Use the given Carbon factory when generating dates.
+     *
+     * @param  object  $factory
+     * @return void
+     */
+    public static function useFactory($factory)
+    {
+        static::$factory = $factory;
+
+        static::$dateClass = null;
+        static::$callable = null;
+    }
+
+    /**
+     * Handle dynamic calls to generate dates.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     *
+     * @throws \RuntimeException
+     */
+    public function __call($method, $parameters)
+    {
+        $defaultClassName = static::DEFAULT_CLASS_NAME;
+
+        // Using callable to generate dates...
+        if (static::$callable) {
+            return call_user_func(static::$callable, $defaultClassName::$method(...$parameters));
+        }
+
+        // Using Carbon factory to generate dates...
+        if (static::$factory) {
+            return static::$factory->$method(...$parameters);
+        }
+
+        $dateClass = static::$dateClass ?: $defaultClassName;
+
+        // Check if the date can be created using the public class method...
+        if (method_exists($dateClass, $method) ||
+            method_exists($dateClass, 'hasMacro') && $dateClass::hasMacro($method)) {
+            return $dateClass::$method(...$parameters);
+        }
+
+        // If that fails, create the date with the default class...
+        $date = $defaultClassName::$method(...$parameters);
+
+        // If the configured class has an "instance" method, we'll try to pass our date into there...
+        if (method_exists($dateClass, 'instance')) {
+            return $dateClass::instance($date);
+        }
+
+        // Otherwise, assume the configured class has a DateTime compatible constructor...
+        return new $dateClass($date->format('Y-m-d H:i:s.u'), $date->getTimezone());
+    }
+}

vendor/illuminate/support/Env.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Dotenv\Repository\Adapter\PutenvAdapter;
+use Dotenv\Repository\RepositoryBuilder;
+use PhpOption\Option;
+
+class Env
+{
+    /**
+     * Indicates if the putenv adapter is enabled.
+     *
+     * @var bool
+     */
+    protected static $putenv = true;
+
+    /**
+     * The environment repository instance.
+     *
+     * @var \Dotenv\Repository\RepositoryInterface|null
+     */
+    protected static $repository;
+
+    /**
+     * Enable the putenv adapter.
+     *
+     * @return void
+     */
+    public static function enablePutenv()
+    {
+        static::$putenv = true;
+        static::$repository = null;
+    }
+
+    /**
+     * Disable the putenv adapter.
+     *
+     * @return void
+     */
+    public static function disablePutenv()
+    {
+        static::$putenv = false;
+        static::$repository = null;
+    }
+
+    /**
+     * Get the environment repository instance.
+     *
+     * @return \Dotenv\Repository\RepositoryInterface
+     */
+    public static function getRepository()
+    {
+        if (static::$repository === null) {
+            $builder = RepositoryBuilder::createWithDefaultAdapters();
+
+            if (static::$putenv) {
+                $builder = $builder->addAdapter(PutenvAdapter::class);
+            }
+
+            static::$repository = $builder->immutable()->make();
+        }
+
+        return static::$repository;
+    }
+
+    /**
+     * Gets the value of an environment variable.
+     *
+     * @param  string  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    public static function get($key, $default = null)
+    {
+        return Option::fromValue(static::getRepository()->get($key))
+            ->map(function ($value) {
+                switch (strtolower($value)) {
+                    case 'true':
+                    case '(true)':
+                        return true;
+                    case 'false':
+                    case '(false)':
+                        return false;
+                    case 'empty':
+                    case '(empty)':
+                        return '';
+                    case 'null':
+                    case '(null)':
+                        return;
+                }
+
+                if (preg_match('/\A([\'"])(.*)\1\z/', $value, $matches)) {
+                    return $matches[2];
+                }
+
+                return $value;
+            })
+            ->getOrCall(fn () => value($default));
+    }
+}

vendor/illuminate/support/Facades/App.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Contracts\Foundation\Application loadEnvironmentFrom(string $file)
+ * @method static \Illuminate\Support\ServiceProvider register(\Illuminate\Support\ServiceProvider|string $provider, bool $force = false)
+ * @method static \Illuminate\Support\ServiceProvider resolveProvider(string $provider)
+ * @method static array getProviders(\Illuminate\Support\ServiceProvider|string $provider)
+ * @method static mixed make($abstract, array $parameters = [])
+ * @method static mixed makeWith($abstract, array $parameters = [])
+ * @method static bool configurationIsCached()
+ * @method static bool hasBeenBootstrapped()
+ * @method static bool isDownForMaintenance()
+ * @method static bool isLocal()
+ * @method static bool isProduction()
+ * @method static bool routesAreCached()
+ * @method static bool runningInConsole()
+ * @method static bool runningUnitTests()
+ * @method static bool shouldSkipMiddleware()
+ * @method static string basePath(string $path = '')
+ * @method static string bootstrapPath(string $path = '')
+ * @method static string configPath(string $path = '')
+ * @method static string databasePath(string $path = '')
+ * @method static string detectEnvironment(callable $callback)
+ * @method static string environmentFile()
+ * @method static string environmentFilePath()
+ * @method static string environmentPath()
+ * @method static void forgetInstance(string $abstract)
+ * @method static string getCachedConfigPath()
+ * @method static string getCachedPackagesPath()
+ * @method static string getCachedRoutesPath()
+ * @method static string getCachedServicesPath()
+ * @method static string getLocale()
+ * @method static string currentLocale()
+ * @method static string getNamespace()
+ * @method static string resourcePath(string $path = '')
+ * @method static string storagePath(string $path = '')
+ * @method static string version()
+ * @method static string|bool environment(string|array ...$environments)
+ * @method static never abort(int $code, string $message = '', array $headers = [])
+ * @method static void boot()
+ * @method static void booted(callable $callback)
+ * @method static void booting(callable $callback)
+ * @method static void bootstrapWith(array $bootstrappers)
+ * @method static void loadDeferredProviders()
+ * @method static void registerConfiguredProviders()
+ * @method static void registerDeferredProvider(string $provider, string $service = null)
+ * @method static void setLocale(string $locale)
+ * @method static void terminate()
+ *
+ * @see \Illuminate\Contracts\Foundation\Application
+ */
+class App extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'app';
+    }
+}

vendor/illuminate/support/Facades/Artisan.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Console\Kernel as ConsoleKernelContract;
+
+/**
+ * @method static \Illuminate\Foundation\Bus\PendingDispatch queue(string $command, array $parameters = [])
+ * @method static \Illuminate\Foundation\Console\ClosureCommand command(string $command, callable $callback)
+ * @method static array all()
+ * @method static int call(string $command, array $parameters = [], \Symfony\Component\Console\Output\OutputInterface|null $outputBuffer = null)
+ * @method static int handle(\Symfony\Component\Console\Input\InputInterface $input, \Symfony\Component\Console\Output\OutputInterface|null $output = null)
+ * @method static string output()
+ * @method static void terminate(\Symfony\Component\Console\Input\InputInterface $input, int $status)
+ *
+ * @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/illuminate/support/Facades/Auth.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Laravel\Ui\UiServiceProvider;
+use RuntimeException;
+
+/**
+ * @method static \Illuminate\Auth\AuthManager extend(string $driver, \Closure $callback)
+ * @method static \Illuminate\Auth\AuthManager provider(string $name, \Closure $callback)
+ * @method static \Illuminate\Contracts\Auth\Authenticatable loginUsingId(mixed $id, bool $remember = false)
+ * @method static \Illuminate\Contracts\Auth\Authenticatable|null user()
+ * @method static \Illuminate\Contracts\Auth\Guard|\Illuminate\Contracts\Auth\StatefulGuard guard(string|null $name = null)
+ * @method static \Illuminate\Contracts\Auth\UserProvider|null createUserProvider(string $provider = null)
+ * @method static \Symfony\Component\HttpFoundation\Response|null onceBasic(string $field = 'email',array $extraConditions = [])
+ * @method static bool attempt(array $credentials = [], bool $remember = false)
+ * @method static bool hasUser()
+ * @method static bool check()
+ * @method static bool guest()
+ * @method static bool once(array $credentials = [])
+ * @method static bool onceUsingId(mixed $id)
+ * @method static bool validate(array $credentials = [])
+ * @method static bool viaRemember()
+ * @method static bool|null logoutOtherDevices(string $password, string $attribute = 'password')
+ * @method static int|string|null id()
+ * @method static void login(\Illuminate\Contracts\Auth\Authenticatable $user, bool $remember = false)
+ * @method static void logout()
+ * @method static void logoutCurrentDevice()
+ * @method static void setUser(\Illuminate\Contracts\Auth\Authenticatable $user)
+ * @method static void shouldUse(string $name);
+ *
+ * @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.
+     *
+     * @param  array  $options
+     * @return void
+     *
+     * @throws \RuntimeException
+     */
+    public static function routes(array $options = [])
+    {
+        if (! static::$app->providerIsLoaded(UiServiceProvider::class)) {
+            throw new RuntimeException('In order to use the Auth::routes() method, please install the laravel/ui package.');
+        }
+
+        static::$app->make('router')->auth($options);
+    }
+}

vendor/illuminate/support/Facades/Blade.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static array getClassComponentAliases()
+ * @method static array getCustomDirectives()
+ * @method static array getExtensions()
+ * @method static bool check(string $name, array ...$parameters)
+ * @method static string compileString(string $value)
+ * @method static string render(string $string, array $data = [], bool $deleteCachedView = false)
+ * @method static string renderComponent(\Illuminate\View\Component $component)
+ * @method static string getPath()
+ * @method static string stripParentheses(string $expression)
+ * @method static void aliasComponent(string $path, string|null $alias = null)
+ * @method static void aliasInclude(string $path, string|null $alias = null)
+ * @method static void compile(string|null $path = null)
+ * @method static void component(string $class, string|null $alias = null, string $prefix = '')
+ * @method static void components(array $components, string $prefix = '')
+ * @method static void anonymousComponentNamespace(string $directory, string $prefix = null)
+ * @method static void componentNamespace(string $prefix, string $directory = null)
+ * @method static void directive(string $name, callable $handler)
+ * @method static void extend(callable $compiler)
+ * @method static void if(string $name, callable $callback)
+ * @method static void include(string $path, string|null $alias = null)
+ * @method static void precompiler(callable $precompiler)
+ * @method static void setEchoFormat(string $format)
+ * @method static void setPath(string $path)
+ * @method static void withDoubleEncoding()
+ * @method static void withoutComponentTags()
+ * @method static void withoutDoubleEncoding()
+ * @method static void stringable(string|callable $class, callable|null $handler = null)
+ *
+ * @see \Illuminate\View\Compilers\BladeCompiler
+ */
+class Blade extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'blade.compiler';
+    }
+}

vendor/illuminate/support/Facades/Broadcast.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Broadcasting\Factory as BroadcastingFactoryContract;
+
+/**
+ * @method static \Illuminate\Broadcasting\Broadcasters\Broadcaster channel(string $channel, callable|string  $callback, array $options = [])
+ * @method static \Illuminate\Broadcasting\BroadcastManager socket($request = null)
+ * @method static \Illuminate\Contracts\Broadcasting\Broadcaster connection($name = null);
+ * @method static mixed auth(\Illuminate\Http\Request $request)
+ * @method static void resolveAuthenticatedUserUsing(Closure $callback)
+ * @method static void routes(array $attributes = null)
+ *
+ * @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/illuminate/support/Facades/Bus.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Bus\Dispatcher as BusDispatcherContract;
+use Illuminate\Foundation\Bus\PendingChain;
+use Illuminate\Support\Testing\Fakes\BusFake;
+
+/**
+ * @method static \Illuminate\Bus\Batch|null findBatch(string $batchId)
+ * @method static \Illuminate\Bus\PendingBatch batch(array|mixed $jobs)
+ * @method static \Illuminate\Contracts\Bus\Dispatcher map(array $map)
+ * @method static \Illuminate\Contracts\Bus\Dispatcher pipeThrough(array $pipes)
+ * @method static \Illuminate\Foundation\Bus\PendingChain chain(array $jobs)
+ * @method static bool hasCommandHandler($command)
+ * @method static bool|mixed getCommandHandler($command)
+ * @method static mixed dispatch($command)
+ * @method static mixed dispatchNow($command, $handler = null)
+ * @method static mixed dispatchSync($command, $handler = null)
+ * @method static void assertDispatched(string|\Closure $command, callable|int $callback = null)
+ * @method static void assertDispatchedTimes(string $command, int $times = 1)
+ * @method static void assertNotDispatched(string|\Closure $command, callable|int $callback = null)
+ * @method static void assertDispatchedAfterResponse(string|\Closure $command, callable|int $callback = null)
+ * @method static void assertDispatchedAfterResponseTimes(string $command, int $times = 1)
+ * @method static void assertNotDispatchedAfterResponse(string|\Closure $command, callable $callback = null)
+ * @method static void assertBatched(callable $callback)
+ * @method static void assertBatchCount(int $count)
+ * @method static void assertChained(array $expectedChain)
+ * @method static void assertDispatchedSync(string|\Closure $command, callable $callback = null)
+ * @method static void assertDispatchedSyncTimes(string $command, int $times = 1)
+ * @method static void assertNotDispatchedSync(string|\Closure $command, callable $callback = null)
+ * @method static void assertDispatchedWithoutChain(string|\Closure $command, callable $callback = null)
+ *
+ * @see \Illuminate\Contracts\Bus\Dispatcher
+ */
+class Bus extends Facade
+{
+    /**
+     * Replace the bound instance with a fake.
+     *
+     * @param  array|string  $jobsToFake
+     * @return \Illuminate\Support\Testing\Fakes\BusFake
+     */
+    public static function fake($jobsToFake = [])
+    {
+        static::swap($fake = new BusFake(static::getFacadeRoot(), $jobsToFake));
+
+        return $fake;
+    }
+
+    /**
+     * Dispatch the given chain of jobs.
+     *
+     * @param  array|mixed  $jobs
+     * @return \Illuminate\Foundation\Bus\PendingDispatch
+     */
+    public static function dispatchChain($jobs)
+    {
+        $jobs = is_array($jobs) ? $jobs : func_get_args();
+
+        return (new PendingChain(array_shift($jobs), $jobs))
+                    ->dispatch();
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return BusDispatcherContract::class;
+    }
+}

vendor/illuminate/support/Facades/Cache.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Cache\TaggedCache tags(array|mixed $names)
+ * @method static \Illuminate\Contracts\Cache\Lock lock(string $name, int $seconds = 0, mixed $owner = null)
+ * @method static \Illuminate\Contracts\Cache\Lock restoreLock(string $name, string $owner)
+ * @method static \Illuminate\Contracts\Cache\Repository  store(string|null $name = null)
+ * @method static \Illuminate\Contracts\Cache\Store getStore()
+ * @method static bool add(string $key, $value, \DateTimeInterface|\DateInterval|int $ttl = null)
+ * @method static bool flush()
+ * @method static bool forever(string $key, $value)
+ * @method static bool forget(string $key)
+ * @method static bool has(string $key)
+ * @method static bool missing(string $key)
+ * @method static bool put(array|string $key, $value, \DateTimeInterface|\DateInterval|int $ttl = null)
+ * @method static int|bool decrement(string $key, $value = 1)
+ * @method static int|bool increment(string $key, $value = 1)
+ * @method static mixed get(array|string $key, mixed $default = null)
+ * @method static mixed pull(string $key, mixed $default = null)
+ * @method static mixed remember(string $key, \DateTimeInterface|\DateInterval|int $ttl, \Closure $callback)
+ * @method static mixed rememberForever(string $key, \Closure $callback)
+ * @method static mixed sear(string $key, \Closure $callback)
+ *
+ * @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/illuminate/support/Facades/Config.php

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

vendor/illuminate/support/Facades/Cookie.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static array getQueuedCookies()
+ * @method static unqueue($name)
+ * @method static void queue(...$parameters)
+ *
+ * @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|null  $key
+     * @param  mixed  $default
+     * @return string|array|null
+     */
+    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/illuminate/support/Facades/Crypt.php

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

vendor/illuminate/support/Facades/DB.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Doctrine\DBAL\Driver\PDOConnection getPdo()
+ * @method static \Illuminate\Database\ConnectionInterface connection(string $name = null)
+ * @method static \Illuminate\Database\Query\Builder table(string $table, string $as = null)
+ * @method static \Illuminate\Database\Query\Builder query()
+ * @method static \Illuminate\Database\Query\Expression raw($value)
+ * @method static array getQueryLog()
+ * @method static array prepareBindings(array $bindings)
+ * @method static array pretend(\Closure $callback)
+ * @method static array select(string $query, array $bindings = [], bool $useReadPdo = true)
+ * @method static bool insert(string $query, array $bindings = [])
+ * @method static bool logging()
+ * @method static bool statement(string $query, array $bindings = [])
+ * @method static bool unprepared(string $query)
+ * @method static int affectingStatement(string $query, array $bindings = [])
+ * @method static int delete(string $query, array $bindings = [])
+ * @method static int transactionLevel()
+ * @method static int update(string $query, array $bindings = [])
+ * @method static mixed selectOne(string $query, array $bindings = [], bool $useReadPdo = true)
+ * @method static mixed transaction(\Closure $callback, int $attempts = 1)
+ * @method static string getDefaultConnection()
+ * @method static void afterCommit(\Closure $callback)
+ * @method static void beginTransaction()
+ * @method static void commit()
+ * @method static void enableQueryLog()
+ * @method static void disableQueryLog()
+ * @method static void flushQueryLog()
+ * @method static void registerDoctrineType(string $class, string $name, string $type)
+ * @method static \Illuminate\Database\Connection beforeExecuting(\Closure $callback)
+ * @method static void listen(\Closure $callback)
+ * @method static void rollBack(int $toLevel = null)
+ * @method static void setDefaultConnection(string $name)
+ *
+ * @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/illuminate/support/Facades/Date.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Support\DateFactory;
+
+/**
+ * @see https://carbon.nesbot.com/docs/
+ * @see https://github.com/briannesbitt/Carbon/blob/master/src/Carbon/Factory.php
+ *
+ * @method static \Illuminate\Support\Carbon create($year = 0, $month = 1, $day = 1, $hour = 0, $minute = 0, $second = 0, $tz = null)
+ * @method static \Illuminate\Support\Carbon createFromDate($year = null, $month = null, $day = null, $tz = null)
+ * @method static \Illuminate\Support\Carbon createFromTime($hour = 0, $minute = 0, $second = 0, $tz = null)
+ * @method static \Illuminate\Support\Carbon createFromTimeString($time, $tz = null)
+ * @method static \Illuminate\Support\Carbon createFromTimestamp($timestamp, $tz = null)
+ * @method static \Illuminate\Support\Carbon createFromTimestampMs($timestamp, $tz = null)
+ * @method static \Illuminate\Support\Carbon createFromTimestampUTC($timestamp)
+ * @method static \Illuminate\Support\Carbon createMidnightDate($year = null, $month = null, $day = null, $tz = null)
+ * @method static void disableHumanDiffOption($humanDiffOption)
+ * @method static void enableHumanDiffOption($humanDiffOption)
+ * @method static \Illuminate\Support\Carbon fromSerialized($value)
+ * @method static array getLastErrors()
+ * @method static \Illuminate\Support\Carbon|null getTestNow()
+ * @method static \Illuminate\Support\Carbon instance($date)
+ * @method static bool isMutable()
+ * @method static \Illuminate\Support\Carbon maxValue()
+ * @method static \Illuminate\Support\Carbon minValue()
+ * @method static \Illuminate\Support\Carbon now($tz = null)
+ * @method static \Illuminate\Support\Carbon parse($time = null, $tz = null)
+ * @method static void setHumanDiffOptions($humanDiffOptions)
+ * @method static void setTestNow($testNow = null)
+ * @method static void setUtf8($utf8)
+ * @method static \Illuminate\Support\Carbon today($tz = null)
+ * @method static \Illuminate\Support\Carbon tomorrow($tz = null)
+ * @method static void useStrictMode($strictModeEnabled = true)
+ * @method static \Illuminate\Support\Carbon yesterday($tz = null)
+ * @method static \Illuminate\Support\Carbon|false createFromFormat($format, $time, $tz = null)
+ * @method static \Illuminate\Support\Carbon|false createSafe($year = null, $month = null, $day = null, $hour = null, $minute = null, $second = null, $tz = null)
+ * @method static \Illuminate\Support\Carbon|null make($var)
+ * @method static \Symfony\Component\Translation\TranslatorInterface getTranslator()
+ * @method static array getAvailableLocales()
+ * @method static array getDays()
+ * @method static array getIsoUnits()
+ * @method static array getWeekendDays()
+ * @method static bool hasFormat($date, $format)
+ * @method static bool hasMacro($name)
+ * @method static bool hasRelativeKeywords($time)
+ * @method static bool hasTestNow()
+ * @method static bool isImmutable()
+ * @method static bool isModifiableUnit($unit)
+ * @method static bool isStrictModeEnabled()
+ * @method static bool localeHasDiffOneDayWords($locale)
+ * @method static bool localeHasDiffSyntax($locale)
+ * @method static bool localeHasDiffTwoDayWords($locale)
+ * @method static bool localeHasPeriodSyntax($locale)
+ * @method static bool localeHasShortUnits($locale)
+ * @method static bool setLocale($locale)
+ * @method static bool shouldOverflowMonths()
+ * @method static bool shouldOverflowYears()
+ * @method static int getHumanDiffOptions()
+ * @method static int getMidDayAt()
+ * @method static int getWeekEndsAt()
+ * @method static int getWeekStartsAt()
+ * @method static mixed executeWithLocale($locale, $func)
+ * @method static mixed use(mixed $handler)
+ * @method static string getLocale()
+ * @method static string pluralUnit(string $unit)
+ * @method static string singularUnit(string $unit)
+ * @method static void macro($name, $macro)
+ * @method static void mixin($mixin)
+ * @method static void resetMonthsOverflow()
+ * @method static void resetToStringFormat()
+ * @method static void resetYearsOverflow()
+ * @method static void serializeUsing($callback)
+ * @method static void setMidDayAt($hour)
+ * @method static void setToStringFormat($format)
+ * @method static void setTranslator(\Symfony\Component\Translation\TranslatorInterface $translator)
+ * @method static void setWeekEndsAt($day)
+ * @method static void setWeekStartsAt($day)
+ * @method static void setWeekendDays($days)
+ * @method static void useCallable(callable $callable)
+ * @method static void useClass(string $class)
+ * @method static void useDefault()
+ * @method static void useFactory(object $factory)
+ * @method static void useMonthsOverflow($monthsOverflow = true)
+ * @method static void useYearsOverflow($yearsOverflow = true)
+ */
+class Date extends Facade
+{
+    const DEFAULT_FACADE = DateFactory::class;
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     *
+     * @throws \RuntimeException
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'date';
+    }
+
+    /**
+     * Resolve the facade root instance from the container.
+     *
+     * @param  string  $name
+     * @return mixed
+     */
+    protected static function resolveFacadeInstance($name)
+    {
+        if (! isset(static::$resolvedInstance[$name]) && ! isset(static::$app, static::$app[$name])) {
+            $class = static::DEFAULT_FACADE;
+
+            static::swap(new $class);
+        }
+
+        return parent::resolveFacadeInstance($name);
+    }
+}

vendor/illuminate/support/Facades/Event.php

@@ -0,0 +1,114 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Testing\Fakes\EventFake;
+
+/**
+ * @method static \Closure createClassListener(string $listener, bool $wildcard = false)
+ * @method static \Closure makeListener(\Closure|string $listener, bool $wildcard = false)
+ * @method static \Illuminate\Events\Dispatcher setQueueResolver(callable $resolver)
+ * @method static array getListeners(string $eventName)
+ * @method static array|null dispatch(string|object $event, mixed $payload = [], bool $halt = false)
+ * @method static array|null until(string|object $event, mixed $payload = [])
+ * @method static bool hasListeners(string $eventName)
+ * @method static void assertDispatched(string|\Closure $event, callable|int $callback = null)
+ * @method static void assertDispatchedTimes(string $event, int $times = 1)
+ * @method static void assertNotDispatched(string|\Closure $event, callable|int $callback = null)
+ * @method static void assertNothingDispatched()
+ * @method static void assertListening(string $expectedEvent, string $expectedListener)
+ * @method static void flush(string $event)
+ * @method static void forget(string $event)
+ * @method static void forgetPushed()
+ * @method static void listen(\Closure|string|array $events, \Closure|string|array $listener = null)
+ * @method static void push(string $event, object|array $payload = [])
+ * @method static void subscribe(object|string $subscriber)
+ *
+ * @see \Illuminate\Events\Dispatcher
+ */
+class Event extends Facade
+{
+    /**
+     * Replace the bound instance with a fake.
+     *
+     * @param  array|string  $eventsToFake
+     * @return \Illuminate\Support\Testing\Fakes\EventFake
+     */
+    public static function fake($eventsToFake = [])
+    {
+        static::swap($fake = new EventFake(static::getFacadeRoot(), $eventsToFake));
+
+        Model::setEventDispatcher($fake);
+        Cache::refreshEventDispatcher();
+
+        return $fake;
+    }
+
+    /**
+     * Replace the bound instance with a fake that fakes all events except the given events.
+     *
+     * @param  string[]|string  $eventsToAllow
+     * @return \Illuminate\Support\Testing\Fakes\EventFake
+     */
+    public static function fakeExcept($eventsToAllow)
+    {
+        return static::fake([
+            function ($eventName) use ($eventsToAllow) {
+                return ! in_array($eventName, (array) $eventsToAllow);
+            },
+        ]);
+    }
+
+    /**
+     * Replace the bound instance with a fake during the given callable's execution.
+     *
+     * @param  callable  $callable
+     * @param  array  $eventsToFake
+     * @return mixed
+     */
+    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);
+            Cache::refreshEventDispatcher();
+        });
+    }
+
+    /**
+     * Replace the bound instance with a fake during the given callable's execution.
+     *
+     * @param  callable  $callable
+     * @param  array  $eventsToAllow
+     * @return mixed
+     */
+    public static function fakeExceptFor(callable $callable, array $eventsToAllow = [])
+    {
+        $originalDispatcher = static::getFacadeRoot();
+
+        static::fakeExcept($eventsToAllow);
+
+        return tap($callable(), function () use ($originalDispatcher) {
+            static::swap($originalDispatcher);
+
+            Model::setEventDispatcher($originalDispatcher);
+            Cache::refreshEventDispatcher();
+        });
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'events';
+    }
+}

vendor/illuminate/support/Facades/Facade.php

@@ -0,0 +1,339 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Closure;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Js;
+use Illuminate\Support\Str;
+use Mockery;
+use Mockery\LegacyMockInterface;
+use RuntimeException;
+
+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;
+
+    /**
+     * Indicates if the resolved instance should be cached.
+     *
+     * @var bool
+     */
+    protected static $cached = true;
+
+    /**
+     * Run a Closure when the facade has been resolved.
+     *
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public static function resolved(Closure $callback)
+    {
+        $accessor = static::getFacadeAccessor();
+
+        if (static::$app->resolved($accessor) === true) {
+            $callback(static::getFacadeRoot());
+        }
+
+        static::$app->afterResolving($accessor, function ($service) use ($callback) {
+            $callback($service);
+        });
+    }
+
+    /**
+     * Convert the facade into a Mockery spy.
+     *
+     * @return \Mockery\MockInterface
+     */
+    public static function spy()
+    {
+        if (! static::isMock()) {
+            $class = static::getMockableClass();
+
+            return tap($class ? Mockery::spy($class) : Mockery::spy(), function ($spy) {
+                static::swap($spy);
+            });
+        }
+    }
+
+    /**
+     * Initiate a partial mock on the facade.
+     *
+     * @return \Mockery\MockInterface
+     */
+    public static function partialMock()
+    {
+        $name = static::getFacadeAccessor();
+
+        $mock = static::isMock()
+            ? static::$resolvedInstance[$name]
+            : static::createFreshMockInstance();
+
+        return $mock->makePartial();
+    }
+
+    /**
+     * 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());
+    }
+
+    /**
+     * Initiate a mock expectation on the facade.
+     *
+     * @return \Mockery\Expectation
+     */
+    public static function expects()
+    {
+        $name = static::getFacadeAccessor();
+
+        $mock = static::isMock()
+            ? static::$resolvedInstance[$name]
+            : static::createFreshMockInstance();
+
+        return $mock->expects(...func_get_args());
+    }
+
+    /**
+     * Create a fresh mock instance for the given class.
+     *
+     * @return \Mockery\MockInterface
+     */
+    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 LegacyMockInterface;
+    }
+
+    /**
+     * 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  $name
+     * @return mixed
+     */
+    protected static function resolveFacadeInstance($name)
+    {
+        if (isset(static::$resolvedInstance[$name])) {
+            return static::$resolvedInstance[$name];
+        }
+
+        if (static::$app) {
+            if (static::$cached) {
+                return static::$resolvedInstance[$name] = static::$app[$name];
+            }
+
+            return 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 default aliases.
+     *
+     * @return \Illuminate\Support\Collection
+     */
+    public static function defaultAliases()
+    {
+        return collect([
+            'App' => App::class,
+            'Arr' => Arr::class,
+            'Artisan' => Artisan::class,
+            'Auth' => Auth::class,
+            'Blade' => Blade::class,
+            'Broadcast' => Broadcast::class,
+            'Bus' => Bus::class,
+            'Cache' => Cache::class,
+            'Config' => Config::class,
+            'Cookie' => Cookie::class,
+            'Crypt' => Crypt::class,
+            'Date' => Date::class,
+            'DB' => DB::class,
+            'Eloquent' => Model::class,
+            'Event' => Event::class,
+            'File' => File::class,
+            'Gate' => Gate::class,
+            'Hash' => Hash::class,
+            'Http' => Http::class,
+            'Js' => Js::class,
+            'Lang' => Lang::class,
+            'Log' => Log::class,
+            'Mail' => Mail::class,
+            'Notification' => Notification::class,
+            'Password' => Password::class,
+            'Queue' => Queue::class,
+            'RateLimiter' => RateLimiter::class,
+            'Redirect' => Redirect::class,
+            'Request' => Request::class,
+            'Response' => Response::class,
+            'Route' => Route::class,
+            'Schema' => Schema::class,
+            'Session' => Session::class,
+            'Storage' => Storage::class,
+            'Str' => Str::class,
+            'URL' => URL::class,
+            'Validator' => Validator::class,
+            'View' => View::class,
+        ]);
+    }
+
+    /**
+     * 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/illuminate/support/Facades/File.php

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

vendor/illuminate/support/Facades/Gate.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Auth\Access\Gate as GateContract;
+
+/**
+ * @method static \Illuminate\Auth\Access\Gate guessPolicyNamesUsing(callable $callback)
+ * @method static \Illuminate\Auth\Access\Response authorize(string $ability, array|mixed $arguments = [])
+ * @method static \Illuminate\Auth\Access\Response inspect(string $ability, array|mixed $arguments = [])
+ * @method static \Illuminate\Auth\Access\Response allowIf(\Closure|bool $condition, string|null $message = null, mixed $code = null)
+ * @method static \Illuminate\Auth\Access\Response denyIf(\Closure|bool $condition, string|null $message = null, mixed $code = null)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate after(callable $callback)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate before(callable $callback)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate define(string $ability, callable|string $callback)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate forUser(\Illuminate\Contracts\Auth\Authenticatable|mixed $user)
+ * @method static \Illuminate\Contracts\Auth\Access\Gate policy(string $class, string $policy)
+ * @method static array abilities()
+ * @method static bool allows(string $ability, array|mixed $arguments = [])
+ * @method static bool any(iterable|string $abilities, array|mixed $arguments = [])
+ * @method static bool check(iterable|string $abilities, array|mixed $arguments = [])
+ * @method static bool denies(string $ability, array|mixed $arguments = [])
+ * @method static bool has(string $ability)
+ * @method static mixed getPolicyFor(object|string $class)
+ * @method static mixed raw(string $ability, array|mixed $arguments = [])
+ *
+ * @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/illuminate/support/Facades/Hash.php

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

vendor/illuminate/support/Facades/Http.php

@@ -0,0 +1,126 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Http\Client\Factory;
+
+/**
+ * @method static \GuzzleHttp\Promise\PromiseInterface response($body = null, $status = 200, $headers = [])
+ * @method static \Illuminate\Http\Client\PendingRequest accept(string $contentType)
+ * @method static \Illuminate\Http\Client\PendingRequest acceptJson()
+ * @method static \Illuminate\Http\Client\PendingRequest asForm()
+ * @method static \Illuminate\Http\Client\PendingRequest asJson()
+ * @method static \Illuminate\Http\Client\PendingRequest asMultipart()
+ * @method static \Illuminate\Http\Client\PendingRequest async()
+ * @method static \Illuminate\Http\Client\PendingRequest attach(string|array $name, string $contents = '', string|null $filename = null, array $headers = [])
+ * @method static \Illuminate\Http\Client\PendingRequest baseUrl(string $url)
+ * @method static \Illuminate\Http\Client\PendingRequest beforeSending(callable $callback)
+ * @method static \Illuminate\Http\Client\PendingRequest bodyFormat(string $format)
+ * @method static \Illuminate\Http\Client\PendingRequest connectTimeout(int $seconds)
+ * @method static \Illuminate\Http\Client\PendingRequest contentType(string $contentType)
+ * @method static \Illuminate\Http\Client\PendingRequest dd()
+ * @method static \Illuminate\Http\Client\PendingRequest dump()
+ * @method static \Illuminate\Http\Client\PendingRequest maxRedirects(int $max)
+ * @method static \Illuminate\Http\Client\PendingRequest retry(int $times, int $sleepMilliseconds = 0, ?callable $when = null, bool $throw = true)
+ * @method static \Illuminate\Http\Client\ResponseSequence sequence(array $responses = [])
+ * @method static \Illuminate\Http\Client\PendingRequest sink(string|resource $to)
+ * @method static \Illuminate\Http\Client\PendingRequest stub(callable $callback)
+ * @method static \Illuminate\Http\Client\PendingRequest timeout(int $seconds)
+ * @method static \Illuminate\Http\Client\PendingRequest withBasicAuth(string $username, string $password)
+ * @method static \Illuminate\Http\Client\PendingRequest withBody(resource|string $content, string $contentType)
+ * @method static \Illuminate\Http\Client\PendingRequest withCookies(array $cookies, string $domain)
+ * @method static \Illuminate\Http\Client\PendingRequest withDigestAuth(string $username, string $password)
+ * @method static \Illuminate\Http\Client\PendingRequest withHeaders(array $headers)
+ * @method static \Illuminate\Http\Client\PendingRequest withMiddleware(callable $middleware)
+ * @method static \Illuminate\Http\Client\PendingRequest withOptions(array $options)
+ * @method static \Illuminate\Http\Client\PendingRequest withToken(string $token, string $type = 'Bearer')
+ * @method static \Illuminate\Http\Client\PendingRequest withUserAgent(string $userAgent)
+ * @method static \Illuminate\Http\Client\PendingRequest withoutRedirecting()
+ * @method static \Illuminate\Http\Client\PendingRequest withoutVerifying()
+ * @method static \Illuminate\Http\Client\PendingRequest throw(callable $callback = null)
+ * @method static \Illuminate\Http\Client\PendingRequest throwIf($condition)
+ * @method \Illuminate\Http\Client\PendingRequest throwUnless($condition)
+ * @method static array pool(callable $callback)
+ * @method static \Illuminate\Http\Client\Response delete(string $url, array $data = [])
+ * @method static \Illuminate\Http\Client\Response get(string $url, array|string|null $query = null)
+ * @method static \Illuminate\Http\Client\Response head(string $url, array|string|null $query = null)
+ * @method static \Illuminate\Http\Client\Response patch(string $url, array $data = [])
+ * @method static \Illuminate\Http\Client\Response post(string $url, array $data = [])
+ * @method static \Illuminate\Http\Client\Response put(string $url, array $data = [])
+ * @method static \Illuminate\Http\Client\Response send(string $method, string $url, array $options = [])
+ * @method static \Illuminate\Http\Client\Factory allowStrayRequests()
+ * @method static void assertSent(callable $callback)
+ * @method static void assertSentInOrder(array $callbacks)
+ * @method static void assertNotSent(callable $callback)
+ * @method static void assertNothingSent()
+ * @method static void assertSentCount(int $count)
+ * @method static void assertSequencesAreEmpty()
+ *
+ * @see \Illuminate\Http\Client\Factory
+ */
+class Http extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return Factory::class;
+    }
+
+    /**
+     * Register a stub callable that will intercept requests and be able to return stub responses.
+     *
+     * @param  \Closure|array  $callback
+     * @return \Illuminate\Http\Client\Factory
+     */
+    public static function fake($callback = null)
+    {
+        return tap(static::getFacadeRoot(), function ($fake) use ($callback) {
+            static::swap($fake->fake($callback));
+        });
+    }
+
+    /**
+     * Register a response sequence for the given URL pattern.
+     *
+     * @param  string  $urlPattern
+     * @return \Illuminate\Http\Client\ResponseSequence
+     */
+    public static function fakeSequence(string $urlPattern = '*')
+    {
+        $fake = tap(static::getFacadeRoot(), function ($fake) {
+            static::swap($fake);
+        });
+
+        return $fake->fakeSequence($urlPattern);
+    }
+
+    /**
+     * Indicate that an exception should be thrown if any request is not faked.
+     *
+     * @return \Illuminate\Http\Client\Factory
+     */
+    public static function preventStrayRequests()
+    {
+        return tap(static::getFacadeRoot(), function ($fake) {
+            static::swap($fake->preventStrayRequests());
+        });
+    }
+
+    /**
+     * Stub the given URL using the given callback.
+     *
+     * @param  string  $url
+     * @param  \Illuminate\Http\Client\Response|\GuzzleHttp\Promise\PromiseInterface|callable  $callback
+     * @return \Illuminate\Http\Client\Factory
+     */
+    public static function stubUrl($url, $callback)
+    {
+        return tap(static::getFacadeRoot(), function ($fake) use ($url, $callback) {
+            static::swap($fake->stubUrl($url, $callback));
+        });
+    }
+}

vendor/illuminate/support/Facades/Lang.php

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

vendor/illuminate/support/Facades/Log.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Psr\Log\LoggerInterface channel(string $channel = null)
+ * @method static \Psr\Log\LoggerInterface stack(array $channels, string $channel = null)
+ * @method static \Psr\Log\LoggerInterface build(array $config)
+ * @method static \Illuminate\Log\Logger withContext(array $context = [])
+ * @method static \Illuminate\Log\Logger withoutContext()
+ * @method static \Illuminate\Log\LogManager shareContext(array $context)
+ * @method static array sharedContext()
+ * @method static void alert(string $message, array $context = [])
+ * @method static void critical(string $message, array $context = [])
+ * @method static void debug(string $message, array $context = [])
+ * @method static void emergency(string $message, array $context = [])
+ * @method static void error(string $message, array $context = [])
+ * @method static void info(string $message, array $context = [])
+ * @method static void log($level, string $message, array $context = [])
+ * @method static void notice(string $message, array $context = [])
+ * @method static void warning(string $message, array $context = [])
+ * @method static void write(string $level, string $message, array $context = [])
+ * @method static void listen(\Closure $callback)
+ *
+ * @see \Illuminate\Log\Logger
+ */
+class Log extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'log';
+    }
+}

vendor/illuminate/support/Facades/Mail.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Support\Testing\Fakes\MailFake;
+
+/**
+ * @method static \Illuminate\Mail\Mailer mailer(string|null $name = null)
+ * @method static void alwaysFrom(string $address, string|null $name = null)
+ * @method static void alwaysReplyTo(string $address, string|null $name = null)
+ * @method static void alwaysReturnPath(string $address)
+ * @method static void alwaysTo(string $address, string|null $name = null)
+ * @method static \Illuminate\Mail\PendingMail bcc($users)
+ * @method static \Illuminate\Mail\PendingMail to($users)
+ * @method static \Illuminate\Support\Collection queued(string $mailable, \Closure|string $callback = null)
+ * @method static \Illuminate\Support\Collection sent(string $mailable, \Closure|string $callback = null)
+ * @method static \Illuminate\Mail\SentMessage|null raw(string $text, $callback)
+ * @method static \Illuminate\Mail\SentMessage|null plain(string $view, array $data, $callback)
+ * @method static \Illuminate\Mail\SentMessage|null html(string $html, $callback)
+ * @method static \Illuminate\Mail\SentMessage|null send(\Illuminate\Contracts\Mail\Mailable|string|array $view, array $data = [], \Closure|string $callback = null)
+ * @method static bool hasQueued(string $mailable)
+ * @method static bool hasSent(string $mailable)
+ * @method static mixed later(\DateTimeInterface|\DateInterval|int $delay, \Illuminate\Contracts\Mail\Mailable|string|array $view, string $queue = null)
+ * @method static mixed laterOn(string $queue, \DateTimeInterface|\DateInterval|int $delay, \Illuminate\Contracts\Mail\Mailable|string|array $view)
+ * @method static mixed queue(\Illuminate\Contracts\Mail\Mailable|string|array $view, string $queue = null)
+ * @method static mixed queueOn(string $queue, \Illuminate\Contracts\Mail\Mailable|string|array $view)
+ * @method static void assertNotQueued(string|\Closure $mailable, callable|null $callback = null)
+ * @method static void assertNotSent(string|\Closure $mailable, callable|null $callback = null)
+ * @method static void assertNotOutgoing(string|\Closure $mailable, callable|null $callback = null)
+ * @method static void assertNothingQueued()
+ * @method static void assertNothingSent()
+ * @method static void assertNothingOutgoing()
+ * @method static void assertQueued(string|\Closure $mailable, callable|int $callback = null)
+ * @method static void assertSent(string|\Closure $mailable, callable|int $callback = null)
+ *
+ * @see \Illuminate\Mail\Mailer
+ * @see \Illuminate\Support\Testing\Fakes\MailFake
+ */
+class Mail extends Facade
+{
+    /**
+     * Replace the bound instance with a fake.
+     *
+     * @return \Illuminate\Support\Testing\Fakes\MailFake
+     */
+    public static function fake()
+    {
+        static::swap($fake = new MailFake);
+
+        return $fake;
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'mail.manager';
+    }
+}

vendor/illuminate/support/Facades/Notification.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Notifications\AnonymousNotifiable;
+use Illuminate\Notifications\ChannelManager;
+use Illuminate\Support\Testing\Fakes\NotificationFake;
+
+/**
+ * @method static \Illuminate\Notifications\ChannelManager locale(string|null $locale)
+ * @method static \Illuminate\Support\Collection sent(mixed $notifiable, string $notification, callable $callback = null)
+ * @method static bool hasSent(mixed $notifiable, string $notification)
+ * @method static mixed channel(string|null $name = null)
+ * @method static void assertNotSentTo(mixed $notifiable, string|\Closure $notification, callable $callback = null)
+ * @method static void assertNothingSent()
+ * @method static void assertNothingSentTo(mixed $notifiable)
+ * @method static void assertSentOnDemand(string|\Closure $notification, callable $callback = null)
+ * @method static void assertSentTo(mixed $notifiable, string|\Closure $notification, callable $callback = null)
+ * @method static void assertSentOnDemandTimes(string $notification, int $times = 1)
+ * @method static void assertSentToTimes(mixed $notifiable, string $notification, int $times = 1)
+ * @method static void assertTimesSent(int $expectedCount, string $notification)
+ * @method static void send(\Illuminate\Support\Collection|array|mixed $notifiables, $notification)
+ * @method static void sendNow(\Illuminate\Support\Collection|array|mixed $notifiables, $notification)
+ *
+ * @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/illuminate/support/Facades/ParallelTesting.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static void setUpProcess(callable $callback)
+ * @method static void setUpTestCase(callable $callback)
+ * @method static void setUpTestDatabase(callable $callback)
+ * @method static void tearDownProcess(callable $callback)
+ * @method static void tearDownTestCase(callable $callback)
+ * @method static int|false token()
+ *
+ * @see \Illuminate\Testing\ParallelTesting
+ */
+class ParallelTesting extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return \Illuminate\Testing\ParallelTesting::class;
+    }
+}

vendor/illuminate/support/Facades/Password.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Auth\PasswordBroker;
+
+/**
+ * @method static mixed reset(array $credentials, \Closure $callback)
+ * @method static string sendResetLink(array $credentials, \Closure $callback = null)
+ * @method static \Illuminate\Contracts\Auth\CanResetPassword getUser(array $credentials)
+ * @method static string createToken(\Illuminate\Contracts\Auth\CanResetPassword $user)
+ * @method static void deleteToken(\Illuminate\Contracts\Auth\CanResetPassword $user)
+ * @method static bool tokenExists(\Illuminate\Contracts\Auth\CanResetPassword $user, string $token)
+ * @method static \Illuminate\Auth\Passwords\TokenRepositoryInterface getRepository()
+ * @method static \Illuminate\Contracts\Auth\PasswordBroker broker(string|null $name = null)
+ *
+ * @see \Illuminate\Auth\Passwords\PasswordBroker
+ */
+class Password extends Facade
+{
+    /**
+     * Constant representing a successfully sent reminder.
+     *
+     * @var string
+     */
+    const RESET_LINK_SENT = PasswordBroker::RESET_LINK_SENT;
+
+    /**
+     * Constant representing a successfully reset password.
+     *
+     * @var string
+     */
+    const PASSWORD_RESET = PasswordBroker::PASSWORD_RESET;
+
+    /**
+     * Constant representing the user not found response.
+     *
+     * @var string
+     */
+    const INVALID_USER = PasswordBroker::INVALID_USER;
+
+    /**
+     * Constant representing an invalid token.
+     *
+     * @var string
+     */
+    const INVALID_TOKEN = PasswordBroker::INVALID_TOKEN;
+
+    /**
+     * Constant representing a throttled reset attempt.
+     *
+     * @var string
+     */
+    const RESET_THROTTLED = PasswordBroker::RESET_THROTTLED;
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'auth.password';
+    }
+}

vendor/illuminate/support/Facades/Queue.php

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

vendor/illuminate/support/Facades/RateLimiter.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Cache\RateLimiter for(string $name, \Closure $callback)
+ * @method static \Closure limiter(string $name)
+ * @method static bool tooManyAttempts($key, $maxAttempts)
+ * @method static int hit($key, $decaySeconds = 60)
+ * @method static mixed attempts($key)
+ * @method static mixed resetAttempts($key)
+ * @method static int retriesLeft($key, $maxAttempts)
+ * @method static void clear($key)
+ * @method static int availableIn($key)
+ * @method static bool attempt($key, $maxAttempts, \Closure $callback, $decaySeconds = 60)
+ *
+ * @see \Illuminate\Cache\RateLimiter
+ */
+class RateLimiter extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return \Illuminate\Cache\RateLimiter::class;
+    }
+}

vendor/illuminate/support/Facades/Redirect.php

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

vendor/illuminate/support/Facades/Redis.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Redis\Connections\Connection connection(string $name = null)
+ * @method static \Illuminate\Redis\Limiters\ConcurrencyLimiterBuilder funnel(string $name)
+ * @method static \Illuminate\Redis\Limiters\DurationLimiterBuilder throttle(string $name)
+ *
+ * @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/illuminate/support/Facades/Request.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Closure getRouteResolver()
+ * @method static \Closure getUserResolver()
+ * @method static \Illuminate\Http\Request capture()
+ * @method static \Illuminate\Http\Request createFrom(\Illuminate\Http\Request $from, \Illuminate\Http\Request|null $to = null)
+ * @method static \Illuminate\Http\Request createFromBase(\Symfony\Component\HttpFoundation\Request $request)
+ * @method static \Illuminate\Http\Request duplicate(array|null $query = null, array|null $request = null, array|null $attributes = null, array|null $cookies = null, array|null $files = null, array|null $server = null)
+ * @method static \Illuminate\Http\Request instance()
+ * @method static \Illuminate\Http\Request merge(array $input)
+ * @method static \Illuminate\Http\Request replace(array $input)
+ * @method static \Illuminate\Http\Request setJson(\Symfony\Component\HttpFoundation\ParameterBag $json)
+ * @method static \Illuminate\Http\Request setRouteResolver(\Closure $callback)
+ * @method static \Illuminate\Http\Request setUserResolver(\Closure $callback)
+ * @method static \Illuminate\Http\UploadedFile|\Illuminate\Http\UploadedFile[]|array|null file(string|null $key = null, mixed $default = null)
+ * @method static \Illuminate\Routing\Route|object|string route(string|null $param = null, string|null $default = null)
+ * @method static \Illuminate\Session\Store session()
+ * @method static \Illuminate\Session\Store|null getSession()
+ * @method static \Symfony\Component\HttpFoundation\ParameterBag|mixed json(string|null $key = null, mixed $default = null)
+ * @method static array all(array|mixed|null $keys = null)
+ * @method static array allFiles()
+ * @method static array except(array|mixed $keys)
+ * @method static array ips()
+ * @method static array keys()
+ * @method static array only(array|mixed $keys)
+ * @method static array segments()
+ * @method static array toArray()
+ * @method static array validate(array $rules, ...$params)
+ * @method static array validateWithBag(string $errorBag, array $rules, ...$params)
+ * @method static bool accepts(string|array $contentTypes)
+ * @method static bool acceptsAnyContentType()
+ * @method static bool acceptsHtml()
+ * @method static bool acceptsJson()
+ * @method static bool ajax()
+ * @method static bool anyFilled(string|array $key)
+ * @method static bool exists(string|array $key)
+ * @method static bool expectsJson()
+ * @method static bool filled(string|array $key)
+ * @method static bool fullUrlIs(mixed ...$patterns)
+ * @method static bool has(string|array $key)
+ * @method static bool hasAny(string|array $key)
+ * @method static bool hasCookie(string $key)
+ * @method static bool hasFile(string $key)
+ * @method static bool hasHeader(string $key)
+ * @method static bool hasValidSignature(bool $absolute = true)
+ * @method static bool is(mixed ...$patterns)
+ * @method static bool isJson()
+ * @method static bool matchesType(string $actual, string $type)
+ * @method static bool offsetExists(string $offset)
+ * @method static bool pjax()
+ * @method static bool prefers(string|array $contentTypes)
+ * @method static bool prefetch()
+ * @method static bool routeIs(mixed ...$patterns)
+ * @method static bool secure()
+ * @method static bool wantsJson()
+ * @method static mixed filterFiles(mixed $files)
+ * @method static mixed offsetGet(string $offset)
+ * @method static mixed user(string|null $guard = null)
+ * @method static string decodedPath()
+ * @method static string fingerprint()
+ * @method static string format($default = 'html')
+ * @method static string fullUrl()
+ * @method static string fullUrlWithQuery(array $query)
+ * @method static string method()
+ * @method static string path()
+ * @method static string root()
+ * @method static string url()
+ * @method static string userAgent()
+ * @method static string|array old(string|null $key = null, string|array|null $default = null)
+ * @method static string|array|null cookie(string|null $key = null, string|array|null $default = null)
+ * @method static string|array|null header(string|null $key = null, string|array|null $default = null)
+ * @method static string|array|null input(string|null $key = null, string|array|null $default = null)
+ * @method static string|array|null post(string|null $key = null, string|array|null $default = null)
+ * @method static string|array|null query(string|null $key = null, string|array|null $default = null)
+ * @method static string|array|null server(string|null $key = null, string|array|null $default = null)
+ * @method static string|null bearerToken()
+ * @method static string|null ip()
+ * @method static string|null segment(int $index, string|null $default = null)
+ * @method static void flash()
+ * @method static void flashExcept(array|mixed $keys)
+ * @method static void flashOnly(array|mixed $keys)
+ * @method static void flush()
+ * @method static void offsetSet(string $offset, mixed $value)
+ * @method static void offsetUnset(string $offset)
+ * @method static void setLaravelSession(\Illuminate\Contracts\Session\Session $session)
+ *
+ * @see \Illuminate\Http\Request
+ */
+class Request extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'request';
+    }
+}

vendor/illuminate/support/Facades/Response.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Contracts\Routing\ResponseFactory as ResponseFactoryContract;
+
+/**
+ * @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 \Illuminate\Http\RedirectResponse redirectGuest(string $path, int $status = 302, array $headers = [], bool|null $secure = null)
+ * @method static \Illuminate\Http\RedirectResponse redirectTo(string $path, int $status = 302, array $headers = [], bool|null $secure = null)
+ * @method static \Illuminate\Http\RedirectResponse redirectToAction(string $action, mixed $parameters = [], int $status = 302, array $headers = [])
+ * @method static \Illuminate\Http\RedirectResponse redirectToIntended(string $default = '/', int $status = 302, array $headers = [], bool|null $secure = null)
+ * @method static \Illuminate\Http\RedirectResponse redirectToRoute(string $route, mixed $parameters = [], int $status = 302, array $headers = [])
+ * @method static \Illuminate\Http\Response make(array|string $content = '', int $status = 200, array $headers = [])
+ * @method static \Illuminate\Http\Response noContent($status = 204, array $headers = [])
+ * @method static \Illuminate\Http\Response view(string $view, array $data = [], int $status = 200, array $headers = [])
+ * @method static \Symfony\Component\HttpFoundation\BinaryFileResponse download(\SplFileInfo|string $file, string|null $name = null, array $headers = [], string|null $disposition = 'attachment')
+ * @method static \Symfony\Component\HttpFoundation\BinaryFileResponse file($file, array $headers = [])
+ * @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')
+ *
+ * @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/illuminate/support/Facades/Route.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Routing\PendingResourceRegistration apiResource(string $name, string $controller, array $options = [])
+ * @method static \Illuminate\Routing\PendingResourceRegistration resource(string $name, string $controller, array $options = [])
+ * @method static \Illuminate\Routing\Route any(string $uri, array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route|null current()
+ * @method static \Illuminate\Routing\Route delete(string $uri, array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route fallback(array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route get(string $uri, array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route|null getCurrentRoute()
+ * @method static \Illuminate\Routing\RouteCollectionInterface getRoutes()
+ * @method static \Illuminate\Routing\Route match(array|string $methods, string $uri, array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route options(string $uri, array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route patch(string $uri, array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route permanentRedirect(string $uri, string $destination)
+ * @method static \Illuminate\Routing\Route post(string $uri, array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route put(string $uri, array|string|callable|null $action = null)
+ * @method static \Illuminate\Routing\Route redirect(string $uri, string $destination, int $status = 302)
+ * @method static \Illuminate\Routing\Route substituteBindings(\Illuminate\Support\Facades\Route $route)
+ * @method static \Illuminate\Routing\Route view(string $uri, string $view, array $data = [], int|array $status = 200, array $headers = [])
+ * @method static \Illuminate\Routing\RouteRegistrar as(string $value)
+ * @method static \Illuminate\Routing\RouteRegistrar controller(string $controller)
+ * @method static \Illuminate\Routing\RouteRegistrar domain(string $value)
+ * @method static \Illuminate\Routing\RouteRegistrar middleware(array|string|null $middleware)
+ * @method static \Illuminate\Routing\RouteRegistrar name(string $value)
+ * @method static \Illuminate\Routing\RouteRegistrar namespace(string|null $value)
+ * @method static \Illuminate\Routing\RouteRegistrar prefix(string $prefix)
+ * @method static \Illuminate\Routing\RouteRegistrar scopeBindings()
+ * @method static \Illuminate\Routing\RouteRegistrar where(array $where)
+ * @method static \Illuminate\Routing\RouteRegistrar withoutMiddleware(array|string $middleware)
+ * @method static \Illuminate\Routing\Router|\Illuminate\Routing\RouteRegistrar group(\Closure|string|array $attributes, \Closure|string $routes)
+ * @method static \Illuminate\Routing\ResourceRegistrar resourceVerbs(array $verbs = [])
+ * @method static string|null currentRouteAction()
+ * @method static string|null currentRouteName()
+ * @method static void apiResources(array $resources, array $options = [])
+ * @method static void bind(string $key, string|callable $binder)
+ * @method static void macro(string $name, object|callable $macro)
+ * @method static void model(string $key, string $class, \Closure|null $callback = null)
+ * @method static void pattern(string $key, string $pattern)
+ * @method static void resources(array $resources, array $options = [])
+ * @method static void substituteImplicitBindings(\Illuminate\Support\Facades\Route $route)
+ * @method static boolean uses(...$patterns)
+ * @method static boolean is(...$patterns)
+ * @method static boolean has(string $name)
+ * @method static mixed input(string $key, string|null $default = null)
+ *
+ * @see \Illuminate\Routing\Router
+ */
+class Route extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'router';
+    }
+}

vendor/illuminate/support/Facades/Schema.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Database\Schema\Builder create(string $table, \Closure $callback)
+ * @method static \Illuminate\Database\Schema\Builder createDatabase(string $name)
+ * @method static \Illuminate\Database\Schema\Builder disableForeignKeyConstraints()
+ * @method static \Illuminate\Database\Schema\Builder drop(string $table)
+ * @method static \Illuminate\Database\Schema\Builder dropDatabaseIfExists(string $name)
+ * @method static \Illuminate\Database\Schema\Builder dropIfExists(string $table)
+ * @method static \Illuminate\Database\Schema\Builder enableForeignKeyConstraints()
+ * @method static \Illuminate\Database\Schema\Builder rename(string $from, string $to)
+ * @method static \Illuminate\Database\Schema\Builder table(string $table, \Closure $callback)
+ * @method static bool hasColumn(string $table, string $column)
+ * @method static bool hasColumns(string $table, array $columns)
+ * @method static bool dropColumns(string $table, array $columns)
+ * @method static void whenTableHasColumn(string $table, string $column, \Closure $callback)
+ * @method static void whenTableDoesntHaveColumn(string $table, string $column, \Closure $callback)
+ * @method static bool hasTable(string $table)
+ * @method static void defaultStringLength(int $length)
+ * @method static array getColumnListing(string $table)
+ * @method static string getColumnType(string $table, string $column)
+ * @method static void morphUsingUuids()
+ * @method static \Illuminate\Database\Connection getConnection()
+ * @method static \Illuminate\Database\Schema\Builder setConnection(\Illuminate\Database\Connection $connection)
+ *
+ * @see \Illuminate\Database\Schema\Builder
+ */
+class Schema extends Facade
+{
+    /**
+     * Indicates if the resolved facade should be cached.
+     *
+     * @var bool
+     */
+    protected static $cached = false;
+
+    /**
+     * Get a schema builder instance for a connection.
+     *
+     * @param  string|null  $name
+     * @return \Illuminate\Database\Schema\Builder
+     */
+    public static function connection($name)
+    {
+        return static::$app['db']->connection($name)->getSchemaBuilder();
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'db.schema';
+    }
+}

vendor/illuminate/support/Facades/Session.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \SessionHandlerInterface getHandler()
+ * @method static array all()
+ * @method static bool exists(string|array $key)
+ * @method static bool handlerNeedsRequest()
+ * @method static bool has(string|array $key)
+ * @method static bool isStarted()
+ * @method static bool migrate(bool $destroy = false)
+ * @method static bool save()
+ * @method static bool start()
+ * @method static mixed get(string $key, $default = null)
+ * @method static mixed flash(string $key, $value = true)
+ * @method static mixed pull(string $key, $default = null)
+ * @method static mixed remove(string $key)
+ * @method static string getId()
+ * @method static string getName()
+ * @method static string token()
+ * @method static string|null previousUrl()
+ * @method static void flush()
+ * @method static void forget(string|array $keys)
+ * @method static void push(string $key, mixed $value)
+ * @method static void put(string|array $key, $value = null)
+ * @method static void setId(string $id)
+ * @method static void setPreviousUrl(string $url)
+ * @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/illuminate/support/Facades/Storage.php

@@ -0,0 +1,106 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+use Illuminate\Filesystem\Filesystem;
+
+/**
+ * @method static \Illuminate\Contracts\Filesystem\Filesystem assertExists(string|array $path)
+ * @method static \Illuminate\Contracts\Filesystem\Filesystem assertDirectoryEmpty(string $path)
+ * @method static \Illuminate\Contracts\Filesystem\Filesystem assertMissing(string|array $path)
+ * @method static \Illuminate\Contracts\Filesystem\Filesystem cloud()
+ * @method static \Illuminate\Contracts\Filesystem\Filesystem build(string|array $root)
+ * @method static \Illuminate\Contracts\Filesystem\Filesystem disk(string|null $name = null)
+ * @method static \Illuminate\Filesystem\FilesystemManager extend(string $driver, \Closure $callback)
+ * @method static \Symfony\Component\HttpFoundation\StreamedResponse download(string $path, string|null $name = null, array|null $headers = [])
+ * @method static \Symfony\Component\HttpFoundation\StreamedResponse response(string $path, string|null $name = null, array|null $headers = [], string|null $disposition = 'inline')
+ * @method static array allDirectories(string|null $directory = null)
+ * @method static array allFiles(string|null $directory = null)
+ * @method static array directories(string|null $directory = null, bool $recursive = false)
+ * @method static array files(string|null $directory = null, bool $recursive = false)
+ * @method static bool append(string $path, string $data)
+ * @method static bool copy(string $from, string $to)
+ * @method static bool delete(string|array $paths)
+ * @method static bool deleteDirectory(string $directory)
+ * @method static bool exists(string $path)
+ * @method static bool makeDirectory(string $path)
+ * @method static bool missing(string $path)
+ * @method static bool move(string $from, string $to)
+ * @method static bool prepend(string $path, string $data)
+ * @method static bool put(string $path, \Psr\Http\Message\StreamInterface|\Illuminate\Http\File|\Illuminate\Http\UploadedFile|string|resource $contents, mixed $options = [])
+ * @method static bool setVisibility(string $path, string $visibility)
+ * @method static bool writeStream(string $path, resource $resource, array $options = [])
+ * @method static int lastModified(string $path)
+ * @method static int size(string $path)
+ * @method static resource|null readStream(string $path)
+ * @method static string get(string $path)
+ * @method static string getVisibility(string $path)
+ * @method static string path(string $path)
+ * @method static string temporaryUrl(string $path, \DateTimeInterface $expiration, array $options = [])
+ * @method static string url(string $path)
+ * @method static string|false mimeType(string $path)
+ * @method static string|false putFile(string $path, \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file, mixed $options = [])
+ * @method static string|false putFileAs(string $path, \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file, string $name, mixed $options = [])
+ * @method static void macro(string $name, object|callable $macro)
+ * @method static void buildTemporaryUrlsUsing(\Closure $callback)
+ *
+ * @see \Illuminate\Filesystem\FilesystemManager
+ */
+class Storage extends Facade
+{
+    /**
+     * Replace the given disk with a local testing disk.
+     *
+     * @param  string|null  $disk
+     * @param  array  $config
+     * @return \Illuminate\Contracts\Filesystem\Filesystem
+     */
+    public static function fake($disk = null, array $config = [])
+    {
+        $disk = $disk ?: static::$app['config']->get('filesystems.default');
+
+        $root = storage_path('framework/testing/disks/'.$disk);
+
+        if ($token = ParallelTesting::token()) {
+            $root = "{$root}_test_{$token}";
+        }
+
+        (new Filesystem)->cleanDirectory($root);
+
+        static::set($disk, $fake = static::createLocalDriver(array_merge($config, [
+            'root' => $root,
+        ])));
+
+        return tap($fake)->buildTemporaryUrlsUsing(function ($path, $expiration) {
+            return URL::to($path.'?expiration='.$expiration->getTimestamp());
+        });
+    }
+
+    /**
+     * Replace the given disk with a persistent local testing disk.
+     *
+     * @param  string|null  $disk
+     * @param  array  $config
+     * @return \Illuminate\Contracts\Filesystem\Filesystem
+     */
+    public static function persistentFake($disk = null, array $config = [])
+    {
+        $disk = $disk ?: static::$app['config']->get('filesystems.default');
+
+        static::set($disk, $fake = static::createLocalDriver(array_merge($config, [
+            'root' => storage_path('framework/testing/disks/'.$disk),
+        ])));
+
+        return $fake;
+    }
+
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'filesystem';
+    }
+}

vendor/illuminate/support/Facades/URL.php

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

vendor/illuminate/support/Facades/Validator.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Contracts\Validation\Validator make(array $data, array $rules, array $messages = [], array $customAttributes = [])
+ * @method static void includeUnvalidatedArrayKeys()
+ * @method static void excludeUnvalidatedArrayKeys()
+ * @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)
+ * @method static array validate(array $data, array $rules, array $messages = [], array $customAttributes = [])
+ *
+ * @see \Illuminate\Validation\Factory
+ */
+class Validator extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'validator';
+    }
+}

vendor/illuminate/support/Facades/View.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Illuminate\Support\Facades;
+
+/**
+ * @method static \Illuminate\Contracts\View\Factory addNamespace(string $namespace, string|array $hints)
+ * @method static \Illuminate\Contracts\View\View first(array $views, \Illuminate\Contracts\Support\Arrayable|array $data = [], array $mergeData = [])
+ * @method static \Illuminate\Contracts\View\Factory replaceNamespace(string $namespace, string|array $hints)
+ * @method static \Illuminate\Contracts\View\Factory addExtension(string $extension, string $engine, \Closure|null $resolver = null)
+ * @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 array composer(array|string $views, \Closure|string $callback)
+ * @method static array creator(array|string $views, \Closure|string $callback)
+ * @method static bool exists(string $view)
+ * @method static mixed share(array|string $key, $value = null)
+ * @method static mixed shared(string $key, $default = null)
+ *
+ * @see \Illuminate\View\Factory
+ */
+class View extends Facade
+{
+    /**
+     * Get the registered name of the component.
+     *
+     * @return string
+     */
+    protected static function getFacadeAccessor()
+    {
+        return 'view';
+    }
+}

vendor/illuminate/support/Fluent.php

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

vendor/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/illuminate/support/HtmlString.php

@@ -0,0 +1,66 @@
+<?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;
+    }
+
+    /**
+     * Determine if the given HTML string is empty.
+     *
+     * @return bool
+     */
+    public function isEmpty()
+    {
+        return $this->html === '';
+    }
+
+    /**
+     * Determine if the given HTML string is not empty.
+     *
+     * @return bool
+     */
+    public function isNotEmpty()
+    {
+        return ! $this->isEmpty();
+    }
+
+    /**
+     * Get the HTML string.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->toHtml();
+    }
+}

vendor/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()->addRealSeconds($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/illuminate/support/Js.php

@@ -0,0 +1,145 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Contracts\Support\Htmlable;
+use Illuminate\Contracts\Support\Jsonable;
+use JsonSerializable;
+
+class Js implements Htmlable
+{
+    /**
+     * The JavaScript string.
+     *
+     * @var string
+     */
+    protected $js;
+
+    /**
+     * Flags that should be used when encoding to JSON.
+     *
+     * @var int
+     */
+    protected const REQUIRED_FLAGS = JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_AMP | JSON_HEX_QUOT | JSON_THROW_ON_ERROR;
+
+    /**
+     * Create a new class instance.
+     *
+     * @param  mixed  $data
+     * @param  int|null  $flags
+     * @param  int  $depth
+     * @return void
+     *
+     * @throws \JsonException
+     */
+    public function __construct($data, $flags = 0, $depth = 512)
+    {
+        $this->js = $this->convertDataToJavaScriptExpression($data, $flags, $depth);
+    }
+
+    /**
+     * Create a new JavaScript string from the given data.
+     *
+     * @param  mixed  $data
+     * @param  int  $flags
+     * @param  int  $depth
+     * @return static
+     *
+     * @throws \JsonException
+     */
+    public static function from($data, $flags = 0, $depth = 512)
+    {
+        return new static($data, $flags, $depth);
+    }
+
+    /**
+     * Convert the given data to a JavaScript expression.
+     *
+     * @param  mixed  $data
+     * @param  int  $flags
+     * @param  int  $depth
+     * @return string
+     *
+     * @throws \JsonException
+     */
+    protected function convertDataToJavaScriptExpression($data, $flags = 0, $depth = 512)
+    {
+        if ($data instanceof self) {
+            return $data->toHtml();
+        }
+
+        $json = $this->jsonEncode($data, $flags, $depth);
+
+        if (is_string($data)) {
+            return "'".substr($json, 1, -1)."'";
+        }
+
+        return $this->convertJsonToJavaScriptExpression($json, $flags);
+    }
+
+    /**
+     * Encode the given data as JSON.
+     *
+     * @param  mixed  $data
+     * @param  int  $flags
+     * @param  int  $depth
+     * @return string
+     *
+     * @throws \JsonException
+     */
+    protected function jsonEncode($data, $flags = 0, $depth = 512)
+    {
+        if ($data instanceof Jsonable) {
+            return $data->toJson($flags | static::REQUIRED_FLAGS);
+        }
+
+        if ($data instanceof Arrayable && ! ($data instanceof JsonSerializable)) {
+            $data = $data->toArray();
+        }
+
+        return json_encode($data, $flags | static::REQUIRED_FLAGS, $depth);
+    }
+
+    /**
+     * Convert the given JSON to a JavaScript expression.
+     *
+     * @param  string  $json
+     * @param  int  $flags
+     * @return string
+     *
+     * @throws \JsonException
+     */
+    protected function convertJsonToJavaScriptExpression($json, $flags = 0)
+    {
+        if ($json === '[]' || $json === '{}') {
+            return $json;
+        }
+
+        if (Str::startsWith($json, ['"', '{', '['])) {
+            return "JSON.parse('".substr(json_encode($json, $flags | static::REQUIRED_FLAGS), 1, -1)."')";
+        }
+
+        return $json;
+    }
+
+    /**
+     * Get the string representation of the data for use in HTML.
+     *
+     * @return string
+     */
+    public function toHtml()
+    {
+        return $this->js;
+    }
+
+    /**
+     * Get the string representation of the data for use in HTML.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->toHtml();
+    }
+}

vendor/illuminate/support/LICENSE.md

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

vendor/illuminate/support/Manager.php

@@ -0,0 +1,193 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Closure;
+use Illuminate\Contracts\Container\Container;
+use InvalidArgumentException;
+
+abstract class Manager
+{
+    /**
+     * The container instance.
+     *
+     * @var \Illuminate\Contracts\Container\Container
+     */
+    protected $container;
+
+    /**
+     * The configuration repository instance.
+     *
+     * @var \Illuminate\Contracts\Config\Repository
+     */
+    protected $config;
+
+    /**
+     * 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\Contracts\Container\Container  $container
+     * @return void
+     */
+    public function __construct(Container $container)
+    {
+        $this->container = $container;
+        $this->config = $container->make('config');
+    }
+
+    /**
+     * Get the default driver name.
+     *
+     * @return string
+     */
+    abstract public function getDefaultDriver();
+
+    /**
+     * Get a driver instance.
+     *
+     * @param  string|null  $driver
+     * @return mixed
+     *
+     * @throws \InvalidArgumentException
+     */
+    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)
+    {
+        // First, we will determine if a custom driver creator exists for the given driver and
+        // if it does not we will check for a creator method for the driver. Custom creator
+        // callbacks allow developers to build their own "drivers" easily using Closures.
+        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->container);
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Get the container instance used by the manager.
+     *
+     * @return \Illuminate\Contracts\Container\Container
+     */
+    public function getContainer()
+    {
+        return $this->container;
+    }
+
+    /**
+     * Set the container instance used by the manager.
+     *
+     * @param  \Illuminate\Contracts\Container\Container  $container
+     * @return $this
+     */
+    public function setContainer(Container $container)
+    {
+        $this->container = $container;
+
+        return $this;
+    }
+
+    /**
+     * Forget all of the resolved driver instances.
+     *
+     * @return $this
+     */
+    public function forgetDrivers()
+    {
+        $this->drivers = [];
+
+        return $this;
+    }
+
+    /**
+     * 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/illuminate/support/MessageBag.php

@@ -0,0 +1,420 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Contracts\Support\Jsonable;
+use Illuminate\Contracts\Support\MessageBag as MessageBagContract;
+use Illuminate\Contracts\Support\MessageProvider;
+use JsonSerializable;
+
+class MessageBag implements 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) {
+            $value = $value instanceof Arrayable ? $value->toArray() : (array) $value;
+
+            $this->messages[$key] = array_unique($value);
+        }
+    }
+
+    /**
+     * Get the keys present in the message bag.
+     *
+     * @return array
+     */
+    public function keys()
+    {
+        return array_keys($this->messages);
+    }
+
+    /**
+     * Add a message to the message 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;
+    }
+
+    /**
+     * Add a message to the message bag if the given conditional is "true".
+     *
+     * @param  bool  $boolean
+     * @param  string  $key
+     * @param  string  $message
+     * @return $this
+     */
+    public function addIf($boolean, $key, $message)
+    {
+        return $boolean ? $this->add($key, $message) : $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 message 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|null  $key
+     * @return bool
+     */
+    public function has($key)
+    {
+        if ($this->isEmpty()) {
+            return false;
+        }
+
+        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 = [])
+    {
+        if ($this->isEmpty()) {
+            return false;
+        }
+
+        $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 message bag for a given key.
+     *
+     * @param  string|null  $key
+     * @param  string|null  $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 message bag for a given key.
+     *
+     * @param  string  $key
+     * @param  string|null  $format
+     * @return array
+     */
+    public function get($key, $format = null)
+    {
+        // If the message exists in the message bag, we will transform it and return
+        // the message. Otherwise, we will check if the key is implicit & collect
+        // all the messages that match the 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 message bag.
+     *
+     * @param  string|null  $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 message bag.
+     *
+     * @param  string|null  $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)
+    {
+        if ($format == ':message') {
+            return (array) $messages;
+        }
+
+        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 message bag.
+     *
+     * @return array
+     */
+    public function messages()
+    {
+        return $this->messages;
+    }
+
+    /**
+     * Get the raw messages in the message bag.
+     *
+     * @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 message bag.
+     *
+     * @return int
+     */
+    public function count(): int
+    {
+        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(): array
+    {
+        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/illuminate/support/MultipleInstanceManager.php

@@ -0,0 +1,191 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Closure;
+use InvalidArgumentException;
+use RuntimeException;
+
+abstract class MultipleInstanceManager
+{
+    /**
+     * The application instance.
+     *
+     * @var \Illuminate\Contracts\Foundation\Application
+     */
+    protected $app;
+
+    /**
+     * The array of resolved instances.
+     *
+     * @var array
+     */
+    protected $instances = [];
+
+    /**
+     * The registered custom instance creators.
+     *
+     * @var array
+     */
+    protected $customCreators = [];
+
+    /**
+     * Create a new manager instance.
+     *
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
+     * @return void
+     */
+    public function __construct($app)
+    {
+        $this->app = $app;
+    }
+
+    /**
+     * Get the default instance name.
+     *
+     * @return string
+     */
+    abstract public function getDefaultInstance();
+
+    /**
+     * Set the default instance name.
+     *
+     * @param  string  $name
+     * @return void
+     */
+    abstract public function setDefaultInstance($name);
+
+    /**
+     * Get the instance specific configuration.
+     *
+     * @param  string  $name
+     * @return array
+     */
+    abstract public function getInstanceConfig($name);
+
+    /**
+     * Get an instance instance by name.
+     *
+     * @param  string|null  $name
+     * @return mixed
+     */
+    public function instance($name = null)
+    {
+        $name = $name ?: $this->getDefaultInstance();
+
+        return $this->instances[$name] = $this->get($name);
+    }
+
+    /**
+     * Attempt to get an instance from the local cache.
+     *
+     * @param  string  $name
+     * @return mixed
+     */
+    protected function get($name)
+    {
+        return $this->instances[$name] ?? $this->resolve($name);
+    }
+
+    /**
+     * Resolve the given instance.
+     *
+     * @param  string  $name
+     * @return mixed
+     *
+     * @throws \InvalidArgumentException
+     */
+    protected function resolve($name)
+    {
+        $config = $this->getInstanceConfig($name);
+
+        if (is_null($config)) {
+            throw new InvalidArgumentException("Instance [{$name}] is not defined.");
+        }
+
+        if (! array_key_exists('driver', $config)) {
+            throw new RuntimeException("Instance [{$name}] does not specify a driver.");
+        }
+
+        if (isset($this->customCreators[$config['driver']])) {
+            return $this->callCustomCreator($config);
+        } else {
+            $driverMethod = 'create'.ucfirst($config['driver']).'Driver';
+
+            if (method_exists($this, $driverMethod)) {
+                return $this->{$driverMethod}($config);
+            } else {
+                throw new InvalidArgumentException("Instance driver [{$config['driver']}] is not supported.");
+            }
+        }
+    }
+
+    /**
+     * Call a custom instance creator.
+     *
+     * @param  array  $config
+     * @return mixed
+     */
+    protected function callCustomCreator(array $config)
+    {
+        return $this->customCreators[$config['driver']]($this->app, $config);
+    }
+
+    /**
+     * Unset the given instances.
+     *
+     * @param  array|string|null  $name
+     * @return $this
+     */
+    public function forgetInstance($name = null)
+    {
+        $name ??= $this->getDefaultInstance();
+
+        foreach ((array) $name as $instanceName) {
+            if (isset($this->instances[$instanceName])) {
+                unset($this->instances[$instanceName]);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Disconnect the given instance and remove from local cache.
+     *
+     * @param  string|null  $name
+     * @return void
+     */
+    public function purge($name = null)
+    {
+        $name ??= $this->getDefaultInstance();
+
+        unset($this->instances[$name]);
+    }
+
+    /**
+     * Register a custom instance creator Closure.
+     *
+     * @param  string  $name
+     * @param  \Closure  $callback
+     * @return $this
+     */
+    public function extend($name, Closure $callback)
+    {
+        $this->customCreators[$name] = $callback->bindTo($this, $this);
+
+        return $this;
+    }
+
+    /**
+     * Dynamically call the default instance.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        return $this->instance()->$method(...$parameters);
+    }
+}

vendor/illuminate/support/NamespacedItemResolver.php

@@ -0,0 +1,112 @@
+<?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 (! str_contains($key, '::')) {
+            $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)
+    {
+        [$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;
+    }
+
+    /**
+     * Flush the cache of parsed keys.
+     *
+     * @return void
+     */
+    public function flushParsedKeys()
+    {
+        $this->parsed = [];
+    }
+}

vendor/illuminate/support/Optional.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace Illuminate\Support;
+
+use ArrayAccess;
+use ArrayObject;
+use Illuminate\Support\Traits\Macroable;
+
+class Optional implements ArrayAccess
+{
+    use 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  mixed  $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): bool
+    {
+        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): mixed
+    {
+        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): void
+    {
+        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): void
+    {
+        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/illuminate/support/Pluralizer.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Doctrine\Inflector\InflectorFactory;
+
+class Pluralizer
+{
+    /**
+     * The cached inflector instance.
+     *
+     * @var static
+     */
+    protected static $inflector;
+
+    /**
+     * The language that should be used by the inflector.
+     *
+     * @var string
+     */
+    protected static $language = 'english';
+
+    /**
+     * Uncountable non-nouns word forms.
+     *
+     * Contains words supported by Doctrine/Inflector/Rules/English/Uninflected.php
+     *
+     * @var string[]
+     */
+    public static $uncountable = [
+        'cattle',
+        'kin',
+        'recommended',
+        'related',
+    ];
+
+    /**
+     * Get the plural form of an English word.
+     *
+     * @param  string  $value
+     * @param  int|array|\Countable  $count
+     * @return string
+     */
+    public static function plural($value, $count = 2)
+    {
+        if (is_countable($count)) {
+            $count = count($count);
+        }
+
+        if ((int) abs($count) === 1 || static::uncountable($value) || preg_match('/^(.*)[A-Za-z0-9\x{0080}-\x{FFFF}]$/u', $value) == 0) {
+            return $value;
+        }
+
+        $plural = static::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 = static::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 ($function($comparison) === $comparison) {
+                return $function($value);
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * Get the inflector instance.
+     *
+     * @return \Doctrine\Inflector\Inflector
+     */
+    public static function inflector()
+    {
+        if (is_null(static::$inflector)) {
+            static::$inflector = InflectorFactory::createForLanguage(static::$language)->build();
+        }
+
+        return static::$inflector;
+    }
+
+    /**
+     * Specify the language that should be used by the inflector.
+     *
+     * @param  string  $language
+     * @return void
+     */
+    public static function useLanguage(string $language)
+    {
+        static::$language = $language;
+
+        static::$inflector = null;
+    }
+}

vendor/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 (str_ends_with($part, '\\')) {
+                        $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 strlen($arg) > 2 && $char === $arg[0] && $char === $arg[strlen($arg) - 1];
+    }
+}

vendor/illuminate/support/Reflector.php

@@ -0,0 +1,162 @@
+<?php
+
+namespace Illuminate\Support;
+
+use ReflectionClass;
+use ReflectionEnum;
+use ReflectionMethod;
+use ReflectionNamedType;
+use ReflectionUnionType;
+
+class Reflector
+{
+    /**
+     * This is a PHP 7.4 compatible implementation of is_callable.
+     *
+     * @param  mixed  $var
+     * @param  bool  $syntaxOnly
+     * @return bool
+     */
+    public static function isCallable($var, $syntaxOnly = false)
+    {
+        if (! is_array($var)) {
+            return is_callable($var, $syntaxOnly);
+        }
+
+        if (! isset($var[0], $var[1]) || ! is_string($var[1] ?? null)) {
+            return false;
+        }
+
+        if ($syntaxOnly &&
+            (is_string($var[0]) || is_object($var[0])) &&
+            is_string($var[1])) {
+            return true;
+        }
+
+        $class = is_object($var[0]) ? get_class($var[0]) : $var[0];
+
+        $method = $var[1];
+
+        if (! class_exists($class)) {
+            return false;
+        }
+
+        if (method_exists($class, $method)) {
+            return (new ReflectionMethod($class, $method))->isPublic();
+        }
+
+        if (is_object($var[0]) && method_exists($class, '__call')) {
+            return (new ReflectionMethod($class, '__call'))->isPublic();
+        }
+
+        if (! is_object($var[0]) && method_exists($class, '__callStatic')) {
+            return (new ReflectionMethod($class, '__callStatic'))->isPublic();
+        }
+
+        return false;
+    }
+
+    /**
+     * Get the class name of the given parameter's type, if possible.
+     *
+     * @param  \ReflectionParameter  $parameter
+     * @return string|null
+     */
+    public static function getParameterClassName($parameter)
+    {
+        $type = $parameter->getType();
+
+        if (! $type instanceof ReflectionNamedType || $type->isBuiltin()) {
+            return;
+        }
+
+        return static::getTypeName($parameter, $type);
+    }
+
+    /**
+     * Get the class names of the given parameter's type, including union types.
+     *
+     * @param  \ReflectionParameter  $parameter
+     * @return array
+     */
+    public static function getParameterClassNames($parameter)
+    {
+        $type = $parameter->getType();
+
+        if (! $type instanceof ReflectionUnionType) {
+            return array_filter([static::getParameterClassName($parameter)]);
+        }
+
+        $unionTypes = [];
+
+        foreach ($type->getTypes() as $listedType) {
+            if (! $listedType instanceof ReflectionNamedType || $listedType->isBuiltin()) {
+                continue;
+            }
+
+            $unionTypes[] = static::getTypeName($parameter, $listedType);
+        }
+
+        return array_filter($unionTypes);
+    }
+
+    /**
+     * Get the given type's class name.
+     *
+     * @param  \ReflectionParameter  $parameter
+     * @param  \ReflectionNamedType  $type
+     * @return string
+     */
+    protected static function getTypeName($parameter, $type)
+    {
+        $name = $type->getName();
+
+        if (! is_null($class = $parameter->getDeclaringClass())) {
+            if ($name === 'self') {
+                return $class->getName();
+            }
+
+            if ($name === 'parent' && $parent = $class->getParentClass()) {
+                return $parent->getName();
+            }
+        }
+
+        return $name;
+    }
+
+    /**
+     * Determine if the parameter's type is a subclass of the given type.
+     *
+     * @param  \ReflectionParameter  $parameter
+     * @param  string  $className
+     * @return bool
+     */
+    public static function isParameterSubclassOf($parameter, $className)
+    {
+        $paramClassName = static::getParameterClassName($parameter);
+
+        return $paramClassName
+            && (class_exists($paramClassName) || interface_exists($paramClassName))
+            && (new ReflectionClass($paramClassName))->isSubclassOf($className);
+    }
+
+    /**
+     * Determine if the parameter's type is a Backed Enum with a string backing type.
+     *
+     * @param  \ReflectionParameter  $parameter
+     * @return bool
+     */
+    public static function isParameterBackedEnumWithStringBackingType($parameter)
+    {
+        $backedEnumClass = (string) $parameter->getType();
+
+        if (function_exists('enum_exists') && enum_exists($backedEnumClass)) {
+            $reflectionBackedEnum = new ReflectionEnum($backedEnumClass);
+
+            return $reflectionBackedEnum->isBacked()
+                && $reflectionBackedEnum->getBackingType()->getName() == 'string';
+        }
+
+        return false;
+    }
+}

vendor/illuminate/support/ServiceProvider.php

@@ -0,0 +1,437 @@
+<?php
+
+namespace Illuminate\Support;
+
+use Closure;
+use Illuminate\Console\Application as Artisan;
+use Illuminate\Contracts\Foundation\CachesConfiguration;
+use Illuminate\Contracts\Foundation\CachesRoutes;
+use Illuminate\Contracts\Support\DeferrableProvider;
+use Illuminate\Database\Eloquent\Factory as ModelFactory;
+use Illuminate\View\Compilers\BladeCompiler;
+
+abstract class ServiceProvider
+{
+    /**
+     * The application instance.
+     *
+     * @var \Illuminate\Contracts\Foundation\Application
+     */
+    protected $app;
+
+    /**
+     * All of the registered booting callbacks.
+     *
+     * @var array
+     */
+    protected $bootingCallbacks = [];
+
+    /**
+     * All of the registered booted callbacks.
+     *
+     * @var array
+     */
+    protected $bootedCallbacks = [];
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Register any application services.
+     *
+     * @return void
+     */
+    public function register()
+    {
+        //
+    }
+
+    /**
+     * Register a booting callback to be run before the "boot" method is called.
+     *
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public function booting(Closure $callback)
+    {
+        $this->bootingCallbacks[] = $callback;
+    }
+
+    /**
+     * Register a booted callback to be run after the "boot" method is called.
+     *
+     * @param  \Closure  $callback
+     * @return void
+     */
+    public function booted(Closure $callback)
+    {
+        $this->bootedCallbacks[] = $callback;
+    }
+
+    /**
+     * Call the registered booting callbacks.
+     *
+     * @return void
+     */
+    public function callBootingCallbacks()
+    {
+        $index = 0;
+
+        while ($index < count($this->bootingCallbacks)) {
+            $this->app->call($this->bootingCallbacks[$index]);
+
+            $index++;
+        }
+    }
+
+    /**
+     * Call the registered booted callbacks.
+     *
+     * @return void
+     */
+    public function callBootedCallbacks()
+    {
+        $index = 0;
+
+        while ($index < count($this->bootedCallbacks)) {
+            $this->app->call($this->bootedCallbacks[$index]);
+
+            $index++;
+        }
+    }
+
+    /**
+     * Merge the given configuration with the existing configuration.
+     *
+     * @param  string  $path
+     * @param  string  $key
+     * @return void
+     */
+    protected function mergeConfigFrom($path, $key)
+    {
+        if (! ($this->app instanceof CachesConfiguration && $this->app->configurationIsCached())) {
+            $config = $this->app->make('config');
+
+            $config->set($key, array_merge(
+                require $path, $config->get($key, [])
+            ));
+        }
+    }
+
+    /**
+     * Load the given routes file if routes are not already cached.
+     *
+     * @param  string  $path
+     * @return void
+     */
+    protected function loadRoutesFrom($path)
+    {
+        if (! ($this->app instanceof CachesRoutes && $this->app->routesAreCached())) {
+            require $path;
+        }
+    }
+
+    /**
+     * Register a view file namespace.
+     *
+     * @param  string|array  $path
+     * @param  string  $namespace
+     * @return void
+     */
+    protected function loadViewsFrom($path, $namespace)
+    {
+        $this->callAfterResolving('view', function ($view) use ($path, $namespace) {
+            if (isset($this->app->config['view']['paths']) &&
+                is_array($this->app->config['view']['paths'])) {
+                foreach ($this->app->config['view']['paths'] as $viewPath) {
+                    if (is_dir($appPath = $viewPath.'/vendor/'.$namespace)) {
+                        $view->addNamespace($namespace, $appPath);
+                    }
+                }
+            }
+
+            $view->addNamespace($namespace, $path);
+        });
+    }
+
+    /**
+     * Register the given view components with a custom prefix.
+     *
+     * @param  string  $prefix
+     * @param  array  $components
+     * @return void
+     */
+    protected function loadViewComponentsAs($prefix, array $components)
+    {
+        $this->callAfterResolving(BladeCompiler::class, function ($blade) use ($prefix, $components) {
+            foreach ($components as $alias => $component) {
+                $blade->component($component, is_string($alias) ? $alias : null, $prefix);
+            }
+        });
+    }
+
+    /**
+     * Register a translation file namespace.
+     *
+     * @param  string  $path
+     * @param  string  $namespace
+     * @return void
+     */
+    protected function loadTranslationsFrom($path, $namespace)
+    {
+        $this->callAfterResolving('translator', function ($translator) use ($path, $namespace) {
+            $translator->addNamespace($namespace, $path);
+        });
+    }
+
+    /**
+     * Register a JSON translation file path.
+     *
+     * @param  string  $path
+     * @return void
+     */
+    protected function loadJsonTranslationsFrom($path)
+    {
+        $this->callAfterResolving('translator', function ($translator) use ($path) {
+            $translator->addJsonPath($path);
+        });
+    }
+
+    /**
+     * Register database migration paths.
+     *
+     * @param  array|string  $paths
+     * @return void
+     */
+    protected function loadMigrationsFrom($paths)
+    {
+        $this->callAfterResolving('migrator', function ($migrator) use ($paths) {
+            foreach ((array) $paths as $path) {
+                $migrator->path($path);
+            }
+        });
+    }
+
+    /**
+     * Register Eloquent model factory paths.
+     *
+     * @deprecated Will be removed in a future Laravel version.
+     *
+     * @param  array|string  $paths
+     * @return void
+     */
+    protected function loadFactoriesFrom($paths)
+    {
+        $this->callAfterResolving(ModelFactory::class, function ($factory) use ($paths) {
+            foreach ((array) $paths as $path) {
+                $factory->load($path);
+            }
+        });
+    }
+
+    /**
+     * Setup an after resolving listener, or fire immediately if already resolved.
+     *
+     * @param  string  $name
+     * @param  callable  $callback
+     * @return void
+     */
+    protected function callAfterResolving($name, $callback)
+    {
+        $this->app->afterResolving($name, $callback);
+
+        if ($this->app->resolved($name)) {
+            $callback($this->app->make($name), $this->app);
+        }
+    }
+
+    /**
+     * Register paths to be published by the publish command.
+     *
+     * @param  array  $paths
+     * @param  mixed  $groups
+     * @return void
+     */
+    protected function publishes(array $paths, $groups = null)
+    {
+        $this->ensurePublishArrayInitialized($class = static::class);
+
+        static::$publishes[$class] = array_merge(static::$publishes[$class], $paths);
+
+        foreach ((array) $groups as $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|null  $provider
+     * @param  string|null  $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 instanceof DeferrableProvider;
+    }
+}

vendor/illuminate/support/Testing/Fakes/BatchRepositoryFake.php

@@ -0,0 +1,142 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Carbon\CarbonImmutable;
+use Closure;
+use Illuminate\Bus\Batch;
+use Illuminate\Bus\BatchRepository;
+use Illuminate\Bus\PendingBatch;
+use Illuminate\Bus\UpdatedBatchJobCounts;
+use Illuminate\Support\Facades\Facade;
+use Illuminate\Support\Str;
+
+class BatchRepositoryFake implements BatchRepository
+{
+    /**
+     * Retrieve a list of batches.
+     *
+     * @param  int  $limit
+     * @param  mixed  $before
+     * @return \Illuminate\Bus\Batch[]
+     */
+    public function get($limit, $before)
+    {
+        return [];
+    }
+
+    /**
+     * Retrieve information about an existing batch.
+     *
+     * @param  string  $batchId
+     * @return \Illuminate\Bus\Batch|null
+     */
+    public function find(string $batchId)
+    {
+        //
+    }
+
+    /**
+     * Store a new pending batch.
+     *
+     * @param  \Illuminate\Bus\PendingBatch  $batch
+     * @return \Illuminate\Bus\Batch
+     */
+    public function store(PendingBatch $batch)
+    {
+        return new Batch(
+            new QueueFake(Facade::getFacadeApplication()),
+            $this,
+            (string) Str::orderedUuid(),
+            $batch->name,
+            count($batch->jobs),
+            count($batch->jobs),
+            0,
+            [],
+            $batch->options,
+            CarbonImmutable::now(),
+            null,
+            null
+        );
+    }
+
+    /**
+     * Increment the total number of jobs within the batch.
+     *
+     * @param  string  $batchId
+     * @param  int  $amount
+     * @return void
+     */
+    public function incrementTotalJobs(string $batchId, int $amount)
+    {
+        //
+    }
+
+    /**
+     * Decrement the total number of pending jobs for the batch.
+     *
+     * @param  string  $batchId
+     * @param  string  $jobId
+     * @return \Illuminate\Bus\UpdatedBatchJobCounts
+     */
+    public function decrementPendingJobs(string $batchId, string $jobId)
+    {
+        return new UpdatedBatchJobCounts;
+    }
+
+    /**
+     * Increment the total number of failed jobs for the batch.
+     *
+     * @param  string  $batchId
+     * @param  string  $jobId
+     * @return \Illuminate\Bus\UpdatedBatchJobCounts
+     */
+    public function incrementFailedJobs(string $batchId, string $jobId)
+    {
+        return new UpdatedBatchJobCounts;
+    }
+
+    /**
+     * Mark the batch that has the given ID as finished.
+     *
+     * @param  string  $batchId
+     * @return void
+     */
+    public function markAsFinished(string $batchId)
+    {
+        //
+    }
+
+    /**
+     * Cancel the batch that has the given ID.
+     *
+     * @param  string  $batchId
+     * @return void
+     */
+    public function cancel(string $batchId)
+    {
+        //
+    }
+
+    /**
+     * Delete the batch that has the given ID.
+     *
+     * @param  string  $batchId
+     * @return void
+     */
+    public function delete(string $batchId)
+    {
+        //
+    }
+
+    /**
+     * Execute the given Closure within a storage specific transaction.
+     *
+     * @param  \Closure  $callback
+     * @return mixed
+     */
+    public function transaction(Closure $callback)
+    {
+        return $callback();
+    }
+}

vendor/illuminate/support/Testing/Fakes/BusFake.php

@@ -0,0 +1,721 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Closure;
+use Illuminate\Bus\PendingBatch;
+use Illuminate\Contracts\Bus\QueueingDispatcher;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Traits\ReflectsClosures;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class BusFake implements QueueingDispatcher
+{
+    use ReflectsClosures;
+
+    /**
+     * The original Bus dispatcher implementation.
+     *
+     * @var \Illuminate\Contracts\Bus\QueueingDispatcher
+     */
+    protected $dispatcher;
+
+    /**
+     * The job types that should be intercepted instead of dispatched.
+     *
+     * @var array
+     */
+    protected $jobsToFake;
+
+    /**
+     * The commands that have been dispatched.
+     *
+     * @var array
+     */
+    protected $commands = [];
+
+    /**
+     * The commands that have been dispatched synchronously.
+     *
+     * @var array
+     */
+    protected $commandsSync = [];
+
+    /**
+     * The commands that have been dispatched after the response has been sent.
+     *
+     * @var array
+     */
+    protected $commandsAfterResponse = [];
+
+    /**
+     * The batches that have been dispatched.
+     *
+     * @var array
+     */
+    protected $batches = [];
+
+    /**
+     * Create a new bus fake instance.
+     *
+     * @param  \Illuminate\Contracts\Bus\QueueingDispatcher  $dispatcher
+     * @param  array|string  $jobsToFake
+     * @return void
+     */
+    public function __construct(QueueingDispatcher $dispatcher, $jobsToFake = [])
+    {
+        $this->dispatcher = $dispatcher;
+
+        $this->jobsToFake = Arr::wrap($jobsToFake);
+    }
+
+    /**
+     * Assert if a job was dispatched based on a truth-test callback.
+     *
+     * @param  string|\Closure  $command
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertDispatched($command, $callback = null)
+    {
+        if ($command instanceof Closure) {
+            [$command, $callback] = [$this->firstClosureParameterType($command), $command];
+        }
+
+        if (is_numeric($callback)) {
+            return $this->assertDispatchedTimes($command, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->dispatched($command, $callback)->count() > 0 ||
+            $this->dispatchedAfterResponse($command, $callback)->count() > 0 ||
+            $this->dispatchedSync($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
+     */
+    public function assertDispatchedTimes($command, $times = 1)
+    {
+        $count = $this->dispatched($command)->count() +
+                 $this->dispatchedAfterResponse($command)->count() +
+                 $this->dispatchedSync($command)->count();
+
+        PHPUnit::assertSame(
+            $times, $count,
+            "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|\Closure  $command
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotDispatched($command, $callback = null)
+    {
+        if ($command instanceof Closure) {
+            [$command, $callback] = [$this->firstClosureParameterType($command), $command];
+        }
+
+        PHPUnit::assertTrue(
+            $this->dispatched($command, $callback)->count() === 0 &&
+            $this->dispatchedAfterResponse($command, $callback)->count() === 0 &&
+            $this->dispatchedSync($command, $callback)->count() === 0,
+            "The unexpected [{$command}] job was dispatched."
+        );
+    }
+
+    /**
+     * Assert that no jobs were dispatched.
+     *
+     * @return void
+     */
+    public function assertNothingDispatched()
+    {
+        PHPUnit::assertEmpty($this->commands, 'Jobs were dispatched unexpectedly.');
+    }
+
+    /**
+     * Assert if a job was explicitly dispatched synchronously based on a truth-test callback.
+     *
+     * @param  string|\Closure  $command
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertDispatchedSync($command, $callback = null)
+    {
+        if ($command instanceof Closure) {
+            [$command, $callback] = [$this->firstClosureParameterType($command), $command];
+        }
+
+        if (is_numeric($callback)) {
+            return $this->assertDispatchedSyncTimes($command, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->dispatchedSync($command, $callback)->count() > 0,
+            "The expected [{$command}] job was not dispatched synchronously."
+        );
+    }
+
+    /**
+     * Assert if a job was pushed synchronously a number of times.
+     *
+     * @param  string  $command
+     * @param  int  $times
+     * @return void
+     */
+    public function assertDispatchedSyncTimes($command, $times = 1)
+    {
+        $count = $this->dispatchedSync($command)->count();
+
+        PHPUnit::assertSame(
+            $times, $count,
+            "The expected [{$command}] job was synchronously pushed {$count} times instead of {$times} times."
+        );
+    }
+
+    /**
+     * Determine if a job was dispatched based on a truth-test callback.
+     *
+     * @param  string|\Closure  $command
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotDispatchedSync($command, $callback = null)
+    {
+        if ($command instanceof Closure) {
+            [$command, $callback] = [$this->firstClosureParameterType($command), $command];
+        }
+
+        PHPUnit::assertCount(
+            0, $this->dispatchedSync($command, $callback),
+            "The unexpected [{$command}] job was dispatched synchronously."
+        );
+    }
+
+    /**
+     * Assert if a job was dispatched after the response was sent based on a truth-test callback.
+     *
+     * @param  string|\Closure  $command
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertDispatchedAfterResponse($command, $callback = null)
+    {
+        if ($command instanceof Closure) {
+            [$command, $callback] = [$this->firstClosureParameterType($command), $command];
+        }
+
+        if (is_numeric($callback)) {
+            return $this->assertDispatchedAfterResponseTimes($command, $callback);
+        }
+
+        PHPUnit::assertTrue(
+            $this->dispatchedAfterResponse($command, $callback)->count() > 0,
+            "The expected [{$command}] job was not dispatched after sending the response."
+        );
+    }
+
+    /**
+     * Assert if a job was pushed after the response was sent a number of times.
+     *
+     * @param  string  $command
+     * @param  int  $times
+     * @return void
+     */
+    public function assertDispatchedAfterResponseTimes($command, $times = 1)
+    {
+        $count = $this->dispatchedAfterResponse($command)->count();
+
+        PHPUnit::assertSame(
+            $times, $count,
+            "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|\Closure  $command
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotDispatchedAfterResponse($command, $callback = null)
+    {
+        if ($command instanceof Closure) {
+            [$command, $callback] = [$this->firstClosureParameterType($command), $command];
+        }
+
+        PHPUnit::assertCount(
+            0, $this->dispatchedAfterResponse($command, $callback),
+            "The unexpected [{$command}] job was dispatched after sending the response."
+        );
+    }
+
+    /**
+     * Assert if a chain of jobs was dispatched.
+     *
+     * @param  array  $expectedChain
+     * @return void
+     */
+    public function assertChained(array $expectedChain)
+    {
+        $command = $expectedChain[0];
+
+        $expectedChain = array_slice($expectedChain, 1);
+
+        $callback = null;
+
+        if ($command instanceof Closure) {
+            [$command, $callback] = [$this->firstClosureParameterType($command), $command];
+        } elseif (! is_string($command)) {
+            $instance = $command;
+
+            $command = get_class($instance);
+
+            $callback = function ($job) use ($instance) {
+                return serialize($this->resetChainPropertiesToDefaults($job)) === serialize($instance);
+            };
+        }
+
+        PHPUnit::assertTrue(
+            $this->dispatched($command, $callback)->isNotEmpty(),
+            "The expected [{$command}] job was not dispatched."
+        );
+
+        PHPUnit::assertTrue(
+            collect($expectedChain)->isNotEmpty(),
+            'The expected chain can not be empty.'
+        );
+
+        $this->isChainOfObjects($expectedChain)
+            ? $this->assertDispatchedWithChainOfObjects($command, $expectedChain, $callback)
+            : $this->assertDispatchedWithChainOfClasses($command, $expectedChain, $callback);
+    }
+
+    /**
+     * Reset the chain properties to their default values on the job.
+     *
+     * @param  mixed  $job
+     * @return mixed
+     */
+    protected function resetChainPropertiesToDefaults($job)
+    {
+        return tap(clone $job, function ($job) {
+            $job->chainConnection = null;
+            $job->chainQueue = null;
+            $job->chainCatchCallbacks = null;
+            $job->chained = [];
+        });
+    }
+
+    /**
+     * Assert if a job was dispatched with an empty chain based on a truth-test callback.
+     *
+     * @param  string|\Closure  $command
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertDispatchedWithoutChain($command, $callback = null)
+    {
+        if ($command instanceof Closure) {
+            [$command, $callback] = [$this->firstClosureParameterType($command), $command];
+        }
+
+        PHPUnit::assertTrue(
+            $this->dispatched($command, $callback)->isNotEmpty(),
+            "The expected [{$command}] job was not dispatched."
+        );
+
+        $this->assertDispatchedWithChainOfClasses($command, [], $callback);
+    }
+
+    /**
+     * Assert if a job was dispatched with chained jobs based on a truth-test callback.
+     *
+     * @param  string  $command
+     * @param  array  $expectedChain
+     * @param  callable|null  $callback
+     * @return void
+     */
+    protected function assertDispatchedWithChainOfObjects($command, $expectedChain, $callback)
+    {
+        $chain = collect($expectedChain)->map(fn ($job) => serialize($job))->all();
+
+        PHPUnit::assertTrue(
+            $this->dispatched($command, $callback)->filter(
+                fn ($job) => $job->chained == $chain
+            )->isNotEmpty(),
+            'The expected chain was not dispatched.'
+        );
+    }
+
+    /**
+     * Assert if a job was dispatched with chained jobs based on a truth-test callback.
+     *
+     * @param  string  $command
+     * @param  array  $expectedChain
+     * @param  callable|null  $callback
+     * @return void
+     */
+    protected function assertDispatchedWithChainOfClasses($command, $expectedChain, $callback)
+    {
+        $matching = $this->dispatched($command, $callback)->map->chained->map(function ($chain) {
+            return collect($chain)->map(
+                fn ($job) => get_class(unserialize($job))
+            );
+        })->filter(
+            fn ($chain) => $chain->all() === $expectedChain
+        );
+
+        PHPUnit::assertTrue(
+            $matching->isNotEmpty(), 'The expected chain was not dispatched.'
+        );
+    }
+
+    /**
+     * Determine if the given chain is entirely composed of objects.
+     *
+     * @param  array  $chain
+     * @return bool
+     */
+    protected function isChainOfObjects($chain)
+    {
+        return ! collect($chain)->contains(fn ($job) => ! is_object($job));
+    }
+
+    /**
+     * Assert if a batch was dispatched based on a truth-test callback.
+     *
+     * @param  callable  $callback
+     * @return void
+     */
+    public function assertBatched(callable $callback)
+    {
+        PHPUnit::assertTrue(
+            $this->batched($callback)->count() > 0,
+            'The expected batch was not dispatched.'
+        );
+    }
+
+    /**
+     * Assert the number of batches that have been dispatched.
+     *
+     * @param  int  $count
+     * @return void
+     */
+    public function assertBatchCount($count)
+    {
+        PHPUnit::assertCount(
+            $count, $this->batches,
+        );
+    }
+
+    /**
+     * 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 ?: fn () => true;
+
+        return collect($this->commands[$command])->filter(fn ($command) => $callback($command));
+    }
+
+    /**
+     * Get all of the jobs dispatched synchronously matching a truth-test callback.
+     *
+     * @param  string  $command
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function dispatchedSync(string $command, $callback = null)
+    {
+        if (! $this->hasDispatchedSync($command)) {
+            return collect();
+        }
+
+        $callback = $callback ?: fn () => true;
+
+        return collect($this->commandsSync[$command])->filter(fn ($command) => $callback($command));
+    }
+
+    /**
+     * Get all of the jobs dispatched after the response was sent matching a truth-test callback.
+     *
+     * @param  string  $command
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function dispatchedAfterResponse(string $command, $callback = null)
+    {
+        if (! $this->hasDispatchedAfterResponse($command)) {
+            return collect();
+        }
+
+        $callback = $callback ?: fn () => true;
+
+        return collect($this->commandsAfterResponse[$command])->filter(fn ($command) => $callback($command));
+    }
+
+    /**
+     * Get all of the pending batches matching a truth-test callback.
+     *
+     * @param  callable  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function batched(callable $callback)
+    {
+        if (empty($this->batches)) {
+            return collect();
+        }
+
+        return collect($this->batches)->filter(fn ($batch) => $callback($batch));
+    }
+
+    /**
+     * 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]);
+    }
+
+    /**
+     * Determine if there are any stored commands for a given class.
+     *
+     * @param  string  $command
+     * @return bool
+     */
+    public function hasDispatchedSync($command)
+    {
+        return isset($this->commandsSync[$command]) && ! empty($this->commandsSync[$command]);
+    }
+
+    /**
+     * Determine if there are any stored commands for a given class.
+     *
+     * @param  string  $command
+     * @return bool
+     */
+    public function hasDispatchedAfterResponse($command)
+    {
+        return isset($this->commandsAfterResponse[$command]) && ! empty($this->commandsAfterResponse[$command]);
+    }
+
+    /**
+     * Dispatch a command to its appropriate handler.
+     *
+     * @param  mixed  $command
+     * @return mixed
+     */
+    public function dispatch($command)
+    {
+        if ($this->shouldFakeJob($command)) {
+            $this->commands[get_class($command)][] = $command;
+        } else {
+            return $this->dispatcher->dispatch($command);
+        }
+    }
+
+    /**
+     * Dispatch a command to its appropriate handler in the current process.
+     *
+     * Queueable jobs will be dispatched to the "sync" queue.
+     *
+     * @param  mixed  $command
+     * @param  mixed  $handler
+     * @return mixed
+     */
+    public function dispatchSync($command, $handler = null)
+    {
+        if ($this->shouldFakeJob($command)) {
+            $this->commandsSync[get_class($command)][] = $command;
+        } else {
+            return $this->dispatcher->dispatchSync($command, $handler);
+        }
+    }
+
+    /**
+     * 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)
+    {
+        if ($this->shouldFakeJob($command)) {
+            $this->commands[get_class($command)][] = $command;
+        } else {
+            return $this->dispatcher->dispatchNow($command, $handler);
+        }
+    }
+
+    /**
+     * Dispatch a command to its appropriate handler behind a queue.
+     *
+     * @param  mixed  $command
+     * @return mixed
+     */
+    public function dispatchToQueue($command)
+    {
+        if ($this->shouldFakeJob($command)) {
+            $this->commands[get_class($command)][] = $command;
+        } else {
+            return $this->dispatcher->dispatchToQueue($command);
+        }
+    }
+
+    /**
+     * Dispatch a command to its appropriate handler.
+     *
+     * @param  mixed  $command
+     * @return mixed
+     */
+    public function dispatchAfterResponse($command)
+    {
+        if ($this->shouldFakeJob($command)) {
+            $this->commandsAfterResponse[get_class($command)][] = $command;
+        } else {
+            return $this->dispatcher->dispatch($command);
+        }
+    }
+
+    /**
+     * Create a new chain of queueable jobs.
+     *
+     * @param  \Illuminate\Support\Collection|array  $jobs
+     * @return \Illuminate\Foundation\Bus\PendingChain
+     */
+    public function chain($jobs)
+    {
+        $jobs = Collection::wrap($jobs);
+
+        return new PendingChainFake($this, $jobs->shift(), $jobs->toArray());
+    }
+
+    /**
+     * Attempt to find the batch with the given ID.
+     *
+     * @param  string  $batchId
+     * @return \Illuminate\Bus\Batch|null
+     */
+    public function findBatch(string $batchId)
+    {
+        //
+    }
+
+    /**
+     * Create a new batch of queueable jobs.
+     *
+     * @param  \Illuminate\Support\Collection|array  $jobs
+     * @return \Illuminate\Bus\PendingBatch
+     */
+    public function batch($jobs)
+    {
+        return new PendingBatchFake($this, Collection::wrap($jobs));
+    }
+
+    /**
+     * Record the fake pending batch dispatch.
+     *
+     * @param  \Illuminate\Bus\PendingBatch  $pendingBatch
+     * @return \Illuminate\Bus\Batch
+     */
+    public function recordPendingBatch(PendingBatch $pendingBatch)
+    {
+        $this->batches[] = $pendingBatch;
+
+        return (new BatchRepositoryFake)->store($pendingBatch);
+    }
+
+    /**
+     * Determine if a command should be faked or actually dispatched.
+     *
+     * @param  mixed  $command
+     * @return bool
+     */
+    protected function shouldFakeJob($command)
+    {
+        if (empty($this->jobsToFake)) {
+            return true;
+        }
+
+        return collect($this->jobsToFake)
+            ->filter(function ($job) use ($command) {
+                return $job instanceof Closure
+                            ? $job($command)
+                            : $job === get_class($command);
+            })->isNotEmpty();
+    }
+
+    /**
+     * Set the pipes commands should be piped through before dispatching.
+     *
+     * @param  array  $pipes
+     * @return $this
+     */
+    public function pipeThrough(array $pipes)
+    {
+        $this->dispatcher->pipeThrough($pipes);
+
+        return $this;
+    }
+
+    /**
+     * Determine if the given command has a handler.
+     *
+     * @param  mixed  $command
+     * @return bool
+     */
+    public function hasCommandHandler($command)
+    {
+        return $this->dispatcher->hasCommandHandler($command);
+    }
+
+    /**
+     * Retrieve the handler for a command.
+     *
+     * @param  mixed  $command
+     * @return mixed
+     */
+    public function getCommandHandler($command)
+    {
+        return $this->dispatcher->getCommandHandler($command);
+    }
+
+    /**
+     * Map a command to a handler.
+     *
+     * @param  array  $map
+     * @return $this
+     */
+    public function map(array $map)
+    {
+        $this->dispatcher->map($map);
+
+        return $this;
+    }
+}

vendor/illuminate/support/Testing/Fakes/EventFake.php

@@ -0,0 +1,331 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Closure;
+use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Str;
+use Illuminate\Support\Traits\ReflectsClosures;
+use PHPUnit\Framework\Assert as PHPUnit;
+use ReflectionFunction;
+
+class EventFake implements Dispatcher
+{
+    use ReflectsClosures;
+
+    /**
+     * 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 has a listener attached to it.
+     *
+     * @param  string  $expectedEvent
+     * @param  string|array  $expectedListener
+     * @return void
+     */
+    public function assertListening($expectedEvent, $expectedListener)
+    {
+        foreach ($this->dispatcher->getListeners($expectedEvent) as $listenerClosure) {
+            $actualListener = (new ReflectionFunction($listenerClosure))
+                        ->getStaticVariables()['listener'];
+
+            if (is_string($actualListener) && Str::contains($actualListener, '@')) {
+                $actualListener = Str::parseCallback($actualListener);
+
+                if (is_string($expectedListener)) {
+                    if (Str::contains($expectedListener, '@')) {
+                        $expectedListener = Str::parseCallback($expectedListener);
+                    } else {
+                        $expectedListener = [$expectedListener, 'handle'];
+                    }
+                }
+            }
+
+            if ($actualListener === $expectedListener ||
+                ($actualListener instanceof Closure &&
+                $expectedListener === Closure::class)) {
+                PHPUnit::assertTrue(true);
+
+                return;
+            }
+        }
+
+        PHPUnit::assertTrue(
+            false,
+            sprintf(
+                'Event [%s] does not have the [%s] listener attached to it',
+                $expectedEvent,
+                print_r($expectedListener, true)
+            )
+        );
+    }
+
+    /**
+     * Assert if an event was dispatched based on a truth-test callback.
+     *
+     * @param  string|\Closure  $event
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertDispatched($event, $callback = null)
+    {
+        if ($event instanceof Closure) {
+            [$event, $callback] = [$this->firstClosureParameterType($event), $event];
+        }
+
+        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 an event was dispatched a number of times.
+     *
+     * @param  string  $event
+     * @param  int  $times
+     * @return void
+     */
+    public function assertDispatchedTimes($event, $times = 1)
+    {
+        $count = $this->dispatched($event)->count();
+
+        PHPUnit::assertSame(
+            $times, $count,
+            "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|\Closure  $event
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotDispatched($event, $callback = null)
+    {
+        if ($event instanceof Closure) {
+            [$event, $callback] = [$this->firstClosureParameterType($event), $event];
+        }
+
+        PHPUnit::assertCount(
+            0, $this->dispatched($event, $callback),
+            "The unexpected [{$event}] event was dispatched."
+        );
+    }
+
+    /**
+     * Assert that no events were dispatched.
+     *
+     * @return void
+     */
+    public function assertNothingDispatched()
+    {
+        $count = count(Arr::flatten($this->events));
+
+        PHPUnit::assertSame(
+            0, $count,
+            "{$count} unexpected events were 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 ?: fn () => true;
+
+        return collect($this->events[$event])->filter(
+            fn ($arguments) => $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  \Closure|string|array  $events
+     * @param  mixed  $listener
+     * @return void
+     */
+    public function listen($events, $listener = null)
+    {
+        $this->dispatcher->listen($events, $listener);
+    }
+
+    /**
+     * Determine if a given event has listeners.
+     *
+     * @param  string  $eventName
+     * @return bool
+     */
+    public function hasListeners($eventName)
+    {
+        return $this->dispatcher->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)
+    {
+        $this->dispatcher->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 dispatch($event, $payload = [], $halt = false)
+    {
+        $name = is_object($event) ? get_class($event) : (string) $event;
+
+        if ($this->shouldFakeEvent($name, $payload)) {
+            $this->events[$name][] = func_get_args();
+        } else {
+            return $this->dispatcher->dispatch($event, $payload, $halt);
+        }
+    }
+
+    /**
+     * Determine if an event should be faked or actually dispatched.
+     *
+     * @param  string  $eventName
+     * @param  mixed  $payload
+     * @return bool
+     */
+    protected function shouldFakeEvent($eventName, $payload)
+    {
+        if (empty($this->eventsToFake)) {
+            return true;
+        }
+
+        return collect($this->eventsToFake)
+            ->filter(function ($event) use ($eventName, $payload) {
+                return $event instanceof Closure
+                            ? $event($eventName, $payload)
+                            : $event === $eventName;
+            })
+            ->isNotEmpty();
+    }
+
+    /**
+     * 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 array|null
+     */
+    public function until($event, $payload = [])
+    {
+        return $this->dispatch($event, $payload, true);
+    }
+}

vendor/illuminate/support/Testing/Fakes/MailFake.php

@@ -0,0 +1,433 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Closure;
+use Illuminate\Contracts\Mail\Factory;
+use Illuminate\Contracts\Mail\Mailable;
+use Illuminate\Contracts\Mail\Mailer;
+use Illuminate\Contracts\Mail\MailQueue;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Support\Traits\ReflectsClosures;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class MailFake implements Factory, Mailer, MailQueue
+{
+    use ReflectsClosures;
+
+    /**
+     * The mailer currently being used to send a message.
+     *
+     * @var string
+     */
+    protected $currentMailer;
+
+    /**
+     * 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|\Closure  $mailable
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertSent($mailable, $callback = null)
+    {
+        [$mailable, $callback] = $this->prepareMailableAndCallback($mailable, $callback);
+
+        if (is_numeric($callback)) {
+            return $this->assertSentTimes($mailable, $callback);
+        }
+
+        $message = "The expected [{$mailable}] mailable was not sent.";
+
+        if (count($this->queuedMailables) > 0) {
+            $message .= ' Did you mean to use assertQueued() instead?';
+        }
+
+        PHPUnit::assertTrue(
+            $this->sent($mailable, $callback)->count() > 0,
+            $message
+        );
+    }
+
+    /**
+     * Assert if a mailable was sent a number of times.
+     *
+     * @param  string  $mailable
+     * @param  int  $times
+     * @return void
+     */
+    protected function assertSentTimes($mailable, $times = 1)
+    {
+        $count = $this->sent($mailable)->count();
+
+        PHPUnit::assertSame(
+            $times, $count,
+            "The expected [{$mailable}] mailable was sent {$count} times instead of {$times} times."
+        );
+    }
+
+    /**
+     * Determine if a mailable was not sent or queued to be sent based on a truth-test callback.
+     *
+     * @param  string|\Closure  $mailable
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotOutgoing($mailable, $callback = null)
+    {
+        $this->assertNotSent($mailable, $callback);
+        $this->assertNotQueued($mailable, $callback);
+    }
+
+    /**
+     * Determine if a mailable was not sent based on a truth-test callback.
+     *
+     * @param  string|\Closure  $mailable
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotSent($mailable, $callback = null)
+    {
+        [$mailable, $callback] = $this->prepareMailableAndCallback($mailable, $callback);
+
+        PHPUnit::assertCount(
+            0, $this->sent($mailable, $callback),
+            "The unexpected [{$mailable}] mailable was sent."
+        );
+    }
+
+    /**
+     * Assert that no mailables were sent or queued to be sent.
+     *
+     * @return void
+     */
+    public function assertNothingOutgoing()
+    {
+        $this->assertNothingSent();
+        $this->assertNothingQueued();
+    }
+
+    /**
+     * Assert that no mailables were sent.
+     *
+     * @return void
+     */
+    public function assertNothingSent()
+    {
+        $mailableNames = collect($this->mailables)->map(
+            fn ($mailable) => get_class($mailable)
+        )->join(', ');
+
+        PHPUnit::assertEmpty($this->mailables, 'The following mailables were sent unexpectedly: '.$mailableNames);
+    }
+
+    /**
+     * Assert if a mailable was queued based on a truth-test callback.
+     *
+     * @param  string|\Closure  $mailable
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertQueued($mailable, $callback = null)
+    {
+        [$mailable, $callback] = $this->prepareMailableAndCallback($mailable, $callback);
+
+        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)
+    {
+        $count = $this->queued($mailable)->count();
+
+        PHPUnit::assertSame(
+            $times, $count,
+            "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|\Closure  $mailable
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotQueued($mailable, $callback = null)
+    {
+        [$mailable, $callback] = $this->prepareMailableAndCallback($mailable, $callback);
+
+        PHPUnit::assertCount(
+            0, $this->queued($mailable, $callback),
+            "The unexpected [{$mailable}] mailable was queued."
+        );
+    }
+
+    /**
+     * Assert that no mailables were queued.
+     *
+     * @return void
+     */
+    public function assertNothingQueued()
+    {
+        $mailableNames = collect($this->queuedMailables)->map(
+            fn ($mailable) => get_class($mailable)
+        )->join(', ');
+
+        PHPUnit::assertEmpty($this->queuedMailables, 'The following mailables were queued unexpectedly: '.$mailableNames);
+    }
+
+    /**
+     * Get all of the mailables matching a truth-test callback.
+     *
+     * @param  string|\Closure  $mailable
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function sent($mailable, $callback = null)
+    {
+        [$mailable, $callback] = $this->prepareMailableAndCallback($mailable, $callback);
+
+        if (! $this->hasSent($mailable)) {
+            return collect();
+        }
+
+        $callback = $callback ?: fn () => true;
+
+        return $this->mailablesOf($mailable)->filter(fn ($mailable) => $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|\Closure  $mailable
+     * @param  callable|null  $callback
+     * @return \Illuminate\Support\Collection
+     */
+    public function queued($mailable, $callback = null)
+    {
+        [$mailable, $callback] = $this->prepareMailableAndCallback($mailable, $callback);
+
+        if (! $this->hasQueued($mailable)) {
+            return collect();
+        }
+
+        $callback = $callback ?: fn () => true;
+
+        return $this->queuedMailablesOf($mailable)->filter(fn ($mailable) => $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(fn ($mailable) => $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(fn ($mailable) => $mailable instanceof $type);
+    }
+
+    /**
+     * Get a mailer instance by name.
+     *
+     * @param  string|null  $name
+     * @return \Illuminate\Contracts\Mail\Mailer
+     */
+    public function mailer($name = null)
+    {
+        $this->currentMailer = $name;
+
+        return $this;
+    }
+
+    /**
+     * 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 with only a raw text part.
+     *
+     * @param  string  $text
+     * @param  \Closure|string  $callback
+     * @return void
+     */
+    public function raw($text, $callback)
+    {
+        //
+    }
+
+    /**
+     * Send a new message using a view.
+     *
+     * @param  \Illuminate\Contracts\Mail\Mailable|string|array  $view
+     * @param  array  $data
+     * @param  \Closure|string|null  $callback
+     * @return void
+     */
+    public function send($view, array $data = [], $callback = null)
+    {
+        if (! $view instanceof Mailable) {
+            return;
+        }
+
+        $view->mailer($this->currentMailer);
+
+        if ($view instanceof ShouldQueue) {
+            return $this->queue($view, $data);
+        }
+
+        $this->currentMailer = null;
+
+        $this->mailables[] = $view;
+    }
+
+    /**
+     * Queue a new e-mail message for sending.
+     *
+     * @param  \Illuminate\Contracts\Mail\Mailable|string|array  $view
+     * @param  string|null  $queue
+     * @return mixed
+     */
+    public function queue($view, $queue = null)
+    {
+        if (! $view instanceof Mailable) {
+            return;
+        }
+
+        $view->mailer($this->currentMailer);
+
+        $this->currentMailer = null;
+
+        $this->queuedMailables[] = $view;
+    }
+
+    /**
+     * Queue a new e-mail message for sending after (n) seconds.
+     *
+     * @param  \DateTimeInterface|\DateInterval|int  $delay
+     * @param  \Illuminate\Contracts\Mail\Mailable|string|array  $view
+     * @param  string|null  $queue
+     * @return mixed
+     */
+    public function later($delay, $view, $queue = null)
+    {
+        $this->queue($view, $queue);
+    }
+
+    /**
+     * Get the array of failed recipients.
+     *
+     * @return array
+     */
+    public function failures()
+    {
+        return [];
+    }
+
+    /**
+     * Infer mailable class using reflection if a typehinted closure is passed to assertion.
+     *
+     * @param  string|\Closure  $mailable
+     * @param  callable|null  $callback
+     * @return array
+     */
+    protected function prepareMailableAndCallback($mailable, $callback)
+    {
+        if ($mailable instanceof Closure) {
+            return [$this->firstClosureParameterType($mailable), $mailable];
+        }
+
+        return [$mailable, $callback];
+    }
+
+    /**
+     * Forget all of the resolved mailer instances.
+     *
+     * @return $this
+     */
+    public function forgetMailers()
+    {
+        $this->currentMailer = null;
+
+        return $this;
+    }
+}

vendor/illuminate/support/Testing/Fakes/NotificationFake.php

@@ -0,0 +1,365 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Closure;
+use Exception;
+use Illuminate\Contracts\Notifications\Dispatcher as NotificationDispatcher;
+use Illuminate\Contracts\Notifications\Factory as NotificationFactory;
+use Illuminate\Contracts\Translation\HasLocalePreference;
+use Illuminate\Notifications\AnonymousNotifiable;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Str;
+use Illuminate\Support\Traits\Macroable;
+use Illuminate\Support\Traits\ReflectsClosures;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class NotificationFake implements NotificationDispatcher, NotificationFactory
+{
+    use Macroable, ReflectsClosures;
+
+    /**
+     * All of the notifications that have been sent.
+     *
+     * @var array
+     */
+    protected $notifications = [];
+
+    /**
+     * Locale used when sending notifications.
+     *
+     * @var string|null
+     */
+    public $locale;
+
+    /**
+     * Assert if a notification was sent on-demand based on a truth-test callback.
+     *
+     * @param  string|\Closure  $notification
+     * @param  callable|null  $callback
+     * @return void
+     *
+     * @throws \Exception
+     */
+    public function assertSentOnDemand($notification, $callback = null)
+    {
+        $this->assertSentTo(new AnonymousNotifiable, $notification, $callback);
+    }
+
+    /**
+     * Assert if a notification was sent based on a truth-test callback.
+     *
+     * @param  mixed  $notifiable
+     * @param  string|\Closure  $notification
+     * @param  callable|null  $callback
+     * @return void
+     *
+     * @throws \Exception
+     */
+    public function assertSentTo($notifiable, $notification, $callback = null)
+    {
+        if (is_array($notifiable) || $notifiable instanceof Collection) {
+            if (count($notifiable) === 0) {
+                throw new Exception('No notifiable given.');
+            }
+
+            foreach ($notifiable as $singleNotifiable) {
+                $this->assertSentTo($singleNotifiable, $notification, $callback);
+            }
+
+            return;
+        }
+
+        if ($notification instanceof Closure) {
+            [$notification, $callback] = [$this->firstClosureParameterType($notification), $notification];
+        }
+
+        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 on-demand a number of times.
+     *
+     * @param  string  $notification
+     * @param  int  $times
+     * @return void
+     */
+    public function assertSentOnDemandTimes($notification, $times = 1)
+    {
+        return $this->assertSentToTimes(new AnonymousNotifiable, $notification, $times);
+    }
+
+    /**
+     * 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)
+    {
+        $count = $this->sent($notifiable, $notification)->count();
+
+        PHPUnit::assertSame(
+            $times, $count,
+            "Expected [{$notification}] to be sent {$times} times, but was sent {$count} times."
+        );
+    }
+
+    /**
+     * Determine if a notification was sent based on a truth-test callback.
+     *
+     * @param  mixed  $notifiable
+     * @param  string|\Closure  $notification
+     * @param  callable|null  $callback
+     * @return void
+     *
+     * @throws \Exception
+     */
+    public function assertNotSentTo($notifiable, $notification, $callback = null)
+    {
+        if (is_array($notifiable) || $notifiable instanceof Collection) {
+            if (count($notifiable) === 0) {
+                throw new Exception('No notifiable given.');
+            }
+
+            foreach ($notifiable as $singleNotifiable) {
+                $this->assertNotSentTo($singleNotifiable, $notification, $callback);
+            }
+
+            return;
+        }
+
+        if ($notification instanceof Closure) {
+            [$notification, $callback] = [$this->firstClosureParameterType($notification), $notification];
+        }
+
+        PHPUnit::assertCount(
+            0, $this->sent($notifiable, $notification, $callback),
+            "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 that no notifications were sent to the given notifiable.
+     *
+     * @param  mixed  $notifiable
+     * @return void
+     *
+     * @throws \Exception
+     */
+    public function assertNothingSentTo($notifiable)
+    {
+        if (is_array($notifiable) || $notifiable instanceof Collection) {
+            if (count($notifiable) === 0) {
+                throw new Exception('No notifiable given.');
+            }
+
+            foreach ($notifiable as $singleNotifiable) {
+                $this->assertNothingSentTo($singleNotifiable);
+            }
+
+            return;
+        }
+
+        PHPUnit::assertEmpty(
+            $this->notifications[get_class($notifiable)][$notifiable->getKey()] ?? [],
+            'Notifications were sent unexpectedly.',
+        );
+    }
+
+    /**
+     * Assert the total amount of times a notification was sent.
+     *
+     * @param  string  $notification
+     * @param  int  $expectedCount
+     * @return void
+     */
+    public function assertSentTimes($notification, $expectedCount)
+    {
+        $actualCount = collect($this->notifications)
+            ->flatten(1)
+            ->reduce(fn ($count, $sent) => $count + count($sent[$notification] ?? []), 0);
+
+        PHPUnit::assertSame(
+            $expectedCount, $actualCount,
+            "Expected [{$notification}] to be sent {$expectedCount} times, but was sent {$actualCount} times."
+        );
+    }
+
+    /**
+     * Assert the total count of notification that were sent.
+     *
+     * @param  int  $expectedCount
+     * @return void
+     */
+    public function assertCount($expectedCount)
+    {
+        $actualCount = collect($this->notifications)->flatten(3)->count();
+
+        PHPUnit::assertSame(
+            $expectedCount, $actualCount,
+            "Expected {$expectedCount} notifications to be sent, but {$actualCount} were sent."
+        );
+    }
+
+    /**
+     * Assert the total amount of times a notification was sent.
+     *
+     * @param  int  $expectedCount
+     * @param  string  $notification
+     * @return void
+     *
+     * @deprecated Use the assertSentTimes method instead
+     */
+    public function assertTimesSent($expectedCount, $notification)
+    {
+        $this->assertSentTimes($notification, $expectedCount);
+    }
+
+    /**
+     * 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 ?: fn () => true;
+
+        $notifications = collect($this->notificationsFor($notifiable, $notification));
+
+        return $notifications->filter(
+            fn ($arguments) => $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)
+    {
+        return $this->notifications[get_class($notifiable)][$notifiable->getKey()][$notification] ?? [];
+    }
+
+    /**
+     * 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)
+    {
+        $this->sendNow($notifiables, $notification);
+    }
+
+    /**
+     * Send the given notification immediately.
+     *
+     * @param  \Illuminate\Support\Collection|array|mixed  $notifiables
+     * @param  mixed  $notification
+     * @param  array|null  $channels
+     * @return void
+     */
+    public function sendNow($notifiables, $notification, array $channels = null)
+    {
+        if (! $notifiables instanceof Collection && ! is_array($notifiables)) {
+            $notifiables = [$notifiables];
+        }
+
+        foreach ($notifiables as $notifiable) {
+            if (! $notification->id) {
+                $notification->id = Str::uuid()->toString();
+            }
+
+            $notifiableChannels = $channels ?: $notification->via($notifiable);
+
+            if (method_exists($notification, 'shouldSend')) {
+                $notifiableChannels = array_filter(
+                    $notifiableChannels,
+                    fn ($channel) => $notification->shouldSend($notifiable, $channel) !== false
+                );
+
+                if (empty($notifiableChannels)) {
+                    continue;
+                }
+            }
+
+            $this->notifications[get_class($notifiable)][$notifiable->getKey()][get_class($notification)][] = [
+                'notification' => $notification,
+                'channels' => $notifiableChannels,
+                'notifiable' => $notifiable,
+                'locale' => $notification->locale ?? $this->locale ?? value(function () use ($notifiable) {
+                    if ($notifiable instanceof HasLocalePreference) {
+                        return $notifiable->preferredLocale();
+                    }
+                }),
+            ];
+        }
+    }
+
+    /**
+     * Get a channel instance by name.
+     *
+     * @param  string|null  $name
+     * @return mixed
+     */
+    public function channel($name = null)
+    {
+        //
+    }
+
+    /**
+     * Set the locale of notifications.
+     *
+     * @param  string  $locale
+     * @return $this
+     */
+    public function locale($locale)
+    {
+        $this->locale = $locale;
+
+        return $this;
+    }
+}

vendor/illuminate/support/Testing/Fakes/PendingBatchFake.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Illuminate\Bus\PendingBatch;
+use Illuminate\Support\Collection;
+
+class PendingBatchFake extends PendingBatch
+{
+    /**
+     * The fake bus instance.
+     *
+     * @var \Illuminate\Support\Testing\Fakes\BusFake
+     */
+    protected $bus;
+
+    /**
+     * Create a new pending batch instance.
+     *
+     * @param  \Illuminate\Support\Testing\Fakes\BusFake  $bus
+     * @param  \Illuminate\Support\Collection  $jobs
+     * @return void
+     */
+    public function __construct(BusFake $bus, Collection $jobs)
+    {
+        $this->bus = $bus;
+        $this->jobs = $jobs;
+    }
+
+    /**
+     * Dispatch the batch.
+     *
+     * @return \Illuminate\Bus\Batch
+     */
+    public function dispatch()
+    {
+        return $this->bus->recordPendingBatch($this);
+    }
+}

vendor/illuminate/support/Testing/Fakes/PendingChainFake.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Closure;
+use Illuminate\Foundation\Bus\PendingChain;
+use Illuminate\Queue\CallQueuedClosure;
+
+class PendingChainFake extends PendingChain
+{
+    /**
+     * The fake bus instance.
+     *
+     * @var \Illuminate\Support\Testing\Fakes\BusFake
+     */
+    protected $bus;
+
+    /**
+     * Create a new pending chain instance.
+     *
+     * @param  \Illuminate\Support\Testing\Fakes\BusFake  $bus
+     * @param  mixed  $job
+     * @param  array  $chain
+     * @return void
+     */
+    public function __construct(BusFake $bus, $job, $chain)
+    {
+        $this->bus = $bus;
+        $this->job = $job;
+        $this->chain = $chain;
+    }
+
+    /**
+     * Dispatch the job with the given arguments.
+     *
+     * @return \Illuminate\Foundation\Bus\PendingDispatch
+     */
+    public function dispatch()
+    {
+        if (is_string($this->job)) {
+            $firstJob = new $this->job(...func_get_args());
+        } elseif ($this->job instanceof Closure) {
+            $firstJob = CallQueuedClosure::create($this->job);
+        } else {
+            $firstJob = $this->job;
+        }
+
+        $firstJob->allOnConnection($this->connection);
+        $firstJob->allOnQueue($this->queue);
+        $firstJob->chain($this->chain);
+        $firstJob->delay($this->delay);
+        $firstJob->chainCatchCallbacks = $this->catchCallbacks();
+
+        return $this->bus->dispatch($firstJob);
+    }
+}

vendor/illuminate/support/Testing/Fakes/PendingMailFake.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use Illuminate\Contracts\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\Contracts\Mail\Mailable  $mailable
+     * @return void
+     */
+    public function send(Mailable $mailable)
+    {
+        $this->mailer->send($this->fill($mailable));
+    }
+
+    /**
+     * Push the given mailable onto the queue.
+     *
+     * @param  \Illuminate\Contracts\Mail\Mailable  $mailable
+     * @return mixed
+     */
+    public function queue(Mailable $mailable)
+    {
+        return $this->mailer->queue($this->fill($mailable));
+    }
+}

vendor/illuminate/support/Testing/Fakes/QueueFake.php

@@ -0,0 +1,461 @@
+<?php
+
+namespace Illuminate\Support\Testing\Fakes;
+
+use BadMethodCallException;
+use Closure;
+use Illuminate\Contracts\Queue\Queue;
+use Illuminate\Queue\QueueManager;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Traits\ReflectsClosures;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class QueueFake extends QueueManager implements Queue
+{
+    use ReflectsClosures;
+
+    /**
+     * The original queue manager.
+     *
+     * @var \Illuminate\Contracts\Queue\Queue
+     */
+    protected $queue;
+
+    /**
+     * The job types that should be intercepted instead of pushed to the queue.
+     *
+     * @var array
+     */
+    protected $jobsToFake;
+
+    /**
+     * All of the jobs that have been pushed.
+     *
+     * @var array
+     */
+    protected $jobs = [];
+
+    /**
+     * Create a new fake queue instance.
+     *
+     * @param  \Illuminate\Contracts\Foundation\Application  $app
+     * @param  array  $jobsToFake
+     * @param  \Illuminate\Queue\QueueManager|null  $queue
+     * @return void
+     */
+    public function __construct($app, $jobsToFake = [], $queue = null)
+    {
+        parent::__construct($app);
+
+        $this->jobsToFake = Collection::wrap($jobsToFake);
+        $this->queue = $queue;
+    }
+
+    /**
+     * Assert if a job was pushed based on a truth-test callback.
+     *
+     * @param  string|\Closure  $job
+     * @param  callable|int|null  $callback
+     * @return void
+     */
+    public function assertPushed($job, $callback = null)
+    {
+        if ($job instanceof Closure) {
+            [$job, $callback] = [$this->firstClosureParameterType($job), $job];
+        }
+
+        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)
+    {
+        $count = $this->pushed($job)->count();
+
+        PHPUnit::assertSame(
+            $times, $count,
+            "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|\Closure  $job
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertPushedOn($queue, $job, $callback = null)
+    {
+        if ($job instanceof Closure) {
+            [$job, $callback] = [$this->firstClosureParameterType($job), $job];
+        }
+
+        $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 an empty chain based on a truth-test callback.
+     *
+     * @param  string  $job
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertPushedWithoutChain($job, $callback = null)
+    {
+        PHPUnit::assertTrue(
+            $this->pushed($job, $callback)->isNotEmpty(),
+            "The expected [{$job}] job was not pushed."
+        );
+
+        $this->assertPushedWithChainOfClasses($job, [], $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(fn ($job) => serialize($job))->all();
+
+        PHPUnit::assertTrue(
+            $this->pushed($job, $callback)->filter(fn ($job) => $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)->contains(fn ($job) => ! is_object($job));
+    }
+
+    /**
+     * Determine if a job was pushed based on a truth-test callback.
+     *
+     * @param  string|\Closure  $job
+     * @param  callable|null  $callback
+     * @return void
+     */
+    public function assertNotPushed($job, $callback = null)
+    {
+        if ($job instanceof Closure) {
+            [$job, $callback] = [$this->firstClosureParameterType($job), $job];
+        }
+
+        PHPUnit::assertCount(
+            0, $this->pushed($job, $callback),
+            "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 ?: fn () => true;
+
+        return collect($this->jobs[$job])->filter(
+            fn ($data) => $callback($data['job'], $data['queue'], $data['data'])
+        )->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|null  $queue
+     * @return int
+     */
+    public function size($queue = null)
+    {
+        return collect($this->jobs)->flatten(1)->filter(
+            fn ($job) => $job['queue'] === $queue
+        )->count();
+    }
+
+    /**
+     * Push a new job onto the queue.
+     *
+     * @param  string|object  $job
+     * @param  mixed  $data
+     * @param  string|null  $queue
+     * @return mixed
+     */
+    public function push($job, $data = '', $queue = null)
+    {
+        if ($this->shouldFakeJob($job)) {
+            $this->jobs[is_object($job) ? get_class($job) : $job][] = [
+                'job' => $job,
+                'queue' => $queue,
+                'data' => $data,
+            ];
+        } else {
+            is_object($job) && isset($job->connection)
+                ? $this->queue->connection($job->connection)->push($job, $data, $queue)
+                : $this->queue->push($job, $data, $queue);
+        }
+    }
+
+    /**
+     * Determine if a job should be faked or actually dispatched.
+     *
+     * @param  object  $job
+     * @return bool
+     */
+    public function shouldFakeJob($job)
+    {
+        if ($this->jobsToFake->isEmpty()) {
+            return true;
+        }
+
+        return $this->jobsToFake->contains(
+            fn ($jobToFake) => $job instanceof ((string) $jobToFake)
+        );
+    }
+
+    /**
+     * Push a raw payload onto the queue.
+     *
+     * @param  string  $payload
+     * @param  string|null  $queue
+     * @param  array  $options
+     * @return mixed
+     */
+    public function pushRaw($payload, $queue = null, array $options = [])
+    {
+        //
+    }
+
+    /**
+     * Push a new job onto the queue after (n) seconds.
+     *
+     * @param  \DateTimeInterface|\DateInterval|int  $delay
+     * @param  string|object  $job
+     * @param  mixed  $data
+     * @param  string|null  $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|object  $job
+     * @param  mixed  $data
+     * @return mixed
+     */
+    public function pushOn($queue, $job, $data = '')
+    {
+        return $this->push($job, $data, $queue);
+    }
+
+    /**
+     * Push a new job onto a specific queue after (n) seconds.
+     *
+     * @param  string  $queue
+     * @param  \DateTimeInterface|\DateInterval|int  $delay
+     * @param  string|object  $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|null  $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|null  $queue
+     * @return mixed
+     */
+    public function bulk($jobs, $data = '', $queue = null)
+    {
+        foreach ($jobs as $job) {
+            $this->push($job, $data, $queue);
+        }
+    }
+
+    /**
+     * Get the jobs that have been pushed.
+     *
+     * @return array
+     */
+    public function pushedJobs()
+    {
+        return $this->jobs;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Override the QueueManager to prevent circular dependency.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     *
+     * @throws \BadMethodCallException
+     */
+    public function __call($method, $parameters)
+    {
+        throw new BadMethodCallException(sprintf(
+            'Call to undefined method %s::%s()', static::class, $method
+        ));
+    }
+}

vendor/illuminate/support/Traits/CapsuleManagerTrait.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Illuminate\Support\Traits;
+
+use Illuminate\Contracts\Container\Container;
+use Illuminate\Support\Fluent;
+
+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/illuminate/support/Traits/ForwardsCalls.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace Illuminate\Support\Traits;
+
+use BadMethodCallException;
+use Error;
+
+trait ForwardsCalls
+{
+    /**
+     * Forward a method call to the given object.
+     *
+     * @param  mixed  $object
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     *
+     * @throws \BadMethodCallException
+     */
+    protected function forwardCallTo($object, $method, $parameters)
+    {
+        try {
+            return $object->{$method}(...$parameters);
+        } catch (Error|BadMethodCallException $e) {
+            $pattern = '~^Call to undefined method (?P<class>[^:]+)::(?P<method>[^\(]+)\(\)$~';
+
+            if (! preg_match($pattern, $e->getMessage(), $matches)) {
+                throw $e;
+            }
+
+            if ($matches['class'] != get_class($object) ||
+                $matches['method'] != $method) {
+                throw $e;
+            }
+
+            static::throwBadMethodCallException($method);
+        }
+    }
+
+    /**
+     * Forward a method call to the given object, returning $this if the forwarded call returned itself.
+     *
+     * @param  mixed  $object
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     *
+     * @throws \BadMethodCallException
+     */
+    protected function forwardDecoratedCallTo($object, $method, $parameters)
+    {
+        $result = $this->forwardCallTo($object, $method, $parameters);
+
+        if ($result === $object) {
+            return $this;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Throw a bad method call exception for the given method.
+     *
+     * @param  string  $method
+     * @return void
+     *
+     * @throws \BadMethodCallException
+     */
+    protected static function throwBadMethodCallException($method)
+    {
+        throw new BadMethodCallException(sprintf(
+            'Call to undefined method %s::%s()', static::class, $method
+        ));
+    }
+}

vendor/illuminate/support/Traits/Localizable.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Illuminate\Support\Traits;
+
+use Illuminate\Container\Container;
+
+trait Localizable
+{
+    /**
+     * Run the callback with the given locale.
+     *
+     * @param  string  $locale
+     * @param  \Closure  $callback
+     * @return mixed
+     */
+    public function withLocale($locale, $callback)
+    {
+        if (! $locale) {
+            return $callback();
+        }
+
+        $app = Container::getInstance();
+
+        $original = $app->getLocale();
+
+        try {
+            $app->setLocale($locale);
+
+            return $callback();
+        } finally {
+            $app->setLocale($original);
+        }
+    }
+}

vendor/illuminate/support/Traits/ReflectsClosures.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Illuminate\Support\Traits;
+
+use Closure;
+use Illuminate\Support\Reflector;
+use ReflectionFunction;
+use RuntimeException;
+
+trait ReflectsClosures
+{
+    /**
+     * Get the class name of the first parameter of the given Closure.
+     *
+     * @param  \Closure  $closure
+     * @return string
+     *
+     * @throws \ReflectionException
+     * @throws \RuntimeException
+     */
+    protected function firstClosureParameterType(Closure $closure)
+    {
+        $types = array_values($this->closureParameterTypes($closure));
+
+        if (! $types) {
+            throw new RuntimeException('The given Closure has no parameters.');
+        }
+
+        if ($types[0] === null) {
+            throw new RuntimeException('The first parameter of the given Closure is missing a type hint.');
+        }
+
+        return $types[0];
+    }
+
+    /**
+     * Get the class names of the first parameter of the given Closure, including union types.
+     *
+     * @param  \Closure  $closure
+     * @return array
+     *
+     * @throws \ReflectionException
+     * @throws \RuntimeException
+     */
+    protected function firstClosureParameterTypes(Closure $closure)
+    {
+        $reflection = new ReflectionFunction($closure);
+
+        $types = collect($reflection->getParameters())->mapWithKeys(function ($parameter) {
+            if ($parameter->isVariadic()) {
+                return [$parameter->getName() => null];
+            }
+
+            return [$parameter->getName() => Reflector::getParameterClassNames($parameter)];
+        })->filter()->values()->all();
+
+        if (empty($types)) {
+            throw new RuntimeException('The given Closure has no parameters.');
+        }
+
+        if (isset($types[0]) && empty($types[0])) {
+            throw new RuntimeException('The first parameter of the given Closure is missing a type hint.');
+        }
+
+        return $types[0];
+    }
+
+    /**
+     * Get the class names / types of the parameters of the given Closure.
+     *
+     * @param  \Closure  $closure
+     * @return array
+     *
+     * @throws \ReflectionException
+     */
+    protected function closureParameterTypes(Closure $closure)
+    {
+        $reflection = new ReflectionFunction($closure);
+
+        return collect($reflection->getParameters())->mapWithKeys(function ($parameter) {
+            if ($parameter->isVariadic()) {
+                return [$parameter->getName() => null];
+            }
+
+            return [$parameter->getName() => Reflector::getParameterClassName($parameter)];
+        })->all();
+    }
+}

vendor/illuminate/support/Traits/Tappable.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Illuminate\Support\Traits;
+
+trait Tappable
+{
+    /**
+     * Call the given Closure with this instance then return the instance.
+     *
+     * @param  callable|null  $callback
+     * @return $this|\Illuminate\Support\HigherOrderTapProxy
+     */
+    public function tap($callback = null)
+    {
+        return tap($this, $callback);
+    }
+}

vendor/illuminate/support/ValidatedInput.php

@@ -0,0 +1,245 @@
+<?php
+
+namespace Illuminate\Support;
+
+use ArrayIterator;
+use Illuminate\Contracts\Support\ValidatedData;
+use stdClass;
+use Traversable;
+
+class ValidatedInput implements ValidatedData
+{
+    /**
+     * The underlying input.
+     *
+     * @var array
+     */
+    protected $input;
+
+    /**
+     * Create a new validated input container.
+     *
+     * @param  array  $input
+     * @return void
+     */
+    public function __construct(array $input)
+    {
+        $this->input = $input;
+    }
+
+    /**
+     * Determine if the validated input has one or more keys.
+     *
+     * @param  mixed  $keys
+     * @return bool
+     */
+    public function has($keys)
+    {
+        $keys = is_array($keys) ? $keys : func_get_args();
+
+        foreach ($keys as $key) {
+            if (! Arr::has($this->input, $key)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Determine if the validated input is missing one or more keys.
+     *
+     * @param  mixed  $keys
+     * @return bool
+     */
+    public function missing($keys)
+    {
+        return ! $this->has($keys);
+    }
+
+    /**
+     * Get a subset containing the provided keys with values from the input data.
+     *
+     * @param  mixed  $keys
+     * @return array
+     */
+    public function only($keys)
+    {
+        $results = [];
+
+        $input = $this->input;
+
+        $placeholder = new stdClass;
+
+        foreach (is_array($keys) ? $keys : func_get_args() as $key) {
+            $value = data_get($input, $key, $placeholder);
+
+            if ($value !== $placeholder) {
+                Arr::set($results, $key, $value);
+            }
+        }
+
+        return $results;
+    }
+
+    /**
+     * Get all of the input except for a specified array of items.
+     *
+     * @param  mixed  $keys
+     * @return array
+     */
+    public function except($keys)
+    {
+        $keys = is_array($keys) ? $keys : func_get_args();
+
+        $results = $this->input;
+
+        Arr::forget($results, $keys);
+
+        return $results;
+    }
+
+    /**
+     * Merge the validated input with the given array of additional data.
+     *
+     * @param  array  $items
+     * @return static
+     */
+    public function merge(array $items)
+    {
+        return new static(array_merge($this->input, $items));
+    }
+
+    /**
+     * Get the input as a collection.
+     *
+     * @return \Illuminate\Support\Collection
+     */
+    public function collect()
+    {
+        return new Collection($this->input);
+    }
+
+    /**
+     * Get the raw, underlying input array.
+     *
+     * @return array
+     */
+    public function all()
+    {
+        return $this->input;
+    }
+
+    /**
+     * Get the instance as an array.
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->all();
+    }
+
+    /**
+     * Dynamically access input data.
+     *
+     * @param  string  $name
+     * @return mixed
+     */
+    public function __get($name)
+    {
+        return $this->input[$name];
+    }
+
+    /**
+     * Dynamically set input data.
+     *
+     * @param  string  $name
+     * @param  mixed  $value
+     * @return mixed
+     */
+    public function __set($name, $value)
+    {
+        $this->input[$name] = $value;
+    }
+
+    /**
+     * Determine if an input key is set.
+     *
+     * @return bool
+     */
+    public function __isset($name)
+    {
+        return isset($this->input[$name]);
+    }
+
+    /**
+     * Remove an input key.
+     *
+     * @param  string  $name
+     * @return void
+     */
+    public function __unset($name)
+    {
+        unset($this->input[$name]);
+    }
+
+    /**
+     * Determine if an item exists at an offset.
+     *
+     * @param  mixed  $key
+     * @return bool
+     */
+    public function offsetExists($key): bool
+    {
+        return isset($this->input[$key]);
+    }
+
+    /**
+     * Get an item at a given offset.
+     *
+     * @param  mixed  $key
+     * @return mixed
+     */
+    public function offsetGet($key): mixed
+    {
+        return $this->input[$key];
+    }
+
+    /**
+     * Set the item at a given offset.
+     *
+     * @param  mixed  $key
+     * @param  mixed  $value
+     * @return void
+     */
+    public function offsetSet($key, $value): void
+    {
+        if (is_null($key)) {
+            $this->input[] = $value;
+        } else {
+            $this->input[$key] = $value;
+        }
+    }
+
+    /**
+     * Unset the item at a given offset.
+     *
+     * @param  string  $key
+     * @return void
+     */
+    public function offsetUnset($key): void
+    {
+        unset($this->input[$key]);
+    }
+
+    /**
+     * Get an iterator for the input.
+     *
+     * @return \ArrayIterator
+     */
+    public function getIterator(): Traversable
+    {
+        return new ArrayIterator($this->input);
+    }
+}

vendor/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(): int
+    {
+        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/illuminate/support/composer.json

@@ -0,0 +1,56 @@
+{
+    "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": "^8.0.2",
+        "ext-json": "*",
+        "ext-mbstring": "*",
+        "doctrine/inflector": "^2.0",
+        "illuminate/collections": "^9.0",
+        "illuminate/conditionable": "^9.0",
+        "illuminate/contracts": "^9.0",
+        "illuminate/macroable": "^9.0",
+        "nesbot/carbon": "^2.53.1",
+        "voku/portable-ascii": "^2.0"
+    },
+    "conflict": {
+        "tightenco/collect": "<5.5.33"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Support\\": ""
+        },
+        "files": [
+            "helpers.php"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "9.x-dev"
+        }
+    },
+    "suggest": {
+        "illuminate/filesystem": "Required to use the composer class (^9.0).",
+        "league/commonmark": "Required to use Str::markdown() and Stringable::markdown() (^2.0.2).",
+        "ramsey/uuid": "Required to use Str::uuid() (^4.2.2).",
+        "symfony/process": "Required to use the composer class (^6.0).",
+        "symfony/var-dumper": "Required to use the dd function (^6.0).",
+        "vlucas/phpdotenv": "Required to use the Env class and env helper (^5.4.1)."
+    },
+    "config": {
+        "sort-packages": true
+    },
+    "minimum-stability": "dev"
+}

vendor/illuminate/support/helpers.php

@@ -0,0 +1,420 @@
+<?php
+
+use Illuminate\Contracts\Support\DeferringDisplayableValue;
+use Illuminate\Contracts\Support\Htmlable;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Env;
+use Illuminate\Support\HigherOrderTapProxy;
+use Illuminate\Support\Optional;
+use Illuminate\Support\Str;
+
+if (! function_exists('append_config')) {
+    /**
+     * Assign high numeric IDs to a config item to force appending.
+     *
+     * @param  array  $array
+     * @return array
+     */
+    function append_config(array $array)
+    {
+        $start = 9999;
+
+        foreach ($array as $key => $value) {
+            if (is_numeric($key)) {
+                $start++;
+
+                $array[$start] = Arr::pull($array, $key);
+            }
+        }
+
+        return $array;
+    }
+}
+
+if (! function_exists('blank')) {
+    /**
+     * Determine if the given value is "blank".
+     *
+     * @param  mixed  $value
+     * @return bool
+     */
+    function blank($value)
+    {
+        if (is_null($value)) {
+            return true;
+        }
+
+        if (is_string($value)) {
+            return trim($value) === '';
+        }
+
+        if (is_numeric($value) || is_bool($value)) {
+            return false;
+        }
+
+        if ($value instanceof Countable) {
+            return count($value) === 0;
+        }
+
+        return empty($value);
+    }
+}
+
+if (! function_exists('class_basename')) {
+    /**
+     * Get the class "basename" of the given object / class.
+     *
+     * @param  string|object  $class
+     * @return string
+     */
+    function class_basename($class)
+    {
+        $class = is_object($class) ? get_class($class) : $class;
+
+        return basename(str_replace('\\', '/', $class));
+    }
+}
+
+if (! function_exists('class_uses_recursive')) {
+    /**
+     * Returns all traits used by a class, its parent classes and trait of their traits.
+     *
+     * @param  object|string  $class
+     * @return array
+     */
+    function class_uses_recursive($class)
+    {
+        if (is_object($class)) {
+            $class = get_class($class);
+        }
+
+        $results = [];
+
+        foreach (array_reverse(class_parents($class)) + [$class => $class] as $class) {
+            $results += trait_uses_recursive($class);
+        }
+
+        return array_unique($results);
+    }
+}
+
+if (! function_exists('e')) {
+    /**
+     * Encode HTML special characters in a string.
+     *
+     * @param  \Illuminate\Contracts\Support\DeferringDisplayableValue|\Illuminate\Contracts\Support\Htmlable|string|null  $value
+     * @param  bool  $doubleEncode
+     * @return string
+     */
+    function e($value, $doubleEncode = true)
+    {
+        if ($value instanceof DeferringDisplayableValue) {
+            $value = $value->resolveDisplayableValue();
+        }
+
+        if ($value instanceof Htmlable) {
+            return $value->toHtml();
+        }
+
+        return htmlspecialchars($value ?? '', ENT_QUOTES, 'UTF-8', $doubleEncode);
+    }
+}
+
+if (! function_exists('env')) {
+    /**
+     * Gets the value of an environment variable.
+     *
+     * @param  string  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    function env($key, $default = null)
+    {
+        return Env::get($key, $default);
+    }
+}
+
+if (! function_exists('filled')) {
+    /**
+     * Determine if a value is "filled".
+     *
+     * @param  mixed  $value
+     * @return bool
+     */
+    function filled($value)
+    {
+        return ! blank($value);
+    }
+}
+
+if (! function_exists('object_get')) {
+    /**
+     * Get an item from an object using "dot" notation.
+     *
+     * @param  object  $object
+     * @param  string|null  $key
+     * @param  mixed  $default
+     * @return mixed
+     */
+    function object_get($object, $key, $default = null)
+    {
+        if (is_null($key) || trim($key) === '') {
+            return $object;
+        }
+
+        foreach (explode('.', $key) as $segment) {
+            if (! is_object($object) || ! isset($object->{$segment})) {
+                return value($default);
+            }
+
+            $object = $object->{$segment};
+        }
+
+        return $object;
+    }
+}
+
+if (! function_exists('optional')) {
+    /**
+     * Provide access to optional objects.
+     *
+     * @param  mixed  $value
+     * @param  callable|null  $callback
+     * @return mixed
+     */
+    function optional($value = null, callable $callback = null)
+    {
+        if (is_null($callback)) {
+            return new Optional($value);
+        } elseif (! is_null($value)) {
+            return $callback($value);
+        }
+    }
+}
+
+if (! function_exists('preg_replace_array')) {
+    /**
+     * Replace a given pattern with each value in the array in sequentially.
+     *
+     * @param  string  $pattern
+     * @param  array  $replacements
+     * @param  string  $subject
+     * @return string
+     */
+    function preg_replace_array($pattern, array $replacements, $subject)
+    {
+        return preg_replace_callback($pattern, function () use (&$replacements) {
+            foreach ($replacements as $value) {
+                return array_shift($replacements);
+            }
+        }, $subject);
+    }
+}
+
+if (! function_exists('retry')) {
+    /**
+     * Retry an operation a given number of times.
+     *
+     * @param  int|array  $times
+     * @param  callable  $callback
+     * @param  int|\Closure  $sleepMilliseconds
+     * @param  callable|null  $when
+     * @return mixed
+     *
+     * @throws \Exception
+     */
+    function retry($times, callable $callback, $sleepMilliseconds = 0, $when = null)
+    {
+        $attempts = 0;
+
+        $backoff = [];
+
+        if (is_array($times)) {
+            $backoff = $times;
+
+            $times = count($times) + 1;
+        }
+
+        beginning:
+        $attempts++;
+        $times--;
+
+        try {
+            return $callback($attempts);
+        } catch (Exception $e) {
+            if ($times < 1 || ($when && ! $when($e))) {
+                throw $e;
+            }
+
+            $sleepMilliseconds = $backoff[$attempts - 1] ?? $sleepMilliseconds;
+
+            if ($sleepMilliseconds) {
+                usleep(value($sleepMilliseconds, $attempts, $e) * 1000);
+            }
+
+            goto beginning;
+        }
+    }
+}
+
+if (! function_exists('str')) {
+    /**
+     * Get a new stringable object from the given string.
+     *
+     * @param  string|null  $string
+     * @return \Illuminate\Support\Stringable|mixed
+     */
+    function str($string = null)
+    {
+        if (func_num_args() === 0) {
+            return new class
+            {
+                public function __call($method, $parameters)
+                {
+                    return Str::$method(...$parameters);
+                }
+
+                public function __toString()
+                {
+                    return '';
+                }
+            };
+        }
+
+        return Str::of($string);
+    }
+}
+
+if (! function_exists('tap')) {
+    /**
+     * Call the given Closure with the given value then return the value.
+     *
+     * @param  mixed  $value
+     * @param  callable|null  $callback
+     * @return mixed
+     */
+    function tap($value, $callback = null)
+    {
+        if (is_null($callback)) {
+            return new HigherOrderTapProxy($value);
+        }
+
+        $callback($value);
+
+        return $value;
+    }
+}
+
+if (! function_exists('throw_if')) {
+    /**
+     * Throw the given exception if the given condition is true.
+     *
+     * @param  mixed  $condition
+     * @param  \Throwable|string  $exception
+     * @param  mixed  ...$parameters
+     * @return mixed
+     *
+     * @throws \Throwable
+     */
+    function throw_if($condition, $exception = 'RuntimeException', ...$parameters)
+    {
+        if ($condition) {
+            if (is_string($exception) && class_exists($exception)) {
+                $exception = new $exception(...$parameters);
+            }
+
+            throw is_string($exception) ? new RuntimeException($exception) : $exception;
+        }
+
+        return $condition;
+    }
+}
+
+if (! function_exists('throw_unless')) {
+    /**
+     * Throw the given exception unless the given condition is true.
+     *
+     * @param  mixed  $condition
+     * @param  \Throwable|string  $exception
+     * @param  mixed  ...$parameters
+     * @return mixed
+     *
+     * @throws \Throwable
+     */
+    function throw_unless($condition, $exception = 'RuntimeException', ...$parameters)
+    {
+        throw_if(! $condition, $exception, ...$parameters);
+
+        return $condition;
+    }
+}
+
+if (! function_exists('trait_uses_recursive')) {
+    /**
+     * Returns all traits used by a trait and its traits.
+     *
+     * @param  string  $trait
+     * @return array
+     */
+    function trait_uses_recursive($trait)
+    {
+        $traits = class_uses($trait) ?: [];
+
+        foreach ($traits as $trait) {
+            $traits += trait_uses_recursive($trait);
+        }
+
+        return $traits;
+    }
+}
+
+if (! function_exists('transform')) {
+    /**
+     * Transform the given value if it is present.
+     *
+     * @param  mixed  $value
+     * @param  callable  $callback
+     * @param  mixed  $default
+     * @return mixed|null
+     */
+    function transform($value, callable $callback, $default = null)
+    {
+        if (filled($value)) {
+            return $callback($value);
+        }
+
+        if (is_callable($default)) {
+            return $default($value);
+        }
+
+        return $default;
+    }
+}
+
+if (! function_exists('windows_os')) {
+    /**
+     * Determine whether the current environment is Windows based.
+     *
+     * @return bool
+     */
+    function windows_os()
+    {
+        return PHP_OS_FAMILY === 'Windows';
+    }
+}
+
+if (! function_exists('with')) {
+    /**
+     * Return the given value, optionally passed through the given callback.
+     *
+     * @template TValue
+     *
+     * @param  TValue  $value
+     * @param  (callable(TValue): TValue)|null  $callback
+     * @return TValue
+     */
+    function with($value, callable $callback = null)
+    {
+        return is_null($callback) ? $value : $callback($value);
+    }
+}