declare(strict_types=1);
 
namespace App\Classes;
 
use Exception;
 
class Manifest
{
    /**
     * @var array<string, mixed>
     */
    protected array $manifest;
 
    protected string $version;
 
    protected int $buildTime;
 
    public function __construct()
    {
        $this->reload();
    }
 
    public function reload(): void
    {
        try {
            $file = config()->string('asset.path').'/'.config()->string('manifest.filename');
            $json = safe_string(file_get_contents($file));
            $buildTime = safe_int(filemtime($file));
            $this->buildTime = $buildTime;
            $this->manifest = json_decode($json, true, flags: JSON_THROW_ON_ERROR);
            $this->version = $this->manifest['version'];
        } catch (Exception) {
            throw new Exception('', 503);
        }
    }
 
    public function getBuildTime(): int
    {
        return $this->buildTime;
    }

            return $instance;
        }
 
        $dependencies = $constructor->getParameters();
 
        // Once we have all the constructor's parameters we can create each of the
        // dependency instances and then use the reflection instances to make a
        // new instance of this class, injecting the created dependencies in.
        try {
            $instances = $this->resolveDependencies($dependencies);
        } catch (BindingResolutionException $e) {
            array_pop($this->buildStack);
 
            throw $e;
        }
 
        array_pop($this->buildStack);
 
        $this->fireAfterResolvingAttributeCallbacks(
            $reflector->getAttributes(), $instance = $reflector->newInstanceArgs($instances)
        );
 
        return $instance;
    }
 
    /**
     * Instantiate a concrete instance of the given self building type.
     *
     * @param  \Closure(static, array): TClass|class-string<TClass>  $concrete
     * @param  \ReflectionClass  $reflector
     * @return TClass
     *
     * @throws \Illuminate\Contracts\Container\BindingResolutionException
     */
    protected function buildSelfBuildingInstance($concrete, $reflector)
    {
        if (! method_exists($concrete, 'newInstance')) {
            throw new BindingResolutionException("No newInstance method exists for [$concrete].");
        }
 

        $needsContextualBuild = ! empty($parameters) || ! is_null($concrete);
 
        // If an instance of the type is currently being managed as a singleton we'll
        // just return an existing instance instead of instantiating new instances
        // so the developer can keep using the same objects instance every time.
        if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
            return $this->instances[$abstract];
        }
 
        $this->with[] = $parameters;
 
        if (is_null($concrete)) {
            $concrete = $this->getConcrete($abstract);
        }
 
        // We're ready to instantiate an instance of the concrete type registered for
        // the binding. This will instantiate the types, as well as resolve any of
        // its "nested" dependencies recursively until all have gotten resolved.
        $object = $this->isBuildable($concrete, $abstract)
            ? $this->build($concrete)
            : $this->make($concrete);
 
        // If we defined any extenders for this type, we'll need to spin through them
        // and apply them to the object being built. This allows for the extension
        // of services, such as changing configuration or decorating the object.
        foreach ($this->getExtenders($abstract) as $extender) {
            $object = $extender($object, $this);
        }
 
        // If the requested type is registered as a singleton we'll want to cache off
        // the instances in "memory" so we can return it later without creating an
        // entirely new instance of an object on each subsequent request for it.
        if ($this->isShared($abstract) && ! $needsContextualBuild) {
            $this->instances[$abstract] = $object;
        }
 
        if ($raiseEvents) {
            $this->fireResolvingCallbacks($abstract, $object);
        }
 

     * @throws \Illuminate\Contracts\Container\BindingResolutionException
     */
    public function makeWith($abstract, array $parameters = [])
    {
        return $this->make($abstract, $parameters);
    }
 
    /**
     * Resolve the given type from the container.
     *
     * @template TClass of object
     *
     * @param  string|class-string<TClass>  $abstract
     * @return ($abstract is class-string<TClass> ? TClass : mixed)
     *
     * @throws \Illuminate\Contracts\Container\BindingResolutionException
     */
    public function make($abstract, array $parameters = [])
    {
        return $this->resolve($abstract, $parameters);
    }
 
    /**
     * {@inheritdoc}
     *
     * @template TClass of object
     *
     * @param  string|class-string<TClass>  $id
     * @return ($id is class-string<TClass> ? TClass : mixed)
     */
    public function get(string $id)
    {
        try {
            return $this->resolve($id);
        } catch (Exception $e) {
            if ($this->has($id) || $e instanceof CircularDependencyException) {
                throw $e;
            }
 
            throw new EntryNotFoundException($id, is_int($e->getCode()) ? $e->getCode() : 0, $e);

     *
     * @throws \Illuminate\Contracts\Container\BindingResolutionException
     */
    protected function resolveClass(ReflectionParameter $parameter)
    {
        $className = Util::getParameterClassName($parameter);
 
        // First we will check if a default value has been defined for the parameter.
        // If it has, and no explicit binding exists, we should return it to avoid
        // overriding any of the developer specified defaults for the parameters.
        if ($parameter->isDefaultValueAvailable() &&
            ! $this->bound($className) &&
            $this->findInContextualBindings($className) === null) {
            return $parameter->getDefaultValue();
        }
 
        try {
            return $parameter->isVariadic()
                ? $this->resolveVariadicClass($parameter)
                : $this->make($className);
        }
 
        // If we can not resolve the class instance, we will check to see if the value
        // is variadic. If it is, we will return an empty array as the value of the
        // dependency similarly to how we handle scalar values in this situation.
        catch (BindingResolutionException $e) {
            if ($parameter->isVariadic()) {
                array_pop($this->with);
 
                return [];
            }
 
            throw $e;
        }
    }
 
    /**
     * Resolve a class based variadic dependency from the container.
     *
     * @return mixed

            // that instead as the value. Otherwise, we will continue with this run
            // of resolutions and let reflection attempt to determine the result.
            if ($this->hasParameterOverride($dependency)) {
                $results[] = $this->getParameterOverride($dependency);
 
                continue;
            }
 
            $result = null;
 
            if (! is_null($attribute = Util::getContextualAttributeFromDependency($dependency))) {
                $result = $this->resolveFromAttribute($attribute);
            }
 
            // If the class is null, it means the dependency is a string or some other
            // primitive type which we can not resolve since it is not a class and
            // we will just bomb out with an error since we have no-where to go.
            $result ??= is_null(Util::getParameterClassName($dependency))
                ? $this->resolvePrimitive($dependency)
                : $this->resolveClass($dependency);
 
            $this->fireAfterResolvingAttributeCallbacks($dependency->getAttributes(), $result);
 
            if ($dependency->isVariadic()) {
                $results = array_merge($results, $result);
            } else {
                $results[] = $result;
            }
        }
 
        return $results;
    }
 
    /**
     * Determine if the given dependency has a parameter override.
     *
     * @param  \ReflectionParameter  $dependency
     * @return bool
     */
    protected function hasParameterOverride($dependency)

        // If there are no constructors, that means there are no dependencies then
        // we can just resolve the instances of the objects right away, without
        // resolving any other types or dependencies out of these containers.
        if (is_null($constructor)) {
            array_pop($this->buildStack);
 
            $this->fireAfterResolvingAttributeCallbacks(
                $reflector->getAttributes(), $instance = new $concrete
            );
 
            return $instance;
        }
 
        $dependencies = $constructor->getParameters();
 
        // Once we have all the constructor's parameters we can create each of the
        // dependency instances and then use the reflection instances to make a
        // new instance of this class, injecting the created dependencies in.
        try {
            $instances = $this->resolveDependencies($dependencies);
        } catch (BindingResolutionException $e) {
            array_pop($this->buildStack);
 
            throw $e;
        }
 
        array_pop($this->buildStack);
 
        $this->fireAfterResolvingAttributeCallbacks(
            $reflector->getAttributes(), $instance = $reflector->newInstanceArgs($instances)
        );
 
        return $instance;
    }
 
    /**
     * Instantiate a concrete instance of the given self building type.
     *
     * @param  \Closure(static, array): TClass|class-string<TClass>  $concrete
     * @param  \ReflectionClass  $reflector

        $needsContextualBuild = ! empty($parameters) || ! is_null($concrete);
 
        // If an instance of the type is currently being managed as a singleton we'll
        // just return an existing instance instead of instantiating new instances
        // so the developer can keep using the same objects instance every time.
        if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
            return $this->instances[$abstract];
        }
 
        $this->with[] = $parameters;
 
        if (is_null($concrete)) {
            $concrete = $this->getConcrete($abstract);
        }
 
        // We're ready to instantiate an instance of the concrete type registered for
        // the binding. This will instantiate the types, as well as resolve any of
        // its "nested" dependencies recursively until all have gotten resolved.
        $object = $this->isBuildable($concrete, $abstract)
            ? $this->build($concrete)
            : $this->make($concrete);
 
        // If we defined any extenders for this type, we'll need to spin through them
        // and apply them to the object being built. This allows for the extension
        // of services, such as changing configuration or decorating the object.
        foreach ($this->getExtenders($abstract) as $extender) {
            $object = $extender($object, $this);
        }
 
        // If the requested type is registered as a singleton we'll want to cache off
        // the instances in "memory" so we can return it later without creating an
        // entirely new instance of an object on each subsequent request for it.
        if ($this->isShared($abstract) && ! $needsContextualBuild) {
            $this->instances[$abstract] = $object;
        }
 
        if ($raiseEvents) {
            $this->fireResolvingCallbacks($abstract, $object);
        }
 

     * @throws \Illuminate\Contracts\Container\BindingResolutionException
     */
    public function makeWith($abstract, array $parameters = [])
    {
        return $this->make($abstract, $parameters);
    }
 
    /**
     * Resolve the given type from the container.
     *
     * @template TClass of object
     *
     * @param  string|class-string<TClass>  $abstract
     * @return ($abstract is class-string<TClass> ? TClass : mixed)
     *
     * @throws \Illuminate\Contracts\Container\BindingResolutionException
     */
    public function make($abstract, array $parameters = [])
    {
        return $this->resolve($abstract, $parameters);
    }
 
    /**
     * {@inheritdoc}
     *
     * @template TClass of object
     *
     * @param  string|class-string<TClass>  $id
     * @return ($id is class-string<TClass> ? TClass : mixed)
     */
    public function get(string $id)
    {
        try {
            return $this->resolve($id);
        } catch (Exception $e) {
            if ($this->has($id) || $e instanceof CircularDependencyException) {
                throw $e;
            }
 
            throw new EntryNotFoundException($id, is_int($e->getCode()) ? $e->getCode() : 0, $e);

        $html .= '<main id="content"><div class=container>';
        $html .= $this->section->render($page->pageId,'Seiten-Inhalt');
        $html .= '</div></main>';
 
        $html .= '<div id="footer"><div class=container>';
        $html .= '<div class="d-none d-xl-block">';
        $html .= '<nav id="menu2">' . DesktopMenu::render($page->locale, 1) . '</nav>';
        $html .= '</div>';
 
        $html .= $this->section->render('page-foot-'.$page->lang,'Seiten-Fuß');
 
        $html .= '</div>';
        $html .= '</div>';
 
        return $html;
    }
}
 
$cms = container()->make(Cms::class);
$page = container()->make(PageController::class);
$layout = container()->make(Layout::class);
$page->setLayout($layout);
$cms->run();
 

<?php
 
declare(strict_types=1);
 
$_ENV['PUBLIC_PATH'] = __DIR__;
 
return require_once __DIR__.'/../cms.php';