diff --git a/extensions/Others/ForceTheme/ForceTheme.php b/extensions/Others/ForceTheme/ForceTheme.php
index a1a399494..6d25546fc 100644
--- a/extensions/Others/ForceTheme/ForceTheme.php
+++ b/extensions/Others/ForceTheme/ForceTheme.php
@@ -41,7 +41,8 @@ class ForceTheme extends Extension
$key = $this->config('local_storage_key') ?: '_x_darkMode';
$modeJs = e($mode);
$keyJs = e($key);
- $script = "";
+ // Only set the default when the user has not yet made a choice; respect any existing selection so toggles persist.
+ $script = "";
return ['view' => new HtmlString($script)];
});
}
diff --git a/extensions/Others/UptimeLab/resources/views/index.blade.php b/extensions/Others/UptimeLab/resources/views/index.blade.php
index 2a5777e13..6d00a4b68 100644
--- a/extensions/Others/UptimeLab/resources/views/index.blade.php
+++ b/extensions/Others/UptimeLab/resources/views/index.blade.php
@@ -1,4 +1,4 @@
-
+
\ No newline at end of file
diff --git a/themes/lucentui/views/layouts/colors.blade.php.bak b/themes/lucentui/views/layouts/colors.blade.php.bak
new file mode 100644
index 000000000..4053e7023
--- /dev/null
+++ b/themes/lucentui/views/layouts/colors.blade.php.bak
@@ -0,0 +1 @@
+{{-- Backup of colors.blade.php before Volt-inspired theme refresh --}}
diff --git a/themes/lucentui/views/vendor/pterodactyl2/console.blade.php b/themes/lucentui/views/vendor/pterodactyl2/console.blade.php
index 107f9b3c2..9c5341491 100644
--- a/themes/lucentui/views/vendor/pterodactyl2/console.blade.php
+++ b/themes/lucentui/views/vendor/pterodactyl2/console.blade.php
@@ -54,7 +54,7 @@
@endassets
{{-- Page Header --}}
diff --git a/vendor/_laravel_ide/discover-43419e1773d5590e98dcbfc1b7903297.php b/vendor/_laravel_ide/discover-43419e1773d5590e98dcbfc1b7903297.php
new file mode 100644
index 000000000..a0f81547e
--- /dev/null
+++ b/vendor/_laravel_ide/discover-43419e1773d5590e98dcbfc1b7903297.php
@@ -0,0 +1,361 @@
+getMessage());
+ }
+}
+
+try {
+ $app = require_once __DIR__ . '/../../bootstrap/app.php';
+} catch (\Throwable $e) {
+ LaravelVsCode::startupError($e);
+ exit(1);
+}
+
+$app->register(new class($app) extends \Illuminate\Support\ServiceProvider
+{
+ public function boot()
+ {
+ config([
+ 'logging.channels.null' => [
+ 'driver' => 'monolog',
+ 'handler' => \Monolog\Handler\NullHandler::class,
+ ],
+ 'logging.default' => 'null',
+ ]);
+ }
+});
+
+try {
+ $kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);
+ $kernel->bootstrap();
+} catch (\Throwable $e) {
+ LaravelVsCode::startupError($e);
+ exit(1);
+}
+
+echo LaravelVsCode::outputMarker('START_OUTPUT');
+
+if (class_exists('\phpDocumentor\Reflection\DocBlockFactory')) {
+ $factory = \phpDocumentor\Reflection\DocBlockFactory::createInstance();
+} else {
+ $factory = null;
+}
+
+$docblocks = new class($factory) {
+ public function __construct(protected $factory) {}
+
+ public function forMethod($method)
+ {
+ if ($this->factory !== null) {
+ $docblock = $this->factory->create($method->getDocComment());
+ $params = collect($docblock->getTagsByName("param"))->map(fn($p) => (string) $p)->all();
+ $return = (string) $docblock->getTagsByName("return")[0] ?? null;
+
+ return [$params, $return];
+ }
+
+
+ $params = collect($method->getParameters())
+ ->map(function (\ReflectionParameter $param) {
+ $types = match ($param?->getType()) {
+ null => [],
+ default => method_exists($param->getType(), "getTypes")
+ ? $param->getType()->getTypes()
+ : [$param->getType()]
+ };
+
+ $types = collect($types)
+ ->filter()
+ ->values()
+ ->map(fn($t) => $t->getName());
+
+ return trim($types->join("|") . " $" . $param->getName());
+ })
+ ->all();
+
+ $return = $method->getReturnType()?->getName();
+
+ return [$params, $return];
+ }
+};
+
+$models = new class($factory) {
+ protected $output;
+
+ public function __construct(protected $factory)
+ {
+ $this->output = new \Symfony\Component\Console\Output\BufferedOutput();
+ }
+
+ public function all()
+ {
+ if (\Illuminate\Support\Facades\File::isDirectory(base_path('app/Models'))) {
+ collect(\Illuminate\Support\Facades\File::allFiles(base_path('app/Models')))
+ ->filter(fn(\Symfony\Component\Finder\SplFileInfo $file) => $file->getExtension() === 'php')
+ ->each(fn($file) => include_once($file));
+ }
+
+ return collect(get_declared_classes())
+ ->filter(fn($class) => is_subclass_of($class, \Illuminate\Database\Eloquent\Model::class))
+ ->filter(fn($class) => !in_array($class, [\Illuminate\Database\Eloquent\Relations\Pivot::class, \Illuminate\Foundation\Auth\User::class]))
+ ->values()
+ ->flatMap(fn(string $className) => $this->getInfo($className))
+ ->filter();
+ }
+
+ protected function getCastReturnType($className)
+ {
+ if ($className === null) {
+ return null;
+ }
+
+ try {
+ $method = (new \ReflectionClass($className))->getMethod('get');
+
+ if ($method->hasReturnType()) {
+ return $method->getReturnType()->getName();
+ }
+
+ return $className;
+ } catch (\Exception | \Throwable $e) {
+ return $className;
+ }
+ }
+
+ protected function fromArtisan($className)
+ {
+ try {
+ \Illuminate\Support\Facades\Artisan::call(
+ "model:show",
+ [
+ "model" => $className,
+ "--json" => true,
+ ],
+ $this->output
+ );
+ } catch (\Exception | \Throwable $e) {
+ return null;
+ }
+
+ return json_decode($this->output->fetch(), true);
+ }
+
+ protected function collectExistingProperties($reflection)
+ {
+ if ($this->factory === null) {
+ return collect();
+ }
+
+ if ($comment = $reflection->getDocComment()) {
+ $docblock = $this->factory->create($comment);
+
+ $existingProperties = collect($docblock->getTagsByName("property"))->map(fn($p) => $p->getVariableName());
+ $existingReadProperties = collect($docblock->getTagsByName("property-read"))->map(fn($p) => $p->getVariableName());
+
+ return $existingProperties->merge($existingReadProperties);
+ }
+
+ return collect();
+ }
+
+ protected function getParentClass(\ReflectionClass $reflection)
+ {
+ if (!$reflection->getParentClass()) {
+ return null;
+ }
+
+ $parent = $reflection->getParentClass()->getName();
+
+ if ($parent === \Illuminate\Database\Eloquent\Model::class) {
+ return null;
+ }
+
+ return \Illuminate\Support\Str::start($parent, '\\');
+ }
+
+ protected function getInfo($className)
+ {
+ if (($data = $this->fromArtisan($className)) === null) {
+ return null;
+ }
+
+ $reflection = new \ReflectionClass($className);
+
+ $data["extends"] = $this->getParentClass($reflection);
+
+ $existingProperties = $this->collectExistingProperties($reflection);
+
+ $data['attributes'] = collect($data['attributes'])
+ ->map(fn($attrs) => array_merge($attrs, [
+ 'title_case' => str($attrs['name'])->title()->replace('_', '')->toString(),
+ 'documented' => $existingProperties->contains($attrs['name']),
+ 'cast' => $this->getCastReturnType($attrs['cast'])
+ ]))
+ ->toArray();
+
+ $data['scopes'] = collect($reflection->getMethods())
+ ->filter(fn(\ReflectionMethod $method) => !$method->isStatic() && ($method->getAttributes(\Illuminate\Database\Eloquent\Attributes\Scope::class) || ($method->isPublic() && str_starts_with($method->name, 'scope'))))
+ ->map(fn(\ReflectionMethod $method) => [
+ "name" => str($method->name)->replace('scope', '')->lcfirst()->toString(),
+ "method" => $method->name,
+ "parameters" => collect($method->getParameters())->map($this->getScopeParameterInfo(...)),
+ ])
+ ->values()
+ ->toArray();
+
+ $data['relations'] = collect($data['relations'])
+ ->map(fn($relation) => array_merge($relation, [
+ 'snake_case' => \Illuminate\Support\Str::snake($relation['name']),
+ ]))
+ ->toArray();
+
+ $data['path'] = LaravelVsCode::relativePath($reflection->getFileName() ?: '');
+
+ return [
+ $className => $data,
+ ];
+ }
+
+ protected function getScopeParameterInfo(\ReflectionParameter $parameter): array
+ {
+ $result = [
+ "name" => $parameter->getName(),
+ "type" => $this->typeToString($parameter->getType()),
+ "hasDefault" => $parameter->isDefaultValueAvailable(),
+ "isVariadic" => $parameter->isVariadic(),
+ "isPassedByReference" => $parameter->isPassedByReference(),
+ ];
+
+ if ($parameter->isDefaultValueAvailable()) {
+ $result['default'] = $this->defaultValueToString($parameter);
+ }
+
+ return $result;
+ }
+
+ protected function typeToString(?\ReflectionType $type): string
+ {
+ return match (true) {
+ $type instanceof \ReflectionNamedType => $this->namedTypeToString($type),
+ $type instanceof \ReflectionUnionType => $this->unionTypeToString($type),
+ $type instanceof \ReflectionIntersectionType => $this->intersectionTypeToString($type),
+ default => 'mixed',
+ };
+ }
+
+ protected function namedTypeToString(\ReflectionNamedType $type): string
+ {
+ $name = $type->getName();
+
+ if (! $type->isBuiltin() && ! in_array($name, ['self', 'parent', 'static'])) {
+ $name = '\\'.$name;
+ }
+
+ if ($type->allowsNull() && ! in_array($name, ['null', 'mixed', 'void'])) {
+ $name = '?'.$name;
+ }
+
+ return $name;
+ }
+
+ protected function unionTypeToString(\ReflectionUnionType $type): string
+ {
+ return implode('|', array_map(function (\ReflectionType $type) {
+ $result = $this->typeToString($type);
+
+ if ($type instanceof \ReflectionIntersectionType) {
+ return "({$result})";
+ }
+
+ return $result;
+ }, $type->getTypes()));
+ }
+
+ protected function intersectionTypeToString(\ReflectionIntersectionType $type): string
+ {
+ return implode('&', array_map($this->typeToString(...), $type->getTypes()));
+ }
+
+ protected function defaultValueToString(\ReflectionParameter $param): string
+ {
+ if ($param->isDefaultValueConstant()) {
+ return '\\'.$param->getDefaultValueConstantName();
+ }
+
+ $value = $param->getDefaultValue();
+
+ return match (true) {
+ is_null($value) => 'null',
+ is_numeric($value) => $value,
+ is_bool($value) => $value ? 'true' : 'false',
+ is_array($value) => '[]',
+ is_object($value) => 'new \\'.get_class($value),
+ default => "'{$value}'",
+ };
+ }
+};
+
+$builder = new class($docblocks) {
+ public function __construct(protected $docblocks) {}
+
+ public function methods()
+ {
+ $reflection = new \ReflectionClass(\Illuminate\Database\Query\Builder::class);
+
+ return collect($reflection->getMethods(\ReflectionMethod::IS_PUBLIC | \ReflectionMethod::IS_PROTECTED))
+ ->filter(fn(ReflectionMethod $method) => !str_starts_with($method->getName(), "__") || (!$method->isPublic() && empty($method->getAttributes(\Illuminate\Database\Eloquent\Attributes\Scope::class))))
+ ->map(fn(\ReflectionMethod $method) => $this->getMethodInfo($method))
+ ->filter()
+ ->values();
+ }
+
+ protected function getMethodInfo($method)
+ {
+ [$params, $return] = $this->docblocks->forMethod($method);
+
+ return [
+ "name" => $method->getName(),
+ "parameters" => $params,
+ "return" => $return,
+ ];
+ }
+};
+
+echo json_encode([
+ 'builderMethods' => $builder->methods(),
+ 'models' => $models->all(),
+]);
+
+echo LaravelVsCode::outputMarker('END_OUTPUT');
+
+exit(0);
diff --git a/vendor/_laravel_ide/discover-4dd8aa2c89a79640c26a5af93ae899b1.php b/vendor/_laravel_ide/discover-4dd8aa2c89a79640c26a5af93ae899b1.php
new file mode 100644
index 000000000..62052d1d0
--- /dev/null
+++ b/vendor/_laravel_ide/discover-4dd8aa2c89a79640c26a5af93ae899b1.php
@@ -0,0 +1,314 @@
+getMessage());
+ }
+}
+
+try {
+ $app = require_once __DIR__ . '/../../bootstrap/app.php';
+} catch (\Throwable $e) {
+ LaravelVsCode::startupError($e);
+ exit(1);
+}
+
+$app->register(new class($app) extends \Illuminate\Support\ServiceProvider
+{
+ public function boot()
+ {
+ config([
+ 'logging.channels.null' => [
+ 'driver' => 'monolog',
+ 'handler' => \Monolog\Handler\NullHandler::class,
+ ],
+ 'logging.default' => 'null',
+ ]);
+ }
+});
+
+try {
+ $kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);
+ $kernel->bootstrap();
+} catch (\Throwable $e) {
+ LaravelVsCode::startupError($e);
+ exit(1);
+}
+
+echo LaravelVsCode::outputMarker('START_OUTPUT');
+
+use Illuminate\Support\Facades\File;
+use Pest\Contracts\HasPrintableTestCaseName;
+use Pest\Support\Str as PestStr;
+use Pest\TestSuite;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Runner\TestSuiteLoader;
+use PHPUnit\TextUI\XmlConfiguration\LoadedFromFileConfiguration;
+use PHPUnit\TextUI\XmlConfiguration\Loader as XmlConfigurationLoader;
+use SebastianBergmann\FileIterator\Facade as FileIterator;
+
+$tests = new class {
+ public function all(): array
+ {
+ if (! $this->isPhpUnitInstalled()) {
+ return [];
+ }
+
+ if ($this->isPestInstalled()) {
+ $this->bootPest();
+ }
+
+ return collect(
+ $this->getTestSuites()
+ )->map(fn ($suite) => [
+ 'name' => $suite['name'],
+ 'files' => collect(array_merge(
+ $this->collectPhpUnitTests($suite['files']),
+ $this->collectPestTests($suite['files']),
+ ))->map($this->pathsTransformer($suite['directories'])),
+ ])->all();
+ }
+
+ protected function pathsTransformer(array $directories): callable
+ {
+ $directories = array_map(LaravelVsCode::relativePath(...), $directories);
+
+ return function (array $file) use ($directories) {
+ return array_merge($file, [
+ 'path' => $path = LaravelVsCode::relativePath($file['path']),
+ 'name' => str($path)->basename()->replace('.php', ''),
+ 'directories' => str($path)->dirname()
+ ->replace($directories, '')
+ ->ltrim(DIRECTORY_SEPARATOR)
+ ->explode(DIRECTORY_SEPARATOR)
+ ->filter(),
+ ]);
+ };
+ }
+
+ protected function isPhpUnitInstalled(): bool
+ {
+ return class_exists(TestCase::class);
+ }
+
+ protected function isPestInstalled(): bool
+ {
+ return class_exists(TestSuite::class);
+ }
+
+ protected function bootPest(): void
+ {
+ require_once base_path('vendor/pestphp/pest/overrides/Runner/TestSuiteLoader.php');
+
+ TestSuite::getInstance(base_path(), 'tests');
+
+ if (file_exists($pestFile = base_path('tests/Pest.php'))) {
+ require_once $pestFile;
+ }
+ }
+
+ /**
+ * @return array, files: array}>
+ */
+ protected function getTestSuites(): array
+ {
+ if (is_null($config = $this->loadConfig())) {
+ return [[
+ 'name' => 'default',
+ 'directories' => [base_path('tests')],
+ 'files' => $this->findTestFiles(base_path('tests')),
+ ]];
+ }
+
+ $result = [];
+
+ foreach ($config->testSuite() as $suite) {
+ $files = collect();
+
+ foreach ($suite->directories() as $directory) {
+ $files->push(...$this->findTestFiles($directory->path()));
+ }
+
+ foreach ($suite->files() as $file) {
+ $files->push($file->path());
+ }
+
+ $result[] = [
+ 'name' => $suite->name(),
+ 'directories' => collect($suite->directories()->asArray())->map->path()->all(),
+ 'files' => $files->all(),
+ ];
+ }
+
+ return $result;
+ }
+
+ protected function loadConfig(): ?LoadedFromFileConfiguration
+ {
+ foreach ([
+ base_path('phpunit.xml'),
+ base_path('phpunit.xml.dist'),
+ ] as $path) {
+ if (File::exists($path)) {
+ return (new XmlConfigurationLoader)->load($path);
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * @return array
+ */
+ protected function findTestFiles(string $directory): array
+ {
+ return (new FileIterator)->getFilesAsArray($directory, 'Test.php');
+ }
+
+ /**
+ * @param array $files
+ * @return array{path:string, tests: array}
+ */
+ protected function collectPestTests(array $files): array
+ {
+ if (! $this->isPestInstalled()) {
+ return [];
+ }
+
+ if (is_null($pest = TestSuite::getInstance())) {
+ return [];
+ }
+
+ $results = [];
+
+ foreach ($files as $path) {
+ if (is_null($factory = $pest->tests->get($path))) {
+ continue;
+ }
+
+ $results[] = [
+ 'path' => $path,
+ 'tests' => collect($factory->methods)
+ ->whereNotNull('description')
+ ->map(fn ($method) => [
+ 'name' => $method->description,
+ 'eventName' => PestStr::evaluable($method->description),
+ 'line' => (new ReflectionFunction($method->closure))->getStartLine(),
+ ])
+ ->values()
+ ->all(),
+ ];
+ }
+
+ return $results;
+ }
+
+ /**
+ * @param array $files
+ * @return array{path:string, tests: array}
+ */
+ protected function collectPhpUnitTests(array $files): array
+ {
+ $loader = new TestSuiteLoader;
+
+ $results = [];
+
+ foreach ($files as $path) {
+ try {
+ $reflection = $loader->load($path);
+ } catch (Throwable $e) {
+ continue;
+ }
+
+ if (! $this->isPhpUnitTest($reflection)) {
+ continue;
+ }
+
+ $tests = $this->extractTestMethods($reflection);
+
+ if (! empty($tests)) {
+ $results[] = compact('path', 'tests');
+ }
+ }
+
+ return $results;
+ }
+
+ protected function isPhpUnitTest(ReflectionClass $reflection): bool
+ {
+ if (! $this->isPestInstalled()) {
+ return $reflection->isSubclassOf(TestCase::class);
+ }
+
+ return $reflection->isSubclassOf(TestCase::class)
+ && ! $reflection->implementsInterface(HasPrintableTestCaseName::class);
+ }
+
+ /**
+ * @param ReflectionClass $reflection
+ * @return array
+ */
+ protected function extractTestMethods(ReflectionClass $reflection): array
+ {
+ $tests = [];
+
+ foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
+ if ($method->getDeclaringClass()->getName() !== $reflection->getName()) {
+ continue;
+ }
+
+ if (! $this->isTestMethod($method)) {
+ continue;
+ }
+
+ $tests[] = [
+ 'name' => $name = $method->getName(),
+ 'eventName' => $name,
+ 'line' => $method->getStartLine(),
+ ];
+ }
+
+ return $tests;
+ }
+
+ protected function isTestMethod(ReflectionMethod $method): bool
+ {
+ return str_starts_with($method->getName(), 'test')
+ || $method->getAttributes(Test::class) !== [];
+ }
+};
+
+echo json_encode($tests->all());
+
+echo LaravelVsCode::outputMarker('END_OUTPUT');
+
+exit(0);
diff --git a/vendor/_laravel_ide/discover-bf37f1dc35944596ec71c910bc1ca84f.php b/vendor/_laravel_ide/discover-bf37f1dc35944596ec71c910bc1ca84f.php
new file mode 100644
index 000000000..6255f926b
--- /dev/null
+++ b/vendor/_laravel_ide/discover-bf37f1dc35944596ec71c910bc1ca84f.php
@@ -0,0 +1,154 @@
+getMessage());
+ }
+}
+
+try {
+ $app = require_once __DIR__ . '/../../bootstrap/app.php';
+} catch (\Throwable $e) {
+ LaravelVsCode::startupError($e);
+ exit(1);
+}
+
+$app->register(new class($app) extends \Illuminate\Support\ServiceProvider
+{
+ public function boot()
+ {
+ config([
+ 'logging.channels.null' => [
+ 'driver' => 'monolog',
+ 'handler' => \Monolog\Handler\NullHandler::class,
+ ],
+ 'logging.default' => 'null',
+ ]);
+ }
+});
+
+try {
+ $kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);
+ $kernel->bootstrap();
+} catch (\Throwable $e) {
+ LaravelVsCode::startupError($e);
+ exit(1);
+}
+
+echo LaravelVsCode::outputMarker('START_OUTPUT');
+
+use Pest\Expectation;
+use Pest\TestSuite;
+
+$pest = new class {
+ public function __construct()
+ {
+ if ($this->isInstalled()) {
+ $this->boot();
+ }
+ }
+
+ public function isInstalled(): bool
+ {
+ return class_exists(TestSuite::class);
+ }
+
+ protected function boot(): void
+ {
+ require_once base_path('vendor/pestphp/pest/overrides/Runner/TestSuiteLoader.php');
+
+ TestSuite::getInstance(base_path(), 'tests');
+
+ if (file_exists($pestFile = base_path('tests/Pest.php'))) {
+ require_once $pestFile;
+ }
+ }
+
+ public function config(): ?array
+ {
+ if (! $this->isInstalled()) {
+ return null;
+ }
+
+ return [
+ 'uses' => $this->uses(),
+ 'expectations' => $this->expectations(),
+ ];
+ }
+
+ protected function uses(): array
+ {
+ if (is_null($instance = TestSuite::getInstance())) {
+ return [];
+ }
+
+ $reflection = new ReflectionProperty($instance->tests, 'uses');
+ $uses = $reflection->getValue($instance->tests);
+
+ return collect($uses)->map(function (array $use, string $path) {
+ [$classOrTraits] = $use;
+
+ return [
+ 'path' => LaravelVsCode::relativePath($path),
+ 'classes' => array_values(array_filter($classOrTraits, fn ($c) => class_exists($c))),
+ 'traits' => array_values(array_filter($classOrTraits, fn ($c) => trait_exists($c))),
+ ];
+ })->values()->all();
+ }
+
+ protected function expectations(): array
+ {
+ $reflection = new ReflectionProperty(Expectation::class, 'extends');
+ $extends = $reflection->getValue();
+
+ return collect($extends)->map(function (Closure $closure, string $name) {
+ $parameters = collect((new ReflectionFunction($closure))->getParameters())
+ ->map(function (ReflectionParameter $param) {
+ $type = $param->hasType() ? $param->getType() . ' ' : '';
+
+ $default = $param->isOptional() && $param->isDefaultValueAvailable()
+ ? ' = ' . var_export($param->getDefaultValue(), true)
+ : '';
+
+ return $type . "$" . $param->getName() . $default;
+ })
+ ->join(', ');
+
+ return compact('name', 'parameters');
+ })->values()->all();
+ }
+};
+
+echo json_encode($pest->config());
+
+echo LaravelVsCode::outputMarker('END_OUTPUT');
+
+exit(0);