$this->container = $container;
    }
 
    /**
     * Dispatch a request to a given controller and method.
     *
     * @param  \Illuminate\Routing\Route  $route
     * @param  mixed  $controller
     * @param  string  $method
     * @return mixed
     */
    public function dispatch(Route $route, $controller, $method)
    {
        $parameters = $this->resolveParameters($route, $controller, $method);
 
        if (method_exists($controller, 'callAction')) {
            return $controller->callAction($method, $parameters);
        }
 
        return $controller->{$method}(...array_values($parameters));
    }
 
    /**
     * Resolve the parameters for the controller.
     *
     * @param  \Illuminate\Routing\Route  $route
     * @param  mixed  $controller
     * @param  string  $method
     * @return array
     */
    protected function resolveParameters(Route $route, $controller, $method)
    {
        return $this->resolveClassMethodDependencies(
            $route->parametersWithoutNulls(), $controller, $method
        );
    }
 
    /**
     * Get the middleware for the controller instance.
     *

    /**
     * Determine if the route action is a serialized Closure.
     *
     * @return bool
     */
    protected function isSerializedClosure()
    {
        return RouteAction::containsSerializedClosure($this->action);
    }
 
    /**
     * Run the route action and return the response.
     *
     * @return mixed
     *
     * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
     */
    protected function runController()
    {
        return $this->controllerDispatcher()->dispatch(
            $this, $this->getController(), $this->getControllerMethod()
        );
    }
 
    /**
     * Get the controller instance for the route.
     *
     * @return mixed
     *
     * @throws \Illuminate\Contracts\Container\BindingResolutionException
     */
    public function getController()
    {
        if (! $this->isControllerAction()) {
            return null;
        }
 
        if (! $this->controller) {
            $class = $this->getControllerClass();
 

     *
     * @throws \UnexpectedValueException
     */
    protected function parseAction($action)
    {
        return RouteAction::parse($this->uri, $action);
    }
 
    /**
     * Run the route action and return the response.
     *
     * @return mixed
     */
    public function run()
    {
        $this->container = $this->container ?: new Container;
 
        try {
            if ($this->isControllerAction()) {
                return $this->runController();
            }
 
            return $this->runCallable();
        } catch (HttpResponseException $e) {
            return $e->getResponse();
        }
    }
 
    /**
     * Checks whether the route's action is a controller.
     *
     * @return bool
     */
    protected function isControllerAction()
    {
        return is_string($this->action['uses']) && ! $this->isSerializedClosure();
    }
 
    /**
     * Run the route action and return the response.

 
    /**
     * Run the given route within a Stack "onion" instance.
     *
     * @param  \Illuminate\Routing\Route  $route
     * @param  \Illuminate\Http\Request  $request
     * @return mixed
     */
    protected function runRouteWithinStack(Route $route, Request $request)
    {
        $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
                                $this->container->make('middleware.disable') === true;
 
        $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
 
        return (new Pipeline($this->container))
            ->send($request)
            ->through($middleware)
            ->then(fn ($request) => $this->prepareResponse(
                $request, $route->run()
            ));
    }
 
    /**
     * Gather the middleware for the given route with resolved class names.
     *
     * @param  \Illuminate\Routing\Route  $route
     * @return array
     */
    public function gatherRouteMiddleware(Route $route)
    {
        return $this->resolveMiddleware($route->gatherMiddleware(), $route->excludedMiddleware());
    }
 
    /**
     * Resolve a flat array of middleware classes from the provided array.
     *
     * @param  array  $middleware
     * @param  array  $excluded
     * @return array

     * @return $this
     */
    public function finally(Closure $callback)
    {
        $this->finally = $callback;
 
        return $this;
    }
 
    /**
     * Get the final piece of the Closure onion.
     *
     * @param  \Closure  $destination
     * @return \Closure
     */
    protected function prepareDestination(Closure $destination)
    {
        return function ($passable) use ($destination) {
            try {
                return $destination($passable);
            } catch (Throwable $e) {
                return $this->handleException($passable, $e);
            }
        };
    }
 
    /**
     * Get a Closure that represents a slice of the application onion.
     *
     * @return \Closure
     */
    protected function carry()
    {
        return function ($stack, $pipe) {
            return function ($passable) use ($stack, $pipe) {
                try {
                    if (is_callable($pipe)) {
                        // If the pipe is a callable, then we will call it directly, but otherwise we
                        // will resolve the pipes out of the dependency container and call it with
                        // the appropriate method and arguments, returning the results back out.

 
        return $this;
    }
 
    /**
     * Run the pipeline with a final destination callback.
     *
     * @param  \Closure  $destination
     * @return mixed
     */
    public function then(Closure $destination)
    {
        $pipeline = array_reduce(
            array_reverse($this->pipes()), $this->carry(), $this->prepareDestination($destination)
        );
 
        try {
            return $this->withinTransaction !== false
                ? $this->getContainer()->make('db')->connection($this->withinTransaction)->transaction(fn () => $pipeline($this->passable))
                : $pipeline($this->passable);
        } finally {
            if ($this->finally) {
                ($this->finally)($this->passable);
            }
        }
    }
 
    /**
     * Run the pipeline and return the result.
     *
     * @return mixed
     */
    public function thenReturn()
    {
        return $this->then(function ($passable) {
            return $passable;
        });
    }
 
    /**

    }
 
    /**
     * Run the given route within a Stack "onion" instance.
     *
     * @param  \Illuminate\Routing\Route  $route
     * @param  \Illuminate\Http\Request  $request
     * @return mixed
     */
    protected function runRouteWithinStack(Route $route, Request $request)
    {
        $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
                                $this->container->make('middleware.disable') === true;
 
        $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
 
        return (new Pipeline($this->container))
            ->send($request)
            ->through($middleware)
            ->then(fn ($request) => $this->prepareResponse(
                $request, $route->run()
            ));
    }
 
    /**
     * Gather the middleware for the given route with resolved class names.
     *
     * @param  \Illuminate\Routing\Route  $route
     * @return array
     */
    public function gatherRouteMiddleware(Route $route)
    {
        return $this->resolveMiddleware($route->gatherMiddleware(), $route->excludedMiddleware());
    }
 
    /**
     * Resolve a flat array of middleware classes from the provided array.
     *
     * @param  array  $middleware
     * @param  array  $excluded

        $this->container->instance(Route::class, $route);
 
        return $route;
    }
 
    /**
     * Return the response for the given route.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Routing\Route  $route
     * @return \Symfony\Component\HttpFoundation\Response
     */
    protected function runRoute(Request $request, Route $route)
    {
        $request->setRouteResolver(fn () => $route);
 
        $this->events->dispatch(new RouteMatched($route, $request));
 
        return $this->prepareResponse($request,
            $this->runRouteWithinStack($route, $request)
        );
    }
 
    /**
     * Run the given route within a Stack "onion" instance.
     *
     * @param  \Illuminate\Routing\Route  $route
     * @param  \Illuminate\Http\Request  $request
     * @return mixed
     */
    protected function runRouteWithinStack(Route $route, Request $request)
    {
        $shouldSkipMiddleware = $this->container->bound('middleware.disable') &&
                                $this->container->make('middleware.disable') === true;
 
        $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddleware($route);
 
        return (new Pipeline($this->container))
            ->send($request)
            ->through($middleware)

     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function dispatch(Request $request)
    {
        $this->currentRequest = $request;
 
        return $this->dispatchToRoute($request);
    }
 
    /**
     * Dispatch the request to a route and return the response.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function dispatchToRoute(Request $request)
    {
        return $this->runRoute($request, $this->findRoute($request));
    }
 
    /**
     * Find the route matching a given request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Routing\Route
     */
    protected function findRoute($request)
    {
        $this->events->dispatch(new Routing($request));
 
        $this->current = $route = $this->routes->match($request);
 
        $route->setContainer($this->container);
 
        $this->container->instance(Route::class, $route);
 
        return $route;
    }

     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function respondWithRoute($name)
    {
        $route = tap($this->routes->getByName($name))->bind($this->currentRequest);
 
        return $this->runRoute($this->currentRequest, $route);
    }
 
    /**
     * Dispatch the request to the application.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function dispatch(Request $request)
    {
        $this->currentRequest = $request;
 
        return $this->dispatchToRoute($request);
    }
 
    /**
     * Dispatch the request to a route and return the response.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function dispatchToRoute(Request $request)
    {
        return $this->runRoute($request, $this->findRoute($request));
    }
 
    /**
     * Find the route matching a given request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Routing\Route
     */
    protected function findRoute($request)

        try {
            Menu::exists();
        } catch (Exception) {
            $install = true;
        }
 
        if ($install) {
            $this->registerInstallRoutes();
        } else {
            $this->moduleMapper->getModules(); // This initializes all Blocks.
            $this->registerRoutes();
            $this->registerPageCollections();
        }
 
        $response = $this->pipeline
            ->send($this->request)
            ->through([Canonical::class])
            ->then(function ($request) {
                try {
                    return $this->router->dispatch($request);
                } catch (NotFoundHttpException) {
                    // Catching this should not be needed. But handling non valid URLs seems broken otherwise... Testcase:
                    // (echo -e 'GET /\xdcber%20uns HTTP/1.1\r\nHost: brenner-tueren.de\r\n\r\n' ; sleep 1) | openssl s_client -connect brenner-tueren.de:443
                    throw new Exception('', 410);
                } catch (MethodNotAllowedHttpException $e) {
                    if (! headers_sent()) {
                        header('Allow: '.$e->getHeaders()['Allow']);
                    }
                    throw new Exception('', 405);
                }
            });
 
        /** @var Response $response */
        $response->send();
    }
 
    public function registerInstallRoutes(): void
    {
        $this->router->get('/', [InstallController::class, 'show']);
        $this->router->post('/', [InstallController::class, 'install']);

     * @return $this
     */
    public function finally(Closure $callback)
    {
        $this->finally = $callback;
 
        return $this;
    }
 
    /**
     * Get the final piece of the Closure onion.
     *
     * @param  \Closure  $destination
     * @return \Closure
     */
    protected function prepareDestination(Closure $destination)
    {
        return function ($passable) use ($destination) {
            try {
                return $destination($passable);
            } catch (Throwable $e) {
                return $this->handleException($passable, $e);
            }
        };
    }
 
    /**
     * Get a Closure that represents a slice of the application onion.
     *
     * @return \Closure
     */
    protected function carry()
    {
        return function ($stack, $pipe) {
            return function ($passable) use ($stack, $pipe) {
                try {
                    if (is_callable($pipe)) {
                        // If the pipe is a callable, then we will call it directly, but otherwise we
                        // will resolve the pipes out of the dependency container and call it with
                        // the appropriate method and arguments, returning the results back out.

    public function handle(Request $request, Closure $next): Response
    {
        $scheme = strtolower(parse_url(config()->string('app.url'), PHP_URL_SCHEME) ?: 'HTTP');
        $host = strtolower(parse_url(config()->string('app.url'), PHP_URL_HOST) ?: 'localhost');
 
        if (str_contains($request->getRequestUri(), 'index.php') ||
            $scheme !== $request->getScheme() ||
            $host !== $request->getHost()) {
            $redirectUrl = $scheme.'://'.$host.str_replace(
                'index.php',
                '',
                $request->getRequestUri()
            );
 
            response()->setStatusCode(301); // moved permanently
 
            return response()->header('Location', $redirectUrl);
        }
 
        return $next($request);
    }
}
 

                        // the appropriate method and arguments, returning the results back out.
                        return $pipe($passable, $stack);
                    } elseif (! is_object($pipe)) {
                        [$name, $parameters] = $this->parsePipeString($pipe);
 
                        // If the pipe is a string we will parse the string and resolve the class out
                        // of the dependency injection container. We can then build a callable and
                        // execute the pipe function giving in the parameters that are required.
                        $pipe = $this->getContainer()->make($name);
 
                        $parameters = array_merge([$passable, $stack], $parameters);
                    } else {
                        // If the pipe is already an object we'll just make a callable and pass it to
                        // the pipe as-is. There is no need to do any extra parsing and formatting
                        // since the object we're given was already a fully instantiated object.
                        $parameters = [$passable, $stack];
                    }
 
                    $carry = method_exists($pipe, $this->method)
                        ? $pipe->{$this->method}(...$parameters)
                        : $pipe(...$parameters);
 
                    return $this->handleCarry($carry);
                } catch (Throwable $e) {
                    return $this->handleException($passable, $e);
                }
            };
        };
    }
 
    /**
     * Parse full pipe string to get name and parameters.
     *
     * @param  string  $pipe
     * @return array
     */
    protected function parsePipeString($pipe)
    {
        [$name, $parameters] = array_pad(explode(':', $pipe, 2), 2, null);
 

 
        return $this;
    }
 
    /**
     * Run the pipeline with a final destination callback.
     *
     * @param  \Closure  $destination
     * @return mixed
     */
    public function then(Closure $destination)
    {
        $pipeline = array_reduce(
            array_reverse($this->pipes()), $this->carry(), $this->prepareDestination($destination)
        );
 
        try {
            return $this->withinTransaction !== false
                ? $this->getContainer()->make('db')->connection($this->withinTransaction)->transaction(fn () => $pipeline($this->passable))
                : $pipeline($this->passable);
        } finally {
            if ($this->finally) {
                ($this->finally)($this->passable);
            }
        }
    }
 
    /**
     * Run the pipeline and return the result.
     *
     * @return mixed
     */
    public function thenReturn()
    {
        return $this->then(function ($passable) {
            return $passable;
        });
    }
 
    /**

    {
        $install = false;
        try {
            Menu::exists();
        } catch (Exception) {
            $install = true;
        }
 
        if ($install) {
            $this->registerInstallRoutes();
        } else {
            $this->moduleMapper->getModules(); // This initializes all Blocks.
            $this->registerRoutes();
            $this->registerPageCollections();
        }
 
        $response = $this->pipeline
            ->send($this->request)
            ->through([Canonical::class])
            ->then(function ($request) {
                try {
                    return $this->router->dispatch($request);
                } catch (NotFoundHttpException) {
                    // Catching this should not be needed. But handling non valid URLs seems broken otherwise... Testcase:
                    // (echo -e 'GET /\xdcber%20uns HTTP/1.1\r\nHost: brenner-tueren.de\r\n\r\n' ; sleep 1) | openssl s_client -connect brenner-tueren.de:443
                    throw new Exception('', 410);
                } catch (MethodNotAllowedHttpException $e) {
                    if (! headers_sent()) {
                        header('Allow: '.$e->getHeaders()['Allow']);
                    }
                    throw new Exception('', 405);
                }
            });
 
        /** @var Response $response */
        $response->send();
    }
 
    public function registerInstallRoutes(): void
    {

        $router->post('/brand', [MarkenCrudController::class, 'postResponse']);
 
        $router->get('/acat', [ArticleCategoryCrudController::class, 'getResponse']);
        $router->post('/acat', [ArticleCategoryCrudController::class, 'postResponse']);
 
        $router->get('/scat', [SpareCategoryCrudController::class, 'getResponse']);
        $router->post('/scat', [SpareCategoryCrudController::class, 'postResponse']);
 
        $router->get('/type', [SpareTypeCrudController::class, 'getResponse']);
        $router->post('/type', [SpareTypeCrudController::class, 'postResponse']);
 
        $router->get('/article', [ArticleCrudController::class, 'getResponse']);
        $router->post('/article', [ArticleCrudController::class, 'postResponse']);
 
        $router->get('/sparepart', [SpareCrudController::class, 'getResponse']);
        $router->post('/sparepart', [SpareCrudController::class, 'postResponse']);
    }
);
 
$cms->run();
 

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