Whoops, looks like something went wrong.

                                                        'You are not allowed to read folders',
                                    
                                                        1430657869
                                    
                                                    );
                                    
                                                }
                                    
                                                throw new InsufficientFolderAccessPermissionsException(
                                    
                                                    'You are not allowed to access the given folder: "' . $folder->getName() . '"',
                                    
                                                    1375955684
                                    
                                                );
                                    
                                            }
                                    
                                

                                            $data = $this->driver->getFolderInfoByIdentifier($identifier);
                                    
                                            $folder = $this->getResourceFactoryInstance()->createFolderObject($this, $data['identifier'] ?? null, $data['name'] ?? null);
                                    
                                    
                                            try {
                                    
                                                $this->assureFolderReadPermission($folder);
                                    
                                            } catch (InsufficientFolderAccessPermissionsException $e) {
                                    
                                                $folder = null;
                                    
                                                if ($returnInaccessibleFolderObject) {
                                    
                                                    // if parent folder is readable return inaccessible folder object
                                    
                                

                                                if (GeneralUtility::isFirstPartOfStr($folderIdentifier, Environment::getPublicPath() . '/')) {
                                    
                                                    $folderIdentifier = PathUtility::stripPathSitePrefix($parts[0]);
                                    
                                                }
                                    
                                            }
                                    
                                            return $this->getStorageObject($storageUid, [], $folderIdentifier)->getFolder($folderIdentifier);
                                    
                                        }
                                    
                                    
                                        /**
                                    
                                         * Gets a storage object from a combined identifier
                                    
                                

                                        public function resolveHandlerData(array $data): array
                                    
                                        {
                                    
                                            $combinedIdentifier = ($data['storage'] ?? '0') . ':' . $data['identifier'];
                                    
                                            try {
                                    
                                                $folder = $this->getResourceFactory()->getFolderObjectFromCombinedIdentifier($combinedIdentifier);
                                    
                                            } catch (FolderDoesNotExistException $e) {
                                    
                                                $folder = null;
                                    
                                            }
                                    
                                            return ['folder' => $folder];
                                    
                                

                                                }
                                    
                                                $fragment = $urnParsed['fragment'] ?? null;
                                    
                                    
                                                if (is_object($this->handlers[$type])) {
                                    
                                                    $result = $this->handlers[$type]->resolveHandlerData($data);
                                    
                                                    $result['type'] = $type;
                                    
                                                } else {
                                    
                                                    throw new UnknownLinkHandlerException('LinkHandler for ' . $type . ' was not registered', 1460581769);
                                    
                                                }
                                    
                                

                                        public function resolve(string $linkParameter): array
                                    
                                        {
                                    
                                            try {
                                    
                                                // Check if the new syntax with "t3://" is used
                                    
                                                return $this->resolveByStringRepresentation($linkParameter);
                                    
                                            } catch (UnknownUrnException $e) {
                                    
                                                $legacyLinkNotationConverter = GeneralUtility::makeInstance(LegacyLinkNotationConverter::class);
                                    
                                                return $legacyLinkNotationConverter->resolve($linkParameter);
                                    
                                            }
                                    
                                

                                                    continue;
                                    
                                                }
                                    
                                    
                                                try {
                                    
                                                    $hrefInformation = $linkService->resolve($attributes['href']);
                                    
                                    
                                                    $brokenLinkAnalysis = new BrokenLinkAnalysisEvent($hrefInformation['type'], $hrefInformation);
                                    
                                                    $this->eventDispatcher->dispatch($brokenLinkAnalysis);
                                    
                                                    if ($brokenLinkAnalysis->isBrokenLink()) {
                                    
                                

                                                } else {
                                    
                                                    // ... else use defaults:
                                    
                                                    switch ($cmd) {
                                    
                                                        case 'detectbrokenlinks':
                                    
                                                            $value = $this->markBrokenLinks($value);
                                    
                                                            break;
                                    
                                                        case 'css_transform':
                                    
                                                            $value = $this->TS_transform_rte($value);
                                    
                                                            break;
                                    
                                

                                                    // If eval=null is set for field, value might be null ... don't transform anything in this case.
                                    
                                                    if ($result['databaseRow'][$fieldName] !== null) {
                                    
                                                        // Process "from-db-to-rte" on current value
                                    
                                                        $richTextParser = GeneralUtility::makeInstance(RteHtmlParser::class);
                                    
                                                        $result['databaseRow'][$fieldName] = $richTextParser->transformTextForRichTextEditor($result['databaseRow'][$fieldName], $richtextConfiguration['proc.'] ?? []);
                                    
                                                    }
                                    
                                                }
                                    
                                            }
                                    
                                    
                                

                                                        1485299408
                                    
                                                    );
                                    
                                                }
                                    
                                    
                                                $result = $provider->addData($result);
                                    
                                            }
                                    
                                    
                                            return $result;
                                    
                                        }
                                    
                                

                                            $orderedProviderList->setProviderList(
                                    
                                                $GLOBALS['TYPO3_CONF_VARS']['SYS']['formEngine']['formDataGroup']['tcaDatabaseRecord']
                                    
                                            );
                                    
                                    
                                            return $orderedProviderList->compile($result);
                                    
                                        }
                                    
                                    }
                                    
                                

                                            // Call the data group provider but take care it does not add or remove result keys
                                    
                                            // This is basically a safety measure against data providers colliding with our array "contract"
                                    
                                            $resultKeysBeforeFormDataGroup = array_keys($result);
                                    
                                    
                                            $result = $this->formDataGroup->compile($result);
                                    
                                    
                                            if (!is_array($result)) {
                                    
                                                throw new \UnexpectedValueException(
                                    
                                                    'Data group provider must return array',
                                    
                                

                                                                    if (!empty($this->defVals) && is_array($this->defVals)) {
                                    
                                                                        $formDataCompilerInput['defaultValues'] = $this->defVals;
                                    
                                                                    }
                                    
                                    
                                                                    $formData = $formDataCompiler->compile($formDataCompilerInput);
                                    
                                    
                                                                    // Set this->viewId if possible
                                    
                                                                    if ($command === 'new'
                                    
                                                                        && $table !== 'pages'
                                    
                                

                                            if (is_array($this->editconf)) {
                                    
                                                $this->formResultCompiler = GeneralUtility::makeInstance(FormResultCompiler::class);
                                    
                                    
                                                // Creating the editing form, wrap it with buttons, document selector etc.
                                    
                                                $editForm = $this->makeEditForm();
                                    
                                                if ($editForm) {
                                    
                                                    $this->firstEl = reset($this->elementsData);
                                    
                                                    // Checking if the currently open document is stored in the list of "open documents" - if not, add it:
                                    
                                                    if (($this->docDat[1] !== $this->storeUrlMd5 || !isset($this->docHandler[$this->storeUrlMd5]))
                                    
                                

                                                }
                                    
                                            }
                                    
                                    
                                            $this->init($request);
                                    
                                            $this->main($request);
                                    
                                    
                                            return new HtmlResponse($this->moduleTemplate->renderContent());
                                    
                                        }
                                    
                                    
                                

                                            }
                                    
                                            $targetIdentifier = $route->getOption('target');
                                    
                                            $target = $this->getCallableFromTarget($targetIdentifier);
                                    
                                            $arguments = [$request];
                                    
                                            return call_user_func_array($target, $arguments);
                                    
                                        }
                                    
                                    
                                        /**
                                    
                                         * Wrapper method for static form protection utility
                                    
                                

                                            // there are Core classes that need the Request object but do not get it handed in
                                    
                                            $this->resetGlobalsToCurrentRequest($request);
                                    
                                            try {
                                    
                                                // Check if the router has the available route and dispatch.
                                    
                                                return $this->dispatcher->dispatch($request);
                                    
                                            } catch (InvalidRequestTokenException $e) {
                                    
                                                // When token was invalid redirect to login
                                    
                                                $loginPage = GeneralUtility::makeInstance(UriBuilder::class)->buildUriFromRoute('login');
                                    
                                                return new RedirectResponse((string)$loginPage);
                                    
                                

                                            if (!$user->isAdmin() && $this->isUserDisallowedAccessBackend($user)) {
                                    
                                                return new RedirectResponse($this->buildFrontendUri($request));
                                    
                                            }
                                    
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    
                                        /**
                                    
                                         * Check if access to BE is disabled by TS config
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                         */
                                    
                                        public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
                                    
                                        {
                                    
                                            $this->dispatcher->reportDeprecatedSignalSlots();
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    }
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                                }
                                    
                                                $site = $this->siteMatcher->matchByPageId($pageId, $rootLine);
                                    
                                                $request = $request->withAttribute('site', $site);
                                    
                                            }
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    }
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                         * @return ResponseInterface
                                    
                                         */
                                    
                                        public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
                                    
                                        {
                                    
                                            $response = $handler->handle($request);
                                    
                                            foreach ($GLOBALS['TYPO3_CONF_VARS']['BE']['HTTP']['Response']['Headers'] ?? [] as $header) {
                                    
                                                [$headerName, $value] = explode(':', $header, 2);
                                    
                                                $response = $response->withAddedHeader($headerName, trim($value));
                                    
                                            }
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                            ob_clean();
                                    
                                            // Initialize output compression if configured
                                    
                                            $this->initializeOutputCompression();
                                    
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    
                                        /**
                                    
                                         * Initialize output compression if configured
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                            if ($GLOBALS['BE_USER'] !== null && $_REQUEST['tx_siteimprove_goto']) {
                                    
                                                $GLOBALS['BE_USER']->setAndSaveSessionData('tx_siteimprove_goto', $_REQUEST['tx_siteimprove_goto']);
                                    
                                            }
                                    
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    }
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                            $GLOBALS['LANG'] = LanguageService::createFromUserPreferences($GLOBALS['BE_USER']);
                                    
                                            // Re-setting the user and take the workspace from the user object now
                                    
                                            $this->setBackendUserAspect($GLOBALS['BE_USER']);
                                    
                                    
                                            $response = $handler->handle($request);
                                    
                                    
                                            // Additional headers to never cache any PHP request should be sent at any time when
                                    
                                            // accessing the TYPO3 Backend
                                    
                                            return $this->applyHeadersToResponse($response);
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                    
                                            // Add the route path to the request
                                    
                                            $request = $request->withAttribute('routePath', $pathToRoute);
                                    
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    }
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                                [$server, $address] = explode('/', $url, 2);
                                    
                                                return new RedirectResponse('https://' . $server . $sslPortSuffix . '/' . $address);
                                    
                                            }
                                    
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    }
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                                $request->getAttribute('normalizedParams')->getRemoteAddress(),
                                    
                                                trim((string)$GLOBALS['TYPO3_CONF_VARS']['BE']['IPmaskList'])
                                    
                                            );
                                    
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    
                                        /**
                                    
                                         * Check adminOnly configuration variable and redirects to an URL in file typo3conf/LOCK_BACKEND
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                         */
                                    
                                        public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
                                    
                                        {
                                    
                                            $request = $request->withAttribute('normalizedParams', NormalizedParams::createFromRequest($request));
                                    
                                            return $handler->handle($request);
                                    
                                        }
                                    
                                    }
                                    
                                

                                    
                                                    if (!$middleware instanceof MiddlewareInterface) {
                                    
                                                        throw new \InvalidArgumentException(get_class($middleware) . ' does not implement ' . MiddlewareInterface::class, 1516821342);
                                    
                                                    }
                                    
                                                    return $middleware->process($request, $this->next);
                                    
                                                }
                                    
                                            };
                                    
                                        }
                                    
                                    }
                                    
                                

                                         * @return ResponseInterface
                                    
                                         */
                                    
                                        public function handle(ServerRequestInterface $request): ResponseInterface
                                    
                                        {
                                    
                                            return $this->tip->handle($request);
                                    
                                        }
                                    
                                    
                                        /**
                                    
                                         * Seed the middleware stack with the inner request handler
                                    
                                

                                         * @return ResponseInterface
                                    
                                         */
                                    
                                        protected function handle(ServerRequestInterface $request): ResponseInterface
                                    
                                        {
                                    
                                            return $this->requestHandler->handle($request);
                                    
                                        }
                                    
                                    
                                        /**
                                    
                                         * Set up the application and shut it down afterwards
                                    
                                

                                                return $this->installToolRedirect();
                                    
                                            }
                                    
                                            // Set up the initial context
                                    
                                            $this->initializeContext();
                                    
                                            return parent::handle($request);
                                    
                                        }
                                    
                                    
                                        /**
                                    
                                         * Check if LocalConfiguration.php and PackageStates.php exist
                                    
                                

                                        final public function run(callable $execute = null)
                                    
                                        {
                                    
                                            try {
                                    
                                                $response = $this->handle(
                                    
                                                    ServerRequestFactory::fromGlobals()
                                    
                                                );
                                    
                                                if ($execute !== null) {
                                    
                                                    call_user_func($execute);
                                    
                                                }
                                    
                                

                                    // Set up the application for the backend
                                    
                                    call_user_func(function () {
                                    
                                        $classLoader = require dirname(dirname(__DIR__)).'/vendor/autoload.php';
                                    
                                        \TYPO3\CMS\Core\Core\SystemEnvironmentBuilder::run(1, \TYPO3\CMS\Core\Core\SystemEnvironmentBuilder::REQUESTTYPE_BE);
                                    
                                        \TYPO3\CMS\Core\Core\Bootstrap::init($classLoader)->get(\TYPO3\CMS\Backend\Http\Application::class)->run();
                                    
                                    });
                                    
                                

                                    call_user_func(function () {
                                    
                                        $classLoader = require dirname(dirname(__DIR__)).'/vendor/autoload.php';
                                    
                                        \TYPO3\CMS\Core\Core\SystemEnvironmentBuilder::run(1, \TYPO3\CMS\Core\Core\SystemEnvironmentBuilder::REQUESTTYPE_BE);
                                    
                                        \TYPO3\CMS\Core\Core\Bootstrap::init($classLoader)->get(\TYPO3\CMS\Backend\Http\Application::class)->run();
                                    
                                    });